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