aboutsummaryrefslogtreecommitdiff
path: root/source/Plugins/Platform/Android/AdbClient.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'source/Plugins/Platform/Android/AdbClient.cpp')
-rw-r--r--source/Plugins/Platform/Android/AdbClient.cpp189
1 files changed, 96 insertions, 93 deletions
diff --git a/source/Plugins/Platform/Android/AdbClient.cpp b/source/Plugins/Platform/Android/AdbClient.cpp
index 2060bd1de735..d3bcee6f487d 100644
--- a/source/Plugins/Platform/Android/AdbClient.cpp
+++ b/source/Plugins/Platform/Android/AdbClient.cpp
@@ -46,7 +46,7 @@ using namespace std::chrono;
namespace {
-const seconds kReadTimeout(8);
+const seconds kReadTimeout(12);
const char *kOKAY = "OKAY";
const char *kFAIL = "FAIL";
const char *kDATA = "DATA";
@@ -65,9 +65,9 @@ const uint32_t kDefaultMode = 0100770; // S_IFREG | S_IRWXU | S_IRWXG
const char *kSocketNamespaceAbstract = "localabstract";
const char *kSocketNamespaceFileSystem = "localfilesystem";
-Error ReadAllBytes(Connection &conn, void *buffer, size_t size) {
+Status ReadAllBytes(Connection &conn, void *buffer, size_t size) {
- Error error;
+ Status error;
ConnectionStatus status;
char *read_buffer = static_cast<char *>(buffer);
@@ -86,7 +86,7 @@ Error ReadAllBytes(Connection &conn, void *buffer, size_t size) {
now = steady_clock::now();
}
if (total_read_bytes < size)
- error = Error(
+ error = Status(
"Unable to read requested number of bytes. Connection status: %d.",
status);
return error;
@@ -94,8 +94,8 @@ Error ReadAllBytes(Connection &conn, void *buffer, size_t size) {
} // namespace
-Error AdbClient::CreateByDeviceID(const std::string &device_id,
- AdbClient &adb) {
+Status AdbClient::CreateByDeviceID(const std::string &device_id,
+ AdbClient &adb) {
DeviceIDList connect_devices;
auto error = adb.GetDevices(connect_devices);
if (error.Fail())
@@ -109,15 +109,15 @@ Error AdbClient::CreateByDeviceID(const std::string &device_id,
if (android_serial.empty()) {
if (connect_devices.size() != 1)
- return Error("Expected a single connected device, got instead %zu - try "
- "setting 'ANDROID_SERIAL'",
- connect_devices.size());
+ return Status("Expected a single connected device, got instead %zu - try "
+ "setting 'ANDROID_SERIAL'",
+ connect_devices.size());
adb.SetDeviceID(connect_devices.front());
} else {
auto find_it = std::find(connect_devices.begin(), connect_devices.end(),
android_serial);
if (find_it == connect_devices.end())
- return Error("Device \"%s\" not found", android_serial.c_str());
+ return Status("Device \"%s\" not found", android_serial.c_str());
adb.SetDeviceID(*find_it);
}
@@ -136,15 +136,15 @@ void AdbClient::SetDeviceID(const std::string &device_id) {
const std::string &AdbClient::GetDeviceID() const { return m_device_id; }
-Error AdbClient::Connect() {
- Error error;
+Status AdbClient::Connect() {
+ Status error;
m_conn.reset(new ConnectionFileDescriptor);
m_conn->Connect("connect://localhost:5037", &error);
return error;
}
-Error AdbClient::GetDevices(DeviceIDList &device_list) {
+Status AdbClient::GetDevices(DeviceIDList &device_list) {
device_list.clear();
auto error = SendMessage("host:devices");
@@ -171,8 +171,8 @@ Error AdbClient::GetDevices(DeviceIDList &device_list) {
return error;
}
-Error AdbClient::SetPortForwarding(const uint16_t local_port,
- const uint16_t remote_port) {
+Status AdbClient::SetPortForwarding(const uint16_t local_port,
+ const uint16_t remote_port) {
char message[48];
snprintf(message, sizeof(message), "forward:tcp:%d;tcp:%d", local_port,
remote_port);
@@ -184,9 +184,10 @@ Error AdbClient::SetPortForwarding(const uint16_t local_port,
return ReadResponseStatus();
}
-Error AdbClient::SetPortForwarding(const uint16_t local_port,
- llvm::StringRef remote_socket_name,
- const UnixSocketNamespace socket_namespace) {
+Status
+AdbClient::SetPortForwarding(const uint16_t local_port,
+ llvm::StringRef remote_socket_name,
+ const UnixSocketNamespace socket_namespace) {
char message[PATH_MAX];
const char *sock_namespace_str =
(socket_namespace == UnixSocketNamespaceAbstract)
@@ -202,7 +203,7 @@ Error AdbClient::SetPortForwarding(const uint16_t local_port,
return ReadResponseStatus();
}
-Error AdbClient::DeletePortForwarding(const uint16_t local_port) {
+Status AdbClient::DeletePortForwarding(const uint16_t local_port) {
char message[32];
snprintf(message, sizeof(message), "killforward:tcp:%d", local_port);
@@ -213,8 +214,8 @@ Error AdbClient::DeletePortForwarding(const uint16_t local_port) {
return ReadResponseStatus();
}
-Error AdbClient::SendMessage(const std::string &packet, const bool reconnect) {
- Error error;
+Status AdbClient::SendMessage(const std::string &packet, const bool reconnect) {
+ Status error;
if (!m_conn || reconnect) {
error = Connect();
if (error.Fail())
@@ -235,13 +236,13 @@ Error AdbClient::SendMessage(const std::string &packet, const bool reconnect) {
return error;
}
-Error AdbClient::SendDeviceMessage(const std::string &packet) {
+Status AdbClient::SendDeviceMessage(const std::string &packet) {
std::ostringstream msg;
msg << "host-serial:" << m_device_id << ":" << packet;
return SendMessage(msg.str());
}
-Error AdbClient::ReadMessage(std::vector<char> &message) {
+Status AdbClient::ReadMessage(std::vector<char> &message) {
message.clear();
char buffer[5];
@@ -262,19 +263,19 @@ Error AdbClient::ReadMessage(std::vector<char> &message) {
return error;
}
-Error AdbClient::ReadMessageStream(std::vector<char> &message,
- milliseconds timeout) {
+Status AdbClient::ReadMessageStream(std::vector<char> &message,
+ milliseconds timeout) {
auto start = steady_clock::now();
message.clear();
- Error error;
+ Status error;
lldb::ConnectionStatus status = lldb::eConnectionStatusSuccess;
char buffer[1024];
while (error.Success() && status == lldb::eConnectionStatusSuccess) {
auto end = steady_clock::now();
auto elapsed = end - start;
if (elapsed >= timeout)
- return Error("Timed out");
+ return Status("Timed out");
size_t n = m_conn->Read(buffer, sizeof(buffer),
duration_cast<microseconds>(timeout - elapsed),
@@ -285,7 +286,7 @@ Error AdbClient::ReadMessageStream(std::vector<char> &message,
return error;
}
-Error AdbClient::ReadResponseStatus() {
+Status AdbClient::ReadResponseStatus() {
char response_id[5];
static const size_t packet_len = 4;
@@ -301,9 +302,9 @@ Error AdbClient::ReadResponseStatus() {
return error;
}
-Error AdbClient::GetResponseError(const char *response_id) {
+Status AdbClient::GetResponseError(const char *response_id) {
if (strcmp(response_id, kFAIL) != 0)
- return Error("Got unexpected response id from adb: \"%s\"", response_id);
+ return Status("Got unexpected response id from adb: \"%s\"", response_id);
std::vector<char> error_message;
auto error = ReadMessage(error_message);
@@ -314,7 +315,7 @@ Error AdbClient::GetResponseError(const char *response_id) {
return error;
}
-Error AdbClient::SwitchDeviceTransport() {
+Status AdbClient::SwitchDeviceTransport() {
std::ostringstream msg;
msg << "host:transport:" << m_device_id;
@@ -325,19 +326,20 @@ Error AdbClient::SwitchDeviceTransport() {
return ReadResponseStatus();
}
-Error AdbClient::StartSync() {
+Status AdbClient::StartSync() {
auto error = SwitchDeviceTransport();
if (error.Fail())
- return Error("Failed to switch to device transport: %s", error.AsCString());
+ return Status("Failed to switch to device transport: %s",
+ error.AsCString());
error = Sync();
if (error.Fail())
- return Error("Sync failed: %s", error.AsCString());
+ return Status("Sync failed: %s", error.AsCString());
return error;
}
-Error AdbClient::Sync() {
+Status AdbClient::Sync() {
auto error = SendMessage("sync:", false);
if (error.Fail())
return error;
@@ -345,17 +347,18 @@ Error AdbClient::Sync() {
return ReadResponseStatus();
}
-Error AdbClient::ReadAllBytes(void *buffer, size_t size) {
+Status AdbClient::ReadAllBytes(void *buffer, size_t size) {
return ::ReadAllBytes(*m_conn, buffer, size);
}
-Error AdbClient::internalShell(const char *command, milliseconds timeout,
- std::vector<char> &output_buf) {
+Status AdbClient::internalShell(const char *command, milliseconds timeout,
+ std::vector<char> &output_buf) {
output_buf.clear();
auto error = SwitchDeviceTransport();
if (error.Fail())
- return Error("Failed to switch to device transport: %s", error.AsCString());
+ return Status("Failed to switch to device transport: %s",
+ error.AsCString());
StreamString adb_command;
adb_command.Printf("shell:%s", command);
@@ -376,15 +379,15 @@ Error AdbClient::internalShell(const char *command, milliseconds timeout,
static const char *kShellPrefix = "/system/bin/sh:";
if (output_buf.size() > strlen(kShellPrefix)) {
if (!memcmp(&output_buf[0], kShellPrefix, strlen(kShellPrefix)))
- return Error("Shell command %s failed: %s", command,
- std::string(output_buf.begin(), output_buf.end()).c_str());
+ return Status("Shell command %s failed: %s", command,
+ std::string(output_buf.begin(), output_buf.end()).c_str());
}
- return Error();
+ return Status();
}
-Error AdbClient::Shell(const char *command, milliseconds timeout,
- std::string *output) {
+Status AdbClient::Shell(const char *command, milliseconds timeout,
+ std::string *output) {
std::vector<char> output_buffer;
auto error = internalShell(command, timeout, output_buffer);
if (error.Fail())
@@ -395,8 +398,8 @@ Error AdbClient::Shell(const char *command, milliseconds timeout,
return error;
}
-Error AdbClient::ShellToFile(const char *command, milliseconds timeout,
- const FileSpec &output_file_spec) {
+Status AdbClient::ShellToFile(const char *command, milliseconds timeout,
+ const FileSpec &output_file_spec) {
std::vector<char> output_buffer;
auto error = internalShell(command, timeout, output_buffer);
if (error.Fail())
@@ -406,17 +409,17 @@ Error AdbClient::ShellToFile(const char *command, milliseconds timeout,
std::error_code EC;
llvm::raw_fd_ostream dst(output_filename, EC, llvm::sys::fs::F_None);
if (EC)
- return Error("Unable to open local file %s", output_filename.c_str());
+ return Status("Unable to open local file %s", output_filename.c_str());
dst.write(&output_buffer[0], output_buffer.size());
dst.close();
if (dst.has_error())
- return Error("Failed to write file %s", output_filename.c_str());
- return Error();
+ return Status("Failed to write file %s", output_filename.c_str());
+ return Status();
}
std::unique_ptr<AdbClient::SyncService>
-AdbClient::GetSyncService(Error &error) {
+AdbClient::GetSyncService(Status &error) {
std::unique_ptr<SyncService> sync_service;
error = StartSync();
if (error.Success())
@@ -425,15 +428,15 @@ AdbClient::GetSyncService(Error &error) {
return sync_service;
}
-Error AdbClient::SyncService::internalPullFile(const FileSpec &remote_file,
- const FileSpec &local_file) {
+Status AdbClient::SyncService::internalPullFile(const FileSpec &remote_file,
+ const FileSpec &local_file) {
const auto local_file_path = local_file.GetPath();
llvm::FileRemover local_file_remover(local_file_path);
std::error_code EC;
llvm::raw_fd_ostream dst(local_file_path, EC, llvm::sys::fs::F_None);
if (EC)
- return Error("Unable to open local file %s", local_file_path.c_str());
+ return Status("Unable to open local file %s", local_file_path.c_str());
const auto remote_file_path = remote_file.GetPath(false);
auto error = SendSyncRequest(kRECV, remote_file_path.length(),
@@ -452,18 +455,18 @@ Error AdbClient::SyncService::internalPullFile(const FileSpec &remote_file,
}
dst.close();
if (dst.has_error())
- return Error("Failed to write file %s", local_file_path.c_str());
+ return Status("Failed to write file %s", local_file_path.c_str());
local_file_remover.releaseFile();
return error;
}
-Error AdbClient::SyncService::internalPushFile(const FileSpec &local_file,
- const FileSpec &remote_file) {
+Status AdbClient::SyncService::internalPushFile(const FileSpec &local_file,
+ const FileSpec &remote_file) {
const auto local_file_path(local_file.GetPath());
std::ifstream src(local_file_path.c_str(), std::ios::in | std::ios::binary);
if (!src.is_open())
- return Error("Unable to open local file %s", local_file_path.c_str());
+ return Status("Unable to open local file %s", local_file_path.c_str());
std::stringstream file_description;
file_description << remote_file.GetPath(false).c_str() << "," << kDefaultMode;
@@ -478,7 +481,7 @@ Error AdbClient::SyncService::internalPushFile(const FileSpec &local_file,
size_t chunk_size = src.gcount();
error = SendSyncRequest(kDATA, chunk_size, chunk);
if (error.Fail())
- return Error("Failed to send file chunk: %s", error.AsCString());
+ return Status("Failed to send file chunk: %s", error.AsCString());
}
error = SendSyncRequest(
kDONE, llvm::sys::toTimeT(FileSystem::GetModificationTime(local_file)),
@@ -490,31 +493,31 @@ Error AdbClient::SyncService::internalPushFile(const FileSpec &local_file,
uint32_t data_len;
error = ReadSyncHeader(response_id, data_len);
if (error.Fail())
- return Error("Failed to read DONE response: %s", error.AsCString());
+ return Status("Failed to read DONE response: %s", error.AsCString());
if (response_id == kFAIL) {
std::string error_message(data_len, 0);
error = ReadAllBytes(&error_message[0], data_len);
if (error.Fail())
- return Error("Failed to read DONE error message: %s", error.AsCString());
- return Error("Failed to push file: %s", error_message.c_str());
+ return Status("Failed to read DONE error message: %s", error.AsCString());
+ return Status("Failed to push file: %s", error_message.c_str());
} else if (response_id != kOKAY)
- return Error("Got unexpected DONE response: %s", response_id.c_str());
+ return Status("Got unexpected DONE response: %s", response_id.c_str());
// If there was an error reading the source file, finish the adb file
// transfer first so that adb isn't expecting any more data.
if (src.bad())
- return Error("Failed read on %s", local_file_path.c_str());
+ return Status("Failed read on %s", local_file_path.c_str());
return error;
}
-Error AdbClient::SyncService::internalStat(const FileSpec &remote_file,
- uint32_t &mode, uint32_t &size,
- uint32_t &mtime) {
+Status AdbClient::SyncService::internalStat(const FileSpec &remote_file,
+ uint32_t &mode, uint32_t &size,
+ uint32_t &mtime) {
const std::string remote_file_path(remote_file.GetPath(false));
auto error = SendSyncRequest(kSTAT, remote_file_path.length(),
remote_file_path.c_str());
if (error.Fail())
- return Error("Failed to send request: %s", error.AsCString());
+ return Status("Failed to send request: %s", error.AsCString());
static const size_t stat_len = strlen(kSTAT);
static const size_t response_len = stat_len + (sizeof(uint32_t) * 3);
@@ -522,7 +525,7 @@ Error AdbClient::SyncService::internalStat(const FileSpec &remote_file,
std::vector<char> buffer(response_len);
error = ReadAllBytes(&buffer[0], buffer.size());
if (error.Fail())
- return Error("Failed to read response: %s", error.AsCString());
+ return Status("Failed to read response: %s", error.AsCString());
DataExtractor extractor(&buffer[0], buffer.size(), eByteOrderLittle,
sizeof(void *));
@@ -530,33 +533,33 @@ Error AdbClient::SyncService::internalStat(const FileSpec &remote_file,
const void *command = extractor.GetData(&offset, stat_len);
if (!command)
- return Error("Failed to get response command");
+ return Status("Failed to get response command");
const char *command_str = static_cast<const char *>(command);
if (strncmp(command_str, kSTAT, stat_len))
- return Error("Got invalid stat command: %s", command_str);
+ return Status("Got invalid stat command: %s", command_str);
mode = extractor.GetU32(&offset);
size = extractor.GetU32(&offset);
mtime = extractor.GetU32(&offset);
- return Error();
+ return Status();
}
-Error AdbClient::SyncService::PullFile(const FileSpec &remote_file,
- const FileSpec &local_file) {
+Status AdbClient::SyncService::PullFile(const FileSpec &remote_file,
+ const FileSpec &local_file) {
return executeCommand([this, &remote_file, &local_file]() {
return internalPullFile(remote_file, local_file);
});
}
-Error AdbClient::SyncService::PushFile(const FileSpec &local_file,
- const FileSpec &remote_file) {
+Status AdbClient::SyncService::PushFile(const FileSpec &local_file,
+ const FileSpec &remote_file) {
return executeCommand([this, &local_file, &remote_file]() {
return internalPushFile(local_file, remote_file);
});
}
-Error AdbClient::SyncService::Stat(const FileSpec &remote_file, uint32_t &mode,
- uint32_t &size, uint32_t &mtime) {
+Status AdbClient::SyncService::Stat(const FileSpec &remote_file, uint32_t &mode,
+ uint32_t &size, uint32_t &mtime) {
return executeCommand([this, &remote_file, &mode, &size, &mtime]() {
return internalStat(remote_file, mode, size, mtime);
});
@@ -569,10 +572,10 @@ bool AdbClient::SyncService::IsConnected() const {
AdbClient::SyncService::SyncService(std::unique_ptr<Connection> &&conn)
: m_conn(std::move(conn)) {}
-Error AdbClient::SyncService::executeCommand(
- const std::function<Error()> &cmd) {
+Status
+AdbClient::SyncService::executeCommand(const std::function<Status()> &cmd) {
if (!m_conn)
- return Error("SyncService is disconnected");
+ return Status("SyncService is disconnected");
const auto error = cmd();
if (error.Fail())
@@ -583,15 +586,15 @@ Error AdbClient::SyncService::executeCommand(
AdbClient::SyncService::~SyncService() {}
-Error AdbClient::SyncService::SendSyncRequest(const char *request_id,
- const uint32_t data_len,
- const void *data) {
+Status AdbClient::SyncService::SendSyncRequest(const char *request_id,
+ const uint32_t data_len,
+ const void *data) {
const DataBufferSP data_sp(new DataBufferHeap(kSyncPacketLen, 0));
DataEncoder encoder(data_sp, eByteOrderLittle, sizeof(void *));
auto offset = encoder.PutData(0, request_id, strlen(request_id));
encoder.PutU32(offset, data_len);
- Error error;
+ Status error;
ConnectionStatus status;
m_conn->Write(data_sp->GetBytes(), kSyncPacketLen, status, &error);
if (error.Fail())
@@ -602,8 +605,8 @@ Error AdbClient::SyncService::SendSyncRequest(const char *request_id,
return error;
}
-Error AdbClient::SyncService::ReadSyncHeader(std::string &response_id,
- uint32_t &data_len) {
+Status AdbClient::SyncService::ReadSyncHeader(std::string &response_id,
+ uint32_t &data_len) {
char buffer[kSyncPacketLen];
auto error = ReadAllBytes(buffer, kSyncPacketLen);
@@ -617,8 +620,8 @@ Error AdbClient::SyncService::ReadSyncHeader(std::string &response_id,
return error;
}
-Error AdbClient::SyncService::PullFileChunk(std::vector<char> &buffer,
- bool &eof) {
+Status AdbClient::SyncService::PullFileChunk(std::vector<char> &buffer,
+ bool &eof) {
buffer.clear();
std::string response_id;
@@ -638,14 +641,14 @@ Error AdbClient::SyncService::PullFileChunk(std::vector<char> &buffer,
std::string error_message(data_len, 0);
error = ReadAllBytes(&error_message[0], data_len);
if (error.Fail())
- return Error("Failed to read pull error message: %s", error.AsCString());
- return Error("Failed to pull file: %s", error_message.c_str());
+ return Status("Failed to read pull error message: %s", error.AsCString());
+ return Status("Failed to pull file: %s", error_message.c_str());
} else
- return Error("Pull failed with unknown response: %s", response_id.c_str());
+ return Status("Pull failed with unknown response: %s", response_id.c_str());
- return Error();
+ return Status();
}
-Error AdbClient::SyncService::ReadAllBytes(void *buffer, size_t size) {
+Status AdbClient::SyncService::ReadAllBytes(void *buffer, size_t size) {
return ::ReadAllBytes(*m_conn, buffer, size);
}