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