commandline.cpp revision dc3b459ff9f0ff71d404ba7198083e532a0dd894
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 send_shell_command(transport, serial, cmd); 774 return 0; 775} 776 777static int mkdirs(const char *path) 778{ 779 int ret; 780 char *x = (char *)path + 1; 781 782 for(;;) { 783 x = adb_dirstart(x); 784 if(x == 0) return 0; 785 *x = 0; 786 ret = adb_mkdir(path, 0775); 787 *x = OS_PATH_SEPARATOR; 788 if((ret < 0) && (errno != EEXIST)) { 789 return ret; 790 } 791 x++; 792 } 793 return 0; 794} 795 796static int backup(int argc, const char** argv) { 797 const char* filename = "./backup.ab"; 798 799 /* find, extract, and use any -f argument */ 800 for (int i = 1; i < argc; i++) { 801 if (!strcmp("-f", argv[i])) { 802 if (i == argc-1) { 803 fprintf(stderr, "adb: -f passed with no filename\n"); 804 return usage(); 805 } 806 filename = argv[i+1]; 807 for (int j = i+2; j <= argc; ) { 808 argv[i++] = argv[j++]; 809 } 810 argc -= 2; 811 argv[argc] = NULL; 812 } 813 } 814 815 /* bare "adb backup" or "adb backup -f filename" are not valid invocations */ 816 if (argc < 2) return usage(); 817 818 adb_unlink(filename); 819 mkdirs(filename); 820 int outFd = adb_creat(filename, 0640); 821 if (outFd < 0) { 822 fprintf(stderr, "adb: unable to open file %s\n", filename); 823 return -1; 824 } 825 826 std::string cmd = "backup:"; 827 --argc; 828 ++argv; 829 while (argc-- > 0) { 830 cmd += " " + escape_arg(*argv++); 831 } 832 833 D("backup. filename=%s cmd=%s\n", filename, cmd.c_str()); 834 int fd = adb_connect(cmd.c_str()); 835 if (fd < 0) { 836 fprintf(stderr, "adb: unable to connect for backup\n"); 837 adb_close(outFd); 838 return -1; 839 } 840 841 printf("Now unlock your device and confirm the backup operation.\n"); 842 copy_to_file(fd, outFd); 843 844 adb_close(fd); 845 adb_close(outFd); 846 return 0; 847} 848 849static int restore(int argc, const char** argv) { 850 const char* filename; 851 int fd, tarFd; 852 853 if (argc != 2) return usage(); 854 855 filename = argv[1]; 856 tarFd = adb_open(filename, O_RDONLY); 857 if (tarFd < 0) { 858 fprintf(stderr, "adb: unable to open file %s\n", filename); 859 return -1; 860 } 861 862 fd = adb_connect("restore:"); 863 if (fd < 0) { 864 fprintf(stderr, "adb: unable to connect for restore\n"); 865 adb_close(tarFd); 866 return -1; 867 } 868 869 printf("Now unlock your device and confirm the restore operation.\n"); 870 copy_to_file(tarFd, fd); 871 872 adb_close(fd); 873 adb_close(tarFd); 874 return 0; 875} 876 877/* <hint> may be: 878 * - A simple product name 879 * e.g., "sooner" 880 * - A relative path from the CWD to the ANDROID_PRODUCT_OUT dir 881 * e.g., "out/target/product/sooner" 882 * - An absolute path to the PRODUCT_OUT dir 883 * e.g., "/src/device/out/target/product/sooner" 884 * 885 * Given <hint>, try to construct an absolute path to the 886 * ANDROID_PRODUCT_OUT dir. 887 */ 888static std::string find_product_out_path(const char* hint) { 889 if (hint == NULL || hint[0] == '\0') { 890 return ""; 891 } 892 893 // If it's already absolute, don't bother doing any work. 894 if (adb_is_absolute_host_path(hint)) { 895 return hint; 896 } 897 898 // If there are any slashes in it, assume it's a relative path; 899 // make it absolute. 900 if (adb_dirstart(hint) != nullptr) { 901 std::string cwd; 902 if (!getcwd(&cwd)) { 903 fprintf(stderr, "adb: getcwd failed: %s\n", strerror(errno)); 904 return ""; 905 } 906 return android::base::StringPrintf("%s%s%s", cwd.c_str(), OS_PATH_SEPARATOR_STR, hint); 907 } 908 909 // It's a string without any slashes. Try to do something with it. 910 // 911 // Try to find the root of the build tree, and build a PRODUCT_OUT 912 // path from there. 913 char* top = getenv("ANDROID_BUILD_TOP"); 914 if (top == nullptr) { 915 fprintf(stderr, "adb: ANDROID_BUILD_TOP not set!\n"); 916 return ""; 917 } 918 919 std::string path = top; 920 path += OS_PATH_SEPARATOR_STR; 921 path += "out"; 922 path += OS_PATH_SEPARATOR_STR; 923 path += "target"; 924 path += OS_PATH_SEPARATOR_STR; 925 path += "product"; 926 path += OS_PATH_SEPARATOR_STR; 927 path += hint; 928 if (!directory_exists(path)) { 929 fprintf(stderr, "adb: Couldn't find a product dir based on -p %s; " 930 "\"%s\" doesn't exist\n", hint, path.c_str()); 931 return ""; 932 } 933 return path; 934} 935 936static void parse_push_pull_args(const char **arg, int narg, char const **path1, 937 char const **path2, int *show_progress, 938 int *copy_attrs) { 939 *show_progress = 0; 940 *copy_attrs = 0; 941 942 while (narg > 0) { 943 if (!strcmp(*arg, "-p")) { 944 *show_progress = 1; 945 } else if (!strcmp(*arg, "-a")) { 946 *copy_attrs = 1; 947 } else { 948 break; 949 } 950 ++arg; 951 --narg; 952 } 953 954 if (narg > 0) { 955 *path1 = *arg; 956 ++arg; 957 --narg; 958 } 959 960 if (narg > 0) { 961 *path2 = *arg; 962 } 963} 964 965static int adb_connect_command(const char* command) { 966 int fd = adb_connect(command); 967 if (fd != -1) { 968 read_and_dump(fd); 969 adb_close(fd); 970 return 0; 971 } 972 fprintf(stderr, "Error: %s\n", adb_error()); 973 return 1; 974} 975 976int adb_commandline(int argc, const char **argv) 977{ 978 char buf[4096]; 979 int no_daemon = 0; 980 int is_daemon = 0; 981 int is_server = 0; 982 int persist = 0; 983 int r; 984 transport_type ttype = kTransportAny; 985 const char* serial = NULL; 986 const char* server_port_str = NULL; 987 988 // If defined, this should be an absolute path to 989 // the directory containing all of the various system images 990 // for a particular product. If not defined, and the adb 991 // command requires this information, then the user must 992 // specify the path using "-p". 993 char* ANDROID_PRODUCT_OUT = getenv("ANDROID_PRODUCT_OUT"); 994 if (ANDROID_PRODUCT_OUT != nullptr) { 995 gProductOutPath = ANDROID_PRODUCT_OUT; 996 } 997 // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint 998 999 serial = getenv("ANDROID_SERIAL"); 1000 1001 /* Validate and assign the server port */ 1002 server_port_str = getenv("ANDROID_ADB_SERVER_PORT"); 1003 int server_port = DEFAULT_ADB_PORT; 1004 if (server_port_str && strlen(server_port_str) > 0) { 1005 server_port = (int) strtol(server_port_str, NULL, 0); 1006 if (server_port <= 0 || server_port > 65535) { 1007 fprintf(stderr, 1008 "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number less than 65535. Got \"%s\"\n", 1009 server_port_str); 1010 return usage(); 1011 } 1012 } 1013 1014 /* modifiers and flags */ 1015 while (argc > 0) { 1016 if (!strcmp(argv[0],"server")) { 1017 is_server = 1; 1018 } else if (!strcmp(argv[0],"nodaemon")) { 1019 no_daemon = 1; 1020 } else if (!strcmp(argv[0], "fork-server")) { 1021 /* this is a special flag used only when the ADB client launches the ADB Server */ 1022 is_daemon = 1; 1023 } else if (!strcmp(argv[0],"persist")) { 1024 persist = 1; 1025 } else if (!strncmp(argv[0], "-p", 2)) { 1026 const char *product = NULL; 1027 if (argv[0][2] == '\0') { 1028 if (argc < 2) return usage(); 1029 product = argv[1]; 1030 argc--; 1031 argv++; 1032 } else { 1033 product = argv[0] + 2; 1034 } 1035 gProductOutPath = find_product_out_path(product); 1036 if (gProductOutPath.empty()) { 1037 fprintf(stderr, "adb: could not resolve \"-p %s\"\n", product); 1038 return usage(); 1039 } 1040 } else if (argv[0][0]=='-' && argv[0][1]=='s') { 1041 if (isdigit(argv[0][2])) { 1042 serial = argv[0] + 2; 1043 } else { 1044 if (argc < 2 || argv[0][2] != '\0') return usage(); 1045 serial = argv[1]; 1046 argc--; 1047 argv++; 1048 } 1049 } else if (!strcmp(argv[0],"-d")) { 1050 ttype = kTransportUsb; 1051 } else if (!strcmp(argv[0],"-e")) { 1052 ttype = kTransportLocal; 1053 } else if (!strcmp(argv[0],"-a")) { 1054 gListenAll = 1; 1055 } else if (!strncmp(argv[0], "-H", 2)) { 1056 const char *hostname = NULL; 1057 if (argv[0][2] == '\0') { 1058 if (argc < 2) return usage(); 1059 hostname = argv[1]; 1060 argc--; 1061 argv++; 1062 } else { 1063 hostname = argv[0] + 2; 1064 } 1065 adb_set_tcp_name(hostname); 1066 1067 } else if (!strncmp(argv[0], "-P", 2)) { 1068 if (argv[0][2] == '\0') { 1069 if (argc < 2) return usage(); 1070 server_port_str = argv[1]; 1071 argc--; 1072 argv++; 1073 } else { 1074 server_port_str = argv[0] + 2; 1075 } 1076 if (strlen(server_port_str) > 0) { 1077 server_port = (int) strtol(server_port_str, NULL, 0); 1078 if (server_port <= 0 || server_port > 65535) { 1079 fprintf(stderr, 1080 "adb: port number must be a positive number less than 65536. Got \"%s\"\n", 1081 server_port_str); 1082 return usage(); 1083 } 1084 } else { 1085 fprintf(stderr, 1086 "adb: port number must be a positive number less than 65536. Got empty string.\n"); 1087 return usage(); 1088 } 1089 } else { 1090 /* out of recognized modifiers and flags */ 1091 break; 1092 } 1093 argc--; 1094 argv++; 1095 } 1096 1097 adb_set_transport(ttype, serial); 1098 adb_set_tcp_specifics(server_port); 1099 1100 if (is_server) { 1101 if (no_daemon || is_daemon) { 1102 r = adb_main(is_daemon, server_port); 1103 } else { 1104 r = launch_server(server_port); 1105 } 1106 if (r) { 1107 fprintf(stderr,"* could not start server *\n"); 1108 } 1109 return r; 1110 } 1111 1112 if (argc == 0) { 1113 return usage(); 1114 } 1115 1116 /* handle wait-for-* prefix */ 1117 if (!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) { 1118 const char* service = argv[0]; 1119 if (!strncmp(service, "wait-for-device", strlen("wait-for-device"))) { 1120 if (ttype == kTransportUsb) { 1121 service = "wait-for-usb"; 1122 } else if (ttype == kTransportLocal) { 1123 service = "wait-for-local"; 1124 } else { 1125 service = "wait-for-any"; 1126 } 1127 } 1128 1129 format_host_command(buf, sizeof buf, service, ttype, serial); 1130 1131 if (adb_command(buf)) { 1132 D("failure: %s *\n",adb_error()); 1133 fprintf(stderr,"error: %s\n", adb_error()); 1134 return 1; 1135 } 1136 1137 /* Allow a command to be run after wait-for-device, 1138 * e.g. 'adb wait-for-device shell'. 1139 */ 1140 if (argc == 1) { 1141 return 0; 1142 } 1143 1144 /* Fall through */ 1145 argc--; 1146 argv++; 1147 } 1148 1149 /* adb_connect() commands */ 1150 if (!strcmp(argv[0], "devices")) { 1151 char *tmp; 1152 const char *listopt; 1153 if (argc < 2) 1154 listopt = ""; 1155 else if (argc == 2 && !strcmp(argv[1], "-l")) 1156 listopt = argv[1]; 1157 else { 1158 fprintf(stderr, "Usage: adb devices [-l]\n"); 1159 return 1; 1160 } 1161 snprintf(buf, sizeof buf, "host:%s%s", argv[0], listopt); 1162 tmp = adb_query(buf); 1163 if (tmp) { 1164 printf("List of devices attached \n"); 1165 printf("%s\n", tmp); 1166 return 0; 1167 } else { 1168 return 1; 1169 } 1170 } 1171 else if (!strcmp(argv[0], "connect")) { 1172 char *tmp; 1173 if (argc != 2) { 1174 fprintf(stderr, "Usage: adb connect <host>[:<port>]\n"); 1175 return 1; 1176 } 1177 snprintf(buf, sizeof buf, "host:connect:%s", argv[1]); 1178 tmp = adb_query(buf); 1179 if (tmp) { 1180 printf("%s\n", tmp); 1181 return 0; 1182 } else { 1183 return 1; 1184 } 1185 } 1186 else if (!strcmp(argv[0], "disconnect")) { 1187 char *tmp; 1188 if (argc > 2) { 1189 fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]]\n"); 1190 return 1; 1191 } 1192 if (argc == 2) { 1193 snprintf(buf, sizeof buf, "host:disconnect:%s", argv[1]); 1194 } else { 1195 snprintf(buf, sizeof buf, "host:disconnect:"); 1196 } 1197 tmp = adb_query(buf); 1198 if (tmp) { 1199 printf("%s\n", tmp); 1200 return 0; 1201 } else { 1202 return 1; 1203 } 1204 } 1205 else if (!strcmp(argv[0], "emu")) { 1206 return adb_send_emulator_command(argc, argv); 1207 } 1208 else if (!strcmp(argv[0], "shell") || !strcmp(argv[0], "hell")) { 1209 char h = (argv[0][0] == 'h'); 1210 1211 if (h) { 1212 printf("\x1b[41;33m"); 1213 fflush(stdout); 1214 } 1215 1216 if (argc < 2) { 1217 D("starting interactive shell\n"); 1218 r = interactive_shell(); 1219 if (h) { 1220 printf("\x1b[0m"); 1221 fflush(stdout); 1222 } 1223 return r; 1224 } 1225 1226 std::string cmd = "shell:"; 1227 cmd += argv[1]; 1228 argc -= 2; 1229 argv += 2; 1230 while (argc-- > 0) { 1231 cmd += " " + escape_arg(*argv++); 1232 } 1233 1234 while (true) { 1235 D("interactive shell loop. cmd=%s\n", cmd.c_str()); 1236 int fd = adb_connect(cmd.c_str()); 1237 int r; 1238 if (fd >= 0) { 1239 D("about to read_and_dump(fd=%d)\n", fd); 1240 read_and_dump(fd); 1241 D("read_and_dump() done.\n"); 1242 adb_close(fd); 1243 r = 0; 1244 } else { 1245 fprintf(stderr,"error: %s\n", adb_error()); 1246 r = -1; 1247 } 1248 1249 if (persist) { 1250 fprintf(stderr,"\n- waiting for device -\n"); 1251 adb_sleep_ms(1000); 1252 do_cmd(ttype, serial, "wait-for-device", 0); 1253 } else { 1254 if (h) { 1255 printf("\x1b[0m"); 1256 fflush(stdout); 1257 } 1258 D("interactive shell loop. return r=%d\n", r); 1259 return r; 1260 } 1261 } 1262 } 1263 else if (!strcmp(argv[0], "exec-in") || !strcmp(argv[0], "exec-out")) { 1264 int exec_in = !strcmp(argv[0], "exec-in"); 1265 1266 std::string cmd = "exec:"; 1267 cmd += argv[1]; 1268 argc -= 2; 1269 argv += 2; 1270 while (argc-- > 0) { 1271 cmd += " " + escape_arg(*argv++); 1272 } 1273 1274 int fd = adb_connect(cmd.c_str()); 1275 if (fd < 0) { 1276 fprintf(stderr, "error: %s\n", adb_error()); 1277 return -1; 1278 } 1279 1280 if (exec_in) { 1281 copy_to_file(STDIN_FILENO, fd); 1282 } else { 1283 copy_to_file(fd, STDOUT_FILENO); 1284 } 1285 1286 adb_close(fd); 1287 return 0; 1288 } 1289 else if (!strcmp(argv[0], "kill-server")) { 1290 int fd; 1291 fd = _adb_connect("host:kill"); 1292 if (fd == -1) { 1293 fprintf(stderr,"* server not running *\n"); 1294 return 1; 1295 } 1296 return 0; 1297 } 1298 else if (!strcmp(argv[0], "sideload")) { 1299 if (argc != 2) return usage(); 1300 if (adb_sideload_host(argv[1])) { 1301 return 1; 1302 } else { 1303 return 0; 1304 } 1305 } 1306 else if (!strcmp(argv[0], "remount") || 1307 !strcmp(argv[0], "reboot") || 1308 !strcmp(argv[0], "reboot-bootloader") || 1309 !strcmp(argv[0], "tcpip") || 1310 !strcmp(argv[0], "usb") || 1311 !strcmp(argv[0], "root") || 1312 !strcmp(argv[0], "unroot") || 1313 !strcmp(argv[0], "disable-verity") || 1314 !strcmp(argv[0], "enable-verity")) { 1315 char command[100]; 1316 if (!strcmp(argv[0], "reboot-bootloader")) { 1317 snprintf(command, sizeof(command), "reboot:bootloader"); 1318 } else if (argc > 1) { 1319 snprintf(command, sizeof(command), "%s:%s", argv[0], argv[1]); 1320 } else { 1321 snprintf(command, sizeof(command), "%s:", argv[0]); 1322 } 1323 return adb_connect_command(command); 1324 } 1325 else if (!strcmp(argv[0], "bugreport")) { 1326 if (argc != 1) return usage(); 1327 do_cmd(ttype, serial, "shell", "bugreport", 0); 1328 return 0; 1329 } 1330 /* adb_command() wrapper commands */ 1331 else if (!strcmp(argv[0], "forward") || !strcmp(argv[0], "reverse")) { 1332 char host_prefix[64]; 1333 char reverse = (char) !strcmp(argv[0], "reverse"); 1334 char remove = 0; 1335 char remove_all = 0; 1336 char list = 0; 1337 char no_rebind = 0; 1338 1339 // Parse options here. 1340 while (argc > 1 && argv[1][0] == '-') { 1341 if (!strcmp(argv[1], "--list")) 1342 list = 1; 1343 else if (!strcmp(argv[1], "--remove")) 1344 remove = 1; 1345 else if (!strcmp(argv[1], "--remove-all")) 1346 remove_all = 1; 1347 else if (!strcmp(argv[1], "--no-rebind")) 1348 no_rebind = 1; 1349 else { 1350 return usage(); 1351 } 1352 argc--; 1353 argv++; 1354 } 1355 1356 // Ensure we can only use one option at a time. 1357 if (list + remove + remove_all + no_rebind > 1) { 1358 return usage(); 1359 } 1360 1361 // Determine the <host-prefix> for this command. 1362 if (reverse) { 1363 snprintf(host_prefix, sizeof host_prefix, "reverse"); 1364 } else { 1365 if (serial) { 1366 snprintf(host_prefix, sizeof host_prefix, "host-serial:%s", 1367 serial); 1368 } else if (ttype == kTransportUsb) { 1369 snprintf(host_prefix, sizeof host_prefix, "host-usb"); 1370 } else if (ttype == kTransportLocal) { 1371 snprintf(host_prefix, sizeof host_prefix, "host-local"); 1372 } else { 1373 snprintf(host_prefix, sizeof host_prefix, "host"); 1374 } 1375 } 1376 1377 // Implement forward --list 1378 if (list) { 1379 if (argc != 1) 1380 return usage(); 1381 snprintf(buf, sizeof buf, "%s:list-forward", host_prefix); 1382 char* forwards = adb_query(buf); 1383 if (forwards == NULL) { 1384 fprintf(stderr, "error: %s\n", adb_error()); 1385 return 1; 1386 } 1387 printf("%s", forwards); 1388 free(forwards); 1389 return 0; 1390 } 1391 1392 // Implement forward --remove-all 1393 else if (remove_all) { 1394 if (argc != 1) 1395 return usage(); 1396 snprintf(buf, sizeof buf, "%s:killforward-all", host_prefix); 1397 } 1398 1399 // Implement forward --remove <local> 1400 else if (remove) { 1401 if (argc != 2) 1402 return usage(); 1403 snprintf(buf, sizeof buf, "%s:killforward:%s", host_prefix, argv[1]); 1404 } 1405 // Or implement one of: 1406 // forward <local> <remote> 1407 // forward --no-rebind <local> <remote> 1408 else 1409 { 1410 if (argc != 3) 1411 return usage(); 1412 const char* command = no_rebind ? "forward:norebind" : "forward"; 1413 snprintf(buf, sizeof buf, "%s:%s:%s;%s", host_prefix, command, argv[1], argv[2]); 1414 } 1415 1416 if (adb_command(buf)) { 1417 fprintf(stderr,"error: %s\n", adb_error()); 1418 return 1; 1419 } 1420 return 0; 1421 } 1422 /* do_sync_*() commands */ 1423 else if (!strcmp(argv[0], "ls")) { 1424 if (argc != 2) return usage(); 1425 return do_sync_ls(argv[1]); 1426 } 1427 else if (!strcmp(argv[0], "push")) { 1428 int show_progress = 0; 1429 int copy_attrs = 0; // unused 1430 const char* lpath = NULL, *rpath = NULL; 1431 1432 parse_push_pull_args(&argv[1], argc - 1, &lpath, &rpath, &show_progress, ©_attrs); 1433 1434 if ((lpath != NULL) && (rpath != NULL)) { 1435 return do_sync_push(lpath, rpath, show_progress); 1436 } 1437 1438 return usage(); 1439 } 1440 else if (!strcmp(argv[0], "pull")) { 1441 int show_progress = 0; 1442 int copy_attrs = 0; 1443 const char* rpath = NULL, *lpath = "."; 1444 1445 parse_push_pull_args(&argv[1], argc - 1, &rpath, &lpath, &show_progress, ©_attrs); 1446 1447 if (rpath != NULL) { 1448 return do_sync_pull(rpath, lpath, show_progress, copy_attrs); 1449 } 1450 1451 return usage(); 1452 } 1453 else if (!strcmp(argv[0], "install")) { 1454 if (argc < 2) return usage(); 1455 return install_app(ttype, serial, argc, argv); 1456 } 1457 else if (!strcmp(argv[0], "install-multiple")) { 1458 if (argc < 2) return usage(); 1459 return install_multiple_app(ttype, serial, argc, argv); 1460 } 1461 else if (!strcmp(argv[0], "uninstall")) { 1462 if (argc < 2) return usage(); 1463 return uninstall_app(ttype, serial, argc, argv); 1464 } 1465 else if (!strcmp(argv[0], "sync")) { 1466 std::string src; 1467 bool list_only = false; 1468 if (argc < 2) { 1469 // No local path was specified. 1470 src = ""; 1471 } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) { 1472 list_only = true; 1473 if (argc == 3) { 1474 src = argv[2]; 1475 } else { 1476 src = ""; 1477 } 1478 } else if (argc == 2) { 1479 // A local path or "android"/"data" arg was specified. 1480 src = argv[1]; 1481 } else { 1482 return usage(); 1483 } 1484 1485 if (src != "" && 1486 src != "system" && src != "data" && src != "vendor" && src != "oem") { 1487 return usage(); 1488 } 1489 1490 std::string system_src_path = product_file("system"); 1491 std::string data_src_path = product_file("data"); 1492 std::string vendor_src_path = product_file("vendor"); 1493 std::string oem_src_path = product_file("oem"); 1494 1495 int rc = 0; 1496 if (rc == 0 && (src.empty() || src == "system")) { 1497 rc = do_sync_sync(system_src_path, "/system", list_only); 1498 } 1499 if (rc == 0 && (src.empty() || src == "vendor") && directory_exists(vendor_src_path)) { 1500 rc = do_sync_sync(vendor_src_path, "/vendor", list_only); 1501 } 1502 if (rc == 0 && (src.empty() || src == "oem") && directory_exists(oem_src_path)) { 1503 rc = do_sync_sync(oem_src_path, "/oem", list_only); 1504 } 1505 if (rc == 0 && (src.empty() || src == "data")) { 1506 rc = do_sync_sync(data_src_path, "/data", list_only); 1507 } 1508 return rc; 1509 } 1510 /* passthrough commands */ 1511 else if (!strcmp(argv[0],"get-state") || 1512 !strcmp(argv[0],"get-serialno") || 1513 !strcmp(argv[0],"get-devpath")) 1514 { 1515 char *tmp; 1516 1517 format_host_command(buf, sizeof buf, argv[0], ttype, serial); 1518 tmp = adb_query(buf); 1519 if (tmp) { 1520 printf("%s\n", tmp); 1521 return 0; 1522 } else { 1523 return 1; 1524 } 1525 } 1526 /* other commands */ 1527 else if (!strcmp(argv[0],"status-window")) { 1528 status_window(ttype, serial); 1529 return 0; 1530 } 1531 else if (!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat") || !strcmp(argv[0],"longcat")) { 1532 return logcat(ttype, serial, argc, argv); 1533 } 1534 else if (!strcmp(argv[0],"ppp")) { 1535 return ppp(argc, argv); 1536 } 1537 else if (!strcmp(argv[0], "start-server")) { 1538 return adb_connect("host:start-server"); 1539 } 1540 else if (!strcmp(argv[0], "backup")) { 1541 return backup(argc, argv); 1542 } 1543 else if (!strcmp(argv[0], "restore")) { 1544 return restore(argc, argv); 1545 } 1546 else if (!strcmp(argv[0], "keygen")) { 1547 if (argc < 2) return usage(); 1548 return adb_auth_keygen(argv[1]); 1549 } 1550 else if (!strcmp(argv[0], "jdwp")) { 1551 return adb_connect_command("jdwp"); 1552 } 1553 /* "adb /?" is a common idiom under Windows */ 1554 else if (!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) { 1555 help(); 1556 return 0; 1557 } 1558 else if (!strcmp(argv[0], "version")) { 1559 version(stdout); 1560 return 0; 1561 } 1562 1563 usage(); 1564 return 1; 1565} 1566 1567#define MAX_ARGV_LENGTH 16 1568static int do_cmd(transport_type ttype, const char* serial, const char *cmd, ...) 1569{ 1570 const char *argv[MAX_ARGV_LENGTH]; 1571 int argc; 1572 va_list ap; 1573 1574 va_start(ap, cmd); 1575 argc = 0; 1576 1577 if (serial) { 1578 argv[argc++] = "-s"; 1579 argv[argc++] = serial; 1580 } else if (ttype == kTransportUsb) { 1581 argv[argc++] = "-d"; 1582 } else if (ttype == kTransportLocal) { 1583 argv[argc++] = "-e"; 1584 } 1585 1586 argv[argc++] = cmd; 1587 while(argc < MAX_ARGV_LENGTH && 1588 (argv[argc] = va_arg(ap, char*)) != 0) argc++; 1589 assert(argc < MAX_ARGV_LENGTH); 1590 va_end(ap); 1591 1592#if 0 1593 int n; 1594 fprintf(stderr,"argc = %d\n",argc); 1595 for(n = 0; n < argc; n++) { 1596 fprintf(stderr,"argv[%d] = \"%s\"\n", n, argv[n]); 1597 } 1598#endif 1599 1600 return adb_commandline(argc, argv); 1601} 1602 1603static int pm_command(transport_type transport, const char* serial, 1604 int argc, const char** argv) 1605{ 1606 std::string cmd = "shell:pm"; 1607 1608 while (argc-- > 0) { 1609 cmd += " " + escape_arg(*argv++); 1610 } 1611 1612 send_shell_command(transport, serial, cmd); 1613 return 0; 1614} 1615 1616static int uninstall_app(transport_type transport, const char* serial, int argc, 1617 const char** argv) 1618{ 1619 /* if the user choose the -k option, we refuse to do it until devices are 1620 out with the option to uninstall the remaining data somehow (adb/ui) */ 1621 if (argc == 3 && strcmp(argv[1], "-k") == 0) 1622 { 1623 printf( 1624 "The -k option uninstalls the application while retaining the data/cache.\n" 1625 "At the moment, there is no way to remove the remaining data.\n" 1626 "You will have to reinstall the application with the same signature, and fully uninstall it.\n" 1627 "If you truly wish to continue, execute 'adb shell pm uninstall -k %s'\n", argv[2]); 1628 return -1; 1629 } 1630 1631 /* 'adb uninstall' takes the same arguments as 'pm uninstall' on device */ 1632 return pm_command(transport, serial, argc, argv); 1633} 1634 1635static int delete_file(transport_type transport, const char* serial, char* filename) 1636{ 1637 std::string cmd = "shell:rm -f " + escape_arg(filename); 1638 send_shell_command(transport, serial, cmd); 1639 return 0; 1640} 1641 1642static const char* get_basename(const char* filename) 1643{ 1644 const char* basename = adb_dirstop(filename); 1645 if (basename) { 1646 basename++; 1647 return basename; 1648 } else { 1649 return filename; 1650 } 1651} 1652 1653static int install_app(transport_type transport, const char* serial, int argc, 1654 const char** argv) 1655{ 1656 static const char *const DATA_DEST = "/data/local/tmp/%s"; 1657 static const char *const SD_DEST = "/sdcard/tmp/%s"; 1658 const char* where = DATA_DEST; 1659 int i; 1660 struct stat sb; 1661 1662 for (i = 1; i < argc; i++) { 1663 if (!strcmp(argv[i], "-s")) { 1664 where = SD_DEST; 1665 } 1666 } 1667 1668 // Find last APK argument. 1669 // All other arguments passed through verbatim. 1670 int last_apk = -1; 1671 for (i = argc - 1; i >= 0; i--) { 1672 const char* file = argv[i]; 1673 char* dot = strrchr(file, '.'); 1674 if (dot && !strcasecmp(dot, ".apk")) { 1675 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 1676 fprintf(stderr, "Invalid APK file: %s\n", file); 1677 return -1; 1678 } 1679 1680 last_apk = i; 1681 break; 1682 } 1683 } 1684 1685 if (last_apk == -1) { 1686 fprintf(stderr, "Missing APK file\n"); 1687 return -1; 1688 } 1689 1690 const char* apk_file = argv[last_apk]; 1691 char apk_dest[PATH_MAX]; 1692 snprintf(apk_dest, sizeof apk_dest, where, get_basename(apk_file)); 1693 int err = do_sync_push(apk_file, apk_dest, 0 /* no show progress */); 1694 if (err) { 1695 goto cleanup_apk; 1696 } else { 1697 argv[last_apk] = apk_dest; /* destination name, not source location */ 1698 } 1699 1700 pm_command(transport, serial, argc, argv); 1701 1702cleanup_apk: 1703 delete_file(transport, serial, apk_dest); 1704 return err; 1705} 1706 1707static int install_multiple_app(transport_type transport, const char* serial, int argc, 1708 const char** argv) 1709{ 1710 int i; 1711 struct stat sb; 1712 uint64_t total_size = 0; 1713 1714 // Find all APK arguments starting at end. 1715 // All other arguments passed through verbatim. 1716 int first_apk = -1; 1717 for (i = argc - 1; i >= 0; i--) { 1718 const char* file = argv[i]; 1719 char* dot = strrchr(file, '.'); 1720 if (dot && !strcasecmp(dot, ".apk")) { 1721 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 1722 fprintf(stderr, "Invalid APK file: %s\n", file); 1723 return -1; 1724 } 1725 1726 total_size += sb.st_size; 1727 first_apk = i; 1728 } else { 1729 break; 1730 } 1731 } 1732 1733 if (first_apk == -1) { 1734 fprintf(stderr, "Missing APK file\n"); 1735 return 1; 1736 } 1737 1738#if defined(_WIN32) // Remove when we're using clang for Win32. 1739 std::string cmd = android::base::StringPrintf("exec:pm install-create -S %u", (unsigned) total_size); 1740#else 1741 std::string cmd = android::base::StringPrintf("exec:pm install-create -S %" PRIu64, total_size); 1742#endif 1743 for (i = 1; i < first_apk; i++) { 1744 cmd += " " + escape_arg(argv[i]); 1745 } 1746 1747 // Create install session 1748 int fd = adb_connect(cmd.c_str()); 1749 if (fd < 0) { 1750 fprintf(stderr, "Connect error for create: %s\n", adb_error()); 1751 return -1; 1752 } 1753 char buf[BUFSIZ]; 1754 read_status_line(fd, buf, sizeof(buf)); 1755 adb_close(fd); 1756 1757 int session_id = -1; 1758 if (!strncmp("Success", buf, 7)) { 1759 char* start = strrchr(buf, '['); 1760 char* end = strrchr(buf, ']'); 1761 if (start && end) { 1762 *end = '\0'; 1763 session_id = strtol(start + 1, NULL, 10); 1764 } 1765 } 1766 if (session_id < 0) { 1767 fprintf(stderr, "Failed to create session\n"); 1768 fputs(buf, stderr); 1769 return -1; 1770 } 1771 1772 // Valid session, now stream the APKs 1773 int success = 1; 1774 for (i = first_apk; i < argc; i++) { 1775 const char* file = argv[i]; 1776 if (stat(file, &sb) == -1) { 1777 fprintf(stderr, "Failed to stat %s\n", file); 1778 success = 0; 1779 goto finalize_session; 1780 } 1781 1782#if defined(_WIN32) // Remove when we're using clang for Win32. 1783 std::string cmd = android::base::StringPrintf( 1784 "exec:pm install-write -S %u %d %d_%s -", 1785 (unsigned) sb.st_size, session_id, i, get_basename(file)); 1786#else 1787 std::string cmd = android::base::StringPrintf( 1788 "exec:pm install-write -S %" PRIu64 " %d %d_%s -", 1789 static_cast<uint64_t>(sb.st_size), session_id, i, get_basename(file)); 1790#endif 1791 1792 int localFd = adb_open(file, O_RDONLY); 1793 if (localFd < 0) { 1794 fprintf(stderr, "Failed to open %s: %s\n", file, adb_error()); 1795 success = 0; 1796 goto finalize_session; 1797 } 1798 1799 int remoteFd = adb_connect(cmd.c_str()); 1800 if (remoteFd < 0) { 1801 fprintf(stderr, "Connect error for write: %s\n", adb_error()); 1802 adb_close(localFd); 1803 success = 0; 1804 goto finalize_session; 1805 } 1806 1807 copy_to_file(localFd, remoteFd); 1808 read_status_line(remoteFd, buf, sizeof(buf)); 1809 1810 adb_close(localFd); 1811 adb_close(remoteFd); 1812 1813 if (strncmp("Success", buf, 7)) { 1814 fprintf(stderr, "Failed to write %s\n", file); 1815 fputs(buf, stderr); 1816 success = 0; 1817 goto finalize_session; 1818 } 1819 } 1820 1821finalize_session: 1822 // Commit session if we streamed everything okay; otherwise abandon 1823 if (success) { 1824 snprintf(buf, sizeof(buf), "exec:pm install-commit %d", session_id); 1825 } else { 1826 snprintf(buf, sizeof(buf), "exec:pm install-abandon %d", session_id); 1827 } 1828 1829 fd = adb_connect(buf); 1830 if (fd < 0) { 1831 fprintf(stderr, "Connect error for finalize: %s\n", adb_error()); 1832 return -1; 1833 } 1834 read_status_line(fd, buf, sizeof(buf)); 1835 adb_close(fd); 1836 1837 if (!strncmp("Success", buf, 7)) { 1838 fputs(buf, stderr); 1839 return 0; 1840 } else { 1841 fprintf(stderr, "Failed to finalize session\n"); 1842 fputs(buf, stderr); 1843 return -1; 1844 } 1845} 1846