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