commandline.cpp revision 28a3e4958e74c4a3537e36329a3511410918c4e4
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 /* Validate and assign the server port */ 1097 const char* server_port_str = getenv("ANDROID_ADB_SERVER_PORT"); 1098 int server_port = DEFAULT_ADB_PORT; 1099 if (server_port_str && strlen(server_port_str) > 0) { 1100 server_port = strtol(server_port_str, nullptr, 0); 1101 if (server_port <= 0 || server_port > 65535) { 1102 fprintf(stderr, 1103 "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number less than 65536. Got \"%s\"\n", 1104 server_port_str); 1105 return usage(); 1106 } 1107 } 1108 1109 // We need to check for -d and -e before we look at $ANDROID_SERIAL. 1110 const char* serial = nullptr; 1111 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 // If none of -d, -e, or -s were specified, try $ANDROID_SERIAL. 1203 if (transport_type == kTransportAny && serial == nullptr) { 1204 serial = getenv("ANDROID_SERIAL"); 1205 } 1206 1207 adb_set_transport(transport_type, serial); 1208 adb_set_tcp_specifics(server_port); 1209 1210 if (is_server) { 1211 if (no_daemon || is_daemon) { 1212 if (is_daemon && (ack_reply_fd == -1)) { 1213 fprintf(stderr, "reply fd for adb server to client communication not specified.\n"); 1214 return usage(); 1215 } 1216 r = adb_main(is_daemon, server_port, ack_reply_fd); 1217 } else { 1218 r = launch_server(server_port); 1219 } 1220 if (r) { 1221 fprintf(stderr,"* could not start server *\n"); 1222 } 1223 return r; 1224 } 1225 1226 if (argc == 0) { 1227 return usage(); 1228 } 1229 1230 /* handle wait-for-* prefix */ 1231 if (!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) { 1232 const char* service = argv[0]; 1233 1234 if (!wait_for_device(service, transport_type, serial)) { 1235 return 1; 1236 } 1237 1238 // Allow a command to be run after wait-for-device, 1239 // e.g. 'adb wait-for-device shell'. 1240 if (argc == 1) { 1241 return 0; 1242 } 1243 1244 /* Fall through */ 1245 argc--; 1246 argv++; 1247 } 1248 1249 /* adb_connect() commands */ 1250 if (!strcmp(argv[0], "devices")) { 1251 const char *listopt; 1252 if (argc < 2) { 1253 listopt = ""; 1254 } else if (argc == 2 && !strcmp(argv[1], "-l")) { 1255 listopt = argv[1]; 1256 } else { 1257 fprintf(stderr, "Usage: adb devices [-l]\n"); 1258 return 1; 1259 } 1260 1261 std::string query = android::base::StringPrintf("host:%s%s", argv[0], listopt); 1262 printf("List of devices attached\n"); 1263 return adb_query_command(query); 1264 } 1265 else if (!strcmp(argv[0], "connect")) { 1266 if (argc != 2) { 1267 fprintf(stderr, "Usage: adb connect <host>[:<port>]\n"); 1268 return 1; 1269 } 1270 1271 std::string query = android::base::StringPrintf("host:connect:%s", argv[1]); 1272 return adb_query_command(query); 1273 } 1274 else if (!strcmp(argv[0], "disconnect")) { 1275 if (argc > 2) { 1276 fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]]\n"); 1277 return 1; 1278 } 1279 1280 std::string query = android::base::StringPrintf("host:disconnect:%s", 1281 (argc == 2) ? argv[1] : ""); 1282 return adb_query_command(query); 1283 } 1284 else if (!strcmp(argv[0], "emu")) { 1285 return adb_send_emulator_command(argc, argv, serial); 1286 } 1287 else if (!strcmp(argv[0], "shell") || !strcmp(argv[0], "hell")) { 1288 char h = (argv[0][0] == 'h'); 1289 1290 FeatureSet features = GetFeatureSet(transport_type, serial); 1291 1292 bool use_shell_protocol = CanUseFeature(features, kFeatureShell2); 1293 if (!use_shell_protocol) { 1294 D("shell protocol not supported, using raw data transfer"); 1295 } else { 1296 D("using shell protocol"); 1297 } 1298 1299 // Parse shell-specific command-line options. 1300 // argv[0] is always "shell". 1301 --argc; 1302 ++argv; 1303 std::string shell_type_arg; 1304 while (argc) { 1305 if (!strcmp(argv[0], "-T") || !strcmp(argv[0], "-t")) { 1306 if (!CanUseFeature(features, kFeatureShell2)) { 1307 fprintf(stderr, "error: target doesn't support PTY args -Tt\n"); 1308 return 1; 1309 } 1310 shell_type_arg = (argv[0][1] == 'T') ? kShellServiceArgRaw 1311 : kShellServiceArgPty; 1312 --argc; 1313 ++argv; 1314 } else if (!strcmp(argv[0], "-x")) { 1315 use_shell_protocol = false; 1316 --argc; 1317 ++argv; 1318 } else { 1319 break; 1320 } 1321 } 1322 1323 if (h) { 1324 printf("\x1b[41;33m"); 1325 fflush(stdout); 1326 } 1327 1328 if (!argc) { 1329 D("starting interactive shell"); 1330 std::string service_string = 1331 ShellServiceString(use_shell_protocol, shell_type_arg, ""); 1332 r = interactive_shell(service_string, use_shell_protocol); 1333 if (h) { 1334 printf("\x1b[0m"); 1335 fflush(stdout); 1336 } 1337 return r; 1338 } 1339 1340 // We don't escape here, just like ssh(1). http://b/20564385. 1341 std::string command = android::base::Join( 1342 std::vector<const char*>(argv, argv + argc), ' '); 1343 std::string service_string = 1344 ShellServiceString(use_shell_protocol, shell_type_arg, command); 1345 1346 while (true) { 1347 D("non-interactive shell loop. cmd=%s", service_string.c_str()); 1348 std::string error; 1349 int fd = adb_connect(service_string, &error); 1350 int r; 1351 if (fd >= 0) { 1352 D("about to read_and_dump(fd=%d)", fd); 1353 r = read_and_dump(fd, use_shell_protocol); 1354 D("read_and_dump() done."); 1355 adb_close(fd); 1356 } else { 1357 fprintf(stderr,"error: %s\n", error.c_str()); 1358 r = -1; 1359 } 1360 1361 if (h) { 1362 printf("\x1b[0m"); 1363 fflush(stdout); 1364 } 1365 D("non-interactive shell loop. return r=%d", r); 1366 return r; 1367 } 1368 } 1369 else if (!strcmp(argv[0], "exec-in") || !strcmp(argv[0], "exec-out")) { 1370 int exec_in = !strcmp(argv[0], "exec-in"); 1371 1372 std::string cmd = "exec:"; 1373 cmd += argv[1]; 1374 argc -= 2; 1375 argv += 2; 1376 while (argc-- > 0) { 1377 cmd += " " + escape_arg(*argv++); 1378 } 1379 1380 std::string error; 1381 int fd = adb_connect(cmd, &error); 1382 if (fd < 0) { 1383 fprintf(stderr, "error: %s\n", error.c_str()); 1384 return -1; 1385 } 1386 1387 if (exec_in) { 1388 copy_to_file(STDIN_FILENO, fd); 1389 } else { 1390 copy_to_file(fd, STDOUT_FILENO); 1391 } 1392 1393 adb_close(fd); 1394 return 0; 1395 } 1396 else if (!strcmp(argv[0], "kill-server")) { 1397 std::string error; 1398 int fd = _adb_connect("host:kill", &error); 1399 if (fd == -2) { 1400 // Failed to make network connection to server. Don't output the 1401 // network error since that is expected. 1402 fprintf(stderr,"* server not running *\n"); 1403 // Successful exit code because the server is already "killed". 1404 return 0; 1405 } else if (fd == -1) { 1406 // Some other error. 1407 fprintf(stderr, "error: %s\n", error.c_str()); 1408 return 1; 1409 } else { 1410 // Successfully connected, kill command sent, okay status came back. 1411 // Server should exit() in a moment, if not already. 1412 adb_close(fd); 1413 return 0; 1414 } 1415 } 1416 else if (!strcmp(argv[0], "sideload")) { 1417 if (argc != 2) return usage(); 1418 if (adb_sideload_host(argv[1])) { 1419 return 1; 1420 } else { 1421 return 0; 1422 } 1423 } 1424 else if (!strcmp(argv[0], "tcpip") && argc > 1) { 1425 return adb_connect_command(android::base::StringPrintf("tcpip:%s", argv[1])); 1426 } 1427 else if (!strcmp(argv[0], "remount") || 1428 !strcmp(argv[0], "reboot") || 1429 !strcmp(argv[0], "reboot-bootloader") || 1430 !strcmp(argv[0], "usb") || 1431 !strcmp(argv[0], "root") || 1432 !strcmp(argv[0], "unroot") || 1433 !strcmp(argv[0], "disable-verity") || 1434 !strcmp(argv[0], "enable-verity")) { 1435 std::string command; 1436 if (!strcmp(argv[0], "reboot-bootloader")) { 1437 command = "reboot:bootloader"; 1438 } else if (argc > 1) { 1439 command = android::base::StringPrintf("%s:%s", argv[0], argv[1]); 1440 } else { 1441 command = android::base::StringPrintf("%s:", argv[0]); 1442 } 1443 return adb_connect_command(command); 1444 } 1445 else if (!strcmp(argv[0], "bugreport")) { 1446 if (argc != 1) return usage(); 1447 // No need for shell protocol with bugreport, always disable for 1448 // simplicity. 1449 return send_shell_command(transport_type, serial, "bugreport", true); 1450 } 1451 else if (!strcmp(argv[0], "forward") || !strcmp(argv[0], "reverse")) { 1452 bool reverse = !strcmp(argv[0], "reverse"); 1453 ++argv; 1454 --argc; 1455 if (argc < 1) return usage(); 1456 1457 // Determine the <host-prefix> for this command. 1458 std::string host_prefix; 1459 if (reverse) { 1460 host_prefix = "reverse"; 1461 } else { 1462 if (serial) { 1463 host_prefix = android::base::StringPrintf("host-serial:%s", serial); 1464 } else if (transport_type == kTransportUsb) { 1465 host_prefix = "host-usb"; 1466 } else if (transport_type == kTransportLocal) { 1467 host_prefix = "host-local"; 1468 } else { 1469 host_prefix = "host"; 1470 } 1471 } 1472 1473 std::string cmd; 1474 if (strcmp(argv[0], "--list") == 0) { 1475 if (argc != 1) return usage(); 1476 return adb_query_command(host_prefix + ":list-forward"); 1477 } else if (strcmp(argv[0], "--remove-all") == 0) { 1478 if (argc != 1) return usage(); 1479 cmd = host_prefix + ":killforward-all"; 1480 } else if (strcmp(argv[0], "--remove") == 0) { 1481 // forward --remove <local> 1482 if (argc != 2) return usage(); 1483 cmd = host_prefix + ":killforward:" + argv[1]; 1484 } else if (strcmp(argv[0], "--no-rebind") == 0) { 1485 // forward --no-rebind <local> <remote> 1486 if (argc != 3) return usage(); 1487 cmd = host_prefix + ":forward:norebind:" + argv[1] + ";" + argv[2]; 1488 } else { 1489 // forward <local> <remote> 1490 if (argc != 2) return usage(); 1491 cmd = host_prefix + ":forward:" + argv[0] + ";" + argv[1]; 1492 } 1493 1494 return adb_command(cmd) ? 0 : 1; 1495 } 1496 /* do_sync_*() commands */ 1497 else if (!strcmp(argv[0], "ls")) { 1498 if (argc != 2) return usage(); 1499 return do_sync_ls(argv[1]) ? 0 : 1; 1500 } 1501 else if (!strcmp(argv[0], "push")) { 1502 bool show_progress = false; 1503 int copy_attrs = 0; 1504 const char* lpath = NULL, *rpath = NULL; 1505 1506 parse_push_pull_args(&argv[1], argc - 1, &lpath, &rpath, &show_progress, ©_attrs); 1507 if (!lpath || !rpath || copy_attrs != 0) return usage(); 1508 return do_sync_push(lpath, rpath, show_progress) ? 0 : 1; 1509 } 1510 else if (!strcmp(argv[0], "pull")) { 1511 bool show_progress = false; 1512 int copy_attrs = 0; 1513 const char* rpath = NULL, *lpath = "."; 1514 1515 parse_push_pull_args(&argv[1], argc - 1, &rpath, &lpath, &show_progress, ©_attrs); 1516 if (!rpath) return usage(); 1517 return do_sync_pull(rpath, lpath, show_progress, copy_attrs) ? 0 : 1; 1518 } 1519 else if (!strcmp(argv[0], "install")) { 1520 if (argc < 2) return usage(); 1521 return install_app(transport_type, serial, argc, argv); 1522 } 1523 else if (!strcmp(argv[0], "install-multiple")) { 1524 if (argc < 2) return usage(); 1525 return install_multiple_app(transport_type, serial, argc, argv); 1526 } 1527 else if (!strcmp(argv[0], "uninstall")) { 1528 if (argc < 2) return usage(); 1529 return uninstall_app(transport_type, serial, argc, argv); 1530 } 1531 else if (!strcmp(argv[0], "sync")) { 1532 std::string src; 1533 bool list_only = false; 1534 if (argc < 2) { 1535 // No local path was specified. 1536 src = ""; 1537 } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) { 1538 list_only = true; 1539 if (argc == 3) { 1540 src = argv[2]; 1541 } else { 1542 src = ""; 1543 } 1544 } else if (argc == 2) { 1545 // A local path or "android"/"data" arg was specified. 1546 src = argv[1]; 1547 } else { 1548 return usage(); 1549 } 1550 1551 if (src != "" && 1552 src != "system" && src != "data" && src != "vendor" && src != "oem") { 1553 return usage(); 1554 } 1555 1556 std::string system_src_path = product_file("system"); 1557 std::string data_src_path = product_file("data"); 1558 std::string vendor_src_path = product_file("vendor"); 1559 std::string oem_src_path = product_file("oem"); 1560 1561 bool okay = true; 1562 if (okay && (src.empty() || src == "system")) { 1563 okay = do_sync_sync(system_src_path, "/system", list_only); 1564 } 1565 if (okay && (src.empty() || src == "vendor") && directory_exists(vendor_src_path)) { 1566 okay = do_sync_sync(vendor_src_path, "/vendor", list_only); 1567 } 1568 if (okay && (src.empty() || src == "oem") && directory_exists(oem_src_path)) { 1569 okay = do_sync_sync(oem_src_path, "/oem", list_only); 1570 } 1571 if (okay && (src.empty() || src == "data")) { 1572 okay = do_sync_sync(data_src_path, "/data", list_only); 1573 } 1574 return okay ? 0 : 1; 1575 } 1576 /* passthrough commands */ 1577 else if (!strcmp(argv[0],"get-state") || 1578 !strcmp(argv[0],"get-serialno") || 1579 !strcmp(argv[0],"get-devpath")) 1580 { 1581 return adb_query_command(format_host_command(argv[0], transport_type, serial)); 1582 } 1583 /* other commands */ 1584 else if (!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat") || !strcmp(argv[0],"longcat")) { 1585 return logcat(transport_type, serial, argc, argv); 1586 } 1587 else if (!strcmp(argv[0],"ppp")) { 1588 return ppp(argc, argv); 1589 } 1590 else if (!strcmp(argv[0], "start-server")) { 1591 std::string error; 1592 const int result = adb_connect("host:start-server", &error); 1593 if (result < 0) { 1594 fprintf(stderr, "error: %s\n", error.c_str()); 1595 } 1596 return result; 1597 } 1598 else if (!strcmp(argv[0], "backup")) { 1599 return backup(argc, argv); 1600 } 1601 else if (!strcmp(argv[0], "restore")) { 1602 return restore(argc, argv); 1603 } 1604 else if (!strcmp(argv[0], "keygen")) { 1605 if (argc < 2) return usage(); 1606 // Always print key generation information for keygen command. 1607 adb_trace_enable(AUTH); 1608 return adb_auth_keygen(argv[1]); 1609 } 1610 else if (!strcmp(argv[0], "jdwp")) { 1611 return adb_connect_command("jdwp"); 1612 } 1613 /* "adb /?" is a common idiom under Windows */ 1614 else if (!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) { 1615 help(); 1616 return 0; 1617 } 1618 else if (!strcmp(argv[0], "version")) { 1619 fprintf(stdout, "%s", adb_version().c_str()); 1620 return 0; 1621 } 1622 else if (!strcmp(argv[0], "features")) { 1623 // Only list the features common to both the adb client and the device. 1624 FeatureSet features = GetFeatureSet(transport_type, serial); 1625 for (const std::string& name : features) { 1626 if (CanUseFeature(features, name)) { 1627 printf("%s\n", name.c_str()); 1628 } 1629 } 1630 return 0; 1631 } 1632 1633 usage(); 1634 return 1; 1635} 1636 1637static int pm_command(TransportType transport, const char* serial, int argc, const char** argv) { 1638 std::string cmd = "pm"; 1639 1640 while (argc-- > 0) { 1641 cmd += " " + escape_arg(*argv++); 1642 } 1643 1644 // TODO(dpursell): add command-line arguments to install/uninstall to 1645 // manually disable shell protocol if needed. 1646 return send_shell_command(transport, serial, cmd, false); 1647} 1648 1649static int uninstall_app(TransportType transport, const char* serial, int argc, const char** argv) { 1650 /* if the user choose the -k option, we refuse to do it until devices are 1651 out with the option to uninstall the remaining data somehow (adb/ui) */ 1652 if (argc == 3 && strcmp(argv[1], "-k") == 0) 1653 { 1654 printf( 1655 "The -k option uninstalls the application while retaining the data/cache.\n" 1656 "At the moment, there is no way to remove the remaining data.\n" 1657 "You will have to reinstall the application with the same signature, and fully uninstall it.\n" 1658 "If you truly wish to continue, execute 'adb shell pm uninstall -k %s'\n", argv[2]); 1659 return -1; 1660 } 1661 1662 /* 'adb uninstall' takes the same arguments as 'pm uninstall' on device */ 1663 return pm_command(transport, serial, argc, argv); 1664} 1665 1666static int delete_file(TransportType transport, const char* serial, const std::string& filename) { 1667 std::string cmd = "rm -f " + escape_arg(filename); 1668 return send_shell_command(transport, serial, cmd, false); 1669} 1670 1671static int install_app(TransportType transport, const char* serial, int argc, const char** argv) { 1672 static const char *const DATA_DEST = "/data/local/tmp/%s"; 1673 static const char *const SD_DEST = "/sdcard/tmp/%s"; 1674 const char* where = DATA_DEST; 1675 int i; 1676 struct stat sb; 1677 1678 for (i = 1; i < argc; i++) { 1679 if (!strcmp(argv[i], "-s")) { 1680 where = SD_DEST; 1681 } 1682 } 1683 1684 // Find last APK argument. 1685 // All other arguments passed through verbatim. 1686 int last_apk = -1; 1687 for (i = argc - 1; i >= 0; i--) { 1688 const char* file = argv[i]; 1689 const char* dot = strrchr(file, '.'); 1690 if (dot && !strcasecmp(dot, ".apk")) { 1691 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 1692 fprintf(stderr, "Invalid APK file: %s\n", file); 1693 return -1; 1694 } 1695 1696 last_apk = i; 1697 break; 1698 } 1699 } 1700 1701 if (last_apk == -1) { 1702 fprintf(stderr, "Missing APK file\n"); 1703 return -1; 1704 } 1705 1706 int result = -1; 1707 const char* apk_file = argv[last_apk]; 1708 std::string apk_dest = android::base::StringPrintf(where, adb_basename(apk_file).c_str()); 1709 if (!do_sync_push(apk_file, apk_dest.c_str(), false)) goto cleanup_apk; 1710 argv[last_apk] = apk_dest.c_str(); /* destination name, not source location */ 1711 result = pm_command(transport, serial, argc, argv); 1712 1713cleanup_apk: 1714 delete_file(transport, serial, apk_dest); 1715 return result; 1716} 1717 1718static int install_multiple_app(TransportType transport, const char* serial, int argc, 1719 const char** argv) 1720{ 1721 int i; 1722 struct stat sb; 1723 uint64_t total_size = 0; 1724 1725 // Find all APK arguments starting at end. 1726 // All other arguments passed through verbatim. 1727 int first_apk = -1; 1728 for (i = argc - 1; i >= 0; i--) { 1729 const char* file = argv[i]; 1730 const char* dot = strrchr(file, '.'); 1731 if (dot && !strcasecmp(dot, ".apk")) { 1732 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 1733 fprintf(stderr, "Invalid APK file: %s\n", file); 1734 return -1; 1735 } 1736 1737 total_size += sb.st_size; 1738 first_apk = i; 1739 } else { 1740 break; 1741 } 1742 } 1743 1744 if (first_apk == -1) { 1745 fprintf(stderr, "Missing APK file\n"); 1746 return 1; 1747 } 1748 1749 std::string cmd = android::base::StringPrintf("exec:pm install-create -S %" PRIu64, total_size); 1750 for (i = 1; i < first_apk; i++) { 1751 cmd += " " + escape_arg(argv[i]); 1752 } 1753 1754 // Create install session 1755 std::string error; 1756 int fd = adb_connect(cmd, &error); 1757 if (fd < 0) { 1758 fprintf(stderr, "Connect error for create: %s\n", error.c_str()); 1759 return -1; 1760 } 1761 char buf[BUFSIZ]; 1762 read_status_line(fd, buf, sizeof(buf)); 1763 adb_close(fd); 1764 1765 int session_id = -1; 1766 if (!strncmp("Success", buf, 7)) { 1767 char* start = strrchr(buf, '['); 1768 char* end = strrchr(buf, ']'); 1769 if (start && end) { 1770 *end = '\0'; 1771 session_id = strtol(start + 1, NULL, 10); 1772 } 1773 } 1774 if (session_id < 0) { 1775 fprintf(stderr, "Failed to create session\n"); 1776 fputs(buf, stderr); 1777 return -1; 1778 } 1779 1780 // Valid session, now stream the APKs 1781 int success = 1; 1782 for (i = first_apk; i < argc; i++) { 1783 const char* file = argv[i]; 1784 if (stat(file, &sb) == -1) { 1785 fprintf(stderr, "Failed to stat %s\n", file); 1786 success = 0; 1787 goto finalize_session; 1788 } 1789 1790 std::string cmd = android::base::StringPrintf( 1791 "exec:pm install-write -S %" PRIu64 " %d %d_%s -", 1792 static_cast<uint64_t>(sb.st_size), session_id, i, adb_basename(file).c_str()); 1793 1794 int localFd = adb_open(file, O_RDONLY); 1795 if (localFd < 0) { 1796 fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno)); 1797 success = 0; 1798 goto finalize_session; 1799 } 1800 1801 std::string error; 1802 int remoteFd = adb_connect(cmd, &error); 1803 if (remoteFd < 0) { 1804 fprintf(stderr, "Connect error for write: %s\n", error.c_str()); 1805 adb_close(localFd); 1806 success = 0; 1807 goto finalize_session; 1808 } 1809 1810 copy_to_file(localFd, remoteFd); 1811 read_status_line(remoteFd, buf, sizeof(buf)); 1812 1813 adb_close(localFd); 1814 adb_close(remoteFd); 1815 1816 if (strncmp("Success", buf, 7)) { 1817 fprintf(stderr, "Failed to write %s\n", file); 1818 fputs(buf, stderr); 1819 success = 0; 1820 goto finalize_session; 1821 } 1822 } 1823 1824finalize_session: 1825 // Commit session if we streamed everything okay; otherwise abandon 1826 std::string service = 1827 android::base::StringPrintf("exec:pm install-%s %d", 1828 success ? "commit" : "abandon", session_id); 1829 fd = adb_connect(service, &error); 1830 if (fd < 0) { 1831 fprintf(stderr, "Connect error for finalize: %s\n", error.c_str()); 1832 return -1; 1833 } 1834 read_status_line(fd, buf, sizeof(buf)); 1835 adb_close(fd); 1836 1837 if (!strncmp("Success", buf, 7)) { 1838 fputs(buf, stderr); 1839 return 0; 1840 } else { 1841 fprintf(stderr, "Failed to finalize session\n"); 1842 fputs(buf, stderr); 1843 return -1; 1844 } 1845} 1846