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