commandline.cpp revision 4e2fd36bc8c16147cab323b0418a7666812d3bc7
1/* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#define TRACE_TAG TRACE_ADB 18 19#include "sysdeps.h" 20 21#include <assert.h> 22#include <ctype.h> 23#include <errno.h> 24#include <inttypes.h> 25#include <limits.h> 26#include <stdarg.h> 27#include <stdint.h> 28#include <stdio.h> 29#include <stdlib.h> 30#include <string.h> 31#include <sys/stat.h> 32#include <sys/types.h> 33 34#include <memory> 35#include <string> 36 37#include <base/logging.h> 38#include <base/stringprintf.h> 39#include <base/strings.h> 40 41#if !defined(_WIN32) 42#include <termios.h> 43#include <unistd.h> 44#endif 45 46#include "adb.h" 47#include "adb_auth.h" 48#include "adb_client.h" 49#include "adb_io.h" 50#include "adb_utils.h" 51#include "file_sync_service.h" 52#include "shell_service.h" 53#include "transport.h" 54 55static int install_app(TransportType t, const char* serial, int argc, const char** argv); 56static int install_multiple_app(TransportType t, const char* serial, int argc, const char** argv); 57static int uninstall_app(TransportType t, const char* serial, int argc, const char** argv); 58 59static std::string gProductOutPath; 60extern int gListenAll; 61 62static std::string product_file(const char *extra) { 63 if (gProductOutPath.empty()) { 64 fprintf(stderr, "adb: Product directory not specified; " 65 "use -p or define ANDROID_PRODUCT_OUT\n"); 66 exit(1); 67 } 68 69 return android::base::StringPrintf("%s%s%s", 70 gProductOutPath.c_str(), OS_PATH_SEPARATOR_STR, extra); 71} 72 73static void help() { 74 fprintf(stderr, "%s\n", adb_version().c_str()); 75 fprintf(stderr, 76 " -a - directs adb to listen on all interfaces for a connection\n" 77 " -d - directs command to the only connected USB device\n" 78 " returns an error if more than one USB device is present.\n" 79 " -e - directs command to the only running emulator.\n" 80 " returns an error if more than one emulator is running.\n" 81 " -s <specific device> - directs command to the device or emulator with the given\n" 82 " serial number or qualifier. Overrides ANDROID_SERIAL\n" 83 " environment variable.\n" 84 " -p <product name or path> - simple product name like 'sooner', or\n" 85 " a relative/absolute path to a product\n" 86 " out directory like 'out/target/product/sooner'.\n" 87 " If -p is not specified, the ANDROID_PRODUCT_OUT\n" 88 " environment variable is used, which must\n" 89 " be an absolute path.\n" 90 " -H - Name of adb server host (default: localhost)\n" 91 " -P - Port of adb server (default: 5037)\n" 92 " devices [-l] - list all connected devices\n" 93 " ('-l' will also list device qualifiers)\n" 94 " connect <host>[:<port>] - connect to a device via TCP/IP\n" 95 " Port 5555 is used by default if no port number is specified.\n" 96 " disconnect [<host>[:<port>]] - disconnect from a TCP/IP device.\n" 97 " Port 5555 is used by default if no port number is specified.\n" 98 " Using this command with no additional arguments\n" 99 " will disconnect from all connected TCP/IP devices.\n" 100 "\n" 101 "device commands:\n" 102 " adb push [-p] <local> <remote>\n" 103 " - copy file/dir to device\n" 104 " ('-p' to display the transfer progress)\n" 105 " adb pull [-p] [-a] <remote> [<local>]\n" 106 " - copy file/dir from device\n" 107 " ('-p' to display the transfer progress)\n" 108 " ('-a' means copy timestamp and mode)\n" 109 " adb sync [ <directory> ] - copy host->device only if changed\n" 110 " (-l means list but don't copy)\n" 111 " adb shell - run remote shell interactively\n" 112 " adb shell [-Tt] <command> - run remote shell command\n" 113 " (-T disables PTY allocation)\n" 114 " (-t forces PTY allocation)\n" 115 " adb emu <command> - run emulator console command\n" 116 " adb logcat [ <filter-spec> ] - View device log\n" 117 " adb forward --list - list all forward socket connections.\n" 118 " the format is a list of lines with the following format:\n" 119 " <serial> \" \" <local> \" \" <remote> \"\\n\"\n" 120 " adb forward <local> <remote> - forward socket connections\n" 121 " forward specs are one of: \n" 122 " tcp:<port>\n" 123 " localabstract:<unix domain socket name>\n" 124 " localreserved:<unix domain socket name>\n" 125 " localfilesystem:<unix domain socket name>\n" 126 " dev:<character device name>\n" 127 " jdwp:<process pid> (remote only)\n" 128 " adb forward --no-rebind <local> <remote>\n" 129 " - same as 'adb forward <local> <remote>' but fails\n" 130 " if <local> is already forwarded\n" 131 " adb forward --remove <local> - remove a specific forward socket connection\n" 132 " adb forward --remove-all - remove all forward socket connections\n" 133 " adb reverse --list - list all reverse socket connections from device\n" 134 " adb reverse <remote> <local> - reverse socket connections\n" 135 " reverse specs are one of:\n" 136 " tcp:<port>\n" 137 " localabstract:<unix domain socket name>\n" 138 " localreserved:<unix domain socket name>\n" 139 " localfilesystem:<unix domain socket name>\n" 140 " adb reverse --norebind <remote> <local>\n" 141 " - same as 'adb reverse <remote> <local>' but fails\n" 142 " if <remote> is already reversed.\n" 143 " adb reverse --remove <remote>\n" 144 " - remove a specific reversed socket connection\n" 145 " adb reverse --remove-all - remove all reversed socket connections from device\n" 146 " adb jdwp - list PIDs of processes hosting a JDWP transport\n" 147 " adb install [-lrtsd] <file>\n" 148 " adb install-multiple [-lrtsdp] <file...>\n" 149 " - push this package file to the device and install it\n" 150 " (-l: forward lock application)\n" 151 " (-r: replace existing application)\n" 152 " (-t: allow test packages)\n" 153 " (-s: install application on sdcard)\n" 154 " (-d: allow version code downgrade)\n" 155 " (-p: partial application install)\n" 156 " adb uninstall [-k] <package> - remove this app package from the device\n" 157 " ('-k' means keep the data and cache directories)\n" 158 " adb bugreport - return all information from the device\n" 159 " that should be included in a bug report.\n" 160 "\n" 161 " adb backup [-f <file>] [-apk|-noapk] [-obb|-noobb] [-shared|-noshared] [-all] [-system|-nosystem] [<packages...>]\n" 162 " - write an archive of the device's data to <file>.\n" 163 " If no -f option is supplied then the data is written\n" 164 " to \"backup.ab\" in the current directory.\n" 165 " (-apk|-noapk enable/disable backup of the .apks themselves\n" 166 " in the archive; the default is noapk.)\n" 167 " (-obb|-noobb enable/disable backup of any installed apk expansion\n" 168 " (aka .obb) files associated with each application; the default\n" 169 " is noobb.)\n" 170 " (-shared|-noshared enable/disable backup of the device's\n" 171 " shared storage / SD card contents; the default is noshared.)\n" 172 " (-all means to back up all installed applications)\n" 173 " (-system|-nosystem toggles whether -all automatically includes\n" 174 " system applications; the default is to include system apps)\n" 175 " (<packages...> is the list of applications to be backed up. If\n" 176 " the -all or -shared flags are passed, then the package\n" 177 " list is optional. Applications explicitly given on the\n" 178 " command line will be included even if -nosystem would\n" 179 " ordinarily cause them to be omitted.)\n" 180 "\n" 181 " adb restore <file> - restore device contents from the <file> backup archive\n" 182 "\n" 183 " adb disable-verity - disable dm-verity checking on USERDEBUG builds\n" 184 " adb enable-verity - re-enable dm-verity checking on USERDEBUG builds\n" 185 " adb keygen <file> - generate adb public/private key. The private key is stored in <file>,\n" 186 " and the public key is stored in <file>.pub. Any existing files\n" 187 " are overwritten.\n" 188 " adb help - show this help message\n" 189 " adb version - show version num\n" 190 "\n" 191 "scripting:\n" 192 " adb wait-for-device - block until device is online\n" 193 " adb start-server - ensure that there is a server running\n" 194 " adb kill-server - kill the server if it is running\n" 195 " adb get-state - prints: offline | bootloader | device\n" 196 " adb get-serialno - prints: <serial-number>\n" 197 " adb get-devpath - prints: <device-path>\n" 198 " adb remount - remounts the /system, /vendor (if present) and /oem (if present) partitions on the device read-write\n" 199 " adb reboot [bootloader|recovery]\n" 200 " - reboots the device, optionally into the bootloader or recovery program.\n" 201 " adb reboot sideload - reboots the device into the sideload mode in recovery program (adb root required).\n" 202 " adb reboot sideload-auto-reboot\n" 203 " - reboots into the sideload mode, then reboots automatically after the sideload regardless of the result.\n" 204 " adb sideload <file> - sideloads the given package\n" 205 " adb root - restarts the adbd daemon with root permissions\n" 206 " adb unroot - restarts the adbd daemon without root permissions\n" 207 " adb usb - restarts the adbd daemon listening on USB\n" 208 " adb tcpip <port> - restarts the adbd daemon listening on TCP on the specified port\n" 209 "\n" 210 "networking:\n" 211 " adb ppp <tty> [parameters] - Run PPP over USB.\n" 212 " Note: you should not automatically start a PPP connection.\n" 213 " <tty> refers to the tty for PPP stream. Eg. dev:/dev/omap_csmi_tty1\n" 214 " [parameters] - Eg. defaultroute debug dump local notty usepeerdns\n" 215 "\n" 216 "adb sync notes: adb sync [ <directory> ]\n" 217 " <localdir> can be interpreted in several ways:\n" 218 "\n" 219 " - If <directory> is not specified, /system, /vendor (if present), /oem (if present) and /data partitions will be updated.\n" 220 "\n" 221 " - If it is \"system\", \"vendor\", \"oem\" or \"data\", only the corresponding partition\n" 222 " is updated.\n" 223 "\n" 224 "environment variables:\n" 225 " ADB_TRACE - Print debug information. A comma separated list of the following values\n" 226 " 1 or all, adb, sockets, packets, rwx, usb, sync, sysdeps, transport, jdwp\n" 227 " ANDROID_SERIAL - The serial number to connect to. -s takes priority over this if given.\n" 228 " ANDROID_LOG_TAGS - When used with the logcat option, only these debug tags are printed.\n" 229 ); 230} 231 232static int usage() { 233 help(); 234 return 1; 235} 236 237#if defined(_WIN32) 238 239// Implemented in sysdeps_win32.cpp. 240void stdin_raw_init(int fd); 241void stdin_raw_restore(int fd); 242 243#else 244static termios g_saved_terminal_state; 245 246static void stdin_raw_init(int fd) { 247 if (tcgetattr(fd, &g_saved_terminal_state)) return; 248 249 termios tio; 250 if (tcgetattr(fd, &tio)) return; 251 252 cfmakeraw(&tio); 253 254 // No timeout but request at least one character per read. 255 tio.c_cc[VTIME] = 0; 256 tio.c_cc[VMIN] = 1; 257 258 tcsetattr(fd, TCSAFLUSH, &tio); 259} 260 261static void stdin_raw_restore(int fd) { 262 tcsetattr(fd, TCSAFLUSH, &g_saved_terminal_state); 263} 264#endif 265 266// Reads from |fd| and prints received data. If |use_shell_protocol| is true 267// this expects that incoming data will use the shell protocol, in which case 268// stdout/stderr are routed independently and the remote exit code will be 269// returned. 270static int read_and_dump(int fd, bool use_shell_protocol=false) { 271 int exit_code = 0; 272 std::unique_ptr<ShellProtocol> protocol; 273 int length = 0; 274 FILE* outfile = stdout; 275 276 char raw_buffer[BUFSIZ]; 277 char* buffer_ptr = raw_buffer; 278 if (use_shell_protocol) { 279 protocol.reset(new ShellProtocol(fd)); 280 if (!protocol) { 281 LOG(ERROR) << "failed to allocate memory for ShellProtocol object"; 282 return 1; 283 } 284 buffer_ptr = protocol->data(); 285 } 286 287 while (fd >= 0) { 288 if (use_shell_protocol) { 289 if (!protocol->Read()) { 290 break; 291 } 292 switch (protocol->id()) { 293 case ShellProtocol::kIdStdout: 294 outfile = stdout; 295 break; 296 case ShellProtocol::kIdStderr: 297 outfile = stderr; 298 break; 299 case ShellProtocol::kIdExit: 300 exit_code = protocol->data()[0]; 301 continue; 302 default: 303 continue; 304 } 305 length = protocol->data_length(); 306 } else { 307 D("read_and_dump(): pre adb_read(fd=%d)", fd); 308 length = adb_read(fd, raw_buffer, sizeof(raw_buffer)); 309 D("read_and_dump(): post adb_read(fd=%d): length=%d", fd, length); 310 if (length <= 0) { 311 break; 312 } 313 } 314 315 fwrite(buffer_ptr, 1, length, outfile); 316 fflush(outfile); 317 } 318 319 return exit_code; 320} 321 322static void read_status_line(int fd, char* buf, size_t count) 323{ 324 count--; 325 while (count > 0) { 326 int len = adb_read(fd, buf, count); 327 if (len <= 0) { 328 break; 329 } 330 331 buf += len; 332 count -= len; 333 } 334 *buf = '\0'; 335} 336 337static void copy_to_file(int inFd, int outFd) { 338 const size_t BUFSIZE = 32 * 1024; 339 char* buf = (char*) malloc(BUFSIZE); 340 if (buf == nullptr) fatal("couldn't allocate buffer for copy_to_file"); 341 int len; 342 long total = 0; 343#ifdef _WIN32 344 int old_stdin_mode = -1; 345 int old_stdout_mode = -1; 346#endif 347 348 D("copy_to_file(%d -> %d)", inFd, outFd); 349 350 if (inFd == STDIN_FILENO) { 351 stdin_raw_init(STDIN_FILENO); 352#ifdef _WIN32 353 old_stdin_mode = _setmode(STDIN_FILENO, _O_BINARY); 354 if (old_stdin_mode == -1) { 355 fatal_errno("could not set stdin to binary"); 356 } 357#endif 358 } 359 360#ifdef _WIN32 361 if (outFd == STDOUT_FILENO) { 362 old_stdout_mode = _setmode(STDOUT_FILENO, _O_BINARY); 363 if (old_stdout_mode == -1) { 364 fatal_errno("could not set stdout to binary"); 365 } 366 } 367#endif 368 369 while (true) { 370 if (inFd == STDIN_FILENO) { 371 len = unix_read(inFd, buf, BUFSIZE); 372 } else { 373 len = adb_read(inFd, buf, BUFSIZE); 374 } 375 if (len == 0) { 376 D("copy_to_file() : read 0 bytes; exiting"); 377 break; 378 } 379 if (len < 0) { 380 D("copy_to_file(): read failed: %s", strerror(errno)); 381 break; 382 } 383 if (outFd == STDOUT_FILENO) { 384 fwrite(buf, 1, len, stdout); 385 fflush(stdout); 386 } else { 387 adb_write(outFd, buf, len); 388 } 389 total += len; 390 } 391 392 if (inFd == STDIN_FILENO) { 393 stdin_raw_restore(STDIN_FILENO); 394#ifdef _WIN32 395 if (_setmode(STDIN_FILENO, old_stdin_mode) == -1) { 396 fatal_errno("could not restore stdin mode"); 397 } 398#endif 399 } 400 401#ifdef _WIN32 402 if (outFd == STDOUT_FILENO) { 403 if (_setmode(STDOUT_FILENO, old_stdout_mode) == -1) { 404 fatal_errno("could not restore stdout mode"); 405 } 406 } 407#endif 408 409 D("copy_to_file() finished after %lu bytes", total); 410 free(buf); 411} 412 413namespace { 414 415// Used to pass multiple values to the stdin read thread. 416struct StdinReadArgs { 417 int stdin_fd, write_fd; 418 std::unique_ptr<ShellProtocol> protocol; 419}; 420 421} // namespace 422 423// Loops to read from stdin and push the data to the given FD. 424// The argument should be a pointer to a StdinReadArgs object. This function 425// will take ownership of the object and delete it when finished. 426static void* stdin_read_thread(void* x) { 427 std::unique_ptr<StdinReadArgs> args(reinterpret_cast<StdinReadArgs*>(x)); 428 int state = 0; 429 430 adb_thread_setname("stdin reader"); 431 432 char raw_buffer[1024]; 433 char* buffer_ptr = raw_buffer; 434 size_t buffer_size = sizeof(raw_buffer); 435 if (args->protocol) { 436 buffer_ptr = args->protocol->data(); 437 buffer_size = args->protocol->data_capacity(); 438 } 439 440 while (true) { 441 // Use unix_read() rather than adb_read() for stdin. 442 D("stdin_read_thread(): pre unix_read(fdi=%d,...)", args->stdin_fd); 443 int r = unix_read(args->stdin_fd, buffer_ptr, buffer_size); 444 D("stdin_read_thread(): post unix_read(fdi=%d,...)", args->stdin_fd); 445 if (r <= 0) break; 446 for (int n = 0; n < r; n++){ 447 switch(buffer_ptr[n]) { 448 case '\n': 449 state = 1; 450 break; 451 case '\r': 452 state = 1; 453 break; 454 case '~': 455 if(state == 1) state++; 456 break; 457 case '.': 458 if(state == 2) { 459 fprintf(stderr,"\n* disconnect *\n"); 460 stdin_raw_restore(args->stdin_fd); 461 exit(0); 462 } 463 default: 464 state = 0; 465 } 466 } 467 if (args->protocol) { 468 if (!args->protocol->Write(ShellProtocol::kIdStdin, r)) { 469 break; 470 } 471 } else { 472 if (!WriteFdExactly(args->write_fd, buffer_ptr, r)) { 473 break; 474 } 475 } 476 } 477 478 return nullptr; 479} 480 481static int interactive_shell(const std::string& service_string, 482 bool use_shell_protocol) { 483 std::string error; 484 int fd = adb_connect(service_string, &error); 485 if (fd < 0) { 486 fprintf(stderr,"error: %s\n", error.c_str()); 487 return 1; 488 } 489 490 StdinReadArgs* args = new StdinReadArgs; 491 if (!args) { 492 LOG(ERROR) << "couldn't allocate StdinReadArgs object"; 493 return 1; 494 } 495 args->stdin_fd = 0; 496 args->write_fd = fd; 497 if (use_shell_protocol) { 498 args->protocol.reset(new ShellProtocol(args->write_fd)); 499 } 500 501 stdin_raw_init(args->stdin_fd); 502 503 int exit_code = 0; 504 if (!adb_thread_create(stdin_read_thread, args)) { 505 PLOG(ERROR) << "error starting stdin read thread"; 506 exit_code = 1; 507 delete args; 508 } else { 509 exit_code = read_and_dump(fd, use_shell_protocol); 510 } 511 512 stdin_raw_restore(args->stdin_fd); 513 return exit_code; 514} 515 516 517static std::string format_host_command(const char* command, TransportType type, const char* serial) { 518 if (serial) { 519 return android::base::StringPrintf("host-serial:%s:%s", serial, command); 520 } 521 522 const char* prefix = "host"; 523 if (type == kTransportUsb) { 524 prefix = "host-usb"; 525 } else if (type == kTransportLocal) { 526 prefix = "host-local"; 527 } 528 return android::base::StringPrintf("%s:%s", prefix, command); 529} 530 531// Returns the FeatureSet for the indicated transport. 532static FeatureSet GetFeatureSet(TransportType transport_type, 533 const char* serial) { 534 std::string result, error; 535 536 if (adb_query(format_host_command("features", transport_type, serial), 537 &result, &error)) { 538 return StringToFeatureSet(result); 539 } 540 return FeatureSet(); 541} 542 543static int adb_download_buffer(const char *service, const char *fn, const void* data, unsigned sz, 544 bool show_progress) 545{ 546 std::string error; 547 int fd = adb_connect(android::base::StringPrintf("%s:%d", service, sz), &error); 548 if (fd < 0) { 549 fprintf(stderr,"error: %s\n", error.c_str()); 550 return -1; 551 } 552 553 int opt = CHUNK_SIZE; 554 opt = adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt)); 555 556 unsigned total = sz; 557 const uint8_t* ptr = reinterpret_cast<const uint8_t*>(data); 558 559 if (show_progress) { 560 const char* x = strrchr(service, ':'); 561 if (x) service = x + 1; 562 } 563 564 while (sz > 0) { 565 unsigned xfer = (sz > CHUNK_SIZE) ? CHUNK_SIZE : sz; 566 if (!WriteFdExactly(fd, ptr, xfer)) { 567 std::string error; 568 adb_status(fd, &error); 569 fprintf(stderr,"* failed to write data '%s' *\n", error.c_str()); 570 return -1; 571 } 572 sz -= xfer; 573 ptr += xfer; 574 if (show_progress) { 575 printf("sending: '%s' %4d%% \r", fn, (int)(100LL - ((100LL * sz) / (total)))); 576 fflush(stdout); 577 } 578 } 579 if (show_progress) { 580 printf("\n"); 581 } 582 583 if (!adb_status(fd, &error)) { 584 fprintf(stderr,"* error response '%s' *\n", error.c_str()); 585 return -1; 586 } 587 588 adb_close(fd); 589 return 0; 590} 591 592#define SIDELOAD_HOST_BLOCK_SIZE (CHUNK_SIZE) 593 594/* 595 * The sideload-host protocol serves the data in a file (given on the 596 * command line) to the client, using a simple protocol: 597 * 598 * - The connect message includes the total number of bytes in the 599 * file and a block size chosen by us. 600 * 601 * - The other side sends the desired block number as eight decimal 602 * digits (eg "00000023" for block 23). Blocks are numbered from 603 * zero. 604 * 605 * - We send back the data of the requested block. The last block is 606 * likely to be partial; when the last block is requested we only 607 * send the part of the block that exists, it's not padded up to the 608 * block size. 609 * 610 * - When the other side sends "DONEDONE" instead of a block number, 611 * we hang up. 612 */ 613static int adb_sideload_host(const char* fn) { 614 unsigned sz; 615 size_t xfer = 0; 616 int status; 617 int last_percent = -1; 618 int opt = SIDELOAD_HOST_BLOCK_SIZE; 619 620 printf("loading: '%s'", fn); 621 fflush(stdout); 622 uint8_t* data = reinterpret_cast<uint8_t*>(load_file(fn, &sz)); 623 if (data == 0) { 624 printf("\n"); 625 fprintf(stderr, "* cannot read '%s' *\n", fn); 626 return -1; 627 } 628 629 std::string service = 630 android::base::StringPrintf("sideload-host:%d:%d", sz, SIDELOAD_HOST_BLOCK_SIZE); 631 std::string error; 632 int fd = adb_connect(service, &error); 633 if (fd < 0) { 634 // Try falling back to the older sideload method. Maybe this 635 // is an older device that doesn't support sideload-host. 636 printf("\n"); 637 status = adb_download_buffer("sideload", fn, data, sz, true); 638 goto done; 639 } 640 641 opt = adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt)); 642 643 while (true) { 644 char buf[9]; 645 if (!ReadFdExactly(fd, buf, 8)) { 646 fprintf(stderr, "* failed to read command: %s\n", strerror(errno)); 647 status = -1; 648 goto done; 649 } 650 buf[8] = '\0'; 651 652 if (strcmp("DONEDONE", buf) == 0) { 653 status = 0; 654 break; 655 } 656 657 int block = strtol(buf, NULL, 10); 658 659 size_t offset = block * SIDELOAD_HOST_BLOCK_SIZE; 660 if (offset >= sz) { 661 fprintf(stderr, "* attempt to read block %d past end\n", block); 662 status = -1; 663 goto done; 664 } 665 uint8_t* start = data + offset; 666 size_t offset_end = offset + SIDELOAD_HOST_BLOCK_SIZE; 667 size_t to_write = SIDELOAD_HOST_BLOCK_SIZE; 668 if (offset_end > sz) { 669 to_write = sz - offset; 670 } 671 672 if(!WriteFdExactly(fd, start, to_write)) { 673 adb_status(fd, &error); 674 fprintf(stderr,"* failed to write data '%s' *\n", error.c_str()); 675 status = -1; 676 goto done; 677 } 678 xfer += to_write; 679 680 // For normal OTA packages, we expect to transfer every byte 681 // twice, plus a bit of overhead (one read during 682 // verification, one read of each byte for installation, plus 683 // extra access to things like the zip central directory). 684 // This estimate of the completion becomes 100% when we've 685 // transferred ~2.13 (=100/47) times the package size. 686 int percent = (int)(xfer * 47LL / (sz ? sz : 1)); 687 if (percent != last_percent) { 688 printf("\rserving: '%s' (~%d%%) ", fn, percent); 689 fflush(stdout); 690 last_percent = percent; 691 } 692 } 693 694 printf("\rTotal xfer: %.2fx%*s\n", (double)xfer / (sz ? sz : 1), (int)strlen(fn)+10, ""); 695 696 done: 697 if (fd >= 0) adb_close(fd); 698 free(data); 699 return status; 700} 701 702/** 703 * Run ppp in "notty" mode against a resource listed as the first parameter 704 * eg: 705 * 706 * ppp dev:/dev/omap_csmi_tty0 <ppp options> 707 * 708 */ 709static int ppp(int argc, const char** argv) { 710#if defined(_WIN32) 711 fprintf(stderr, "error: adb %s not implemented on Win32\n", argv[0]); 712 return -1; 713#else 714 if (argc < 2) { 715 fprintf(stderr, "usage: adb %s <adb service name> [ppp opts]\n", 716 argv[0]); 717 718 return 1; 719 } 720 721 const char* adb_service_name = argv[1]; 722 std::string error; 723 int fd = adb_connect(adb_service_name, &error); 724 if (fd < 0) { 725 fprintf(stderr,"Error: Could not open adb service: %s. Error: %s\n", 726 adb_service_name, error.c_str()); 727 return 1; 728 } 729 730 pid_t pid = fork(); 731 732 if (pid < 0) { 733 perror("from fork()"); 734 return 1; 735 } else if (pid == 0) { 736 int err; 737 int i; 738 const char **ppp_args; 739 740 // copy args 741 ppp_args = (const char **) alloca(sizeof(char *) * argc + 1); 742 ppp_args[0] = "pppd"; 743 for (i = 2 ; i < argc ; i++) { 744 //argv[2] and beyond become ppp_args[1] and beyond 745 ppp_args[i - 1] = argv[i]; 746 } 747 ppp_args[i-1] = NULL; 748 749 // child side 750 751 dup2(fd, STDIN_FILENO); 752 dup2(fd, STDOUT_FILENO); 753 adb_close(STDERR_FILENO); 754 adb_close(fd); 755 756 err = execvp("pppd", (char * const *)ppp_args); 757 758 if (err < 0) { 759 perror("execing pppd"); 760 } 761 exit(-1); 762 } else { 763 // parent side 764 765 adb_close(fd); 766 return 0; 767 } 768#endif /* !defined(_WIN32) */ 769} 770 771static bool wait_for_device(const char* service, TransportType t, const char* serial) { 772 // Was the caller vague about what they'd like us to wait for? 773 // If so, check they weren't more specific in their choice of transport type. 774 if (strcmp(service, "wait-for-device") == 0) { 775 if (t == kTransportUsb) { 776 service = "wait-for-usb"; 777 } else if (t == kTransportLocal) { 778 service = "wait-for-local"; 779 } else { 780 service = "wait-for-any"; 781 } 782 } 783 784 std::string cmd = format_host_command(service, t, serial); 785 return adb_command(cmd); 786} 787 788static int send_shell_command(TransportType transport_type, const char* serial, 789 const std::string& command) { 790 int fd; 791 while (true) { 792 std::string error; 793 fd = adb_connect(command, &error); 794 if (fd >= 0) { 795 break; 796 } 797 fprintf(stderr,"- waiting for device -\n"); 798 adb_sleep_ms(1000); 799 wait_for_device("wait-for-device", transport_type, serial); 800 } 801 802 FeatureSet features = GetFeatureSet(transport_type, serial); 803 int exit_code = read_and_dump(fd, features.count(kFeatureShell2) > 0); 804 805 if (adb_close(fd) < 0) { 806 PLOG(ERROR) << "failure closing FD " << fd; 807 } 808 809 return exit_code; 810} 811 812static int logcat(TransportType transport, const char* serial, int argc, const char** argv) { 813 char* log_tags = getenv("ANDROID_LOG_TAGS"); 814 std::string quoted = escape_arg(log_tags == nullptr ? "" : log_tags); 815 816 std::string cmd = "shell:export ANDROID_LOG_TAGS=\"" + quoted + "\"; exec logcat"; 817 818 if (!strcmp(argv[0], "longcat")) { 819 cmd += " -v long"; 820 } 821 822 --argc; 823 ++argv; 824 while (argc-- > 0) { 825 cmd += " " + escape_arg(*argv++); 826 } 827 828 return send_shell_command(transport, serial, cmd); 829} 830 831static int backup(int argc, const char** argv) { 832 const char* filename = "./backup.ab"; 833 834 /* find, extract, and use any -f argument */ 835 for (int i = 1; i < argc; i++) { 836 if (!strcmp("-f", argv[i])) { 837 if (i == argc-1) { 838 fprintf(stderr, "adb: -f passed with no filename\n"); 839 return usage(); 840 } 841 filename = argv[i+1]; 842 for (int j = i+2; j <= argc; ) { 843 argv[i++] = argv[j++]; 844 } 845 argc -= 2; 846 argv[argc] = NULL; 847 } 848 } 849 850 /* bare "adb backup" or "adb backup -f filename" are not valid invocations */ 851 if (argc < 2) return usage(); 852 853 adb_unlink(filename); 854 mkdirs(filename); 855 int outFd = adb_creat(filename, 0640); 856 if (outFd < 0) { 857 fprintf(stderr, "adb: unable to open file %s\n", filename); 858 return -1; 859 } 860 861 std::string cmd = "backup:"; 862 --argc; 863 ++argv; 864 while (argc-- > 0) { 865 cmd += " " + escape_arg(*argv++); 866 } 867 868 D("backup. filename=%s cmd=%s", filename, cmd.c_str()); 869 std::string error; 870 int fd = adb_connect(cmd, &error); 871 if (fd < 0) { 872 fprintf(stderr, "adb: unable to connect for backup: %s\n", error.c_str()); 873 adb_close(outFd); 874 return -1; 875 } 876 877 printf("Now unlock your device and confirm the backup operation.\n"); 878 copy_to_file(fd, outFd); 879 880 adb_close(fd); 881 adb_close(outFd); 882 return 0; 883} 884 885static int restore(int argc, const char** argv) { 886 if (argc != 2) return usage(); 887 888 const char* filename = argv[1]; 889 int tarFd = adb_open(filename, O_RDONLY); 890 if (tarFd < 0) { 891 fprintf(stderr, "adb: unable to open file %s: %s\n", filename, strerror(errno)); 892 return -1; 893 } 894 895 std::string error; 896 int fd = adb_connect("restore:", &error); 897 if (fd < 0) { 898 fprintf(stderr, "adb: unable to connect for restore: %s\n", error.c_str()); 899 adb_close(tarFd); 900 return -1; 901 } 902 903 printf("Now unlock your device and confirm the restore operation.\n"); 904 copy_to_file(tarFd, fd); 905 906 adb_close(fd); 907 adb_close(tarFd); 908 return 0; 909} 910 911/* <hint> may be: 912 * - A simple product name 913 * e.g., "sooner" 914 * - A relative path from the CWD to the ANDROID_PRODUCT_OUT dir 915 * e.g., "out/target/product/sooner" 916 * - An absolute path to the PRODUCT_OUT dir 917 * e.g., "/src/device/out/target/product/sooner" 918 * 919 * Given <hint>, try to construct an absolute path to the 920 * ANDROID_PRODUCT_OUT dir. 921 */ 922static std::string find_product_out_path(const std::string& hint) { 923 if (hint.empty()) { 924 return ""; 925 } 926 927 // If it's already absolute, don't bother doing any work. 928 if (adb_is_absolute_host_path(hint.c_str())) { 929 return hint; 930 } 931 932 // If there are any slashes in it, assume it's a relative path; 933 // make it absolute. 934 if (hint.find_first_of(OS_PATH_SEPARATORS) != std::string::npos) { 935 std::string cwd; 936 if (!getcwd(&cwd)) { 937 fprintf(stderr, "adb: getcwd failed: %s\n", strerror(errno)); 938 return ""; 939 } 940 return android::base::StringPrintf("%s%c%s", cwd.c_str(), OS_PATH_SEPARATOR, hint.c_str()); 941 } 942 943 // It's a string without any slashes. Try to do something with it. 944 // 945 // Try to find the root of the build tree, and build a PRODUCT_OUT 946 // path from there. 947 char* top = getenv("ANDROID_BUILD_TOP"); 948 if (top == nullptr) { 949 fprintf(stderr, "adb: ANDROID_BUILD_TOP not set!\n"); 950 return ""; 951 } 952 953 std::string path = top; 954 path += OS_PATH_SEPARATOR_STR; 955 path += "out"; 956 path += OS_PATH_SEPARATOR_STR; 957 path += "target"; 958 path += OS_PATH_SEPARATOR_STR; 959 path += "product"; 960 path += OS_PATH_SEPARATOR_STR; 961 path += hint; 962 if (!directory_exists(path)) { 963 fprintf(stderr, "adb: Couldn't find a product dir based on -p %s; " 964 "\"%s\" doesn't exist\n", hint.c_str(), path.c_str()); 965 return ""; 966 } 967 return path; 968} 969 970static void parse_push_pull_args(const char **arg, int narg, char const **path1, 971 char const **path2, bool* show_progress, 972 int *copy_attrs) { 973 *show_progress = false; 974 *copy_attrs = 0; 975 976 while (narg > 0) { 977 if (!strcmp(*arg, "-p")) { 978 *show_progress = true; 979 } else if (!strcmp(*arg, "-a")) { 980 *copy_attrs = 1; 981 } else { 982 break; 983 } 984 ++arg; 985 --narg; 986 } 987 988 if (narg > 0) { 989 *path1 = *arg; 990 ++arg; 991 --narg; 992 } 993 994 if (narg > 0) { 995 *path2 = *arg; 996 } 997} 998 999static int adb_connect_command(const std::string& command) { 1000 std::string error; 1001 int fd = adb_connect(command, &error); 1002 if (fd < 0) { 1003 fprintf(stderr, "error: %s\n", error.c_str()); 1004 return 1; 1005 } 1006 read_and_dump(fd); 1007 adb_close(fd); 1008 return 0; 1009} 1010 1011static int adb_query_command(const std::string& command) { 1012 std::string result; 1013 std::string error; 1014 if (!adb_query(command, &result, &error)) { 1015 fprintf(stderr, "error: %s\n", error.c_str()); 1016 return 1; 1017 } 1018 printf("%s\n", result.c_str()); 1019 return 0; 1020} 1021 1022// Disallow stdin, stdout, and stderr. 1023static bool _is_valid_ack_reply_fd(const int ack_reply_fd) { 1024#ifdef _WIN32 1025 const HANDLE ack_reply_handle = cast_int_to_handle(ack_reply_fd); 1026 return (GetStdHandle(STD_INPUT_HANDLE) != ack_reply_handle) && 1027 (GetStdHandle(STD_OUTPUT_HANDLE) != ack_reply_handle) && 1028 (GetStdHandle(STD_ERROR_HANDLE) != ack_reply_handle); 1029#else 1030 return ack_reply_fd > 2; 1031#endif 1032} 1033 1034int adb_commandline(int argc, const char **argv) { 1035 int no_daemon = 0; 1036 int is_daemon = 0; 1037 int is_server = 0; 1038 int r; 1039 TransportType transport_type = kTransportAny; 1040 int ack_reply_fd = -1; 1041 1042 // If defined, this should be an absolute path to 1043 // the directory containing all of the various system images 1044 // for a particular product. If not defined, and the adb 1045 // command requires this information, then the user must 1046 // specify the path using "-p". 1047 char* ANDROID_PRODUCT_OUT = getenv("ANDROID_PRODUCT_OUT"); 1048 if (ANDROID_PRODUCT_OUT != nullptr) { 1049 gProductOutPath = ANDROID_PRODUCT_OUT; 1050 } 1051 // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint 1052 1053 const char* serial = getenv("ANDROID_SERIAL"); 1054 1055 /* Validate and assign the server port */ 1056 const char* server_port_str = getenv("ANDROID_ADB_SERVER_PORT"); 1057 int server_port = DEFAULT_ADB_PORT; 1058 if (server_port_str && strlen(server_port_str) > 0) { 1059 server_port = strtol(server_port_str, nullptr, 0); 1060 if (server_port <= 0 || server_port > 65535) { 1061 fprintf(stderr, 1062 "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number less than 65536. Got \"%s\"\n", 1063 server_port_str); 1064 return usage(); 1065 } 1066 } 1067 1068 /* modifiers and flags */ 1069 while (argc > 0) { 1070 if (!strcmp(argv[0],"server")) { 1071 is_server = 1; 1072 } else if (!strcmp(argv[0],"nodaemon")) { 1073 no_daemon = 1; 1074 } else if (!strcmp(argv[0], "fork-server")) { 1075 /* this is a special flag used only when the ADB client launches the ADB Server */ 1076 is_daemon = 1; 1077 } else if (!strcmp(argv[0], "--reply-fd")) { 1078 if (argc < 2) return usage(); 1079 const char* reply_fd_str = argv[1]; 1080 argc--; 1081 argv++; 1082 ack_reply_fd = strtol(reply_fd_str, nullptr, 10); 1083 if (!_is_valid_ack_reply_fd(ack_reply_fd)) { 1084 fprintf(stderr, "adb: invalid reply fd \"%s\"\n", reply_fd_str); 1085 return usage(); 1086 } 1087 } else if (!strncmp(argv[0], "-p", 2)) { 1088 const char* product = nullptr; 1089 if (argv[0][2] == '\0') { 1090 if (argc < 2) return usage(); 1091 product = argv[1]; 1092 argc--; 1093 argv++; 1094 } else { 1095 product = argv[0] + 2; 1096 } 1097 gProductOutPath = find_product_out_path(product); 1098 if (gProductOutPath.empty()) { 1099 fprintf(stderr, "adb: could not resolve \"-p %s\"\n", product); 1100 return usage(); 1101 } 1102 } else if (argv[0][0]=='-' && argv[0][1]=='s') { 1103 if (isdigit(argv[0][2])) { 1104 serial = argv[0] + 2; 1105 } else { 1106 if (argc < 2 || argv[0][2] != '\0') return usage(); 1107 serial = argv[1]; 1108 argc--; 1109 argv++; 1110 } 1111 } else if (!strcmp(argv[0],"-d")) { 1112 transport_type = kTransportUsb; 1113 } else if (!strcmp(argv[0],"-e")) { 1114 transport_type = kTransportLocal; 1115 } else if (!strcmp(argv[0],"-a")) { 1116 gListenAll = 1; 1117 } else if (!strncmp(argv[0], "-H", 2)) { 1118 const char *hostname = NULL; 1119 if (argv[0][2] == '\0') { 1120 if (argc < 2) return usage(); 1121 hostname = argv[1]; 1122 argc--; 1123 argv++; 1124 } else { 1125 hostname = argv[0] + 2; 1126 } 1127 adb_set_tcp_name(hostname); 1128 1129 } else if (!strncmp(argv[0], "-P", 2)) { 1130 if (argv[0][2] == '\0') { 1131 if (argc < 2) return usage(); 1132 server_port_str = argv[1]; 1133 argc--; 1134 argv++; 1135 } else { 1136 server_port_str = argv[0] + 2; 1137 } 1138 if (strlen(server_port_str) > 0) { 1139 server_port = (int) strtol(server_port_str, NULL, 0); 1140 if (server_port <= 0 || server_port > 65535) { 1141 fprintf(stderr, 1142 "adb: port number must be a positive number less than 65536. Got \"%s\"\n", 1143 server_port_str); 1144 return usage(); 1145 } 1146 } else { 1147 fprintf(stderr, 1148 "adb: port number must be a positive number less than 65536. Got empty string.\n"); 1149 return usage(); 1150 } 1151 } else { 1152 /* out of recognized modifiers and flags */ 1153 break; 1154 } 1155 argc--; 1156 argv++; 1157 } 1158 1159 adb_set_transport(transport_type, serial); 1160 adb_set_tcp_specifics(server_port); 1161 1162 if (is_server) { 1163 if (no_daemon || is_daemon) { 1164 if (is_daemon && (ack_reply_fd == -1)) { 1165 fprintf(stderr, "reply fd for adb server to client communication not specified.\n"); 1166 return usage(); 1167 } 1168 r = adb_main(is_daemon, server_port, ack_reply_fd); 1169 } else { 1170 r = launch_server(server_port); 1171 } 1172 if (r) { 1173 fprintf(stderr,"* could not start server *\n"); 1174 } 1175 return r; 1176 } 1177 1178 if (argc == 0) { 1179 return usage(); 1180 } 1181 1182 /* handle wait-for-* prefix */ 1183 if (!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) { 1184 const char* service = argv[0]; 1185 1186 if (!wait_for_device(service, transport_type, serial)) { 1187 return 1; 1188 } 1189 1190 // Allow a command to be run after wait-for-device, 1191 // e.g. 'adb wait-for-device shell'. 1192 if (argc == 1) { 1193 return 0; 1194 } 1195 1196 /* Fall through */ 1197 argc--; 1198 argv++; 1199 } 1200 1201 /* adb_connect() commands */ 1202 if (!strcmp(argv[0], "devices")) { 1203 const char *listopt; 1204 if (argc < 2) { 1205 listopt = ""; 1206 } else if (argc == 2 && !strcmp(argv[1], "-l")) { 1207 listopt = argv[1]; 1208 } else { 1209 fprintf(stderr, "Usage: adb devices [-l]\n"); 1210 return 1; 1211 } 1212 1213 std::string query = android::base::StringPrintf("host:%s%s", argv[0], listopt); 1214 printf("List of devices attached\n"); 1215 return adb_query_command(query); 1216 } 1217 else if (!strcmp(argv[0], "connect")) { 1218 if (argc != 2) { 1219 fprintf(stderr, "Usage: adb connect <host>[:<port>]\n"); 1220 return 1; 1221 } 1222 1223 std::string query = android::base::StringPrintf("host:connect:%s", argv[1]); 1224 return adb_query_command(query); 1225 } 1226 else if (!strcmp(argv[0], "disconnect")) { 1227 if (argc > 2) { 1228 fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]]\n"); 1229 return 1; 1230 } 1231 1232 std::string query = android::base::StringPrintf("host:disconnect:%s", 1233 (argc == 2) ? argv[1] : ""); 1234 return adb_query_command(query); 1235 } 1236 else if (!strcmp(argv[0], "emu")) { 1237 return adb_send_emulator_command(argc, argv, serial); 1238 } 1239 else if (!strcmp(argv[0], "shell") || !strcmp(argv[0], "hell")) { 1240 char h = (argv[0][0] == 'h'); 1241 1242 FeatureSet features = GetFeatureSet(transport_type, serial); 1243 1244 bool use_shell_protocol = (features.count(kFeatureShell2) > 0); 1245 if (!use_shell_protocol) { 1246 D("shell protocol not supported, using raw data transfer"); 1247 } else { 1248 D("using shell protocol"); 1249 } 1250 1251 // Parse shell-specific command-line options. 1252 // argv[0] is always "shell". 1253 --argc; 1254 ++argv; 1255 std::string shell_type_arg; 1256 while (argc) { 1257 if (!strcmp(argv[0], "-T") || !strcmp(argv[0], "-t")) { 1258 if (features.count(kFeatureShell2) == 0) { 1259 fprintf(stderr, "error: target doesn't support PTY args -Tt\n"); 1260 return 1; 1261 } 1262 shell_type_arg = argv[0]; 1263 --argc; 1264 ++argv; 1265 } else { 1266 break; 1267 } 1268 } 1269 std::string service_string = android::base::StringPrintf( 1270 "shell%s:", shell_type_arg.c_str()); 1271 1272 if (h) { 1273 printf("\x1b[41;33m"); 1274 fflush(stdout); 1275 } 1276 1277 if (!argc) { 1278 D("starting interactive shell"); 1279 r = interactive_shell(service_string, use_shell_protocol); 1280 if (h) { 1281 printf("\x1b[0m"); 1282 fflush(stdout); 1283 } 1284 return r; 1285 } 1286 1287 // We don't escape here, just like ssh(1). http://b/20564385. 1288 service_string += android::base::Join( 1289 std::vector<const char*>(argv, argv + argc), ' '); 1290 1291 while (true) { 1292 D("non-interactive shell loop. cmd=%s", service_string.c_str()); 1293 std::string error; 1294 int fd = adb_connect(service_string, &error); 1295 int r; 1296 if (fd >= 0) { 1297 D("about to read_and_dump(fd=%d)", fd); 1298 r = read_and_dump(fd, use_shell_protocol); 1299 D("read_and_dump() done."); 1300 adb_close(fd); 1301 } else { 1302 fprintf(stderr,"error: %s\n", error.c_str()); 1303 r = -1; 1304 } 1305 1306 if (h) { 1307 printf("\x1b[0m"); 1308 fflush(stdout); 1309 } 1310 D("non-interactive shell loop. return r=%d", r); 1311 return r; 1312 } 1313 } 1314 else if (!strcmp(argv[0], "exec-in") || !strcmp(argv[0], "exec-out")) { 1315 int exec_in = !strcmp(argv[0], "exec-in"); 1316 1317 std::string cmd = "exec:"; 1318 cmd += argv[1]; 1319 argc -= 2; 1320 argv += 2; 1321 while (argc-- > 0) { 1322 cmd += " " + escape_arg(*argv++); 1323 } 1324 1325 std::string error; 1326 int fd = adb_connect(cmd, &error); 1327 if (fd < 0) { 1328 fprintf(stderr, "error: %s\n", error.c_str()); 1329 return -1; 1330 } 1331 1332 if (exec_in) { 1333 copy_to_file(STDIN_FILENO, fd); 1334 } else { 1335 copy_to_file(fd, STDOUT_FILENO); 1336 } 1337 1338 adb_close(fd); 1339 return 0; 1340 } 1341 else if (!strcmp(argv[0], "kill-server")) { 1342 std::string error; 1343 int fd = _adb_connect("host:kill", &error); 1344 if (fd == -2) { 1345 // Failed to make network connection to server. Don't output the 1346 // network error since that is expected. 1347 fprintf(stderr,"* server not running *\n"); 1348 // Successful exit code because the server is already "killed". 1349 return 0; 1350 } else if (fd == -1) { 1351 // Some other error. 1352 fprintf(stderr, "error: %s\n", error.c_str()); 1353 return 1; 1354 } else { 1355 // Successfully connected, kill command sent, okay status came back. 1356 // Server should exit() in a moment, if not already. 1357 adb_close(fd); 1358 return 0; 1359 } 1360 } 1361 else if (!strcmp(argv[0], "sideload")) { 1362 if (argc != 2) return usage(); 1363 if (adb_sideload_host(argv[1])) { 1364 return 1; 1365 } else { 1366 return 0; 1367 } 1368 } 1369 else if (!strcmp(argv[0], "tcpip") && argc > 1) { 1370 return adb_connect_command(android::base::StringPrintf("tcpip:%s", argv[1])); 1371 } 1372 else if (!strcmp(argv[0], "remount") || 1373 !strcmp(argv[0], "reboot") || 1374 !strcmp(argv[0], "reboot-bootloader") || 1375 !strcmp(argv[0], "usb") || 1376 !strcmp(argv[0], "root") || 1377 !strcmp(argv[0], "unroot") || 1378 !strcmp(argv[0], "disable-verity") || 1379 !strcmp(argv[0], "enable-verity")) { 1380 std::string command; 1381 if (!strcmp(argv[0], "reboot-bootloader")) { 1382 command = "reboot:bootloader"; 1383 } else if (argc > 1) { 1384 command = android::base::StringPrintf("%s:%s", argv[0], argv[1]); 1385 } else { 1386 command = android::base::StringPrintf("%s:", argv[0]); 1387 } 1388 return adb_connect_command(command); 1389 } 1390 else if (!strcmp(argv[0], "bugreport")) { 1391 if (argc != 1) return usage(); 1392 return send_shell_command(transport_type, serial, "shell:bugreport"); 1393 } 1394 else if (!strcmp(argv[0], "forward") || !strcmp(argv[0], "reverse")) { 1395 bool reverse = !strcmp(argv[0], "reverse"); 1396 ++argv; 1397 --argc; 1398 if (argc < 1) return usage(); 1399 1400 // Determine the <host-prefix> for this command. 1401 std::string host_prefix; 1402 if (reverse) { 1403 host_prefix = "reverse"; 1404 } else { 1405 if (serial) { 1406 host_prefix = android::base::StringPrintf("host-serial:%s", serial); 1407 } else if (transport_type == kTransportUsb) { 1408 host_prefix = "host-usb"; 1409 } else if (transport_type == kTransportLocal) { 1410 host_prefix = "host-local"; 1411 } else { 1412 host_prefix = "host"; 1413 } 1414 } 1415 1416 std::string cmd; 1417 if (strcmp(argv[0], "--list") == 0) { 1418 if (argc != 1) return usage(); 1419 return adb_query_command(host_prefix + ":list-forward"); 1420 } else if (strcmp(argv[0], "--remove-all") == 0) { 1421 if (argc != 1) return usage(); 1422 cmd = host_prefix + ":killforward-all"; 1423 } else if (strcmp(argv[0], "--remove") == 0) { 1424 // forward --remove <local> 1425 if (argc != 2) return usage(); 1426 cmd = host_prefix + ":killforward:" + argv[1]; 1427 } else if (strcmp(argv[0], "--no-rebind") == 0) { 1428 // forward --no-rebind <local> <remote> 1429 if (argc != 3) return usage(); 1430 cmd = host_prefix + ":forward:norebind:" + argv[1] + ";" + argv[2]; 1431 } else { 1432 // forward <local> <remote> 1433 if (argc != 2) return usage(); 1434 cmd = host_prefix + ":forward:" + argv[0] + ";" + argv[1]; 1435 } 1436 1437 return adb_command(cmd) ? 0 : 1; 1438 } 1439 /* do_sync_*() commands */ 1440 else if (!strcmp(argv[0], "ls")) { 1441 if (argc != 2) return usage(); 1442 return do_sync_ls(argv[1]) ? 0 : 1; 1443 } 1444 else if (!strcmp(argv[0], "push")) { 1445 bool show_progress = false; 1446 int copy_attrs = 0; 1447 const char* lpath = NULL, *rpath = NULL; 1448 1449 parse_push_pull_args(&argv[1], argc - 1, &lpath, &rpath, &show_progress, ©_attrs); 1450 if (!lpath || !rpath || copy_attrs != 0) return usage(); 1451 return do_sync_push(lpath, rpath, show_progress) ? 0 : 1; 1452 } 1453 else if (!strcmp(argv[0], "pull")) { 1454 bool show_progress = false; 1455 int copy_attrs = 0; 1456 const char* rpath = NULL, *lpath = "."; 1457 1458 parse_push_pull_args(&argv[1], argc - 1, &rpath, &lpath, &show_progress, ©_attrs); 1459 if (!rpath) return usage(); 1460 return do_sync_pull(rpath, lpath, show_progress, copy_attrs) ? 0 : 1; 1461 } 1462 else if (!strcmp(argv[0], "install")) { 1463 if (argc < 2) return usage(); 1464 return install_app(transport_type, serial, argc, argv); 1465 } 1466 else if (!strcmp(argv[0], "install-multiple")) { 1467 if (argc < 2) return usage(); 1468 return install_multiple_app(transport_type, serial, argc, argv); 1469 } 1470 else if (!strcmp(argv[0], "uninstall")) { 1471 if (argc < 2) return usage(); 1472 return uninstall_app(transport_type, serial, argc, argv); 1473 } 1474 else if (!strcmp(argv[0], "sync")) { 1475 std::string src; 1476 bool list_only = false; 1477 if (argc < 2) { 1478 // No local path was specified. 1479 src = ""; 1480 } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) { 1481 list_only = true; 1482 if (argc == 3) { 1483 src = argv[2]; 1484 } else { 1485 src = ""; 1486 } 1487 } else if (argc == 2) { 1488 // A local path or "android"/"data" arg was specified. 1489 src = argv[1]; 1490 } else { 1491 return usage(); 1492 } 1493 1494 if (src != "" && 1495 src != "system" && src != "data" && src != "vendor" && src != "oem") { 1496 return usage(); 1497 } 1498 1499 std::string system_src_path = product_file("system"); 1500 std::string data_src_path = product_file("data"); 1501 std::string vendor_src_path = product_file("vendor"); 1502 std::string oem_src_path = product_file("oem"); 1503 1504 bool okay = true; 1505 if (okay && (src.empty() || src == "system")) { 1506 okay = do_sync_sync(system_src_path, "/system", list_only); 1507 } 1508 if (okay && (src.empty() || src == "vendor") && directory_exists(vendor_src_path)) { 1509 okay = do_sync_sync(vendor_src_path, "/vendor", list_only); 1510 } 1511 if (okay && (src.empty() || src == "oem") && directory_exists(oem_src_path)) { 1512 okay = do_sync_sync(oem_src_path, "/oem", list_only); 1513 } 1514 if (okay && (src.empty() || src == "data")) { 1515 okay = do_sync_sync(data_src_path, "/data", list_only); 1516 } 1517 return okay ? 0 : 1; 1518 } 1519 /* passthrough commands */ 1520 else if (!strcmp(argv[0],"get-state") || 1521 !strcmp(argv[0],"get-serialno") || 1522 !strcmp(argv[0],"get-devpath")) 1523 { 1524 return adb_query_command(format_host_command(argv[0], transport_type, serial)); 1525 } 1526 /* other commands */ 1527 else if (!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat") || !strcmp(argv[0],"longcat")) { 1528 return logcat(transport_type, serial, argc, argv); 1529 } 1530 else if (!strcmp(argv[0],"ppp")) { 1531 return ppp(argc, argv); 1532 } 1533 else if (!strcmp(argv[0], "start-server")) { 1534 std::string error; 1535 const int result = adb_connect("host:start-server", &error); 1536 if (result < 0) { 1537 fprintf(stderr, "error: %s\n", error.c_str()); 1538 } 1539 return result; 1540 } 1541 else if (!strcmp(argv[0], "backup")) { 1542 return backup(argc, argv); 1543 } 1544 else if (!strcmp(argv[0], "restore")) { 1545 return restore(argc, argv); 1546 } 1547 else if (!strcmp(argv[0], "keygen")) { 1548 if (argc < 2) return usage(); 1549 return adb_auth_keygen(argv[1]); 1550 } 1551 else if (!strcmp(argv[0], "jdwp")) { 1552 return adb_connect_command("jdwp"); 1553 } 1554 /* "adb /?" is a common idiom under Windows */ 1555 else if (!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) { 1556 help(); 1557 return 0; 1558 } 1559 else if (!strcmp(argv[0], "version")) { 1560 fprintf(stdout, "%s", adb_version().c_str()); 1561 return 0; 1562 } 1563 else if (!strcmp(argv[0], "features")) { 1564 // Only list the features common to both the adb client and the device. 1565 FeatureSet features = GetFeatureSet(transport_type, serial); 1566 for (const std::string& name : features) { 1567 if (supported_features().count(name) > 0) { 1568 printf("%s\n", name.c_str()); 1569 } 1570 } 1571 return 0; 1572 } 1573 1574 usage(); 1575 return 1; 1576} 1577 1578static int pm_command(TransportType transport, const char* serial, int argc, const char** argv) { 1579 std::string cmd = "shell:pm"; 1580 1581 while (argc-- > 0) { 1582 cmd += " " + escape_arg(*argv++); 1583 } 1584 1585 return send_shell_command(transport, serial, cmd); 1586} 1587 1588static int uninstall_app(TransportType transport, const char* serial, int argc, const char** argv) { 1589 /* if the user choose the -k option, we refuse to do it until devices are 1590 out with the option to uninstall the remaining data somehow (adb/ui) */ 1591 if (argc == 3 && strcmp(argv[1], "-k") == 0) 1592 { 1593 printf( 1594 "The -k option uninstalls the application while retaining the data/cache.\n" 1595 "At the moment, there is no way to remove the remaining data.\n" 1596 "You will have to reinstall the application with the same signature, and fully uninstall it.\n" 1597 "If you truly wish to continue, execute 'adb shell pm uninstall -k %s'\n", argv[2]); 1598 return -1; 1599 } 1600 1601 /* 'adb uninstall' takes the same arguments as 'pm uninstall' on device */ 1602 return pm_command(transport, serial, argc, argv); 1603} 1604 1605static int delete_file(TransportType transport, const char* serial, const std::string& filename) { 1606 std::string cmd = "shell:rm -f " + escape_arg(filename); 1607 return send_shell_command(transport, serial, cmd); 1608} 1609 1610static int install_app(TransportType transport, const char* serial, int argc, const char** argv) { 1611 static const char *const DATA_DEST = "/data/local/tmp/%s"; 1612 static const char *const SD_DEST = "/sdcard/tmp/%s"; 1613 const char* where = DATA_DEST; 1614 int i; 1615 struct stat sb; 1616 1617 for (i = 1; i < argc; i++) { 1618 if (!strcmp(argv[i], "-s")) { 1619 where = SD_DEST; 1620 } 1621 } 1622 1623 // Find last APK argument. 1624 // All other arguments passed through verbatim. 1625 int last_apk = -1; 1626 for (i = argc - 1; i >= 0; i--) { 1627 const char* file = argv[i]; 1628 const char* dot = strrchr(file, '.'); 1629 if (dot && !strcasecmp(dot, ".apk")) { 1630 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 1631 fprintf(stderr, "Invalid APK file: %s\n", file); 1632 return -1; 1633 } 1634 1635 last_apk = i; 1636 break; 1637 } 1638 } 1639 1640 if (last_apk == -1) { 1641 fprintf(stderr, "Missing APK file\n"); 1642 return -1; 1643 } 1644 1645 int result = -1; 1646 const char* apk_file = argv[last_apk]; 1647 std::string apk_dest = android::base::StringPrintf(where, adb_basename(apk_file).c_str()); 1648 if (!do_sync_push(apk_file, apk_dest.c_str(), false)) goto cleanup_apk; 1649 argv[last_apk] = apk_dest.c_str(); /* destination name, not source location */ 1650 result = pm_command(transport, serial, argc, argv); 1651 1652cleanup_apk: 1653 delete_file(transport, serial, apk_dest); 1654 return result; 1655} 1656 1657static int install_multiple_app(TransportType transport, const char* serial, int argc, 1658 const char** argv) 1659{ 1660 int i; 1661 struct stat sb; 1662 uint64_t total_size = 0; 1663 1664 // Find all APK arguments starting at end. 1665 // All other arguments passed through verbatim. 1666 int first_apk = -1; 1667 for (i = argc - 1; i >= 0; i--) { 1668 const char* file = argv[i]; 1669 const char* dot = strrchr(file, '.'); 1670 if (dot && !strcasecmp(dot, ".apk")) { 1671 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 1672 fprintf(stderr, "Invalid APK file: %s\n", file); 1673 return -1; 1674 } 1675 1676 total_size += sb.st_size; 1677 first_apk = i; 1678 } else { 1679 break; 1680 } 1681 } 1682 1683 if (first_apk == -1) { 1684 fprintf(stderr, "Missing APK file\n"); 1685 return 1; 1686 } 1687 1688 std::string cmd = android::base::StringPrintf("exec:pm install-create -S %" PRIu64, total_size); 1689 for (i = 1; i < first_apk; i++) { 1690 cmd += " " + escape_arg(argv[i]); 1691 } 1692 1693 // Create install session 1694 std::string error; 1695 int fd = adb_connect(cmd, &error); 1696 if (fd < 0) { 1697 fprintf(stderr, "Connect error for create: %s\n", error.c_str()); 1698 return -1; 1699 } 1700 char buf[BUFSIZ]; 1701 read_status_line(fd, buf, sizeof(buf)); 1702 adb_close(fd); 1703 1704 int session_id = -1; 1705 if (!strncmp("Success", buf, 7)) { 1706 char* start = strrchr(buf, '['); 1707 char* end = strrchr(buf, ']'); 1708 if (start && end) { 1709 *end = '\0'; 1710 session_id = strtol(start + 1, NULL, 10); 1711 } 1712 } 1713 if (session_id < 0) { 1714 fprintf(stderr, "Failed to create session\n"); 1715 fputs(buf, stderr); 1716 return -1; 1717 } 1718 1719 // Valid session, now stream the APKs 1720 int success = 1; 1721 for (i = first_apk; i < argc; i++) { 1722 const char* file = argv[i]; 1723 if (stat(file, &sb) == -1) { 1724 fprintf(stderr, "Failed to stat %s\n", file); 1725 success = 0; 1726 goto finalize_session; 1727 } 1728 1729 std::string cmd = android::base::StringPrintf( 1730 "exec:pm install-write -S %" PRIu64 " %d %d_%s -", 1731 static_cast<uint64_t>(sb.st_size), session_id, i, adb_basename(file).c_str()); 1732 1733 int localFd = adb_open(file, O_RDONLY); 1734 if (localFd < 0) { 1735 fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno)); 1736 success = 0; 1737 goto finalize_session; 1738 } 1739 1740 std::string error; 1741 int remoteFd = adb_connect(cmd, &error); 1742 if (remoteFd < 0) { 1743 fprintf(stderr, "Connect error for write: %s\n", error.c_str()); 1744 adb_close(localFd); 1745 success = 0; 1746 goto finalize_session; 1747 } 1748 1749 copy_to_file(localFd, remoteFd); 1750 read_status_line(remoteFd, buf, sizeof(buf)); 1751 1752 adb_close(localFd); 1753 adb_close(remoteFd); 1754 1755 if (strncmp("Success", buf, 7)) { 1756 fprintf(stderr, "Failed to write %s\n", file); 1757 fputs(buf, stderr); 1758 success = 0; 1759 goto finalize_session; 1760 } 1761 } 1762 1763finalize_session: 1764 // Commit session if we streamed everything okay; otherwise abandon 1765 std::string service = 1766 android::base::StringPrintf("exec:pm install-%s %d", 1767 success ? "commit" : "abandon", session_id); 1768 fd = adb_connect(service, &error); 1769 if (fd < 0) { 1770 fprintf(stderr, "Connect error for finalize: %s\n", error.c_str()); 1771 return -1; 1772 } 1773 read_status_line(fd, buf, sizeof(buf)); 1774 adb_close(fd); 1775 1776 if (!strncmp("Success", buf, 7)) { 1777 fputs(buf, stderr); 1778 return 0; 1779 } else { 1780 fprintf(stderr, "Failed to finalize session\n"); 1781 fputs(buf, stderr); 1782 return -1; 1783 } 1784} 1785