1 //===-- AdbClient.cpp -------------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 // Other libraries and framework includes 11 #include "AdbClient.h" 12 13 #include "llvm/ADT/STLExtras.h" 14 #include "llvm/ADT/SmallVector.h" 15 #include "llvm/ADT/StringRef.h" 16 #include "llvm/Support/FileUtilities.h" 17 18 #include "lldb/Core/DataBuffer.h" 19 #include "lldb/Core/DataBufferHeap.h" 20 #include "lldb/Core/DataEncoder.h" 21 #include "lldb/Core/DataExtractor.h" 22 #include "lldb/Core/StreamString.h" 23 #include "lldb/Host/ConnectionFileDescriptor.h" 24 #include "lldb/Host/FileSpec.h" 25 #include "lldb/Host/FileSystem.h" 26 #include "lldb/Host/PosixApi.h" 27 28 #include <limits.h> 29 30 #include <algorithm> 31 #include <cstdlib> 32 #include <fstream> 33 #include <sstream> 34 35 // On Windows, transitive dependencies pull in <Windows.h>, which defines a 36 // macro that clashes with a method name. 37 #ifdef SendMessage 38 #undef SendMessage 39 #endif 40 41 using namespace lldb; 42 using namespace lldb_private; 43 using namespace lldb_private::platform_android; 44 using namespace std::chrono; 45 46 namespace { 47 48 const seconds kReadTimeout(8); 49 const char *kOKAY = "OKAY"; 50 const char *kFAIL = "FAIL"; 51 const char *kDATA = "DATA"; 52 const char *kDONE = "DONE"; 53 54 const char *kSEND = "SEND"; 55 const char *kRECV = "RECV"; 56 const char *kSTAT = "STAT"; 57 58 const size_t kSyncPacketLen = 8; 59 // Maximum size of a filesync DATA packet. 60 const size_t kMaxPushData = 2 * 1024; 61 // Default mode for pushed files. 62 const uint32_t kDefaultMode = 0100770; // S_IFREG | S_IRWXU | S_IRWXG 63 64 const char *kSocketNamespaceAbstract = "localabstract"; 65 const char *kSocketNamespaceFileSystem = "localfilesystem"; 66 67 Error ReadAllBytes(Connection &conn, void *buffer, size_t size) { 68 69 Error error; 70 ConnectionStatus status; 71 char *read_buffer = static_cast<char *>(buffer); 72 73 auto now = steady_clock::now(); 74 const auto deadline = now + kReadTimeout; 75 size_t total_read_bytes = 0; 76 while (total_read_bytes < size && now < deadline) { 77 auto read_bytes = 78 conn.Read(read_buffer + total_read_bytes, size - total_read_bytes, 79 duration_cast<microseconds>(deadline - now), status, &error); 80 if (error.Fail()) 81 return error; 82 total_read_bytes += read_bytes; 83 if (status != eConnectionStatusSuccess) 84 break; 85 now = steady_clock::now(); 86 } 87 if (total_read_bytes < size) 88 error = Error( 89 "Unable to read requested number of bytes. Connection status: %d.", 90 status); 91 return error; 92 } 93 94 } // namespace 95 96 Error AdbClient::CreateByDeviceID(const std::string &device_id, 97 AdbClient &adb) { 98 DeviceIDList connect_devices; 99 auto error = adb.GetDevices(connect_devices); 100 if (error.Fail()) 101 return error; 102 103 std::string android_serial; 104 if (!device_id.empty()) 105 android_serial = device_id; 106 else if (const char *env_serial = std::getenv("ANDROID_SERIAL")) 107 android_serial = env_serial; 108 109 if (android_serial.empty()) { 110 if (connect_devices.size() != 1) 111 return Error("Expected a single connected device, got instead %zu - try " 112 "setting 'ANDROID_SERIAL'", 113 connect_devices.size()); 114 adb.SetDeviceID(connect_devices.front()); 115 } else { 116 auto find_it = std::find(connect_devices.begin(), connect_devices.end(), 117 android_serial); 118 if (find_it == connect_devices.end()) 119 return Error("Device \"%s\" not found", android_serial.c_str()); 120 121 adb.SetDeviceID(*find_it); 122 } 123 return error; 124 } 125 126 AdbClient::AdbClient() {} 127 128 AdbClient::AdbClient(const std::string &device_id) : m_device_id(device_id) {} 129 130 AdbClient::~AdbClient() {} 131 132 void AdbClient::SetDeviceID(const std::string &device_id) { 133 m_device_id = device_id; 134 } 135 136 const std::string &AdbClient::GetDeviceID() const { return m_device_id; } 137 138 Error AdbClient::Connect() { 139 Error error; 140 m_conn.reset(new ConnectionFileDescriptor); 141 m_conn->Connect("connect://localhost:5037", &error); 142 143 return error; 144 } 145 146 Error AdbClient::GetDevices(DeviceIDList &device_list) { 147 device_list.clear(); 148 149 auto error = SendMessage("host:devices"); 150 if (error.Fail()) 151 return error; 152 153 error = ReadResponseStatus(); 154 if (error.Fail()) 155 return error; 156 157 std::vector<char> in_buffer; 158 error = ReadMessage(in_buffer); 159 160 llvm::StringRef response(&in_buffer[0], in_buffer.size()); 161 llvm::SmallVector<llvm::StringRef, 4> devices; 162 response.split(devices, "\n", -1, false); 163 164 for (const auto device : devices) 165 device_list.push_back(device.split('\t').first); 166 167 // Force disconnect since ADB closes connection after host:devices 168 // response is sent. 169 m_conn.reset(); 170 return error; 171 } 172 173 Error AdbClient::SetPortForwarding(const uint16_t local_port, 174 const uint16_t remote_port) { 175 char message[48]; 176 snprintf(message, sizeof(message), "forward:tcp:%d;tcp:%d", local_port, 177 remote_port); 178 179 const auto error = SendDeviceMessage(message); 180 if (error.Fail()) 181 return error; 182 183 return ReadResponseStatus(); 184 } 185 186 Error AdbClient::SetPortForwarding(const uint16_t local_port, 187 llvm::StringRef remote_socket_name, 188 const UnixSocketNamespace socket_namespace) { 189 char message[PATH_MAX]; 190 const char *sock_namespace_str = 191 (socket_namespace == UnixSocketNamespaceAbstract) 192 ? kSocketNamespaceAbstract 193 : kSocketNamespaceFileSystem; 194 snprintf(message, sizeof(message), "forward:tcp:%d;%s:%s", local_port, 195 sock_namespace_str, remote_socket_name.str().c_str()); 196 197 const auto error = SendDeviceMessage(message); 198 if (error.Fail()) 199 return error; 200 201 return ReadResponseStatus(); 202 } 203 204 Error AdbClient::DeletePortForwarding(const uint16_t local_port) { 205 char message[32]; 206 snprintf(message, sizeof(message), "killforward:tcp:%d", local_port); 207 208 const auto error = SendDeviceMessage(message); 209 if (error.Fail()) 210 return error; 211 212 return ReadResponseStatus(); 213 } 214 215 Error AdbClient::SendMessage(const std::string &packet, const bool reconnect) { 216 Error error; 217 if (!m_conn || reconnect) { 218 error = Connect(); 219 if (error.Fail()) 220 return error; 221 } 222 223 char length_buffer[5]; 224 snprintf(length_buffer, sizeof(length_buffer), "%04x", 225 static_cast<int>(packet.size())); 226 227 ConnectionStatus status; 228 229 m_conn->Write(length_buffer, 4, status, &error); 230 if (error.Fail()) 231 return error; 232 233 m_conn->Write(packet.c_str(), packet.size(), status, &error); 234 return error; 235 } 236 237 Error AdbClient::SendDeviceMessage(const std::string &packet) { 238 std::ostringstream msg; 239 msg << "host-serial:" << m_device_id << ":" << packet; 240 return SendMessage(msg.str()); 241 } 242 243 Error AdbClient::ReadMessage(std::vector<char> &message) { 244 message.clear(); 245 246 char buffer[5]; 247 buffer[4] = 0; 248 249 auto error = ReadAllBytes(buffer, 4); 250 if (error.Fail()) 251 return error; 252 253 unsigned int packet_len = 0; 254 sscanf(buffer, "%x", &packet_len); 255 256 message.resize(packet_len, 0); 257 error = ReadAllBytes(&message[0], packet_len); 258 if (error.Fail()) 259 message.clear(); 260 261 return error; 262 } 263 264 Error AdbClient::ReadMessageStream(std::vector<char> &message, 265 milliseconds timeout) { 266 auto start = steady_clock::now(); 267 message.clear(); 268 269 Error error; 270 lldb::ConnectionStatus status = lldb::eConnectionStatusSuccess; 271 char buffer[1024]; 272 while (error.Success() && status == lldb::eConnectionStatusSuccess) { 273 auto end = steady_clock::now(); 274 auto elapsed = end - start; 275 if (elapsed >= timeout) 276 return Error("Timed out"); 277 278 size_t n = m_conn->Read(buffer, sizeof(buffer), 279 duration_cast<microseconds>(timeout - elapsed), 280 status, &error); 281 if (n > 0) 282 message.insert(message.end(), &buffer[0], &buffer[n]); 283 } 284 return error; 285 } 286 287 Error AdbClient::ReadResponseStatus() { 288 char response_id[5]; 289 290 static const size_t packet_len = 4; 291 response_id[packet_len] = 0; 292 293 auto error = ReadAllBytes(response_id, packet_len); 294 if (error.Fail()) 295 return error; 296 297 if (strncmp(response_id, kOKAY, packet_len) != 0) 298 return GetResponseError(response_id); 299 300 return error; 301 } 302 303 Error AdbClient::GetResponseError(const char *response_id) { 304 if (strcmp(response_id, kFAIL) != 0) 305 return Error("Got unexpected response id from adb: \"%s\"", response_id); 306 307 std::vector<char> error_message; 308 auto error = ReadMessage(error_message); 309 if (error.Success()) 310 error.SetErrorString( 311 std::string(&error_message[0], error_message.size()).c_str()); 312 313 return error; 314 } 315 316 Error AdbClient::SwitchDeviceTransport() { 317 std::ostringstream msg; 318 msg << "host:transport:" << m_device_id; 319 320 auto error = SendMessage(msg.str()); 321 if (error.Fail()) 322 return error; 323 324 return ReadResponseStatus(); 325 } 326 327 Error AdbClient::StartSync() { 328 auto error = SwitchDeviceTransport(); 329 if (error.Fail()) 330 return Error("Failed to switch to device transport: %s", error.AsCString()); 331 332 error = Sync(); 333 if (error.Fail()) 334 return Error("Sync failed: %s", error.AsCString()); 335 336 return error; 337 } 338 339 Error AdbClient::Sync() { 340 auto error = SendMessage("sync:", false); 341 if (error.Fail()) 342 return error; 343 344 return ReadResponseStatus(); 345 } 346 347 Error AdbClient::ReadAllBytes(void *buffer, size_t size) { 348 return ::ReadAllBytes(*m_conn, buffer, size); 349 } 350 351 Error AdbClient::internalShell(const char *command, milliseconds timeout, 352 std::vector<char> &output_buf) { 353 output_buf.clear(); 354 355 auto error = SwitchDeviceTransport(); 356 if (error.Fail()) 357 return Error("Failed to switch to device transport: %s", error.AsCString()); 358 359 StreamString adb_command; 360 adb_command.Printf("shell:%s", command); 361 error = SendMessage(adb_command.GetString(), false); 362 if (error.Fail()) 363 return error; 364 365 error = ReadResponseStatus(); 366 if (error.Fail()) 367 return error; 368 369 error = ReadMessageStream(output_buf, timeout); 370 if (error.Fail()) 371 return error; 372 373 // ADB doesn't propagate return code of shell execution - if 374 // output starts with /system/bin/sh: most likely command failed. 375 static const char *kShellPrefix = "/system/bin/sh:"; 376 if (output_buf.size() > strlen(kShellPrefix)) { 377 if (!memcmp(&output_buf[0], kShellPrefix, strlen(kShellPrefix))) 378 return Error("Shell command %s failed: %s", command, 379 std::string(output_buf.begin(), output_buf.end()).c_str()); 380 } 381 382 return Error(); 383 } 384 385 Error AdbClient::Shell(const char *command, milliseconds timeout, 386 std::string *output) { 387 std::vector<char> output_buffer; 388 auto error = internalShell(command, timeout, output_buffer); 389 if (error.Fail()) 390 return error; 391 392 if (output) 393 output->assign(output_buffer.begin(), output_buffer.end()); 394 return error; 395 } 396 397 Error AdbClient::ShellToFile(const char *command, milliseconds timeout, 398 const FileSpec &output_file_spec) { 399 std::vector<char> output_buffer; 400 auto error = internalShell(command, timeout, output_buffer); 401 if (error.Fail()) 402 return error; 403 404 const auto output_filename = output_file_spec.GetPath(); 405 std::ofstream dst(output_filename, std::ios::out | std::ios::binary); 406 if (!dst.is_open()) 407 return Error("Unable to open local file %s", output_filename.c_str()); 408 409 dst.write(&output_buffer[0], output_buffer.size()); 410 dst.close(); 411 if (!dst) 412 return Error("Failed to write file %s", output_filename.c_str()); 413 return Error(); 414 } 415 416 std::unique_ptr<AdbClient::SyncService> 417 AdbClient::GetSyncService(Error &error) { 418 std::unique_ptr<SyncService> sync_service; 419 error = StartSync(); 420 if (error.Success()) 421 sync_service.reset(new SyncService(std::move(m_conn))); 422 423 return sync_service; 424 } 425 426 Error AdbClient::SyncService::internalPullFile(const FileSpec &remote_file, 427 const FileSpec &local_file) { 428 const auto local_file_path = local_file.GetPath(); 429 llvm::FileRemover local_file_remover(local_file_path); 430 431 std::ofstream dst(local_file_path, std::ios::out | std::ios::binary); 432 if (!dst.is_open()) 433 return Error("Unable to open local file %s", local_file_path.c_str()); 434 435 const auto remote_file_path = remote_file.GetPath(false); 436 auto error = SendSyncRequest(kRECV, remote_file_path.length(), 437 remote_file_path.c_str()); 438 if (error.Fail()) 439 return error; 440 441 std::vector<char> chunk; 442 bool eof = false; 443 while (!eof) { 444 error = PullFileChunk(chunk, eof); 445 if (error.Fail()) 446 return error; 447 if (!eof) 448 dst.write(&chunk[0], chunk.size()); 449 } 450 451 local_file_remover.releaseFile(); 452 return error; 453 } 454 455 Error AdbClient::SyncService::internalPushFile(const FileSpec &local_file, 456 const FileSpec &remote_file) { 457 const auto local_file_path(local_file.GetPath()); 458 std::ifstream src(local_file_path.c_str(), std::ios::in | std::ios::binary); 459 if (!src.is_open()) 460 return Error("Unable to open local file %s", local_file_path.c_str()); 461 462 std::stringstream file_description; 463 file_description << remote_file.GetPath(false).c_str() << "," << kDefaultMode; 464 std::string file_description_str = file_description.str(); 465 auto error = SendSyncRequest(kSEND, file_description_str.length(), 466 file_description_str.c_str()); 467 if (error.Fail()) 468 return error; 469 470 char chunk[kMaxPushData]; 471 while (!src.eof() && !src.read(chunk, kMaxPushData).bad()) { 472 size_t chunk_size = src.gcount(); 473 error = SendSyncRequest(kDATA, chunk_size, chunk); 474 if (error.Fail()) 475 return Error("Failed to send file chunk: %s", error.AsCString()); 476 } 477 error = SendSyncRequest( 478 kDONE, llvm::sys::toTimeT(FileSystem::GetModificationTime(local_file)), 479 nullptr); 480 if (error.Fail()) 481 return error; 482 483 std::string response_id; 484 uint32_t data_len; 485 error = ReadSyncHeader(response_id, data_len); 486 if (error.Fail()) 487 return Error("Failed to read DONE response: %s", error.AsCString()); 488 if (response_id == kFAIL) { 489 std::string error_message(data_len, 0); 490 error = ReadAllBytes(&error_message[0], data_len); 491 if (error.Fail()) 492 return Error("Failed to read DONE error message: %s", error.AsCString()); 493 return Error("Failed to push file: %s", error_message.c_str()); 494 } else if (response_id != kOKAY) 495 return Error("Got unexpected DONE response: %s", response_id.c_str()); 496 497 // If there was an error reading the source file, finish the adb file 498 // transfer first so that adb isn't expecting any more data. 499 if (src.bad()) 500 return Error("Failed read on %s", local_file_path.c_str()); 501 return error; 502 } 503 504 Error AdbClient::SyncService::internalStat(const FileSpec &remote_file, 505 uint32_t &mode, uint32_t &size, 506 uint32_t &mtime) { 507 const std::string remote_file_path(remote_file.GetPath(false)); 508 auto error = SendSyncRequest(kSTAT, remote_file_path.length(), 509 remote_file_path.c_str()); 510 if (error.Fail()) 511 return Error("Failed to send request: %s", error.AsCString()); 512 513 static const size_t stat_len = strlen(kSTAT); 514 static const size_t response_len = stat_len + (sizeof(uint32_t) * 3); 515 516 std::vector<char> buffer(response_len); 517 error = ReadAllBytes(&buffer[0], buffer.size()); 518 if (error.Fail()) 519 return Error("Failed to read response: %s", error.AsCString()); 520 521 DataExtractor extractor(&buffer[0], buffer.size(), eByteOrderLittle, 522 sizeof(void *)); 523 offset_t offset = 0; 524 525 const void *command = extractor.GetData(&offset, stat_len); 526 if (!command) 527 return Error("Failed to get response command"); 528 const char *command_str = static_cast<const char *>(command); 529 if (strncmp(command_str, kSTAT, stat_len)) 530 return Error("Got invalid stat command: %s", command_str); 531 532 mode = extractor.GetU32(&offset); 533 size = extractor.GetU32(&offset); 534 mtime = extractor.GetU32(&offset); 535 return Error(); 536 } 537 538 Error AdbClient::SyncService::PullFile(const FileSpec &remote_file, 539 const FileSpec &local_file) { 540 return executeCommand([this, &remote_file, &local_file]() { 541 return internalPullFile(remote_file, local_file); 542 }); 543 } 544 545 Error AdbClient::SyncService::PushFile(const FileSpec &local_file, 546 const FileSpec &remote_file) { 547 return executeCommand([this, &local_file, &remote_file]() { 548 return internalPushFile(local_file, remote_file); 549 }); 550 } 551 552 Error AdbClient::SyncService::Stat(const FileSpec &remote_file, uint32_t &mode, 553 uint32_t &size, uint32_t &mtime) { 554 return executeCommand([this, &remote_file, &mode, &size, &mtime]() { 555 return internalStat(remote_file, mode, size, mtime); 556 }); 557 } 558 559 bool AdbClient::SyncService::IsConnected() const { 560 return m_conn && m_conn->IsConnected(); 561 } 562 563 AdbClient::SyncService::SyncService(std::unique_ptr<Connection> &&conn) 564 : m_conn(std::move(conn)) {} 565 566 Error AdbClient::SyncService::executeCommand( 567 const std::function<Error()> &cmd) { 568 if (!m_conn) 569 return Error("SyncService is disconnected"); 570 571 const auto error = cmd(); 572 if (error.Fail()) 573 m_conn.reset(); 574 575 return error; 576 } 577 578 AdbClient::SyncService::~SyncService() {} 579 580 Error AdbClient::SyncService::SendSyncRequest(const char *request_id, 581 const uint32_t data_len, 582 const void *data) { 583 const DataBufferSP data_sp(new DataBufferHeap(kSyncPacketLen, 0)); 584 DataEncoder encoder(data_sp, eByteOrderLittle, sizeof(void *)); 585 auto offset = encoder.PutData(0, request_id, strlen(request_id)); 586 encoder.PutU32(offset, data_len); 587 588 Error error; 589 ConnectionStatus status; 590 m_conn->Write(data_sp->GetBytes(), kSyncPacketLen, status, &error); 591 if (error.Fail()) 592 return error; 593 594 if (data) 595 m_conn->Write(data, data_len, status, &error); 596 return error; 597 } 598 599 Error AdbClient::SyncService::ReadSyncHeader(std::string &response_id, 600 uint32_t &data_len) { 601 char buffer[kSyncPacketLen]; 602 603 auto error = ReadAllBytes(buffer, kSyncPacketLen); 604 if (error.Success()) { 605 response_id.assign(&buffer[0], 4); 606 DataExtractor extractor(&buffer[4], 4, eByteOrderLittle, sizeof(void *)); 607 offset_t offset = 0; 608 data_len = extractor.GetU32(&offset); 609 } 610 611 return error; 612 } 613 614 Error AdbClient::SyncService::PullFileChunk(std::vector<char> &buffer, 615 bool &eof) { 616 buffer.clear(); 617 618 std::string response_id; 619 uint32_t data_len; 620 auto error = ReadSyncHeader(response_id, data_len); 621 if (error.Fail()) 622 return error; 623 624 if (response_id == kDATA) { 625 buffer.resize(data_len, 0); 626 error = ReadAllBytes(&buffer[0], data_len); 627 if (error.Fail()) 628 buffer.clear(); 629 } else if (response_id == kDONE) { 630 eof = true; 631 } else if (response_id == kFAIL) { 632 std::string error_message(data_len, 0); 633 error = ReadAllBytes(&error_message[0], data_len); 634 if (error.Fail()) 635 return Error("Failed to read pull error message: %s", error.AsCString()); 636 return Error("Failed to pull file: %s", error_message.c_str()); 637 } else 638 return Error("Pull failed with unknown response: %s", response_id.c_str()); 639 640 return Error(); 641 } 642 643 Error AdbClient::SyncService::ReadAllBytes(void *buffer, size_t size) { 644 return ::ReadAllBytes(*m_conn, buffer, size); 645 } 646