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