commandline.cpp revision 53daee6a2b415caa0ff3e425c7fa613c834bca61
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 int len; 316 long total = 0; 317 318 D("copy_to_file(%d -> %d)\n", inFd, outFd); 319 320 if (inFd == STDIN_FILENO) { 321 stdin_raw_init(STDIN_FILENO); 322 } 323 324 while (true) { 325 if (inFd == STDIN_FILENO) { 326 len = unix_read(inFd, buf, BUFSIZE); 327 } else { 328 len = adb_read(inFd, buf, BUFSIZE); 329 } 330 if (len == 0) { 331 D("copy_to_file() : read 0 bytes; exiting\n"); 332 break; 333 } 334 if (len < 0) { 335 if (errno == EINTR) { 336 D("copy_to_file() : EINTR, retrying\n"); 337 continue; 338 } 339 D("copy_to_file() : error %d\n", errno); 340 break; 341 } 342 if (outFd == STDOUT_FILENO) { 343 fwrite(buf, 1, len, stdout); 344 fflush(stdout); 345 } else { 346 adb_write(outFd, buf, len); 347 } 348 total += len; 349 } 350 351 if (inFd == STDIN_FILENO) { 352 stdin_raw_restore(STDIN_FILENO); 353 } 354 355 D("copy_to_file() finished after %lu bytes\n", total); 356 free(buf); 357} 358 359static void *stdin_read_thread(void *x) 360{ 361 int fd, fdi; 362 unsigned char buf[1024]; 363 int r, n; 364 int state = 0; 365 366 int *fds = (int*) x; 367 fd = fds[0]; 368 fdi = fds[1]; 369 free(fds); 370 371 for(;;) { 372 /* fdi is really the client's stdin, so use read, not adb_read here */ 373 D("stdin_read_thread(): pre unix_read(fdi=%d,...)\n", fdi); 374 r = unix_read(fdi, buf, 1024); 375 D("stdin_read_thread(): post unix_read(fdi=%d,...)\n", fdi); 376 if(r == 0) break; 377 if(r < 0) { 378 if(errno == EINTR) continue; 379 break; 380 } 381 for(n = 0; n < r; n++){ 382 switch(buf[n]) { 383 case '\n': 384 state = 1; 385 break; 386 case '\r': 387 state = 1; 388 break; 389 case '~': 390 if(state == 1) state++; 391 break; 392 case '.': 393 if(state == 2) { 394 fprintf(stderr,"\n* disconnect *\n"); 395 stdin_raw_restore(fdi); 396 exit(0); 397 } 398 default: 399 state = 0; 400 } 401 } 402 r = adb_write(fd, buf, r); 403 if(r <= 0) { 404 break; 405 } 406 } 407 return 0; 408} 409 410static int interactive_shell() { 411 adb_thread_t thr; 412 int fdi, fd; 413 414 fd = adb_connect("shell:"); 415 if(fd < 0) { 416 fprintf(stderr,"error: %s\n", adb_error()); 417 return 1; 418 } 419 fdi = 0; //dup(0); 420 421 int* fds = reinterpret_cast<int*>(malloc(sizeof(int) * 2)); 422 fds[0] = fd; 423 fds[1] = fdi; 424 425 stdin_raw_init(fdi); 426 adb_thread_create(&thr, stdin_read_thread, fds); 427 read_and_dump(fd); 428 stdin_raw_restore(fdi); 429 return 0; 430} 431 432 433static void format_host_command(char* buffer, size_t buflen, const char* command, transport_type ttype, const char* serial) 434{ 435 if (serial) { 436 snprintf(buffer, buflen, "host-serial:%s:%s", serial, command); 437 } else { 438 const char* prefix = "host"; 439 if (ttype == kTransportUsb) 440 prefix = "host-usb"; 441 else if (ttype == kTransportLocal) 442 prefix = "host-local"; 443 444 snprintf(buffer, buflen, "%s:%s", prefix, command); 445 } 446} 447 448static int adb_download_buffer(const char *service, const char *fn, const void* data, int sz, 449 unsigned progress) 450{ 451 char buf[4096]; 452 unsigned total; 453 int fd; 454 455 sprintf(buf,"%s:%d", service, sz); 456 fd = adb_connect(buf); 457 if(fd < 0) { 458 fprintf(stderr,"error: %s\n", adb_error()); 459 return -1; 460 } 461 462 int opt = CHUNK_SIZE; 463 opt = adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt)); 464 465 total = sz; 466 const uint8_t* ptr = reinterpret_cast<const uint8_t*>(data); 467 468 if(progress) { 469 char *x = strrchr(service, ':'); 470 if(x) service = x + 1; 471 } 472 473 while(sz > 0) { 474 unsigned xfer = (sz > CHUNK_SIZE) ? CHUNK_SIZE : sz; 475 if(!WriteFdExactly(fd, ptr, xfer)) { 476 adb_status(fd); 477 fprintf(stderr,"* failed to write data '%s' *\n", adb_error()); 478 return -1; 479 } 480 sz -= xfer; 481 ptr += xfer; 482 if(progress) { 483 printf("sending: '%s' %4d%% \r", fn, (int)(100LL - ((100LL * sz) / (total)))); 484 fflush(stdout); 485 } 486 } 487 if(progress) { 488 printf("\n"); 489 } 490 491 if(!ReadFdExactly(fd, buf, 4)){ 492 fprintf(stderr,"* error reading response *\n"); 493 adb_close(fd); 494 return -1; 495 } 496 if(memcmp(buf, "OKAY", 4)) { 497 buf[4] = 0; 498 fprintf(stderr,"* error response '%s' *\n", buf); 499 adb_close(fd); 500 return -1; 501 } 502 503 adb_close(fd); 504 return 0; 505} 506 507#define SIDELOAD_HOST_BLOCK_SIZE (CHUNK_SIZE) 508 509/* 510 * The sideload-host protocol serves the data in a file (given on the 511 * command line) to the client, using a simple protocol: 512 * 513 * - The connect message includes the total number of bytes in the 514 * file and a block size chosen by us. 515 * 516 * - The other side sends the desired block number as eight decimal 517 * digits (eg "00000023" for block 23). Blocks are numbered from 518 * zero. 519 * 520 * - We send back the data of the requested block. The last block is 521 * likely to be partial; when the last block is requested we only 522 * send the part of the block that exists, it's not padded up to the 523 * block size. 524 * 525 * - When the other side sends "DONEDONE" instead of a block number, 526 * we hang up. 527 */ 528static int adb_sideload_host(const char* fn) { 529 unsigned sz; 530 size_t xfer = 0; 531 int status; 532 int last_percent = -1; 533 int opt = SIDELOAD_HOST_BLOCK_SIZE; 534 535 printf("loading: '%s'", fn); 536 fflush(stdout); 537 uint8_t* data = reinterpret_cast<uint8_t*>(load_file(fn, &sz)); 538 if (data == 0) { 539 printf("\n"); 540 fprintf(stderr, "* cannot read '%s' *\n", fn); 541 return -1; 542 } 543 544 char buf[100]; 545 sprintf(buf, "sideload-host:%d:%d", sz, SIDELOAD_HOST_BLOCK_SIZE); 546 int fd = adb_connect(buf); 547 if (fd < 0) { 548 // Try falling back to the older sideload method. Maybe this 549 // is an older device that doesn't support sideload-host. 550 printf("\n"); 551 status = adb_download_buffer("sideload", fn, data, sz, 1); 552 goto done; 553 } 554 555 opt = adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt)); 556 557 while (true) { 558 if (!ReadFdExactly(fd, buf, 8)) { 559 fprintf(stderr, "* failed to read command: %s\n", adb_error()); 560 status = -1; 561 goto done; 562 } 563 564 if (strncmp("DONEDONE", buf, 8) == 0) { 565 status = 0; 566 break; 567 } 568 569 buf[8] = '\0'; 570 int block = strtol(buf, NULL, 10); 571 572 size_t offset = block * SIDELOAD_HOST_BLOCK_SIZE; 573 if (offset >= sz) { 574 fprintf(stderr, "* attempt to read past end: %s\n", adb_error()); 575 status = -1; 576 goto done; 577 } 578 uint8_t* start = data + offset; 579 size_t offset_end = offset + SIDELOAD_HOST_BLOCK_SIZE; 580 size_t to_write = SIDELOAD_HOST_BLOCK_SIZE; 581 if (offset_end > sz) { 582 to_write = sz - offset; 583 } 584 585 if(!WriteFdExactly(fd, start, to_write)) { 586 adb_status(fd); 587 fprintf(stderr,"* failed to write data '%s' *\n", adb_error()); 588 status = -1; 589 goto done; 590 } 591 xfer += to_write; 592 593 // For normal OTA packages, we expect to transfer every byte 594 // twice, plus a bit of overhead (one read during 595 // verification, one read of each byte for installation, plus 596 // extra access to things like the zip central directory). 597 // This estimate of the completion becomes 100% when we've 598 // transferred ~2.13 (=100/47) times the package size. 599 int percent = (int)(xfer * 47LL / (sz ? sz : 1)); 600 if (percent != last_percent) { 601 printf("\rserving: '%s' (~%d%%) ", fn, percent); 602 fflush(stdout); 603 last_percent = percent; 604 } 605 } 606 607 printf("\rTotal xfer: %.2fx%*s\n", (double)xfer / (sz ? sz : 1), (int)strlen(fn)+10, ""); 608 609 done: 610 if (fd >= 0) adb_close(fd); 611 free(data); 612 return status; 613} 614 615static void status_window(transport_type ttype, const char* serial) 616{ 617 char command[4096]; 618 char *state = 0; 619 char *laststate = 0; 620 621 /* silence stderr */ 622#ifdef _WIN32 623 /* XXX: TODO */ 624#else 625 int fd; 626 fd = unix_open("/dev/null", O_WRONLY); 627 dup2(fd, 2); 628 adb_close(fd); 629#endif 630 631 format_host_command(command, sizeof command, "get-state", ttype, serial); 632 633 for(;;) { 634 adb_sleep_ms(250); 635 636 if(state) { 637 free(state); 638 state = 0; 639 } 640 641 state = adb_query(command); 642 643 if(state) { 644 if(laststate && !strcmp(state,laststate)){ 645 continue; 646 } else { 647 if(laststate) free(laststate); 648 laststate = strdup(state); 649 } 650 } 651 652 printf("%c[2J%c[2H", 27, 27); 653 printf("Android Debug Bridge\n"); 654 printf("State: %s\n", state ? state : "offline"); 655 fflush(stdout); 656 } 657} 658 659/** 660 * Run ppp in "notty" mode against a resource listed as the first parameter 661 * eg: 662 * 663 * ppp dev:/dev/omap_csmi_tty0 <ppp options> 664 * 665 */ 666static int ppp(int argc, const char** argv) { 667#if defined(_WIN32) 668 fprintf(stderr, "error: adb %s not implemented on Win32\n", argv[0]); 669 return -1; 670#else 671 pid_t pid; 672 int fd; 673 674 if (argc < 2) { 675 fprintf(stderr, "usage: adb %s <adb service name> [ppp opts]\n", 676 argv[0]); 677 678 return 1; 679 } 680 681 const char* adb_service_name = argv[1]; 682 fd = adb_connect(adb_service_name); 683 684 if(fd < 0) { 685 fprintf(stderr,"Error: Could not open adb service: %s. Error: %s\n", 686 adb_service_name, adb_error()); 687 return 1; 688 } 689 690 pid = fork(); 691 692 if (pid < 0) { 693 perror("from fork()"); 694 return 1; 695 } else if (pid == 0) { 696 int err; 697 int i; 698 const char **ppp_args; 699 700 // copy args 701 ppp_args = (const char **) alloca(sizeof(char *) * argc + 1); 702 ppp_args[0] = "pppd"; 703 for (i = 2 ; i < argc ; i++) { 704 //argv[2] and beyond become ppp_args[1] and beyond 705 ppp_args[i - 1] = argv[i]; 706 } 707 ppp_args[i-1] = NULL; 708 709 // child side 710 711 dup2(fd, STDIN_FILENO); 712 dup2(fd, STDOUT_FILENO); 713 adb_close(STDERR_FILENO); 714 adb_close(fd); 715 716 err = execvp("pppd", (char * const *)ppp_args); 717 718 if (err < 0) { 719 perror("execing pppd"); 720 } 721 exit(-1); 722 } else { 723 // parent side 724 725 adb_close(fd); 726 return 0; 727 } 728#endif /* !defined(_WIN32) */ 729} 730 731static int send_shell_command(transport_type transport, const char* serial, 732 const std::string& command) { 733 int fd; 734 while (true) { 735 fd = adb_connect(command.c_str()); 736 if (fd >= 0) 737 break; 738 fprintf(stderr,"- waiting for device -\n"); 739 adb_sleep_ms(1000); 740 do_cmd(transport, serial, "wait-for-device", 0); 741 } 742 743 read_and_dump(fd); 744 int rc = adb_close(fd); 745 if (rc) { 746 perror("close"); 747 } 748 return rc; 749} 750 751static int logcat(transport_type transport, const char* serial, int argc, const char** argv) { 752 char* log_tags = getenv("ANDROID_LOG_TAGS"); 753 std::string quoted = escape_arg(log_tags == nullptr ? "" : log_tags); 754 755 std::string cmd = "shell:export ANDROID_LOG_TAGS=\"" + quoted + "\"; exec logcat"; 756 757 if (!strcmp(argv[0], "longcat")) { 758 cmd += " -v long"; 759 } 760 761 --argc; 762 ++argv; 763 while (argc-- > 0) { 764 cmd += " " + escape_arg(*argv++); 765 } 766 767 send_shell_command(transport, serial, cmd); 768 return 0; 769} 770 771static int mkdirs(const char *path) 772{ 773 int ret; 774 char *x = (char *)path + 1; 775 776 for(;;) { 777 x = adb_dirstart(x); 778 if(x == 0) return 0; 779 *x = 0; 780 ret = adb_mkdir(path, 0775); 781 *x = OS_PATH_SEPARATOR; 782 if((ret < 0) && (errno != EEXIST)) { 783 return ret; 784 } 785 x++; 786 } 787 return 0; 788} 789 790static int backup(int argc, const char** argv) { 791 const char* filename = "./backup.ab"; 792 793 /* find, extract, and use any -f argument */ 794 for (int i = 1; i < argc; i++) { 795 if (!strcmp("-f", argv[i])) { 796 if (i == argc-1) { 797 fprintf(stderr, "adb: -f passed with no filename\n"); 798 return usage(); 799 } 800 filename = argv[i+1]; 801 for (int j = i+2; j <= argc; ) { 802 argv[i++] = argv[j++]; 803 } 804 argc -= 2; 805 argv[argc] = NULL; 806 } 807 } 808 809 /* bare "adb backup" or "adb backup -f filename" are not valid invocations */ 810 if (argc < 2) return usage(); 811 812 adb_unlink(filename); 813 mkdirs(filename); 814 int outFd = adb_creat(filename, 0640); 815 if (outFd < 0) { 816 fprintf(stderr, "adb: unable to open file %s\n", filename); 817 return -1; 818 } 819 820 std::string cmd = "backup:"; 821 --argc; 822 ++argv; 823 while (argc-- > 0) { 824 cmd += " " + escape_arg(*argv++); 825 } 826 827 D("backup. filename=%s cmd=%s\n", filename, cmd.c_str()); 828 int fd = adb_connect(cmd.c_str()); 829 if (fd < 0) { 830 fprintf(stderr, "adb: unable to connect for backup\n"); 831 adb_close(outFd); 832 return -1; 833 } 834 835 printf("Now unlock your device and confirm the backup operation.\n"); 836 copy_to_file(fd, outFd); 837 838 adb_close(fd); 839 adb_close(outFd); 840 return 0; 841} 842 843static int restore(int argc, const char** argv) { 844 const char* filename; 845 int fd, tarFd; 846 847 if (argc != 2) return usage(); 848 849 filename = argv[1]; 850 tarFd = adb_open(filename, O_RDONLY); 851 if (tarFd < 0) { 852 fprintf(stderr, "adb: unable to open file %s\n", filename); 853 return -1; 854 } 855 856 fd = adb_connect("restore:"); 857 if (fd < 0) { 858 fprintf(stderr, "adb: unable to connect for restore\n"); 859 adb_close(tarFd); 860 return -1; 861 } 862 863 printf("Now unlock your device and confirm the restore operation.\n"); 864 copy_to_file(tarFd, fd); 865 866 adb_close(fd); 867 adb_close(tarFd); 868 return 0; 869} 870 871/* <hint> may be: 872 * - A simple product name 873 * e.g., "sooner" 874 * - A relative path from the CWD to the ANDROID_PRODUCT_OUT dir 875 * e.g., "out/target/product/sooner" 876 * - An absolute path to the PRODUCT_OUT dir 877 * e.g., "/src/device/out/target/product/sooner" 878 * 879 * Given <hint>, try to construct an absolute path to the 880 * ANDROID_PRODUCT_OUT dir. 881 */ 882static std::string find_product_out_path(const char* hint) { 883 if (hint == NULL || hint[0] == '\0') { 884 return ""; 885 } 886 887 // If it's already absolute, don't bother doing any work. 888 if (adb_is_absolute_host_path(hint)) { 889 return hint; 890 } 891 892 // If there are any slashes in it, assume it's a relative path; 893 // make it absolute. 894 if (adb_dirstart(hint) != nullptr) { 895 std::string cwd; 896 if (!getcwd(&cwd)) { 897 fprintf(stderr, "adb: getcwd failed: %s\n", strerror(errno)); 898 return ""; 899 } 900 return android::base::StringPrintf("%s%s%s", cwd.c_str(), OS_PATH_SEPARATOR_STR, hint); 901 } 902 903 // It's a string without any slashes. Try to do something with it. 904 // 905 // Try to find the root of the build tree, and build a PRODUCT_OUT 906 // path from there. 907 char* top = getenv("ANDROID_BUILD_TOP"); 908 if (top == nullptr) { 909 fprintf(stderr, "adb: ANDROID_BUILD_TOP not set!\n"); 910 return ""; 911 } 912 913 std::string path = top; 914 path += OS_PATH_SEPARATOR_STR; 915 path += "out"; 916 path += OS_PATH_SEPARATOR_STR; 917 path += "target"; 918 path += OS_PATH_SEPARATOR_STR; 919 path += "product"; 920 path += OS_PATH_SEPARATOR_STR; 921 path += hint; 922 if (!directory_exists(path)) { 923 fprintf(stderr, "adb: Couldn't find a product dir based on -p %s; " 924 "\"%s\" doesn't exist\n", hint, path.c_str()); 925 return ""; 926 } 927 return path; 928} 929 930static void parse_push_pull_args(const char **arg, int narg, char const **path1, 931 char const **path2, int *show_progress, 932 int *copy_attrs) { 933 *show_progress = 0; 934 *copy_attrs = 0; 935 936 while (narg > 0) { 937 if (!strcmp(*arg, "-p")) { 938 *show_progress = 1; 939 } else if (!strcmp(*arg, "-a")) { 940 *copy_attrs = 1; 941 } else { 942 break; 943 } 944 ++arg; 945 --narg; 946 } 947 948 if (narg > 0) { 949 *path1 = *arg; 950 ++arg; 951 --narg; 952 } 953 954 if (narg > 0) { 955 *path2 = *arg; 956 } 957} 958 959static int adb_connect_command(const char* command) { 960 int fd = adb_connect(command); 961 if (fd != -1) { 962 read_and_dump(fd); 963 adb_close(fd); 964 return 0; 965 } 966 fprintf(stderr, "Error: %s\n", adb_error()); 967 return 1; 968} 969 970int adb_commandline(int argc, const char **argv) 971{ 972 char buf[4096]; 973 int no_daemon = 0; 974 int is_daemon = 0; 975 int is_server = 0; 976 int persist = 0; 977 int r; 978 transport_type ttype = kTransportAny; 979 const char* serial = NULL; 980 const char* server_port_str = NULL; 981 982 // If defined, this should be an absolute path to 983 // the directory containing all of the various system images 984 // for a particular product. If not defined, and the adb 985 // command requires this information, then the user must 986 // specify the path using "-p". 987 char* ANDROID_PRODUCT_OUT = getenv("ANDROID_PRODUCT_OUT"); 988 if (ANDROID_PRODUCT_OUT != nullptr) { 989 gProductOutPath = ANDROID_PRODUCT_OUT; 990 } 991 // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint 992 993 serial = getenv("ANDROID_SERIAL"); 994 995 /* Validate and assign the server port */ 996 server_port_str = getenv("ANDROID_ADB_SERVER_PORT"); 997 int server_port = DEFAULT_ADB_PORT; 998 if (server_port_str && strlen(server_port_str) > 0) { 999 server_port = (int) strtol(server_port_str, NULL, 0); 1000 if (server_port <= 0 || server_port > 65535) { 1001 fprintf(stderr, 1002 "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number less than 65535. Got \"%s\"\n", 1003 server_port_str); 1004 return usage(); 1005 } 1006 } 1007 1008 /* modifiers and flags */ 1009 while (argc > 0) { 1010 if (!strcmp(argv[0],"server")) { 1011 is_server = 1; 1012 } else if (!strcmp(argv[0],"nodaemon")) { 1013 no_daemon = 1; 1014 } else if (!strcmp(argv[0], "fork-server")) { 1015 /* this is a special flag used only when the ADB client launches the ADB Server */ 1016 is_daemon = 1; 1017 } else if (!strcmp(argv[0],"persist")) { 1018 persist = 1; 1019 } else if (!strncmp(argv[0], "-p", 2)) { 1020 const char *product = NULL; 1021 if (argv[0][2] == '\0') { 1022 if (argc < 2) return usage(); 1023 product = argv[1]; 1024 argc--; 1025 argv++; 1026 } else { 1027 product = argv[0] + 2; 1028 } 1029 gProductOutPath = find_product_out_path(product); 1030 if (gProductOutPath.empty()) { 1031 fprintf(stderr, "adb: could not resolve \"-p %s\"\n", product); 1032 return usage(); 1033 } 1034 } else if (argv[0][0]=='-' && argv[0][1]=='s') { 1035 if (isdigit(argv[0][2])) { 1036 serial = argv[0] + 2; 1037 } else { 1038 if (argc < 2 || argv[0][2] != '\0') return usage(); 1039 serial = argv[1]; 1040 argc--; 1041 argv++; 1042 } 1043 } else if (!strcmp(argv[0],"-d")) { 1044 ttype = kTransportUsb; 1045 } else if (!strcmp(argv[0],"-e")) { 1046 ttype = kTransportLocal; 1047 } else if (!strcmp(argv[0],"-a")) { 1048 gListenAll = 1; 1049 } else if (!strncmp(argv[0], "-H", 2)) { 1050 const char *hostname = NULL; 1051 if (argv[0][2] == '\0') { 1052 if (argc < 2) return usage(); 1053 hostname = argv[1]; 1054 argc--; 1055 argv++; 1056 } else { 1057 hostname = argv[0] + 2; 1058 } 1059 adb_set_tcp_name(hostname); 1060 1061 } else if (!strncmp(argv[0], "-P", 2)) { 1062 if (argv[0][2] == '\0') { 1063 if (argc < 2) return usage(); 1064 server_port_str = argv[1]; 1065 argc--; 1066 argv++; 1067 } else { 1068 server_port_str = argv[0] + 2; 1069 } 1070 if (strlen(server_port_str) > 0) { 1071 server_port = (int) strtol(server_port_str, NULL, 0); 1072 if (server_port <= 0 || server_port > 65535) { 1073 fprintf(stderr, 1074 "adb: port number must be a positive number less than 65536. Got \"%s\"\n", 1075 server_port_str); 1076 return usage(); 1077 } 1078 } else { 1079 fprintf(stderr, 1080 "adb: port number must be a positive number less than 65536. Got empty string.\n"); 1081 return usage(); 1082 } 1083 } else { 1084 /* out of recognized modifiers and flags */ 1085 break; 1086 } 1087 argc--; 1088 argv++; 1089 } 1090 1091 adb_set_transport(ttype, serial); 1092 adb_set_tcp_specifics(server_port); 1093 1094 if (is_server) { 1095 if (no_daemon || is_daemon) { 1096 r = adb_main(is_daemon, server_port); 1097 } else { 1098 r = launch_server(server_port); 1099 } 1100 if (r) { 1101 fprintf(stderr,"* could not start server *\n"); 1102 } 1103 return r; 1104 } 1105 1106 if (argc == 0) { 1107 return usage(); 1108 } 1109 1110 /* handle wait-for-* prefix */ 1111 if (!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) { 1112 const char* service = argv[0]; 1113 if (!strncmp(service, "wait-for-device", strlen("wait-for-device"))) { 1114 if (ttype == kTransportUsb) { 1115 service = "wait-for-usb"; 1116 } else if (ttype == kTransportLocal) { 1117 service = "wait-for-local"; 1118 } else { 1119 service = "wait-for-any"; 1120 } 1121 } 1122 1123 format_host_command(buf, sizeof buf, service, ttype, serial); 1124 1125 if (adb_command(buf)) { 1126 D("failure: %s *\n",adb_error()); 1127 fprintf(stderr,"error: %s\n", adb_error()); 1128 return 1; 1129 } 1130 1131 /* Allow a command to be run after wait-for-device, 1132 * e.g. 'adb wait-for-device shell'. 1133 */ 1134 if (argc == 1) { 1135 return 0; 1136 } 1137 1138 /* Fall through */ 1139 argc--; 1140 argv++; 1141 } 1142 1143 /* adb_connect() commands */ 1144 if (!strcmp(argv[0], "devices")) { 1145 char *tmp; 1146 const char *listopt; 1147 if (argc < 2) 1148 listopt = ""; 1149 else if (argc == 2 && !strcmp(argv[1], "-l")) 1150 listopt = argv[1]; 1151 else { 1152 fprintf(stderr, "Usage: adb devices [-l]\n"); 1153 return 1; 1154 } 1155 snprintf(buf, sizeof buf, "host:%s%s", argv[0], listopt); 1156 tmp = adb_query(buf); 1157 if (tmp) { 1158 printf("List of devices attached \n"); 1159 printf("%s\n", tmp); 1160 return 0; 1161 } else { 1162 return 1; 1163 } 1164 } 1165 else if (!strcmp(argv[0], "connect")) { 1166 char *tmp; 1167 if (argc != 2) { 1168 fprintf(stderr, "Usage: adb connect <host>[:<port>]\n"); 1169 return 1; 1170 } 1171 snprintf(buf, sizeof buf, "host:connect:%s", argv[1]); 1172 tmp = adb_query(buf); 1173 if (tmp) { 1174 printf("%s\n", tmp); 1175 return 0; 1176 } else { 1177 return 1; 1178 } 1179 } 1180 else if (!strcmp(argv[0], "disconnect")) { 1181 char *tmp; 1182 if (argc > 2) { 1183 fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]]\n"); 1184 return 1; 1185 } 1186 if (argc == 2) { 1187 snprintf(buf, sizeof buf, "host:disconnect:%s", argv[1]); 1188 } else { 1189 snprintf(buf, sizeof buf, "host:disconnect:"); 1190 } 1191 tmp = adb_query(buf); 1192 if (tmp) { 1193 printf("%s\n", tmp); 1194 return 0; 1195 } else { 1196 return 1; 1197 } 1198 } 1199 else if (!strcmp(argv[0], "emu")) { 1200 return adb_send_emulator_command(argc, argv); 1201 } 1202 else if (!strcmp(argv[0], "shell") || !strcmp(argv[0], "hell")) { 1203 char h = (argv[0][0] == 'h'); 1204 1205 if (h) { 1206 printf("\x1b[41;33m"); 1207 fflush(stdout); 1208 } 1209 1210 if (argc < 2) { 1211 D("starting interactive shell\n"); 1212 r = interactive_shell(); 1213 if (h) { 1214 printf("\x1b[0m"); 1215 fflush(stdout); 1216 } 1217 return r; 1218 } 1219 1220 std::string cmd = "shell:"; 1221 cmd += argv[1]; 1222 argc -= 2; 1223 argv += 2; 1224 while (argc-- > 0) { 1225 cmd += " " + escape_arg(*argv++); 1226 } 1227 1228 while (true) { 1229 D("interactive shell loop. cmd=%s\n", cmd.c_str()); 1230 int fd = adb_connect(cmd.c_str()); 1231 int r; 1232 if (fd >= 0) { 1233 D("about to read_and_dump(fd=%d)\n", fd); 1234 read_and_dump(fd); 1235 D("read_and_dump() done.\n"); 1236 adb_close(fd); 1237 r = 0; 1238 } else { 1239 fprintf(stderr,"error: %s\n", adb_error()); 1240 r = -1; 1241 } 1242 1243 if (persist) { 1244 fprintf(stderr,"\n- waiting for device -\n"); 1245 adb_sleep_ms(1000); 1246 do_cmd(ttype, serial, "wait-for-device", 0); 1247 } else { 1248 if (h) { 1249 printf("\x1b[0m"); 1250 fflush(stdout); 1251 } 1252 D("interactive shell loop. return r=%d\n", r); 1253 return r; 1254 } 1255 } 1256 } 1257 else if (!strcmp(argv[0], "exec-in") || !strcmp(argv[0], "exec-out")) { 1258 int exec_in = !strcmp(argv[0], "exec-in"); 1259 1260 std::string cmd = "exec:"; 1261 cmd += argv[1]; 1262 argc -= 2; 1263 argv += 2; 1264 while (argc-- > 0) { 1265 cmd += " " + escape_arg(*argv++); 1266 } 1267 1268 int fd = adb_connect(cmd.c_str()); 1269 if (fd < 0) { 1270 fprintf(stderr, "error: %s\n", adb_error()); 1271 return -1; 1272 } 1273 1274 if (exec_in) { 1275 copy_to_file(STDIN_FILENO, fd); 1276 } else { 1277 copy_to_file(fd, STDOUT_FILENO); 1278 } 1279 1280 adb_close(fd); 1281 return 0; 1282 } 1283 else if (!strcmp(argv[0], "kill-server")) { 1284 int fd; 1285 fd = _adb_connect("host:kill"); 1286 if (fd == -1) { 1287 fprintf(stderr,"* server not running *\n"); 1288 return 1; 1289 } 1290 return 0; 1291 } 1292 else if (!strcmp(argv[0], "sideload")) { 1293 if (argc != 2) return usage(); 1294 if (adb_sideload_host(argv[1])) { 1295 return 1; 1296 } else { 1297 return 0; 1298 } 1299 } 1300 else if (!strcmp(argv[0], "remount") || 1301 !strcmp(argv[0], "reboot") || 1302 !strcmp(argv[0], "reboot-bootloader") || 1303 !strcmp(argv[0], "tcpip") || 1304 !strcmp(argv[0], "usb") || 1305 !strcmp(argv[0], "root") || 1306 !strcmp(argv[0], "unroot") || 1307 !strcmp(argv[0], "disable-verity") || 1308 !strcmp(argv[0], "enable-verity")) { 1309 char command[100]; 1310 if (!strcmp(argv[0], "reboot-bootloader")) { 1311 snprintf(command, sizeof(command), "reboot:bootloader"); 1312 } else if (argc > 1) { 1313 snprintf(command, sizeof(command), "%s:%s", argv[0], argv[1]); 1314 } else { 1315 snprintf(command, sizeof(command), "%s:", argv[0]); 1316 } 1317 return adb_connect_command(command); 1318 } 1319 else if (!strcmp(argv[0], "bugreport")) { 1320 if (argc != 1) return usage(); 1321 do_cmd(ttype, serial, "shell", "bugreport", 0); 1322 return 0; 1323 } 1324 /* adb_command() wrapper commands */ 1325 else if (!strcmp(argv[0], "forward") || !strcmp(argv[0], "reverse")) { 1326 char host_prefix[64]; 1327 char reverse = (char) !strcmp(argv[0], "reverse"); 1328 char remove = 0; 1329 char remove_all = 0; 1330 char list = 0; 1331 char no_rebind = 0; 1332 1333 // Parse options here. 1334 while (argc > 1 && argv[1][0] == '-') { 1335 if (!strcmp(argv[1], "--list")) 1336 list = 1; 1337 else if (!strcmp(argv[1], "--remove")) 1338 remove = 1; 1339 else if (!strcmp(argv[1], "--remove-all")) 1340 remove_all = 1; 1341 else if (!strcmp(argv[1], "--no-rebind")) 1342 no_rebind = 1; 1343 else { 1344 return usage(); 1345 } 1346 argc--; 1347 argv++; 1348 } 1349 1350 // Ensure we can only use one option at a time. 1351 if (list + remove + remove_all + no_rebind > 1) { 1352 return usage(); 1353 } 1354 1355 // Determine the <host-prefix> for this command. 1356 if (reverse) { 1357 snprintf(host_prefix, sizeof host_prefix, "reverse"); 1358 } else { 1359 if (serial) { 1360 snprintf(host_prefix, sizeof host_prefix, "host-serial:%s", 1361 serial); 1362 } else if (ttype == kTransportUsb) { 1363 snprintf(host_prefix, sizeof host_prefix, "host-usb"); 1364 } else if (ttype == kTransportLocal) { 1365 snprintf(host_prefix, sizeof host_prefix, "host-local"); 1366 } else { 1367 snprintf(host_prefix, sizeof host_prefix, "host"); 1368 } 1369 } 1370 1371 // Implement forward --list 1372 if (list) { 1373 if (argc != 1) 1374 return usage(); 1375 snprintf(buf, sizeof buf, "%s:list-forward", host_prefix); 1376 char* forwards = adb_query(buf); 1377 if (forwards == NULL) { 1378 fprintf(stderr, "error: %s\n", adb_error()); 1379 return 1; 1380 } 1381 printf("%s", forwards); 1382 free(forwards); 1383 return 0; 1384 } 1385 1386 // Implement forward --remove-all 1387 else if (remove_all) { 1388 if (argc != 1) 1389 return usage(); 1390 snprintf(buf, sizeof buf, "%s:killforward-all", host_prefix); 1391 } 1392 1393 // Implement forward --remove <local> 1394 else if (remove) { 1395 if (argc != 2) 1396 return usage(); 1397 snprintf(buf, sizeof buf, "%s:killforward:%s", host_prefix, argv[1]); 1398 } 1399 // Or implement one of: 1400 // forward <local> <remote> 1401 // forward --no-rebind <local> <remote> 1402 else 1403 { 1404 if (argc != 3) 1405 return usage(); 1406 const char* command = no_rebind ? "forward:norebind" : "forward"; 1407 snprintf(buf, sizeof buf, "%s:%s:%s;%s", host_prefix, command, argv[1], argv[2]); 1408 } 1409 1410 if (adb_command(buf)) { 1411 fprintf(stderr,"error: %s\n", adb_error()); 1412 return 1; 1413 } 1414 return 0; 1415 } 1416 /* do_sync_*() commands */ 1417 else if (!strcmp(argv[0], "ls")) { 1418 if (argc != 2) return usage(); 1419 return do_sync_ls(argv[1]); 1420 } 1421 else if (!strcmp(argv[0], "push")) { 1422 int show_progress = 0; 1423 int copy_attrs = 0; // unused 1424 const char* lpath = NULL, *rpath = NULL; 1425 1426 parse_push_pull_args(&argv[1], argc - 1, &lpath, &rpath, &show_progress, ©_attrs); 1427 1428 if ((lpath != NULL) && (rpath != NULL)) { 1429 return do_sync_push(lpath, rpath, show_progress); 1430 } 1431 1432 return usage(); 1433 } 1434 else if (!strcmp(argv[0], "pull")) { 1435 int show_progress = 0; 1436 int copy_attrs = 0; 1437 const char* rpath = NULL, *lpath = "."; 1438 1439 parse_push_pull_args(&argv[1], argc - 1, &rpath, &lpath, &show_progress, ©_attrs); 1440 1441 if (rpath != NULL) { 1442 return do_sync_pull(rpath, lpath, show_progress, copy_attrs); 1443 } 1444 1445 return usage(); 1446 } 1447 else if (!strcmp(argv[0], "install")) { 1448 if (argc < 2) return usage(); 1449 return install_app(ttype, serial, argc, argv); 1450 } 1451 else if (!strcmp(argv[0], "install-multiple")) { 1452 if (argc < 2) return usage(); 1453 return install_multiple_app(ttype, serial, argc, argv); 1454 } 1455 else if (!strcmp(argv[0], "uninstall")) { 1456 if (argc < 2) return usage(); 1457 return uninstall_app(ttype, serial, argc, argv); 1458 } 1459 else if (!strcmp(argv[0], "sync")) { 1460 std::string src_arg; 1461 bool list_only = false; 1462 if (argc < 2) { 1463 // No local path was specified. 1464 src_arg = ""; 1465 } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) { 1466 list_only = 1; 1467 if (argc == 3) { 1468 src_arg = argv[2]; 1469 } else { 1470 src_arg = ""; 1471 } 1472 } else if (argc == 2) { 1473 // A local path or "android"/"data" arg was specified. 1474 src_arg = argv[1]; 1475 } else { 1476 return usage(); 1477 } 1478 1479 if (src_arg != "" && 1480 src_arg != "system" && src_arg != "data" && src_arg != "vendor" && src_arg != "oem") { 1481 return usage(); 1482 } 1483 1484 std::string system_src_path = product_file("system"); 1485 std::string data_src_path = product_file("data"); 1486 std::string vendor_src_path = product_file("vendor"); 1487 std::string oem_src_path = product_file("oem"); 1488 if (!directory_exists(vendor_src_path)) { 1489 vendor_src_path = ""; 1490 } 1491 if (!directory_exists(oem_src_path)) { 1492 oem_src_path = ""; 1493 } 1494 1495 int rc = 0; 1496 if (rc == 0 && (src_arg.empty() || src_arg == "system")) { 1497 rc = do_sync_sync(system_src_path.c_str(), "/system", list_only); 1498 } 1499 if (rc == 0 && (src_arg.empty() || src_arg == "vendor")) { 1500 rc = do_sync_sync(vendor_src_path.c_str(), "/vendor", list_only); 1501 } 1502 if(rc == 0 && (src_arg.empty() || src_arg == "oem")) { 1503 rc = do_sync_sync(oem_src_path.c_str(), "/oem", list_only); 1504 } 1505 if (rc == 0 && (src_arg.empty() || src_arg == "data")) { 1506 rc = do_sync_sync(data_src_path.c_str(), "/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