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