commandline.cpp revision fe54c96ab28a59a87c0c26ac4e6664826b4644ea
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 --norebind <remote> <local>\n" 143 " - same as 'adb reverse <remote> <local>' but fails\n" 144 " if <remote> is already reversed.\n" 145 " adb reverse --remove <remote>\n" 146 " - remove a specific reversed socket connection\n" 147 " adb reverse --remove-all - remove all reversed socket connections from device\n" 148 " adb jdwp - list PIDs of processes hosting a JDWP transport\n" 149 " adb install [-lrtsdg] <file>\n" 150 " - push this package file to the device and install it\n" 151 " (-l: forward lock application)\n" 152 " (-r: replace existing application)\n" 153 " (-t: allow test packages)\n" 154 " (-s: install application on sdcard)\n" 155 " (-d: allow version code downgrade)\n" 156 " (-g: grant all runtime permissions)\n" 157 " adb install-multiple [-lrtsdpg] <file...>\n" 158 " - push this package file to the device and install it\n" 159 " (-l: forward lock application)\n" 160 " (-r: replace existing application)\n" 161 " (-t: allow test packages)\n" 162 " (-s: install application on sdcard)\n" 163 " (-d: allow version code downgrade)\n" 164 " (-p: partial application install)\n" 165 " (-g: grant all runtime permissions)\n" 166 " adb uninstall [-k] <package> - remove this app package from the device\n" 167 " ('-k' means keep the data and cache directories)\n" 168 " adb bugreport - return all information from the device\n" 169 " that should be included in a bug report.\n" 170 "\n" 171 " adb backup [-f <file>] [-apk|-noapk] [-obb|-noobb] [-shared|-noshared] [-all] [-system|-nosystem] [<packages...>]\n" 172 " - write an archive of the device's data to <file>.\n" 173 " If no -f option is supplied then the data is written\n" 174 " to \"backup.ab\" in the current directory.\n" 175 " (-apk|-noapk enable/disable backup of the .apks themselves\n" 176 " in the archive; the default is noapk.)\n" 177 " (-obb|-noobb enable/disable backup of any installed apk expansion\n" 178 " (aka .obb) files associated with each application; the default\n" 179 " is noobb.)\n" 180 " (-shared|-noshared enable/disable backup of the device's\n" 181 " shared storage / SD card contents; the default is noshared.)\n" 182 " (-all means to back up all installed applications)\n" 183 " (-system|-nosystem toggles whether -all automatically includes\n" 184 " system applications; the default is to include system apps)\n" 185 " (<packages...> is the list of applications to be backed up. If\n" 186 " the -all or -shared flags are passed, then the package\n" 187 " list is optional. Applications explicitly given on the\n" 188 " command line will be included even if -nosystem would\n" 189 " ordinarily cause them to be omitted.)\n" 190 "\n" 191 " adb restore <file> - restore device contents from the <file> backup archive\n" 192 "\n" 193 " adb disable-verity - disable dm-verity checking on USERDEBUG builds\n" 194 " adb enable-verity - re-enable dm-verity checking on USERDEBUG builds\n" 195 " adb keygen <file> - generate adb public/private key. The private key is stored in <file>,\n" 196 " and the public key is stored in <file>.pub. Any existing files\n" 197 " are overwritten.\n" 198 " adb help - show this help message\n" 199 " adb version - show version num\n" 200 "\n" 201 "scripting:\n" 202 " adb wait-for-device - block until device is online\n" 203 " adb start-server - ensure that there is a server running\n" 204 " adb kill-server - kill the server if it is running\n" 205 " adb get-state - prints: offline | bootloader | device\n" 206 " adb get-serialno - prints: <serial-number>\n" 207 " adb get-devpath - prints: <device-path>\n" 208 " adb remount - remounts the /system, /vendor (if present) and /oem (if present) partitions on the device read-write\n" 209 " adb reboot [bootloader|recovery]\n" 210 " - reboots the device, optionally into the bootloader or recovery program.\n" 211 " adb reboot sideload - reboots the device into the sideload mode in recovery program (adb root required).\n" 212 " adb reboot sideload-auto-reboot\n" 213 " - reboots into the sideload mode, then reboots automatically after the sideload regardless of the result.\n" 214 " adb sideload <file> - sideloads the given package\n" 215 " adb root - restarts the adbd daemon with root permissions\n" 216 " adb unroot - restarts the adbd daemon without root permissions\n" 217 " adb usb - restarts the adbd daemon listening on USB\n" 218 " adb tcpip <port> - restarts the adbd daemon listening on TCP on the specified port\n" 219 "\n" 220 "networking:\n" 221 " adb ppp <tty> [parameters] - Run PPP over USB.\n" 222 " Note: you should not automatically start a PPP connection.\n" 223 " <tty> refers to the tty for PPP stream. Eg. dev:/dev/omap_csmi_tty1\n" 224 " [parameters] - Eg. defaultroute debug dump local notty usepeerdns\n" 225 "\n" 226 "adb sync notes: adb sync [ <directory> ]\n" 227 " <localdir> can be interpreted in several ways:\n" 228 "\n" 229 " - If <directory> is not specified, /system, /vendor (if present), /oem (if present) and /data partitions will be updated.\n" 230 "\n" 231 " - If it is \"system\", \"vendor\", \"oem\" or \"data\", only the corresponding partition\n" 232 " is updated.\n" 233 "\n" 234 "environment variables:\n" 235 " ADB_TRACE - Print debug information. A comma separated list of the following values\n" 236 " 1 or all, adb, sockets, packets, rwx, usb, sync, sysdeps, transport, jdwp\n" 237 " ANDROID_SERIAL - The serial number to connect to. -s takes priority over this if given.\n" 238 " ANDROID_LOG_TAGS - When used with the logcat option, only these debug tags are printed.\n" 239 ); 240} 241 242static int usage() { 243 help(); 244 return 1; 245} 246 247#if defined(_WIN32) 248 249// Implemented in sysdeps_win32.cpp. 250void stdin_raw_init(int fd); 251void stdin_raw_restore(int fd); 252 253#else 254static termios g_saved_terminal_state; 255 256static void stdin_raw_init(int fd) { 257 if (tcgetattr(fd, &g_saved_terminal_state)) return; 258 259 termios tio; 260 if (tcgetattr(fd, &tio)) return; 261 262 cfmakeraw(&tio); 263 264 // No timeout but request at least one character per read. 265 tio.c_cc[VTIME] = 0; 266 tio.c_cc[VMIN] = 1; 267 268 tcsetattr(fd, TCSAFLUSH, &tio); 269} 270 271static void stdin_raw_restore(int fd) { 272 tcsetattr(fd, TCSAFLUSH, &g_saved_terminal_state); 273} 274#endif 275 276// Reads from |fd| and prints received data. If |use_shell_protocol| is true 277// this expects that incoming data will use the shell protocol, in which case 278// stdout/stderr are routed independently and the remote exit code will be 279// returned. 280static int read_and_dump(int fd, bool use_shell_protocol=false) { 281 int exit_code = 0; 282 std::unique_ptr<ShellProtocol> protocol; 283 int length = 0; 284 FILE* outfile = stdout; 285 286 char raw_buffer[BUFSIZ]; 287 char* buffer_ptr = raw_buffer; 288 if (use_shell_protocol) { 289 protocol.reset(new ShellProtocol(fd)); 290 if (!protocol) { 291 LOG(ERROR) << "failed to allocate memory for ShellProtocol object"; 292 return 1; 293 } 294 buffer_ptr = protocol->data(); 295 } 296 297 while (fd >= 0) { 298 if (use_shell_protocol) { 299 if (!protocol->Read()) { 300 break; 301 } 302 switch (protocol->id()) { 303 case ShellProtocol::kIdStdout: 304 outfile = stdout; 305 break; 306 case ShellProtocol::kIdStderr: 307 outfile = stderr; 308 break; 309 case ShellProtocol::kIdExit: 310 exit_code = protocol->data()[0]; 311 continue; 312 default: 313 continue; 314 } 315 length = protocol->data_length(); 316 } else { 317 D("read_and_dump(): pre adb_read(fd=%d)", fd); 318 length = adb_read(fd, raw_buffer, sizeof(raw_buffer)); 319 D("read_and_dump(): post adb_read(fd=%d): length=%d", fd, length); 320 if (length <= 0) { 321 break; 322 } 323 } 324 325 fwrite(buffer_ptr, 1, length, outfile); 326 fflush(outfile); 327 } 328 329 return exit_code; 330} 331 332static void read_status_line(int fd, char* buf, size_t count) 333{ 334 count--; 335 while (count > 0) { 336 int len = adb_read(fd, buf, count); 337 if (len <= 0) { 338 break; 339 } 340 341 buf += len; 342 count -= len; 343 } 344 *buf = '\0'; 345} 346 347static void copy_to_file(int inFd, int outFd) { 348 const size_t BUFSIZE = 32 * 1024; 349 char* buf = (char*) malloc(BUFSIZE); 350 if (buf == nullptr) fatal("couldn't allocate buffer for copy_to_file"); 351 int len; 352 long total = 0; 353#ifdef _WIN32 354 int old_stdin_mode = -1; 355 int old_stdout_mode = -1; 356#endif 357 358 D("copy_to_file(%d -> %d)", inFd, outFd); 359 360 if (inFd == STDIN_FILENO) { 361 stdin_raw_init(STDIN_FILENO); 362#ifdef _WIN32 363 old_stdin_mode = _setmode(STDIN_FILENO, _O_BINARY); 364 if (old_stdin_mode == -1) { 365 fatal_errno("could not set stdin to binary"); 366 } 367#endif 368 } 369 370#ifdef _WIN32 371 if (outFd == STDOUT_FILENO) { 372 old_stdout_mode = _setmode(STDOUT_FILENO, _O_BINARY); 373 if (old_stdout_mode == -1) { 374 fatal_errno("could not set stdout to binary"); 375 } 376 } 377#endif 378 379 while (true) { 380 if (inFd == STDIN_FILENO) { 381 len = unix_read(inFd, buf, BUFSIZE); 382 } else { 383 len = adb_read(inFd, buf, BUFSIZE); 384 } 385 if (len == 0) { 386 D("copy_to_file() : read 0 bytes; exiting"); 387 break; 388 } 389 if (len < 0) { 390 D("copy_to_file(): read failed: %s", strerror(errno)); 391 break; 392 } 393 if (outFd == STDOUT_FILENO) { 394 fwrite(buf, 1, len, stdout); 395 fflush(stdout); 396 } else { 397 adb_write(outFd, buf, len); 398 } 399 total += len; 400 } 401 402 if (inFd == STDIN_FILENO) { 403 stdin_raw_restore(STDIN_FILENO); 404#ifdef _WIN32 405 if (_setmode(STDIN_FILENO, old_stdin_mode) == -1) { 406 fatal_errno("could not restore stdin mode"); 407 } 408#endif 409 } 410 411#ifdef _WIN32 412 if (outFd == STDOUT_FILENO) { 413 if (_setmode(STDOUT_FILENO, old_stdout_mode) == -1) { 414 fatal_errno("could not restore stdout mode"); 415 } 416 } 417#endif 418 419 D("copy_to_file() finished after %lu bytes", total); 420 free(buf); 421} 422 423namespace { 424 425// Used to pass multiple values to the stdin read thread. 426struct StdinReadArgs { 427 int stdin_fd, write_fd; 428 bool raw_stdin; 429 std::unique_ptr<ShellProtocol> protocol; 430}; 431 432} // namespace 433 434// Loops to read from stdin and push the data to the given FD. 435// The argument should be a pointer to a StdinReadArgs object. This function 436// will take ownership of the object and delete it when finished. 437static void* stdin_read_thread(void* x) { 438 std::unique_ptr<StdinReadArgs> args(reinterpret_cast<StdinReadArgs*>(x)); 439 int state = 0; 440 441 adb_thread_setname("stdin reader"); 442 443#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 mkdirs(filename); 954 int outFd = adb_creat(filename, 0640); 955 if (outFd < 0) { 956 fprintf(stderr, "adb: unable to open file %s\n", filename); 957 return -1; 958 } 959 960 std::string cmd = "backup:"; 961 --argc; 962 ++argv; 963 while (argc-- > 0) { 964 cmd += " " + escape_arg(*argv++); 965 } 966 967 D("backup. filename=%s cmd=%s", filename, cmd.c_str()); 968 std::string error; 969 int fd = adb_connect(cmd, &error); 970 if (fd < 0) { 971 fprintf(stderr, "adb: unable to connect for backup: %s\n", error.c_str()); 972 adb_close(outFd); 973 return -1; 974 } 975 976 printf("Now unlock your device and confirm the backup operation.\n"); 977 copy_to_file(fd, outFd); 978 979 adb_close(fd); 980 adb_close(outFd); 981 return 0; 982} 983 984static int restore(int argc, const char** argv) { 985 if (argc != 2) return usage(); 986 987 const char* filename = argv[1]; 988 int tarFd = adb_open(filename, O_RDONLY); 989 if (tarFd < 0) { 990 fprintf(stderr, "adb: unable to open file %s: %s\n", filename, strerror(errno)); 991 return -1; 992 } 993 994 std::string error; 995 int fd = adb_connect("restore:", &error); 996 if (fd < 0) { 997 fprintf(stderr, "adb: unable to connect for restore: %s\n", error.c_str()); 998 adb_close(tarFd); 999 return -1; 1000 } 1001 1002 printf("Now unlock your device and confirm the restore operation.\n"); 1003 copy_to_file(tarFd, fd); 1004 1005 adb_close(fd); 1006 adb_close(tarFd); 1007 return 0; 1008} 1009 1010/* <hint> may be: 1011 * - A simple product name 1012 * e.g., "sooner" 1013 * - A relative path from the CWD to the ANDROID_PRODUCT_OUT dir 1014 * e.g., "out/target/product/sooner" 1015 * - An absolute path to the PRODUCT_OUT dir 1016 * e.g., "/src/device/out/target/product/sooner" 1017 * 1018 * Given <hint>, try to construct an absolute path to the 1019 * ANDROID_PRODUCT_OUT dir. 1020 */ 1021static std::string find_product_out_path(const std::string& hint) { 1022 if (hint.empty()) { 1023 return ""; 1024 } 1025 1026 // If it's already absolute, don't bother doing any work. 1027 if (adb_is_absolute_host_path(hint.c_str())) { 1028 return hint; 1029 } 1030 1031 // If there are any slashes in it, assume it's a relative path; 1032 // make it absolute. 1033 if (hint.find_first_of(OS_PATH_SEPARATORS) != std::string::npos) { 1034 std::string cwd; 1035 if (!getcwd(&cwd)) { 1036 fprintf(stderr, "adb: getcwd failed: %s\n", strerror(errno)); 1037 return ""; 1038 } 1039 return android::base::StringPrintf("%s%c%s", cwd.c_str(), OS_PATH_SEPARATOR, hint.c_str()); 1040 } 1041 1042 // It's a string without any slashes. Try to do something with it. 1043 // 1044 // Try to find the root of the build tree, and build a PRODUCT_OUT 1045 // path from there. 1046 char* top = getenv("ANDROID_BUILD_TOP"); 1047 if (top == nullptr) { 1048 fprintf(stderr, "adb: ANDROID_BUILD_TOP not set!\n"); 1049 return ""; 1050 } 1051 1052 std::string path = top; 1053 path += OS_PATH_SEPARATOR_STR; 1054 path += "out"; 1055 path += OS_PATH_SEPARATOR_STR; 1056 path += "target"; 1057 path += OS_PATH_SEPARATOR_STR; 1058 path += "product"; 1059 path += OS_PATH_SEPARATOR_STR; 1060 path += hint; 1061 if (!directory_exists(path)) { 1062 fprintf(stderr, "adb: Couldn't find a product dir based on -p %s; " 1063 "\"%s\" doesn't exist\n", hint.c_str(), path.c_str()); 1064 return ""; 1065 } 1066 return path; 1067} 1068 1069static void parse_push_pull_args(const char** arg, int narg, 1070 std::vector<const char*>* srcs, 1071 const char** dst, bool* copy_attrs) { 1072 *copy_attrs = false; 1073 1074 srcs->clear(); 1075 bool ignore_flags = false; 1076 while (narg > 0) { 1077 if (ignore_flags || *arg[0] != '-') { 1078 srcs->push_back(*arg); 1079 } else { 1080 if (!strcmp(*arg, "-p")) { 1081 // Silently ignore for backwards compatibility. 1082 } else if (!strcmp(*arg, "-a")) { 1083 *copy_attrs = true; 1084 } else if (!strcmp(*arg, "--")) { 1085 ignore_flags = true; 1086 } else { 1087 fprintf(stderr, "adb: unrecognized option '%s'\n", *arg); 1088 exit(1); 1089 } 1090 } 1091 ++arg; 1092 --narg; 1093 } 1094 1095 if (srcs->size() > 1) { 1096 *dst = srcs->back(); 1097 srcs->pop_back(); 1098 } 1099} 1100 1101static int adb_connect_command(const std::string& command) { 1102 std::string error; 1103 int fd = adb_connect(command, &error); 1104 if (fd < 0) { 1105 fprintf(stderr, "error: %s\n", error.c_str()); 1106 return 1; 1107 } 1108 read_and_dump(fd); 1109 adb_close(fd); 1110 return 0; 1111} 1112 1113static int adb_query_command(const std::string& command) { 1114 std::string result; 1115 std::string error; 1116 if (!adb_query(command, &result, &error)) { 1117 fprintf(stderr, "error: %s\n", error.c_str()); 1118 return 1; 1119 } 1120 printf("%s\n", result.c_str()); 1121 return 0; 1122} 1123 1124// Disallow stdin, stdout, and stderr. 1125static bool _is_valid_ack_reply_fd(const int ack_reply_fd) { 1126#ifdef _WIN32 1127 const HANDLE ack_reply_handle = cast_int_to_handle(ack_reply_fd); 1128 return (GetStdHandle(STD_INPUT_HANDLE) != ack_reply_handle) && 1129 (GetStdHandle(STD_OUTPUT_HANDLE) != ack_reply_handle) && 1130 (GetStdHandle(STD_ERROR_HANDLE) != ack_reply_handle); 1131#else 1132 return ack_reply_fd > 2; 1133#endif 1134} 1135 1136int adb_commandline(int argc, const char **argv) { 1137 int no_daemon = 0; 1138 int is_daemon = 0; 1139 int is_server = 0; 1140 int r; 1141 TransportType transport_type = kTransportAny; 1142 int ack_reply_fd = -1; 1143 1144 // If defined, this should be an absolute path to 1145 // the directory containing all of the various system images 1146 // for a particular product. If not defined, and the adb 1147 // command requires this information, then the user must 1148 // specify the path using "-p". 1149 char* ANDROID_PRODUCT_OUT = getenv("ANDROID_PRODUCT_OUT"); 1150 if (ANDROID_PRODUCT_OUT != nullptr) { 1151 gProductOutPath = ANDROID_PRODUCT_OUT; 1152 } 1153 // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint 1154 1155 /* Validate and assign the server port */ 1156 const char* server_port_str = getenv("ANDROID_ADB_SERVER_PORT"); 1157 int server_port = DEFAULT_ADB_PORT; 1158 if (server_port_str && strlen(server_port_str) > 0) { 1159 server_port = strtol(server_port_str, nullptr, 0); 1160 if (server_port <= 0 || server_port > 65535) { 1161 fprintf(stderr, 1162 "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number less than 65536. Got \"%s\"\n", 1163 server_port_str); 1164 return usage(); 1165 } 1166 } 1167 1168 // We need to check for -d and -e before we look at $ANDROID_SERIAL. 1169 const char* serial = nullptr; 1170 1171 while (argc > 0) { 1172 if (!strcmp(argv[0],"server")) { 1173 is_server = 1; 1174 } else if (!strcmp(argv[0],"nodaemon")) { 1175 no_daemon = 1; 1176 } else if (!strcmp(argv[0], "fork-server")) { 1177 /* this is a special flag used only when the ADB client launches the ADB Server */ 1178 is_daemon = 1; 1179 } else if (!strcmp(argv[0], "--reply-fd")) { 1180 if (argc < 2) return usage(); 1181 const char* reply_fd_str = argv[1]; 1182 argc--; 1183 argv++; 1184 ack_reply_fd = strtol(reply_fd_str, nullptr, 10); 1185 if (!_is_valid_ack_reply_fd(ack_reply_fd)) { 1186 fprintf(stderr, "adb: invalid reply fd \"%s\"\n", reply_fd_str); 1187 return usage(); 1188 } 1189 } else if (!strncmp(argv[0], "-p", 2)) { 1190 const char* product = nullptr; 1191 if (argv[0][2] == '\0') { 1192 if (argc < 2) return usage(); 1193 product = argv[1]; 1194 argc--; 1195 argv++; 1196 } else { 1197 product = argv[0] + 2; 1198 } 1199 gProductOutPath = find_product_out_path(product); 1200 if (gProductOutPath.empty()) { 1201 fprintf(stderr, "adb: could not resolve \"-p %s\"\n", product); 1202 return usage(); 1203 } 1204 } else if (argv[0][0]=='-' && argv[0][1]=='s') { 1205 if (isdigit(argv[0][2])) { 1206 serial = argv[0] + 2; 1207 } else { 1208 if (argc < 2 || argv[0][2] != '\0') return usage(); 1209 serial = argv[1]; 1210 argc--; 1211 argv++; 1212 } 1213 } else if (!strcmp(argv[0],"-d")) { 1214 transport_type = kTransportUsb; 1215 } else if (!strcmp(argv[0],"-e")) { 1216 transport_type = kTransportLocal; 1217 } else if (!strcmp(argv[0],"-a")) { 1218 gListenAll = 1; 1219 } else if (!strncmp(argv[0], "-H", 2)) { 1220 const char *hostname = NULL; 1221 if (argv[0][2] == '\0') { 1222 if (argc < 2) return usage(); 1223 hostname = argv[1]; 1224 argc--; 1225 argv++; 1226 } else { 1227 hostname = argv[0] + 2; 1228 } 1229 adb_set_tcp_name(hostname); 1230 1231 } else if (!strncmp(argv[0], "-P", 2)) { 1232 if (argv[0][2] == '\0') { 1233 if (argc < 2) return usage(); 1234 server_port_str = argv[1]; 1235 argc--; 1236 argv++; 1237 } else { 1238 server_port_str = argv[0] + 2; 1239 } 1240 if (strlen(server_port_str) > 0) { 1241 server_port = (int) strtol(server_port_str, NULL, 0); 1242 if (server_port <= 0 || server_port > 65535) { 1243 fprintf(stderr, 1244 "adb: port number must be a positive number less than 65536. Got \"%s\"\n", 1245 server_port_str); 1246 return usage(); 1247 } 1248 } else { 1249 fprintf(stderr, 1250 "adb: port number must be a positive number less than 65536. Got empty string.\n"); 1251 return usage(); 1252 } 1253 } else { 1254 /* out of recognized modifiers and flags */ 1255 break; 1256 } 1257 argc--; 1258 argv++; 1259 } 1260 1261 // If none of -d, -e, or -s were specified, try $ANDROID_SERIAL. 1262 if (transport_type == kTransportAny && serial == nullptr) { 1263 serial = getenv("ANDROID_SERIAL"); 1264 } 1265 1266 adb_set_transport(transport_type, serial); 1267 adb_set_tcp_specifics(server_port); 1268 1269 if (is_server) { 1270 if (no_daemon || is_daemon) { 1271 if (is_daemon && (ack_reply_fd == -1)) { 1272 fprintf(stderr, "reply fd for adb server to client communication not specified.\n"); 1273 return usage(); 1274 } 1275 r = adb_main(is_daemon, server_port, ack_reply_fd); 1276 } else { 1277 r = launch_server(server_port); 1278 } 1279 if (r) { 1280 fprintf(stderr,"* could not start server *\n"); 1281 } 1282 return r; 1283 } 1284 1285 if (argc == 0) { 1286 return usage(); 1287 } 1288 1289 /* handle wait-for-* prefix */ 1290 if (!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) { 1291 const char* service = argv[0]; 1292 1293 if (!wait_for_device(service, transport_type, serial)) { 1294 return 1; 1295 } 1296 1297 // Allow a command to be run after wait-for-device, 1298 // e.g. 'adb wait-for-device shell'. 1299 if (argc == 1) { 1300 return 0; 1301 } 1302 1303 /* Fall through */ 1304 argc--; 1305 argv++; 1306 } 1307 1308 /* adb_connect() commands */ 1309 if (!strcmp(argv[0], "devices")) { 1310 const char *listopt; 1311 if (argc < 2) { 1312 listopt = ""; 1313 } else if (argc == 2 && !strcmp(argv[1], "-l")) { 1314 listopt = argv[1]; 1315 } else { 1316 fprintf(stderr, "Usage: adb devices [-l]\n"); 1317 return 1; 1318 } 1319 1320 std::string query = android::base::StringPrintf("host:%s%s", argv[0], listopt); 1321 printf("List of devices attached\n"); 1322 return adb_query_command(query); 1323 } 1324 else if (!strcmp(argv[0], "connect")) { 1325 if (argc != 2) { 1326 fprintf(stderr, "Usage: adb connect <host>[:<port>]\n"); 1327 return 1; 1328 } 1329 1330 std::string query = android::base::StringPrintf("host:connect:%s", argv[1]); 1331 return adb_query_command(query); 1332 } 1333 else if (!strcmp(argv[0], "disconnect")) { 1334 if (argc > 2) { 1335 fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]]\n"); 1336 return 1; 1337 } 1338 1339 std::string query = android::base::StringPrintf("host:disconnect:%s", 1340 (argc == 2) ? argv[1] : ""); 1341 return adb_query_command(query); 1342 } 1343 else if (!strcmp(argv[0], "emu")) { 1344 return adb_send_emulator_command(argc, argv, serial); 1345 } 1346 else if (!strcmp(argv[0], "shell") || !strcmp(argv[0], "hell")) { 1347 char h = (argv[0][0] == 'h'); 1348 1349 FeatureSet features = GetFeatureSet(transport_type, serial); 1350 1351 bool use_shell_protocol = CanUseFeature(features, kFeatureShell2); 1352 if (!use_shell_protocol) { 1353 D("shell protocol not supported, using raw data transfer"); 1354 } else { 1355 D("using shell protocol"); 1356 } 1357 1358 // Parse shell-specific command-line options. 1359 // argv[0] is always "shell". 1360 --argc; 1361 ++argv; 1362 int t_arg_count = 0; 1363 while (argc) { 1364 if (!strcmp(argv[0], "-T") || !strcmp(argv[0], "-t")) { 1365 if (!CanUseFeature(features, kFeatureShell2)) { 1366 fprintf(stderr, "error: target doesn't support PTY args -Tt\n"); 1367 return 1; 1368 } 1369 // Like ssh, -t arguments are cumulative so that multiple -t's 1370 // are needed to force a PTY. 1371 if (argv[0][1] == 't') { 1372 ++t_arg_count; 1373 } else { 1374 t_arg_count = -1; 1375 } 1376 --argc; 1377 ++argv; 1378 } else if (!strcmp(argv[0], "-x")) { 1379 use_shell_protocol = false; 1380 --argc; 1381 ++argv; 1382 } else { 1383 break; 1384 } 1385 } 1386 1387 std::string shell_type_arg; 1388 if (CanUseFeature(features, kFeatureShell2)) { 1389 if (t_arg_count < 0) { 1390 shell_type_arg = kShellServiceArgRaw; 1391 } else if (t_arg_count == 0) { 1392 // If stdin isn't a TTY, default to a raw shell; this lets 1393 // things like `adb shell < my_script.sh` work as expected. 1394 // Otherwise leave |shell_type_arg| blank which uses PTY for 1395 // interactive shells and raw for non-interactive. 1396 if (!unix_isatty(STDIN_FILENO)) { 1397 shell_type_arg = kShellServiceArgRaw; 1398 } 1399 } else if (t_arg_count == 1) { 1400 // A single -t arg isn't enough to override implicit -T. 1401 if (!unix_isatty(STDIN_FILENO)) { 1402 fprintf(stderr, 1403 "Remote PTY will not be allocated because stdin is not a terminal.\n" 1404 "Use multiple -t options to force remote PTY allocation.\n"); 1405 shell_type_arg = kShellServiceArgRaw; 1406 } else { 1407 shell_type_arg = kShellServiceArgPty; 1408 } 1409 } else { 1410 shell_type_arg = kShellServiceArgPty; 1411 } 1412 } 1413 1414 std::string command; 1415 if (argc) { 1416 // We don't escape here, just like ssh(1). http://b/20564385. 1417 command = android::base::Join( 1418 std::vector<const char*>(argv, argv + argc), ' '); 1419 } 1420 1421 if (h) { 1422 printf("\x1b[41;33m"); 1423 fflush(stdout); 1424 } 1425 1426 r = RemoteShell(use_shell_protocol, shell_type_arg, command); 1427 1428 if (h) { 1429 printf("\x1b[0m"); 1430 fflush(stdout); 1431 } 1432 1433 return r; 1434 } 1435 else if (!strcmp(argv[0], "exec-in") || !strcmp(argv[0], "exec-out")) { 1436 int exec_in = !strcmp(argv[0], "exec-in"); 1437 1438 std::string cmd = "exec:"; 1439 cmd += argv[1]; 1440 argc -= 2; 1441 argv += 2; 1442 while (argc-- > 0) { 1443 cmd += " " + escape_arg(*argv++); 1444 } 1445 1446 std::string error; 1447 int fd = adb_connect(cmd, &error); 1448 if (fd < 0) { 1449 fprintf(stderr, "error: %s\n", error.c_str()); 1450 return -1; 1451 } 1452 1453 if (exec_in) { 1454 copy_to_file(STDIN_FILENO, fd); 1455 } else { 1456 copy_to_file(fd, STDOUT_FILENO); 1457 } 1458 1459 adb_close(fd); 1460 return 0; 1461 } 1462 else if (!strcmp(argv[0], "kill-server")) { 1463 std::string error; 1464 int fd = _adb_connect("host:kill", &error); 1465 if (fd == -2) { 1466 // Failed to make network connection to server. Don't output the 1467 // network error since that is expected. 1468 fprintf(stderr,"* server not running *\n"); 1469 // Successful exit code because the server is already "killed". 1470 return 0; 1471 } else if (fd == -1) { 1472 // Some other error. 1473 fprintf(stderr, "error: %s\n", error.c_str()); 1474 return 1; 1475 } else { 1476 // Successfully connected, kill command sent, okay status came back. 1477 // Server should exit() in a moment, if not already. 1478 ReadOrderlyShutdown(fd); 1479 adb_close(fd); 1480 return 0; 1481 } 1482 } 1483 else if (!strcmp(argv[0], "sideload")) { 1484 if (argc != 2) return usage(); 1485 if (adb_sideload_host(argv[1])) { 1486 return 1; 1487 } else { 1488 return 0; 1489 } 1490 } 1491 else if (!strcmp(argv[0], "tcpip") && argc > 1) { 1492 return adb_connect_command(android::base::StringPrintf("tcpip:%s", argv[1])); 1493 } 1494 else if (!strcmp(argv[0], "remount") || 1495 !strcmp(argv[0], "reboot") || 1496 !strcmp(argv[0], "reboot-bootloader") || 1497 !strcmp(argv[0], "usb") || 1498 !strcmp(argv[0], "root") || 1499 !strcmp(argv[0], "unroot") || 1500 !strcmp(argv[0], "disable-verity") || 1501 !strcmp(argv[0], "enable-verity")) { 1502 std::string command; 1503 if (!strcmp(argv[0], "reboot-bootloader")) { 1504 command = "reboot:bootloader"; 1505 } else if (argc > 1) { 1506 command = android::base::StringPrintf("%s:%s", argv[0], argv[1]); 1507 } else { 1508 command = android::base::StringPrintf("%s:", argv[0]); 1509 } 1510 return adb_connect_command(command); 1511 } 1512 else if (!strcmp(argv[0], "bugreport")) { 1513 if (argc != 1) return usage(); 1514 // No need for shell protocol with bugreport, always disable for 1515 // simplicity. 1516 return send_shell_command(transport_type, serial, "bugreport", true); 1517 } 1518 else if (!strcmp(argv[0], "forward") || !strcmp(argv[0], "reverse")) { 1519 bool reverse = !strcmp(argv[0], "reverse"); 1520 ++argv; 1521 --argc; 1522 if (argc < 1) return usage(); 1523 1524 // Determine the <host-prefix> for this command. 1525 std::string host_prefix; 1526 if (reverse) { 1527 host_prefix = "reverse"; 1528 } else { 1529 if (serial) { 1530 host_prefix = android::base::StringPrintf("host-serial:%s", serial); 1531 } else if (transport_type == kTransportUsb) { 1532 host_prefix = "host-usb"; 1533 } else if (transport_type == kTransportLocal) { 1534 host_prefix = "host-local"; 1535 } else { 1536 host_prefix = "host"; 1537 } 1538 } 1539 1540 std::string cmd; 1541 if (strcmp(argv[0], "--list") == 0) { 1542 if (argc != 1) return usage(); 1543 return adb_query_command(host_prefix + ":list-forward"); 1544 } else if (strcmp(argv[0], "--remove-all") == 0) { 1545 if (argc != 1) return usage(); 1546 cmd = host_prefix + ":killforward-all"; 1547 } else if (strcmp(argv[0], "--remove") == 0) { 1548 // forward --remove <local> 1549 if (argc != 2) return usage(); 1550 cmd = host_prefix + ":killforward:" + argv[1]; 1551 } else if (strcmp(argv[0], "--no-rebind") == 0) { 1552 // forward --no-rebind <local> <remote> 1553 if (argc != 3) return usage(); 1554 cmd = host_prefix + ":forward:norebind:" + argv[1] + ";" + argv[2]; 1555 } else { 1556 // forward <local> <remote> 1557 if (argc != 2) return usage(); 1558 cmd = host_prefix + ":forward:" + argv[0] + ";" + argv[1]; 1559 } 1560 1561 return adb_command(cmd) ? 0 : 1; 1562 } 1563 /* do_sync_*() commands */ 1564 else if (!strcmp(argv[0], "ls")) { 1565 if (argc != 2) return usage(); 1566 return do_sync_ls(argv[1]) ? 0 : 1; 1567 } 1568 else if (!strcmp(argv[0], "push")) { 1569 bool copy_attrs = false; 1570 std::vector<const char*> srcs; 1571 const char* dst = nullptr; 1572 1573 parse_push_pull_args(&argv[1], argc - 1, &srcs, &dst, ©_attrs); 1574 if (srcs.empty() || !dst) return usage(); 1575 return do_sync_push(srcs, dst) ? 0 : 1; 1576 } 1577 else if (!strcmp(argv[0], "pull")) { 1578 bool copy_attrs = false; 1579 std::vector<const char*> srcs; 1580 const char* dst = "."; 1581 1582 parse_push_pull_args(&argv[1], argc - 1, &srcs, &dst, ©_attrs); 1583 if (srcs.empty()) return usage(); 1584 return do_sync_pull(srcs, dst, copy_attrs) ? 0 : 1; 1585 } 1586 else if (!strcmp(argv[0], "install")) { 1587 if (argc < 2) return usage(); 1588 return install_app(transport_type, serial, argc, argv); 1589 } 1590 else if (!strcmp(argv[0], "install-multiple")) { 1591 if (argc < 2) return usage(); 1592 return install_multiple_app(transport_type, serial, argc, argv); 1593 } 1594 else if (!strcmp(argv[0], "uninstall")) { 1595 if (argc < 2) return usage(); 1596 return uninstall_app(transport_type, serial, argc, argv); 1597 } 1598 else if (!strcmp(argv[0], "sync")) { 1599 std::string src; 1600 bool list_only = false; 1601 if (argc < 2) { 1602 // No local path was specified. 1603 src = ""; 1604 } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) { 1605 list_only = true; 1606 if (argc == 3) { 1607 src = argv[2]; 1608 } else { 1609 src = ""; 1610 } 1611 } else if (argc == 2) { 1612 // A local path or "android"/"data" arg was specified. 1613 src = argv[1]; 1614 } else { 1615 return usage(); 1616 } 1617 1618 if (src != "" && 1619 src != "system" && src != "data" && src != "vendor" && src != "oem") { 1620 return usage(); 1621 } 1622 1623 std::string system_src_path = product_file("system"); 1624 std::string data_src_path = product_file("data"); 1625 std::string vendor_src_path = product_file("vendor"); 1626 std::string oem_src_path = product_file("oem"); 1627 1628 bool okay = true; 1629 if (okay && (src.empty() || src == "system")) { 1630 okay = do_sync_sync(system_src_path, "/system", list_only); 1631 } 1632 if (okay && (src.empty() || src == "vendor") && directory_exists(vendor_src_path)) { 1633 okay = do_sync_sync(vendor_src_path, "/vendor", list_only); 1634 } 1635 if (okay && (src.empty() || src == "oem") && directory_exists(oem_src_path)) { 1636 okay = do_sync_sync(oem_src_path, "/oem", list_only); 1637 } 1638 if (okay && (src.empty() || src == "data")) { 1639 okay = do_sync_sync(data_src_path, "/data", list_only); 1640 } 1641 return okay ? 0 : 1; 1642 } 1643 /* passthrough commands */ 1644 else if (!strcmp(argv[0],"get-state") || 1645 !strcmp(argv[0],"get-serialno") || 1646 !strcmp(argv[0],"get-devpath")) 1647 { 1648 return adb_query_command(format_host_command(argv[0], transport_type, serial)); 1649 } 1650 /* other commands */ 1651 else if (!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat") || !strcmp(argv[0],"longcat")) { 1652 return logcat(transport_type, serial, argc, argv); 1653 } 1654 else if (!strcmp(argv[0],"ppp")) { 1655 return ppp(argc, argv); 1656 } 1657 else if (!strcmp(argv[0], "start-server")) { 1658 std::string error; 1659 const int result = adb_connect("host:start-server", &error); 1660 if (result < 0) { 1661 fprintf(stderr, "error: %s\n", error.c_str()); 1662 } 1663 return result; 1664 } 1665 else if (!strcmp(argv[0], "backup")) { 1666 return backup(argc, argv); 1667 } 1668 else if (!strcmp(argv[0], "restore")) { 1669 return restore(argc, argv); 1670 } 1671 else if (!strcmp(argv[0], "keygen")) { 1672 if (argc < 2) return usage(); 1673 // Always print key generation information for keygen command. 1674 adb_trace_enable(AUTH); 1675 return adb_auth_keygen(argv[1]); 1676 } 1677 else if (!strcmp(argv[0], "jdwp")) { 1678 return adb_connect_command("jdwp"); 1679 } 1680 /* "adb /?" is a common idiom under Windows */ 1681 else if (!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) { 1682 help(); 1683 return 0; 1684 } 1685 else if (!strcmp(argv[0], "version")) { 1686 fprintf(stdout, "%s", adb_version().c_str()); 1687 return 0; 1688 } 1689 else if (!strcmp(argv[0], "features")) { 1690 // Only list the features common to both the adb client and the device. 1691 FeatureSet features = GetFeatureSet(transport_type, serial); 1692 for (const std::string& name : features) { 1693 if (CanUseFeature(features, name)) { 1694 printf("%s\n", name.c_str()); 1695 } 1696 } 1697 return 0; 1698 } 1699 1700 usage(); 1701 return 1; 1702} 1703 1704static int pm_command(TransportType transport, const char* serial, int argc, const char** argv) { 1705 std::string cmd = "pm"; 1706 1707 while (argc-- > 0) { 1708 cmd += " " + escape_arg(*argv++); 1709 } 1710 1711 // TODO(dpursell): add command-line arguments to install/uninstall to 1712 // manually disable shell protocol if needed. 1713 return send_shell_command(transport, serial, cmd, false); 1714} 1715 1716static int uninstall_app(TransportType transport, const char* serial, int argc, const char** argv) { 1717 /* if the user choose the -k option, we refuse to do it until devices are 1718 out with the option to uninstall the remaining data somehow (adb/ui) */ 1719 if (argc == 3 && strcmp(argv[1], "-k") == 0) 1720 { 1721 printf( 1722 "The -k option uninstalls the application while retaining the data/cache.\n" 1723 "At the moment, there is no way to remove the remaining data.\n" 1724 "You will have to reinstall the application with the same signature, and fully uninstall it.\n" 1725 "If you truly wish to continue, execute 'adb shell pm uninstall -k %s'\n", argv[2]); 1726 return -1; 1727 } 1728 1729 /* 'adb uninstall' takes the same arguments as 'pm uninstall' on device */ 1730 return pm_command(transport, serial, argc, argv); 1731} 1732 1733static int delete_file(TransportType transport, const char* serial, const std::string& filename) { 1734 std::string cmd = "rm -f " + escape_arg(filename); 1735 return send_shell_command(transport, serial, cmd, false); 1736} 1737 1738static int install_app(TransportType transport, const char* serial, int argc, const char** argv) { 1739 static const char *const DATA_DEST = "/data/local/tmp/%s"; 1740 static const char *const SD_DEST = "/sdcard/tmp/%s"; 1741 const char* where = DATA_DEST; 1742 int i; 1743 struct stat sb; 1744 1745 for (i = 1; i < argc; i++) { 1746 if (!strcmp(argv[i], "-s")) { 1747 where = SD_DEST; 1748 } 1749 } 1750 1751 // Find last APK argument. 1752 // All other arguments passed through verbatim. 1753 int last_apk = -1; 1754 for (i = argc - 1; i >= 0; i--) { 1755 const char* file = argv[i]; 1756 const char* dot = strrchr(file, '.'); 1757 if (dot && !strcasecmp(dot, ".apk")) { 1758 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 1759 fprintf(stderr, "Invalid APK file: %s\n", file); 1760 return -1; 1761 } 1762 1763 last_apk = i; 1764 break; 1765 } 1766 } 1767 1768 if (last_apk == -1) { 1769 fprintf(stderr, "Missing APK file\n"); 1770 return -1; 1771 } 1772 1773 int result = -1; 1774 std::vector<const char*> apk_file = {argv[last_apk]}; 1775 std::string apk_dest = android::base::StringPrintf( 1776 where, adb_basename(argv[last_apk]).c_str()); 1777 if (!do_sync_push(apk_file, apk_dest.c_str())) goto cleanup_apk; 1778 argv[last_apk] = apk_dest.c_str(); /* destination name, not source location */ 1779 result = pm_command(transport, serial, argc, argv); 1780 1781cleanup_apk: 1782 delete_file(transport, serial, apk_dest); 1783 return result; 1784} 1785 1786static int install_multiple_app(TransportType transport, const char* serial, int argc, 1787 const char** argv) 1788{ 1789 int i; 1790 struct stat sb; 1791 uint64_t total_size = 0; 1792 1793 // Find all APK arguments starting at end. 1794 // All other arguments passed through verbatim. 1795 int first_apk = -1; 1796 for (i = argc - 1; i >= 0; i--) { 1797 const char* file = argv[i]; 1798 const char* dot = strrchr(file, '.'); 1799 if (dot && !strcasecmp(dot, ".apk")) { 1800 if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { 1801 fprintf(stderr, "Invalid APK file: %s\n", file); 1802 return -1; 1803 } 1804 1805 total_size += sb.st_size; 1806 first_apk = i; 1807 } else { 1808 break; 1809 } 1810 } 1811 1812 if (first_apk == -1) { 1813 fprintf(stderr, "Missing APK file\n"); 1814 return 1; 1815 } 1816 1817 std::string cmd = android::base::StringPrintf("exec:pm install-create -S %" PRIu64, total_size); 1818 for (i = 1; i < first_apk; i++) { 1819 cmd += " " + escape_arg(argv[i]); 1820 } 1821 1822 // Create install session 1823 std::string error; 1824 int fd = adb_connect(cmd, &error); 1825 if (fd < 0) { 1826 fprintf(stderr, "Connect error for create: %s\n", error.c_str()); 1827 return -1; 1828 } 1829 char buf[BUFSIZ]; 1830 read_status_line(fd, buf, sizeof(buf)); 1831 adb_close(fd); 1832 1833 int session_id = -1; 1834 if (!strncmp("Success", buf, 7)) { 1835 char* start = strrchr(buf, '['); 1836 char* end = strrchr(buf, ']'); 1837 if (start && end) { 1838 *end = '\0'; 1839 session_id = strtol(start + 1, NULL, 10); 1840 } 1841 } 1842 if (session_id < 0) { 1843 fprintf(stderr, "Failed to create session\n"); 1844 fputs(buf, stderr); 1845 return -1; 1846 } 1847 1848 // Valid session, now stream the APKs 1849 int success = 1; 1850 for (i = first_apk; i < argc; i++) { 1851 const char* file = argv[i]; 1852 if (stat(file, &sb) == -1) { 1853 fprintf(stderr, "Failed to stat %s\n", file); 1854 success = 0; 1855 goto finalize_session; 1856 } 1857 1858 std::string cmd = android::base::StringPrintf( 1859 "exec:pm install-write -S %" PRIu64 " %d %d_%s -", 1860 static_cast<uint64_t>(sb.st_size), session_id, i, adb_basename(file).c_str()); 1861 1862 int localFd = adb_open(file, O_RDONLY); 1863 if (localFd < 0) { 1864 fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno)); 1865 success = 0; 1866 goto finalize_session; 1867 } 1868 1869 std::string error; 1870 int remoteFd = adb_connect(cmd, &error); 1871 if (remoteFd < 0) { 1872 fprintf(stderr, "Connect error for write: %s\n", error.c_str()); 1873 adb_close(localFd); 1874 success = 0; 1875 goto finalize_session; 1876 } 1877 1878 copy_to_file(localFd, remoteFd); 1879 read_status_line(remoteFd, buf, sizeof(buf)); 1880 1881 adb_close(localFd); 1882 adb_close(remoteFd); 1883 1884 if (strncmp("Success", buf, 7)) { 1885 fprintf(stderr, "Failed to write %s\n", file); 1886 fputs(buf, stderr); 1887 success = 0; 1888 goto finalize_session; 1889 } 1890 } 1891 1892finalize_session: 1893 // Commit session if we streamed everything okay; otherwise abandon 1894 std::string service = 1895 android::base::StringPrintf("exec:pm install-%s %d", 1896 success ? "commit" : "abandon", session_id); 1897 fd = adb_connect(service, &error); 1898 if (fd < 0) { 1899 fprintf(stderr, "Connect error for finalize: %s\n", error.c_str()); 1900 return -1; 1901 } 1902 read_status_line(fd, buf, sizeof(buf)); 1903 adb_close(fd); 1904 1905 if (!strncmp("Success", buf, 7)) { 1906 fputs(buf, stderr); 1907 return 0; 1908 } else { 1909 fprintf(stderr, "Failed to finalize session\n"); 1910 fputs(buf, stderr); 1911 return -1; 1912 } 1913} 1914