commandline.cpp revision 1ed57f0dc333c0bc0800e222c569cca8a71deb89
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 bool raw_stdin; 429 std::unique_ptr<ShellProtocol> protocol; 430}; 431 432} // namespace 433 434// Loops to read from stdin and push the data to the given FD. 435// The argument should be a pointer to a StdinReadArgs object. This function 436// will take ownership of the object and delete it when finished. 437static void* stdin_read_thread(void* x) { 438 std::unique_ptr<StdinReadArgs> args(reinterpret_cast<StdinReadArgs*>(x)); 439 int state = 0; 440 441 adb_thread_setname("stdin reader"); 442 443 char raw_buffer[1024]; 444 char* buffer_ptr = raw_buffer; 445 size_t buffer_size = sizeof(raw_buffer); 446 if (args->protocol) { 447 buffer_ptr = args->protocol->data(); 448 buffer_size = args->protocol->data_capacity(); 449 } 450 451 while (true) { 452 // Use unix_read() rather than adb_read() for stdin. 453 D("stdin_read_thread(): pre unix_read(fdi=%d,...)", args->stdin_fd); 454 int r = unix_read(args->stdin_fd, buffer_ptr, buffer_size); 455 D("stdin_read_thread(): post unix_read(fdi=%d,...)", args->stdin_fd); 456 if (r <= 0) { 457 // Only devices using the shell protocol know to close subprocess 458 // stdin. For older devices we want to just leave the connection 459 // open, otherwise an unpredictable amount of return data could 460 // be lost due to the FD closing before all data has been received. 461 if (args->protocol) { 462 args->protocol->Write(ShellProtocol::kIdCloseStdin, 0); 463 } 464 break; 465 } 466 // If we made stdin raw, check input for the "~." escape sequence. In 467 // this situation signals like Ctrl+C are sent remotely rather than 468 // interpreted locally so this provides an emergency out if the remote 469 // process starts ignoring the signal. SSH also does this, see the 470 // "escape characters" section on the ssh man page for more info. 471 if (args->raw_stdin) { 472 for (int n = 0; n < r; n++){ 473 switch(buffer_ptr[n]) { 474 case '\n': 475 state = 1; 476 break; 477 case '\r': 478 state = 1; 479 break; 480 case '~': 481 if(state == 1) state++; 482 break; 483 case '.': 484 if(state == 2) { 485 stdin_raw_restore(args->stdin_fd); 486 fprintf(stderr,"\n* disconnect *\n"); 487 exit(0); 488 } 489 default: 490 state = 0; 491 } 492 } 493 } 494 if (args->protocol) { 495 if (!args->protocol->Write(ShellProtocol::kIdStdin, r)) { 496 break; 497 } 498 } else { 499 if (!WriteFdExactly(args->write_fd, buffer_ptr, r)) { 500 break; 501 } 502 } 503 } 504 505 return nullptr; 506} 507 508// Returns a shell service string with the indicated arguments and command. 509static std::string ShellServiceString(bool use_shell_protocol, 510 const std::string& type_arg, 511 const std::string& command) { 512 std::vector<std::string> args; 513 if (use_shell_protocol) { 514 args.push_back(kShellServiceArgShellProtocol); 515 } 516 if (!type_arg.empty()) { 517 args.push_back(type_arg); 518 } 519 520 // Shell service string can look like: shell[,arg1,arg2,...]:[command]. 521 return android::base::StringPrintf("shell%s%s:%s", 522 args.empty() ? "" : ",", 523 android::base::Join(args, ',').c_str(), 524 command.c_str()); 525} 526 527// Connects to a shell on the device and read/writes data. 528// 529// Note: currently this function doesn't properly clean up resources; the 530// FD connected to the adb server is never closed and the stdin read thread 531// may never exit. 532// 533// On success returns the remote exit code if |use_shell_protocol| is true, 534// 0 otherwise. On failure returns 1. 535static int RemoteShell(bool use_shell_protocol, const std::string& type_arg, 536 const std::string& command) { 537 std::string service_string = ShellServiceString(use_shell_protocol, 538 type_arg, command); 539 540 // Make local stdin raw if the device allocates a PTY, which happens if: 541 // 1. We are explicitly asking for a PTY shell, or 542 // 2. We don't specify shell type and are starting an interactive session. 543 bool raw_stdin = (type_arg == kShellServiceArgPty || 544 (type_arg.empty() && command.empty())); 545 546 std::string error; 547 int fd = adb_connect(service_string, &error); 548 if (fd < 0) { 549 fprintf(stderr,"error: %s\n", error.c_str()); 550 return 1; 551 } 552 553 StdinReadArgs* args = new StdinReadArgs; 554 if (!args) { 555 LOG(ERROR) << "couldn't allocate StdinReadArgs object"; 556 return 1; 557 } 558 args->stdin_fd = STDIN_FILENO; 559 args->write_fd = fd; 560 args->raw_stdin = raw_stdin; 561 if (use_shell_protocol) { 562 args->protocol.reset(new ShellProtocol(args->write_fd)); 563 } 564 565 if (raw_stdin) { 566 stdin_raw_init(STDIN_FILENO); 567 } 568 569 int exit_code = 0; 570 if (!adb_thread_create(stdin_read_thread, args)) { 571 PLOG(ERROR) << "error starting stdin read thread"; 572 exit_code = 1; 573 delete args; 574 } else { 575 exit_code = read_and_dump(fd, use_shell_protocol); 576 } 577 578 if (raw_stdin) { 579 stdin_raw_restore(STDIN_FILENO); 580 } 581 582 // TODO(dpursell): properly exit stdin_read_thread and close |fd|. 583 584 return exit_code; 585} 586 587 588static std::string format_host_command(const char* command, TransportType type, const char* serial) { 589 if (serial) { 590 return android::base::StringPrintf("host-serial:%s:%s", serial, command); 591 } 592 593 const char* prefix = "host"; 594 if (type == kTransportUsb) { 595 prefix = "host-usb"; 596 } else if (type == kTransportLocal) { 597 prefix = "host-local"; 598 } 599 return android::base::StringPrintf("%s:%s", prefix, command); 600} 601 602// Returns the FeatureSet for the indicated transport. 603static FeatureSet GetFeatureSet(TransportType transport_type, 604 const char* serial) { 605 std::string result, error; 606 607 if (adb_query(format_host_command("features", transport_type, serial), 608 &result, &error)) { 609 return StringToFeatureSet(result); 610 } 611 return FeatureSet(); 612} 613 614static int adb_download_buffer(const char *service, const char *fn, const void* data, unsigned sz, 615 bool show_progress) 616{ 617 std::string error; 618 int fd = adb_connect(android::base::StringPrintf("%s:%d", service, sz), &error); 619 if (fd < 0) { 620 fprintf(stderr,"error: %s\n", error.c_str()); 621 return -1; 622 } 623 624 int opt = CHUNK_SIZE; 625 opt = adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt)); 626 627 unsigned total = sz; 628 const uint8_t* ptr = reinterpret_cast<const uint8_t*>(data); 629 630 if (show_progress) { 631 const char* x = strrchr(service, ':'); 632 if (x) service = x + 1; 633 } 634 635 while (sz > 0) { 636 unsigned xfer = (sz > CHUNK_SIZE) ? CHUNK_SIZE : sz; 637 if (!WriteFdExactly(fd, ptr, xfer)) { 638 std::string error; 639 adb_status(fd, &error); 640 fprintf(stderr,"* failed to write data '%s' *\n", error.c_str()); 641 return -1; 642 } 643 sz -= xfer; 644 ptr += xfer; 645 if (show_progress) { 646 printf("sending: '%s' %4d%% \r", fn, (int)(100LL - ((100LL * sz) / (total)))); 647 fflush(stdout); 648 } 649 } 650 if (show_progress) { 651 printf("\n"); 652 } 653 654 if (!adb_status(fd, &error)) { 655 fprintf(stderr,"* error response '%s' *\n", error.c_str()); 656 return -1; 657 } 658 659 adb_close(fd); 660 return 0; 661} 662 663#define SIDELOAD_HOST_BLOCK_SIZE (CHUNK_SIZE) 664 665/* 666 * The sideload-host protocol serves the data in a file (given on the 667 * command line) to the client, using a simple protocol: 668 * 669 * - The connect message includes the total number of bytes in the 670 * file and a block size chosen by us. 671 * 672 * - The other side sends the desired block number as eight decimal 673 * digits (eg "00000023" for block 23). Blocks are numbered from 674 * zero. 675 * 676 * - We send back the data of the requested block. The last block is 677 * likely to be partial; when the last block is requested we only 678 * send the part of the block that exists, it's not padded up to the 679 * block size. 680 * 681 * - When the other side sends "DONEDONE" instead of a block number, 682 * we hang up. 683 */ 684static int adb_sideload_host(const char* fn) { 685 unsigned sz; 686 size_t xfer = 0; 687 int status; 688 int last_percent = -1; 689 int opt = SIDELOAD_HOST_BLOCK_SIZE; 690 691 printf("loading: '%s'", fn); 692 fflush(stdout); 693 uint8_t* data = reinterpret_cast<uint8_t*>(load_file(fn, &sz)); 694 if (data == 0) { 695 printf("\n"); 696 fprintf(stderr, "* cannot read '%s' *\n", fn); 697 return -1; 698 } 699 700 std::string service = 701 android::base::StringPrintf("sideload-host:%d:%d", sz, SIDELOAD_HOST_BLOCK_SIZE); 702 std::string error; 703 int fd = adb_connect(service, &error); 704 if (fd < 0) { 705 // Try falling back to the older sideload method. Maybe this 706 // is an older device that doesn't support sideload-host. 707 printf("\n"); 708 status = adb_download_buffer("sideload", fn, data, sz, true); 709 goto done; 710 } 711 712 opt = adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt)); 713 714 while (true) { 715 char buf[9]; 716 if (!ReadFdExactly(fd, buf, 8)) { 717 fprintf(stderr, "* failed to read command: %s\n", strerror(errno)); 718 status = -1; 719 goto done; 720 } 721 buf[8] = '\0'; 722 723 if (strcmp("DONEDONE", buf) == 0) { 724 status = 0; 725 break; 726 } 727 728 int block = strtol(buf, NULL, 10); 729 730 size_t offset = block * SIDELOAD_HOST_BLOCK_SIZE; 731 if (offset >= sz) { 732 fprintf(stderr, "* attempt to read block %d past end\n", block); 733 status = -1; 734 goto done; 735 } 736 uint8_t* start = data + offset; 737 size_t offset_end = offset + SIDELOAD_HOST_BLOCK_SIZE; 738 size_t to_write = SIDELOAD_HOST_BLOCK_SIZE; 739 if (offset_end > sz) { 740 to_write = sz - offset; 741 } 742 743 if(!WriteFdExactly(fd, start, to_write)) { 744 adb_status(fd, &error); 745 fprintf(stderr,"* failed to write data '%s' *\n", error.c_str()); 746 status = -1; 747 goto done; 748 } 749 xfer += to_write; 750 751 // For normal OTA packages, we expect to transfer every byte 752 // twice, plus a bit of overhead (one read during 753 // verification, one read of each byte for installation, plus 754 // extra access to things like the zip central directory). 755 // This estimate of the completion becomes 100% when we've 756 // transferred ~2.13 (=100/47) times the package size. 757 int percent = (int)(xfer * 47LL / (sz ? sz : 1)); 758 if (percent != last_percent) { 759 printf("\rserving: '%s' (~%d%%) ", fn, percent); 760 fflush(stdout); 761 last_percent = percent; 762 } 763 } 764 765 printf("\rTotal xfer: %.2fx%*s\n", (double)xfer / (sz ? sz : 1), (int)strlen(fn)+10, ""); 766 767 done: 768 if (fd >= 0) adb_close(fd); 769 free(data); 770 return status; 771} 772 773/** 774 * Run ppp in "notty" mode against a resource listed as the first parameter 775 * eg: 776 * 777 * ppp dev:/dev/omap_csmi_tty0 <ppp options> 778 * 779 */ 780static int ppp(int argc, const char** argv) { 781#if defined(_WIN32) 782 fprintf(stderr, "error: adb %s not implemented on Win32\n", argv[0]); 783 return -1; 784#else 785 if (argc < 2) { 786 fprintf(stderr, "usage: adb %s <adb service name> [ppp opts]\n", 787 argv[0]); 788 789 return 1; 790 } 791 792 const char* adb_service_name = argv[1]; 793 std::string error; 794 int fd = adb_connect(adb_service_name, &error); 795 if (fd < 0) { 796 fprintf(stderr,"Error: Could not open adb service: %s. Error: %s\n", 797 adb_service_name, error.c_str()); 798 return 1; 799 } 800 801 pid_t pid = fork(); 802 803 if (pid < 0) { 804 perror("from fork()"); 805 return 1; 806 } else if (pid == 0) { 807 int err; 808 int i; 809 const char **ppp_args; 810 811 // copy args 812 ppp_args = (const char **) alloca(sizeof(char *) * argc + 1); 813 ppp_args[0] = "pppd"; 814 for (i = 2 ; i < argc ; i++) { 815 //argv[2] and beyond become ppp_args[1] and beyond 816 ppp_args[i - 1] = argv[i]; 817 } 818 ppp_args[i-1] = NULL; 819 820 // child side 821 822 dup2(fd, STDIN_FILENO); 823 dup2(fd, STDOUT_FILENO); 824 adb_close(STDERR_FILENO); 825 adb_close(fd); 826 827 err = execvp("pppd", (char * const *)ppp_args); 828 829 if (err < 0) { 830 perror("execing pppd"); 831 } 832 exit(-1); 833 } else { 834 // parent side 835 836 adb_close(fd); 837 return 0; 838 } 839#endif /* !defined(_WIN32) */ 840} 841 842static bool wait_for_device(const char* service, TransportType t, const char* serial) { 843 // Was the caller vague about what they'd like us to wait for? 844 // If so, check they weren't more specific in their choice of transport type. 845 if (strcmp(service, "wait-for-device") == 0) { 846 if (t == kTransportUsb) { 847 service = "wait-for-usb"; 848 } else if (t == kTransportLocal) { 849 service = "wait-for-local"; 850 } else { 851 service = "wait-for-any"; 852 } 853 } 854 855 std::string cmd = format_host_command(service, t, serial); 856 return adb_command(cmd); 857} 858 859// Connects to the device "shell" service with |command| and prints the 860// resulting output. 861static int send_shell_command(TransportType transport_type, const char* serial, 862 const std::string& command, 863 bool disable_shell_protocol) { 864 // Only use shell protocol if it's supported and the caller doesn't want 865 // to explicitly disable it. 866 bool use_shell_protocol = false; 867 if (!disable_shell_protocol) { 868 FeatureSet features = GetFeatureSet(transport_type, serial); 869 use_shell_protocol = CanUseFeature(features, kFeatureShell2); 870 } 871 872 std::string service_string = ShellServiceString(use_shell_protocol, "", 873 command); 874 875 int fd; 876 while (true) { 877 std::string error; 878 fd = adb_connect(service_string, &error); 879 if (fd >= 0) { 880 break; 881 } 882 fprintf(stderr,"- waiting for device -\n"); 883 adb_sleep_ms(1000); 884 wait_for_device("wait-for-device", transport_type, serial); 885 } 886 887 int exit_code = read_and_dump(fd, use_shell_protocol); 888 889 if (adb_close(fd) < 0) { 890 PLOG(ERROR) << "failure closing FD " << fd; 891 } 892 893 return exit_code; 894} 895 896static int logcat(TransportType transport, const char* serial, int argc, const char** argv) { 897 char* log_tags = getenv("ANDROID_LOG_TAGS"); 898 std::string quoted = escape_arg(log_tags == nullptr ? "" : log_tags); 899 900 std::string cmd = "export ANDROID_LOG_TAGS=\"" + quoted + "\"; exec logcat"; 901 902 if (!strcmp(argv[0], "longcat")) { 903 cmd += " -v long"; 904 } 905 906 --argc; 907 ++argv; 908 while (argc-- > 0) { 909 cmd += " " + escape_arg(*argv++); 910 } 911 912 // No need for shell protocol with logcat, always disable for simplicity. 913 return send_shell_command(transport, serial, cmd, true); 914} 915 916static int backup(int argc, const char** argv) { 917 const char* filename = "./backup.ab"; 918 919 /* find, extract, and use any -f argument */ 920 for (int i = 1; i < argc; i++) { 921 if (!strcmp("-f", argv[i])) { 922 if (i == argc-1) { 923 fprintf(stderr, "adb: -f passed with no filename\n"); 924 return usage(); 925 } 926 filename = argv[i+1]; 927 for (int j = i+2; j <= argc; ) { 928 argv[i++] = argv[j++]; 929 } 930 argc -= 2; 931 argv[argc] = NULL; 932 } 933 } 934 935 /* bare "adb backup" or "adb backup -f filename" are not valid invocations */ 936 if (argc < 2) return usage(); 937 938 adb_unlink(filename); 939 mkdirs(filename); 940 int outFd = adb_creat(filename, 0640); 941 if (outFd < 0) { 942 fprintf(stderr, "adb: unable to open file %s\n", filename); 943 return -1; 944 } 945 946 std::string cmd = "backup:"; 947 --argc; 948 ++argv; 949 while (argc-- > 0) { 950 cmd += " " + escape_arg(*argv++); 951 } 952 953 D("backup. filename=%s cmd=%s", filename, cmd.c_str()); 954 std::string error; 955 int fd = adb_connect(cmd, &error); 956 if (fd < 0) { 957 fprintf(stderr, "adb: unable to connect for backup: %s\n", error.c_str()); 958 adb_close(outFd); 959 return -1; 960 } 961 962 printf("Now unlock your device and confirm the backup operation.\n"); 963 copy_to_file(fd, outFd); 964 965 adb_close(fd); 966 adb_close(outFd); 967 return 0; 968} 969 970static int restore(int argc, const char** argv) { 971 if (argc != 2) return usage(); 972 973 const char* filename = argv[1]; 974 int tarFd = adb_open(filename, O_RDONLY); 975 if (tarFd < 0) { 976 fprintf(stderr, "adb: unable to open file %s: %s\n", filename, strerror(errno)); 977 return -1; 978 } 979 980 std::string error; 981 int fd = adb_connect("restore:", &error); 982 if (fd < 0) { 983 fprintf(stderr, "adb: unable to connect for restore: %s\n", error.c_str()); 984 adb_close(tarFd); 985 return -1; 986 } 987 988 printf("Now unlock your device and confirm the restore operation.\n"); 989 copy_to_file(tarFd, fd); 990 991 adb_close(fd); 992 adb_close(tarFd); 993 return 0; 994} 995 996/* <hint> may be: 997 * - A simple product name 998 * e.g., "sooner" 999 * - A relative path from the CWD to the ANDROID_PRODUCT_OUT dir 1000 * e.g., "out/target/product/sooner" 1001 * - An absolute path to the PRODUCT_OUT dir 1002 * e.g., "/src/device/out/target/product/sooner" 1003 * 1004 * Given <hint>, try to construct an absolute path to the 1005 * ANDROID_PRODUCT_OUT dir. 1006 */ 1007static std::string find_product_out_path(const std::string& hint) { 1008 if (hint.empty()) { 1009 return ""; 1010 } 1011 1012 // If it's already absolute, don't bother doing any work. 1013 if (adb_is_absolute_host_path(hint.c_str())) { 1014 return hint; 1015 } 1016 1017 // If there are any slashes in it, assume it's a relative path; 1018 // make it absolute. 1019 if (hint.find_first_of(OS_PATH_SEPARATORS) != std::string::npos) { 1020 std::string cwd; 1021 if (!getcwd(&cwd)) { 1022 fprintf(stderr, "adb: getcwd failed: %s\n", strerror(errno)); 1023 return ""; 1024 } 1025 return android::base::StringPrintf("%s%c%s", cwd.c_str(), OS_PATH_SEPARATOR, hint.c_str()); 1026 } 1027 1028 // It's a string without any slashes. Try to do something with it. 1029 // 1030 // Try to find the root of the build tree, and build a PRODUCT_OUT 1031 // path from there. 1032 char* top = getenv("ANDROID_BUILD_TOP"); 1033 if (top == nullptr) { 1034 fprintf(stderr, "adb: ANDROID_BUILD_TOP not set!\n"); 1035 return ""; 1036 } 1037 1038 std::string path = top; 1039 path += OS_PATH_SEPARATOR_STR; 1040 path += "out"; 1041 path += OS_PATH_SEPARATOR_STR; 1042 path += "target"; 1043 path += OS_PATH_SEPARATOR_STR; 1044 path += "product"; 1045 path += OS_PATH_SEPARATOR_STR; 1046 path += hint; 1047 if (!directory_exists(path)) { 1048 fprintf(stderr, "adb: Couldn't find a product dir based on -p %s; " 1049 "\"%s\" doesn't exist\n", hint.c_str(), path.c_str()); 1050 return ""; 1051 } 1052 return path; 1053} 1054 1055static void parse_push_pull_args(const char **arg, int narg, char const **path1, 1056 char const **path2, bool* show_progress, 1057 int *copy_attrs) { 1058 *show_progress = false; 1059 *copy_attrs = 0; 1060 1061 while (narg > 0) { 1062 if (!strcmp(*arg, "-p")) { 1063 *show_progress = true; 1064 } else if (!strcmp(*arg, "-a")) { 1065 *copy_attrs = 1; 1066 } else { 1067 break; 1068 } 1069 ++arg; 1070 --narg; 1071 } 1072 1073 if (narg > 0) { 1074 *path1 = *arg; 1075 ++arg; 1076 --narg; 1077 } 1078 1079 if (narg > 0) { 1080 *path2 = *arg; 1081 } 1082} 1083 1084static int adb_connect_command(const std::string& command) { 1085 std::string error; 1086 int fd = adb_connect(command, &error); 1087 if (fd < 0) { 1088 fprintf(stderr, "error: %s\n", error.c_str()); 1089 return 1; 1090 } 1091 read_and_dump(fd); 1092 adb_close(fd); 1093 return 0; 1094} 1095 1096static int adb_query_command(const std::string& command) { 1097 std::string result; 1098 std::string error; 1099 if (!adb_query(command, &result, &error)) { 1100 fprintf(stderr, "error: %s\n", error.c_str()); 1101 return 1; 1102 } 1103 printf("%s\n", result.c_str()); 1104 return 0; 1105} 1106 1107// Disallow stdin, stdout, and stderr. 1108static bool _is_valid_ack_reply_fd(const int ack_reply_fd) { 1109#ifdef _WIN32 1110 const HANDLE ack_reply_handle = cast_int_to_handle(ack_reply_fd); 1111 return (GetStdHandle(STD_INPUT_HANDLE) != ack_reply_handle) && 1112 (GetStdHandle(STD_OUTPUT_HANDLE) != ack_reply_handle) && 1113 (GetStdHandle(STD_ERROR_HANDLE) != ack_reply_handle); 1114#else 1115 return ack_reply_fd > 2; 1116#endif 1117} 1118 1119int adb_commandline(int argc, const char **argv) { 1120 int no_daemon = 0; 1121 int is_daemon = 0; 1122 int is_server = 0; 1123 int r; 1124 TransportType transport_type = kTransportAny; 1125 int ack_reply_fd = -1; 1126 1127 // If defined, this should be an absolute path to 1128 // the directory containing all of the various system images 1129 // for a particular product. If not defined, and the adb 1130 // command requires this information, then the user must 1131 // specify the path using "-p". 1132 char* ANDROID_PRODUCT_OUT = getenv("ANDROID_PRODUCT_OUT"); 1133 if (ANDROID_PRODUCT_OUT != nullptr) { 1134 gProductOutPath = ANDROID_PRODUCT_OUT; 1135 } 1136 // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint 1137 1138 /* Validate and assign the server port */ 1139 const char* server_port_str = getenv("ANDROID_ADB_SERVER_PORT"); 1140 int server_port = DEFAULT_ADB_PORT; 1141 if (server_port_str && strlen(server_port_str) > 0) { 1142 server_port = strtol(server_port_str, nullptr, 0); 1143 if (server_port <= 0 || server_port > 65535) { 1144 fprintf(stderr, 1145 "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number less than 65536. Got \"%s\"\n", 1146 server_port_str); 1147 return usage(); 1148 } 1149 } 1150 1151 // We need to check for -d and -e before we look at $ANDROID_SERIAL. 1152 const char* serial = nullptr; 1153 1154 while (argc > 0) { 1155 if (!strcmp(argv[0],"server")) { 1156 is_server = 1; 1157 } else if (!strcmp(argv[0],"nodaemon")) { 1158 no_daemon = 1; 1159 } else if (!strcmp(argv[0], "fork-server")) { 1160 /* this is a special flag used only when the ADB client launches the ADB Server */ 1161 is_daemon = 1; 1162 } else if (!strcmp(argv[0], "--reply-fd")) { 1163 if (argc < 2) return usage(); 1164 const char* reply_fd_str = argv[1]; 1165 argc--; 1166 argv++; 1167 ack_reply_fd = strtol(reply_fd_str, nullptr, 10); 1168 if (!_is_valid_ack_reply_fd(ack_reply_fd)) { 1169 fprintf(stderr, "adb: invalid reply fd \"%s\"\n", reply_fd_str); 1170 return usage(); 1171 } 1172 } else if (!strncmp(argv[0], "-p", 2)) { 1173 const char* product = nullptr; 1174 if (argv[0][2] == '\0') { 1175 if (argc < 2) return usage(); 1176 product = argv[1]; 1177 argc--; 1178 argv++; 1179 } else { 1180 product = argv[0] + 2; 1181 } 1182 gProductOutPath = find_product_out_path(product); 1183 if (gProductOutPath.empty()) { 1184 fprintf(stderr, "adb: could not resolve \"-p %s\"\n", product); 1185 return usage(); 1186 } 1187 } else if (argv[0][0]=='-' && argv[0][1]=='s') { 1188 if (isdigit(argv[0][2])) { 1189 serial = argv[0] + 2; 1190 } else { 1191 if (argc < 2 || argv[0][2] != '\0') return usage(); 1192 serial = argv[1]; 1193 argc--; 1194 argv++; 1195 } 1196 } else if (!strcmp(argv[0],"-d")) { 1197 transport_type = kTransportUsb; 1198 } else if (!strcmp(argv[0],"-e")) { 1199 transport_type = kTransportLocal; 1200 } else if (!strcmp(argv[0],"-a")) { 1201 gListenAll = 1; 1202 } else if (!strncmp(argv[0], "-H", 2)) { 1203 const char *hostname = NULL; 1204 if (argv[0][2] == '\0') { 1205 if (argc < 2) return usage(); 1206 hostname = argv[1]; 1207 argc--; 1208 argv++; 1209 } else { 1210 hostname = argv[0] + 2; 1211 } 1212 adb_set_tcp_name(hostname); 1213 1214 } else if (!strncmp(argv[0], "-P", 2)) { 1215 if (argv[0][2] == '\0') { 1216 if (argc < 2) return usage(); 1217 server_port_str = argv[1]; 1218 argc--; 1219 argv++; 1220 } else { 1221 server_port_str = argv[0] + 2; 1222 } 1223 if (strlen(server_port_str) > 0) { 1224 server_port = (int) strtol(server_port_str, NULL, 0); 1225 if (server_port <= 0 || server_port > 65535) { 1226 fprintf(stderr, 1227 "adb: port number must be a positive number less than 65536. Got \"%s\"\n", 1228 server_port_str); 1229 return usage(); 1230 } 1231 } else { 1232 fprintf(stderr, 1233 "adb: port number must be a positive number less than 65536. Got empty string.\n"); 1234 return usage(); 1235 } 1236 } else { 1237 /* out of recognized modifiers and flags */ 1238 break; 1239 } 1240 argc--; 1241 argv++; 1242 } 1243 1244 // If none of -d, -e, or -s were specified, try $ANDROID_SERIAL. 1245 if (transport_type == kTransportAny && serial == nullptr) { 1246 serial = getenv("ANDROID_SERIAL"); 1247 } 1248 1249 adb_set_transport(transport_type, serial); 1250 adb_set_tcp_specifics(server_port); 1251 1252 if (is_server) { 1253 if (no_daemon || is_daemon) { 1254 if (is_daemon && (ack_reply_fd == -1)) { 1255 fprintf(stderr, "reply fd for adb server to client communication not specified.\n"); 1256 return usage(); 1257 } 1258 r = adb_main(is_daemon, server_port, ack_reply_fd); 1259 } else { 1260 r = launch_server(server_port); 1261 } 1262 if (r) { 1263 fprintf(stderr,"* could not start server *\n"); 1264 } 1265 return r; 1266 } 1267 1268 if (argc == 0) { 1269 return usage(); 1270 } 1271 1272 /* handle wait-for-* prefix */ 1273 if (!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) { 1274 const char* service = argv[0]; 1275 1276 if (!wait_for_device(service, transport_type, serial)) { 1277 return 1; 1278 } 1279 1280 // Allow a command to be run after wait-for-device, 1281 // e.g. 'adb wait-for-device shell'. 1282 if (argc == 1) { 1283 return 0; 1284 } 1285 1286 /* Fall through */ 1287 argc--; 1288 argv++; 1289 } 1290 1291 /* adb_connect() commands */ 1292 if (!strcmp(argv[0], "devices")) { 1293 const char *listopt; 1294 if (argc < 2) { 1295 listopt = ""; 1296 } else if (argc == 2 && !strcmp(argv[1], "-l")) { 1297 listopt = argv[1]; 1298 } else { 1299 fprintf(stderr, "Usage: adb devices [-l]\n"); 1300 return 1; 1301 } 1302 1303 std::string query = android::base::StringPrintf("host:%s%s", argv[0], listopt); 1304 printf("List of devices attached\n"); 1305 return adb_query_command(query); 1306 } 1307 else if (!strcmp(argv[0], "connect")) { 1308 if (argc != 2) { 1309 fprintf(stderr, "Usage: adb connect <host>[:<port>]\n"); 1310 return 1; 1311 } 1312 1313 std::string query = android::base::StringPrintf("host:connect:%s", argv[1]); 1314 return adb_query_command(query); 1315 } 1316 else if (!strcmp(argv[0], "disconnect")) { 1317 if (argc > 2) { 1318 fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]]\n"); 1319 return 1; 1320 } 1321 1322 std::string query = android::base::StringPrintf("host:disconnect:%s", 1323 (argc == 2) ? argv[1] : ""); 1324 return adb_query_command(query); 1325 } 1326 else if (!strcmp(argv[0], "emu")) { 1327 return adb_send_emulator_command(argc, argv, serial); 1328 } 1329 else if (!strcmp(argv[0], "shell") || !strcmp(argv[0], "hell")) { 1330 char h = (argv[0][0] == 'h'); 1331 1332 FeatureSet features = GetFeatureSet(transport_type, serial); 1333 1334 bool use_shell_protocol = CanUseFeature(features, kFeatureShell2); 1335 if (!use_shell_protocol) { 1336 D("shell protocol not supported, using raw data transfer"); 1337 } else { 1338 D("using shell protocol"); 1339 } 1340 1341 // Parse shell-specific command-line options. 1342 // argv[0] is always "shell". 1343 --argc; 1344 ++argv; 1345 std::string shell_type_arg; 1346 while (argc) { 1347 if (!strcmp(argv[0], "-T") || !strcmp(argv[0], "-t")) { 1348 if (!CanUseFeature(features, kFeatureShell2)) { 1349 fprintf(stderr, "error: target doesn't support PTY args -Tt\n"); 1350 return 1; 1351 } 1352 shell_type_arg = (argv[0][1] == 'T') ? kShellServiceArgRaw 1353 : kShellServiceArgPty; 1354 --argc; 1355 ++argv; 1356 } else if (!strcmp(argv[0], "-x")) { 1357 use_shell_protocol = false; 1358 --argc; 1359 ++argv; 1360 } else { 1361 break; 1362 } 1363 } 1364 1365 std::string command; 1366 if (argc) { 1367 // We don't escape here, just like ssh(1). http://b/20564385. 1368 command = android::base::Join( 1369 std::vector<const char*>(argv, argv + argc), ' '); 1370 } 1371 1372 if (h) { 1373 printf("\x1b[41;33m"); 1374 fflush(stdout); 1375 } 1376 1377 r = RemoteShell(use_shell_protocol, shell_type_arg, command); 1378 1379 if (h) { 1380 printf("\x1b[0m"); 1381 fflush(stdout); 1382 } 1383 1384 return r; 1385 } 1386 else if (!strcmp(argv[0], "exec-in") || !strcmp(argv[0], "exec-out")) { 1387 int exec_in = !strcmp(argv[0], "exec-in"); 1388 1389 std::string cmd = "exec:"; 1390 cmd += argv[1]; 1391 argc -= 2; 1392 argv += 2; 1393 while (argc-- > 0) { 1394 cmd += " " + escape_arg(*argv++); 1395 } 1396 1397 std::string error; 1398 int fd = adb_connect(cmd, &error); 1399 if (fd < 0) { 1400 fprintf(stderr, "error: %s\n", error.c_str()); 1401 return -1; 1402 } 1403 1404 if (exec_in) { 1405 copy_to_file(STDIN_FILENO, fd); 1406 } else { 1407 copy_to_file(fd, STDOUT_FILENO); 1408 } 1409 1410 adb_close(fd); 1411 return 0; 1412 } 1413 else if (!strcmp(argv[0], "kill-server")) { 1414 std::string error; 1415 int fd = _adb_connect("host:kill", &error); 1416 if (fd == -2) { 1417 // Failed to make network connection to server. Don't output the 1418 // network error since that is expected. 1419 fprintf(stderr,"* server not running *\n"); 1420 // Successful exit code because the server is already "killed". 1421 return 0; 1422 } else if (fd == -1) { 1423 // Some other error. 1424 fprintf(stderr, "error: %s\n", error.c_str()); 1425 return 1; 1426 } else { 1427 // Successfully connected, kill command sent, okay status came back. 1428 // Server should exit() in a moment, if not already. 1429 adb_close(fd); 1430 return 0; 1431 } 1432 } 1433 else if (!strcmp(argv[0], "sideload")) { 1434 if (argc != 2) return usage(); 1435 if (adb_sideload_host(argv[1])) { 1436 return 1; 1437 } else { 1438 return 0; 1439 } 1440 } 1441 else if (!strcmp(argv[0], "tcpip") && argc > 1) { 1442 return adb_connect_command(android::base::StringPrintf("tcpip:%s", argv[1])); 1443 } 1444 else if (!strcmp(argv[0], "remount") || 1445 !strcmp(argv[0], "reboot") || 1446 !strcmp(argv[0], "reboot-bootloader") || 1447 !strcmp(argv[0], "usb") || 1448 !strcmp(argv[0], "root") || 1449 !strcmp(argv[0], "unroot") || 1450 !strcmp(argv[0], "disable-verity") || 1451 !strcmp(argv[0], "enable-verity")) { 1452 std::string command; 1453 if (!strcmp(argv[0], "reboot-bootloader")) { 1454 command = "reboot:bootloader"; 1455 } else if (argc > 1) { 1456 command = android::base::StringPrintf("%s:%s", argv[0], argv[1]); 1457 } else { 1458 command = android::base::StringPrintf("%s:", argv[0]); 1459 } 1460 return adb_connect_command(command); 1461 } 1462 else if (!strcmp(argv[0], "bugreport")) { 1463 if (argc != 1) return usage(); 1464 // No need for shell protocol with bugreport, always disable for 1465 // simplicity. 1466 return send_shell_command(transport_type, serial, "bugreport", true); 1467 } 1468 else if (!strcmp(argv[0], "forward") || !strcmp(argv[0], "reverse")) { 1469 bool reverse = !strcmp(argv[0], "reverse"); 1470 ++argv; 1471 --argc; 1472 if (argc < 1) return usage(); 1473 1474 // Determine the <host-prefix> for this command. 1475 std::string host_prefix; 1476 if (reverse) { 1477 host_prefix = "reverse"; 1478 } else { 1479 if (serial) { 1480 host_prefix = android::base::StringPrintf("host-serial:%s", serial); 1481 } else if (transport_type == kTransportUsb) { 1482 host_prefix = "host-usb"; 1483 } else if (transport_type == kTransportLocal) { 1484 host_prefix = "host-local"; 1485 } else { 1486 host_prefix = "host"; 1487 } 1488 } 1489 1490 std::string cmd; 1491 if (strcmp(argv[0], "--list") == 0) { 1492 if (argc != 1) return usage(); 1493 return adb_query_command(host_prefix + ":list-forward"); 1494 } else if (strcmp(argv[0], "--remove-all") == 0) { 1495 if (argc != 1) return usage(); 1496 cmd = host_prefix + ":killforward-all"; 1497 } else if (strcmp(argv[0], "--remove") == 0) { 1498 // forward --remove <local> 1499 if (argc != 2) return usage(); 1500 cmd = host_prefix + ":killforward:" + argv[1]; 1501 } else if (strcmp(argv[0], "--no-rebind") == 0) { 1502 // forward --no-rebind <local> <remote> 1503 if (argc != 3) return usage(); 1504 cmd = host_prefix + ":forward:norebind:" + argv[1] + ";" + argv[2]; 1505 } else { 1506 // forward <local> <remote> 1507 if (argc != 2) return usage(); 1508 cmd = host_prefix + ":forward:" + argv[0] + ";" + argv[1]; 1509 } 1510 1511 return adb_command(cmd) ? 0 : 1; 1512 } 1513 /* do_sync_*() commands */ 1514 else if (!strcmp(argv[0], "ls")) { 1515 if (argc != 2) return usage(); 1516 return do_sync_ls(argv[1]) ? 0 : 1; 1517 } 1518 else if (!strcmp(argv[0], "push")) { 1519 bool show_progress = false; 1520 int copy_attrs = 0; 1521 const char* lpath = NULL, *rpath = NULL; 1522 1523 parse_push_pull_args(&argv[1], argc - 1, &lpath, &rpath, &show_progress, ©_attrs); 1524 if (!lpath || !rpath || copy_attrs != 0) return usage(); 1525 return do_sync_push(lpath, rpath, show_progress) ? 0 : 1; 1526 } 1527 else if (!strcmp(argv[0], "pull")) { 1528 bool show_progress = false; 1529 int copy_attrs = 0; 1530 const char* rpath = NULL, *lpath = "."; 1531 1532 parse_push_pull_args(&argv[1], argc - 1, &rpath, &lpath, &show_progress, ©_attrs); 1533 if (!rpath) return usage(); 1534 return do_sync_pull(rpath, lpath, show_progress, copy_attrs) ? 0 : 1; 1535 } 1536 else if (!strcmp(argv[0], "install")) { 1537 if (argc < 2) return usage(); 1538 return install_app(transport_type, serial, argc, argv); 1539 } 1540 else if (!strcmp(argv[0], "install-multiple")) { 1541 if (argc < 2) return usage(); 1542 return install_multiple_app(transport_type, serial, argc, argv); 1543 } 1544 else if (!strcmp(argv[0], "uninstall")) { 1545 if (argc < 2) return usage(); 1546 return uninstall_app(transport_type, serial, argc, argv); 1547 } 1548 else if (!strcmp(argv[0], "sync")) { 1549 std::string src; 1550 bool list_only = false; 1551 if (argc < 2) { 1552 // No local path was specified. 1553 src = ""; 1554 } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) { 1555 list_only = true; 1556 if (argc == 3) { 1557 src = argv[2]; 1558 } else { 1559 src = ""; 1560 } 1561 } else if (argc == 2) { 1562 // A local path or "android"/"data" arg was specified. 1563 src = argv[1]; 1564 } else { 1565 return usage(); 1566 } 1567 1568 if (src != "" && 1569 src != "system" && src != "data" && src != "vendor" && src != "oem") { 1570 return usage(); 1571 } 1572 1573 std::string system_src_path = product_file("system"); 1574 std::string data_src_path = product_file("data"); 1575 std::string vendor_src_path = product_file("vendor"); 1576 std::string oem_src_path = product_file("oem"); 1577 1578 bool okay = true; 1579 if (okay && (src.empty() || src == "system")) { 1580 okay = do_sync_sync(system_src_path, "/system", list_only); 1581 } 1582 if (okay && (src.empty() || src == "vendor") && directory_exists(vendor_src_path)) { 1583 okay = do_sync_sync(vendor_src_path, "/vendor", list_only); 1584 } 1585 if (okay && (src.empty() || src == "oem") && directory_exists(oem_src_path)) { 1586 okay = do_sync_sync(oem_src_path, "/oem", list_only); 1587 } 1588 if (okay && (src.empty() || src == "data")) { 1589 okay = do_sync_sync(data_src_path, "/data", list_only); 1590 } 1591 return okay ? 0 : 1; 1592 } 1593 /* passthrough commands */ 1594 else if (!strcmp(argv[0],"get-state") || 1595 !strcmp(argv[0],"get-serialno") || 1596 !strcmp(argv[0],"get-devpath")) 1597 { 1598 return adb_query_command(format_host_command(argv[0], transport_type, serial)); 1599 } 1600 /* other commands */ 1601 else if (!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat") || !strcmp(argv[0],"longcat")) { 1602 return logcat(transport_type, serial, argc, argv); 1603 } 1604 else if (!strcmp(argv[0],"ppp")) { 1605 return ppp(argc, argv); 1606 } 1607 else if (!strcmp(argv[0], "start-server")) { 1608 std::string error; 1609 const int result = adb_connect("host:start-server", &error); 1610 if (result < 0) { 1611 fprintf(stderr, "error: %s\n", error.c_str()); 1612 } 1613 return result; 1614 } 1615 else if (!strcmp(argv[0], "backup")) { 1616 return backup(argc, argv); 1617 } 1618 else if (!strcmp(argv[0], "restore")) { 1619 return restore(argc, argv); 1620 } 1621 else if (!strcmp(argv[0], "keygen")) { 1622 if (argc < 2) return usage(); 1623 // Always print key generation information for keygen command. 1624 adb_trace_enable(AUTH); 1625 return adb_auth_keygen(argv[1]); 1626 } 1627 else if (!strcmp(argv[0], "jdwp")) { 1628 return adb_connect_command("jdwp"); 1629 } 1630 /* "adb /?" is a common idiom under Windows */ 1631 else if (!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) { 1632 help(); 1633 return 0; 1634 } 1635 else if (!strcmp(argv[0], "version")) { 1636 fprintf(stdout, "%s", adb_version().c_str()); 1637 return 0; 1638 } 1639 else if (!strcmp(argv[0], "features")) { 1640 // Only list the features common to both the adb client and the device. 1641 FeatureSet features = GetFeatureSet(transport_type, serial); 1642 for (const std::string& name : features) { 1643 if (CanUseFeature(features, name)) { 1644 printf("%s\n", name.c_str()); 1645 } 1646 } 1647 return 0; 1648 } 1649 1650 usage(); 1651 return 1; 1652} 1653 1654static int pm_command(TransportType transport, const char* serial, int argc, const char** argv) { 1655 std::string cmd = "pm"; 1656 1657 while (argc-- > 0) { 1658 cmd += " " + escape_arg(*argv++); 1659 } 1660 1661 // TODO(dpursell): add command-line arguments to install/uninstall to 1662 // manually disable shell protocol if needed. 1663 return send_shell_command(transport, serial, cmd, false); 1664} 1665 1666static int uninstall_app(TransportType transport, const char* serial, int argc, const char** argv) { 1667 /* if the user choose the -k option, we refuse to do it until devices are 1668 out with the option to uninstall the remaining data somehow (adb/ui) */ 1669 if (argc == 3 && strcmp(argv[1], "-k") == 0) 1670 { 1671 printf( 1672 "The -k option uninstalls the application while retaining the data/cache.\n" 1673 "At the moment, there is no way to remove the remaining data.\n" 1674 "You will have to reinstall the application with the same signature, and fully uninstall it.\n" 1675 "If you truly wish to continue, execute 'adb shell pm uninstall -k %s'\n", argv[2]); 1676 return -1; 1677 } 1678 1679 /* 'adb uninstall' takes the same arguments as 'pm uninstall' on device */ 1680 return pm_command(transport, serial, argc, argv); 1681} 1682 1683static int delete_file(TransportType transport, const char* serial, const std::string& filename) { 1684 std::string cmd = "rm -f " + escape_arg(filename); 1685 return send_shell_command(transport, serial, cmd, false); 1686} 1687 1688static int install_app(TransportType transport, const char* serial, int argc, const char** argv) { 1689 static const char *const DATA_DEST = "/data/local/tmp/%s"; 1690 static const char *const SD_DEST = "/sdcard/tmp/%s"; 1691 const char* where = DATA_DEST; 1692 int i; 1693 struct stat sb; 1694 1695 for (i = 1; i < argc; i++) { 1696 if (!strcmp(argv[i], "-s")) { 1697 where = SD_DEST; 1698 } 1699 } 1700 1701 // Find last APK argument. 1702 // All other arguments passed through verbatim. 1703 int last_apk = -1; 1704 for (i = argc - 1; i >= 0; i--) { 1705 const char* file = argv[i]; 1706 const char* dot = strrchr(file, '.'); 1707 if (dot && !strcasecmp(dot, ".apk")) { 1708 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 1709 fprintf(stderr, "Invalid APK file: %s\n", file); 1710 return -1; 1711 } 1712 1713 last_apk = i; 1714 break; 1715 } 1716 } 1717 1718 if (last_apk == -1) { 1719 fprintf(stderr, "Missing APK file\n"); 1720 return -1; 1721 } 1722 1723 int result = -1; 1724 const char* apk_file = argv[last_apk]; 1725 std::string apk_dest = android::base::StringPrintf(where, adb_basename(apk_file).c_str()); 1726 if (!do_sync_push(apk_file, apk_dest.c_str(), false)) goto cleanup_apk; 1727 argv[last_apk] = apk_dest.c_str(); /* destination name, not source location */ 1728 result = pm_command(transport, serial, argc, argv); 1729 1730cleanup_apk: 1731 delete_file(transport, serial, apk_dest); 1732 return result; 1733} 1734 1735static int install_multiple_app(TransportType transport, const char* serial, int argc, 1736 const char** argv) 1737{ 1738 int i; 1739 struct stat sb; 1740 uint64_t total_size = 0; 1741 1742 // Find all APK arguments starting at end. 1743 // All other arguments passed through verbatim. 1744 int first_apk = -1; 1745 for (i = argc - 1; i >= 0; i--) { 1746 const char* file = argv[i]; 1747 const char* dot = strrchr(file, '.'); 1748 if (dot && !strcasecmp(dot, ".apk")) { 1749 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 1750 fprintf(stderr, "Invalid APK file: %s\n", file); 1751 return -1; 1752 } 1753 1754 total_size += sb.st_size; 1755 first_apk = i; 1756 } else { 1757 break; 1758 } 1759 } 1760 1761 if (first_apk == -1) { 1762 fprintf(stderr, "Missing APK file\n"); 1763 return 1; 1764 } 1765 1766 std::string cmd = android::base::StringPrintf("exec:pm install-create -S %" PRIu64, total_size); 1767 for (i = 1; i < first_apk; i++) { 1768 cmd += " " + escape_arg(argv[i]); 1769 } 1770 1771 // Create install session 1772 std::string error; 1773 int fd = adb_connect(cmd, &error); 1774 if (fd < 0) { 1775 fprintf(stderr, "Connect error for create: %s\n", error.c_str()); 1776 return -1; 1777 } 1778 char buf[BUFSIZ]; 1779 read_status_line(fd, buf, sizeof(buf)); 1780 adb_close(fd); 1781 1782 int session_id = -1; 1783 if (!strncmp("Success", buf, 7)) { 1784 char* start = strrchr(buf, '['); 1785 char* end = strrchr(buf, ']'); 1786 if (start && end) { 1787 *end = '\0'; 1788 session_id = strtol(start + 1, NULL, 10); 1789 } 1790 } 1791 if (session_id < 0) { 1792 fprintf(stderr, "Failed to create session\n"); 1793 fputs(buf, stderr); 1794 return -1; 1795 } 1796 1797 // Valid session, now stream the APKs 1798 int success = 1; 1799 for (i = first_apk; i < argc; i++) { 1800 const char* file = argv[i]; 1801 if (stat(file, &sb) == -1) { 1802 fprintf(stderr, "Failed to stat %s\n", file); 1803 success = 0; 1804 goto finalize_session; 1805 } 1806 1807 std::string cmd = android::base::StringPrintf( 1808 "exec:pm install-write -S %" PRIu64 " %d %d_%s -", 1809 static_cast<uint64_t>(sb.st_size), session_id, i, adb_basename(file).c_str()); 1810 1811 int localFd = adb_open(file, O_RDONLY); 1812 if (localFd < 0) { 1813 fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno)); 1814 success = 0; 1815 goto finalize_session; 1816 } 1817 1818 std::string error; 1819 int remoteFd = adb_connect(cmd, &error); 1820 if (remoteFd < 0) { 1821 fprintf(stderr, "Connect error for write: %s\n", error.c_str()); 1822 adb_close(localFd); 1823 success = 0; 1824 goto finalize_session; 1825 } 1826 1827 copy_to_file(localFd, remoteFd); 1828 read_status_line(remoteFd, buf, sizeof(buf)); 1829 1830 adb_close(localFd); 1831 adb_close(remoteFd); 1832 1833 if (strncmp("Success", buf, 7)) { 1834 fprintf(stderr, "Failed to write %s\n", file); 1835 fputs(buf, stderr); 1836 success = 0; 1837 goto finalize_session; 1838 } 1839 } 1840 1841finalize_session: 1842 // Commit session if we streamed everything okay; otherwise abandon 1843 std::string service = 1844 android::base::StringPrintf("exec:pm install-%s %d", 1845 success ? "commit" : "abandon", session_id); 1846 fd = adb_connect(service, &error); 1847 if (fd < 0) { 1848 fprintf(stderr, "Connect error for finalize: %s\n", error.c_str()); 1849 return -1; 1850 } 1851 read_status_line(fd, buf, sizeof(buf)); 1852 adb_close(fd); 1853 1854 if (!strncmp("Success", buf, 7)) { 1855 fputs(buf, stderr); 1856 return 0; 1857 } else { 1858 fprintf(stderr, "Failed to finalize session\n"); 1859 fputs(buf, stderr); 1860 return -1; 1861 } 1862} 1863