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