Home | History | Annotate | Download | only in adb
      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 #include <stdio.h>
     18 #include <stdint.h>
     19 #include <stdlib.h>
     20 #include <string.h>
     21 #include <errno.h>
     22 #include <unistd.h>
     23 #include <limits.h>
     24 #include <stdarg.h>
     25 #include <sys/types.h>
     26 #include <sys/stat.h>
     27 #include <ctype.h>
     28 #include <assert.h>
     29 
     30 #include "sysdeps.h"
     31 
     32 #ifdef HAVE_TERMIO_H
     33 #include <termios.h>
     34 #endif
     35 
     36 #define  TRACE_TAG  TRACE_ADB
     37 #include "adb.h"
     38 #include "adb_client.h"
     39 #include "file_sync_service.h"
     40 
     41 static int do_cmd(transport_type ttype, char* serial, char *cmd, ...);
     42 
     43 void get_my_path(char *s, size_t maxLen);
     44 int find_sync_dirs(const char *srcarg,
     45         char **android_srcdir_out, char **data_srcdir_out, char **vendor_srcdir_out);
     46 int install_app(transport_type transport, char* serial, int argc, char** argv);
     47 int install_multiple_app(transport_type transport, char* serial, int argc, char** argv);
     48 int uninstall_app(transport_type transport, char* serial, int argc, char** argv);
     49 
     50 static const char *gProductOutPath = NULL;
     51 extern int gListenAll;
     52 
     53 static char *product_file(const char *extra)
     54 {
     55     int n;
     56     char *x;
     57 
     58     if (gProductOutPath == NULL) {
     59         fprintf(stderr, "adb: Product directory not specified; "
     60                 "use -p or define ANDROID_PRODUCT_OUT\n");
     61         exit(1);
     62     }
     63 
     64     n = strlen(gProductOutPath) + strlen(extra) + 2;
     65     x = malloc(n);
     66     if (x == 0) {
     67         fprintf(stderr, "adb: Out of memory (product_file())\n");
     68         exit(1);
     69     }
     70 
     71     snprintf(x, (size_t)n, "%s" OS_PATH_SEPARATOR_STR "%s", gProductOutPath, extra);
     72     return x;
     73 }
     74 
     75 void version(FILE * out) {
     76     fprintf(out, "Android Debug Bridge version %d.%d.%d\n",
     77          ADB_VERSION_MAJOR, ADB_VERSION_MINOR, ADB_SERVER_VERSION);
     78 }
     79 
     80 void help()
     81 {
     82     version(stderr);
     83 
     84     fprintf(stderr,
     85         "\n"
     86         " -a                            - directs adb to listen on all interfaces for a connection\n"
     87         " -d                            - directs command to the only connected USB device\n"
     88         "                                 returns an error if more than one USB device is present.\n"
     89         " -e                            - directs command to the only running emulator.\n"
     90         "                                 returns an error if more than one emulator is running.\n"
     91         " -s <specific device>          - directs command to the device or emulator with the given\n"
     92         "                                 serial number or qualifier. Overrides ANDROID_SERIAL\n"
     93         "                                 environment variable.\n"
     94         " -p <product name or path>     - simple product name like 'sooner', or\n"
     95         "                                 a relative/absolute path to a product\n"
     96         "                                 out directory like 'out/target/product/sooner'.\n"
     97         "                                 If -p is not specified, the ANDROID_PRODUCT_OUT\n"
     98         "                                 environment variable is used, which must\n"
     99         "                                 be an absolute path.\n"
    100         " -H                            - Name of adb server host (default: localhost)\n"
    101         " -P                            - Port of adb server (default: 5037)\n"
    102         " devices [-l]                  - list all connected devices\n"
    103         "                                 ('-l' will also list device qualifiers)\n"
    104         " connect <host>[:<port>]       - connect to a device via TCP/IP\n"
    105         "                                 Port 5555 is used by default if no port number is specified.\n"
    106         " disconnect [<host>[:<port>]]  - disconnect from a TCP/IP device.\n"
    107         "                                 Port 5555 is used by default if no port number is specified.\n"
    108         "                                 Using this command with no additional arguments\n"
    109         "                                 will disconnect from all connected TCP/IP devices.\n"
    110         "\n"
    111         "device commands:\n"
    112         "  adb push [-p] <local> <remote>\n"
    113         "                               - copy file/dir to device\n"
    114         "                                 ('-p' to display the transfer progress)\n"
    115         "  adb pull [-p] [-a] <remote> [<local>]\n"
    116         "                               - copy file/dir from device\n"
    117         "                                 ('-p' to display the transfer progress)\n"
    118         "                                 ('-a' means copy timestamp and mode)\n"
    119         "  adb sync [ <directory> ]     - copy host->device only if changed\n"
    120         "                                 (-l means list but don't copy)\n"
    121         "                                 (see 'adb help all')\n"
    122         "  adb shell                    - run remote shell interactively\n"
    123         "  adb shell <command>          - run remote shell command\n"
    124         "  adb emu <command>            - run emulator console command\n"
    125         "  adb logcat [ <filter-spec> ] - View device log\n"
    126         "  adb forward --list           - list all forward socket connections.\n"
    127         "                                 the format is a list of lines with the following format:\n"
    128         "                                    <serial> \" \" <local> \" \" <remote> \"\\n\"\n"
    129         "  adb forward <local> <remote> - forward socket connections\n"
    130         "                                 forward specs are one of: \n"
    131         "                                   tcp:<port>\n"
    132         "                                   localabstract:<unix domain socket name>\n"
    133         "                                   localreserved:<unix domain socket name>\n"
    134         "                                   localfilesystem:<unix domain socket name>\n"
    135         "                                   dev:<character device name>\n"
    136         "                                   jdwp:<process pid> (remote only)\n"
    137         "  adb forward --no-rebind <local> <remote>\n"
    138         "                               - same as 'adb forward <local> <remote>' but fails\n"
    139         "                                 if <local> is already forwarded\n"
    140         "  adb forward --remove <local> - remove a specific forward socket connection\n"
    141         "  adb forward --remove-all     - remove all forward socket connections\n"
    142         "  adb reverse --list           - list all reverse socket connections from device\n"
    143         "  adb reverse <remote> <local> - reverse socket connections\n"
    144         "                                 reverse specs are one of:\n"
    145         "                                   tcp:<port>\n"
    146         "                                   localabstract:<unix domain socket name>\n"
    147         "                                   localreserved:<unix domain socket name>\n"
    148         "                                   localfilesystem:<unix domain socket name>\n"
    149         "  adb reverse --norebind <remote> <local>\n"
    150         "                               - same as 'adb reverse <remote> <local>' but fails\n"
    151         "                                 if <remote> is already reversed.\n"
    152         "  adb reverse --remove <remote>\n"
    153         "                               - remove a specific reversed socket connection\n"
    154         "  adb reverse --remove-all     - remove all reversed socket connections from device\n"
    155         "  adb jdwp                     - list PIDs of processes hosting a JDWP transport\n"
    156         "  adb install [-lrtsd] <file>\n"
    157         "  adb install-multiple [-lrtsdp] <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         "  adb uninstall [-k] <package> - remove this app package from the device\n"
    166         "                                 ('-k' means keep the data and cache directories)\n"
    167         "  adb bugreport                - return all information from the device\n"
    168         "                                 that should be included in a bug report.\n"
    169         "\n"
    170         "  adb backup [-f <file>] [-apk|-noapk] [-obb|-noobb] [-shared|-noshared] [-all] [-system|-nosystem] [<packages...>]\n"
    171         "                               - write an archive of the device's data to <file>.\n"
    172         "                                 If no -f option is supplied then the data is written\n"
    173         "                                 to \"backup.ab\" in the current directory.\n"
    174         "                                 (-apk|-noapk enable/disable backup of the .apks themselves\n"
    175         "                                    in the archive; the default is noapk.)\n"
    176         "                                 (-obb|-noobb enable/disable backup of any installed apk expansion\n"
    177         "                                    (aka .obb) files associated with each application; the default\n"
    178         "                                    is noobb.)\n"
    179         "                                 (-shared|-noshared enable/disable backup of the device's\n"
    180         "                                    shared storage / SD card contents; the default is noshared.)\n"
    181         "                                 (-all means to back up all installed applications)\n"
    182         "                                 (-system|-nosystem toggles whether -all automatically includes\n"
    183         "                                    system applications; the default is to include system apps)\n"
    184         "                                 (<packages...> is the list of applications to be backed up.  If\n"
    185         "                                    the -all or -shared flags are passed, then the package\n"
    186         "                                    list is optional.  Applications explicitly given on the\n"
    187         "                                    command line will be included even if -nosystem would\n"
    188         "                                    ordinarily cause them to be omitted.)\n"
    189         "\n"
    190         "  adb restore <file>           - restore device contents from the <file> backup archive\n"
    191         "\n"
    192         "  adb help                     - show this help message\n"
    193         "  adb version                  - show version num\n"
    194         "\n"
    195         "scripting:\n"
    196         "  adb wait-for-device          - block until device is online\n"
    197         "  adb start-server             - ensure that there is a server running\n"
    198         "  adb kill-server              - kill the server if it is running\n"
    199         "  adb get-state                - prints: offline | bootloader | device\n"
    200         "  adb get-serialno             - prints: <serial-number>\n"
    201         "  adb get-devpath              - prints: <device-path>\n"
    202         "  adb status-window            - continuously print device status for a specified device\n"
    203         "  adb remount                  - remounts the /system and /vendor (if present) partitions on the device read-write\n"
    204         "  adb reboot [bootloader|recovery] - reboots the device, optionally into the bootloader or recovery program\n"
    205         "  adb reboot-bootloader        - reboots the device into the bootloader\n"
    206         "  adb root                     - restarts the adbd daemon with root permissions\n"
    207         "  adb usb                      - restarts the adbd daemon listening on USB\n"
    208         "  adb tcpip <port>             - restarts the adbd daemon listening on TCP on the specified port"
    209         "\n"
    210         "networking:\n"
    211         "  adb ppp <tty> [parameters]   - Run PPP over USB.\n"
    212         " Note: you should not automatically start a PPP connection.\n"
    213         " <tty> refers to the tty for PPP stream. Eg. dev:/dev/omap_csmi_tty1\n"
    214         " [parameters] - Eg. defaultroute debug dump local notty usepeerdns\n"
    215         "\n"
    216         "adb sync notes: adb sync [ <directory> ]\n"
    217         "  <localdir> can be interpreted in several ways:\n"
    218         "\n"
    219         "  - If <directory> is not specified, /system, /vendor (if present), and /data partitions will be updated.\n"
    220         "\n"
    221         "  - If it is \"system\", \"vendor\" or \"data\", only the corresponding partition\n"
    222         "    is updated.\n"
    223         "\n"
    224         "environmental variables:\n"
    225         "  ADB_TRACE                    - Print debug information. A comma separated list of the following values\n"
    226         "                                 1 or all, adb, sockets, packets, rwx, usb, sync, sysdeps, transport, jdwp\n"
    227         "  ANDROID_SERIAL               - The serial number to connect to. -s takes priority over this if given.\n"
    228         "  ANDROID_LOG_TAGS             - When used with the logcat option, only these debug tags are printed.\n"
    229         );
    230 }
    231 
    232 int usage()
    233 {
    234     help();
    235     return 1;
    236 }
    237 
    238 #ifdef HAVE_TERMIO_H
    239 static struct termios tio_save;
    240 
    241 static void stdin_raw_init(int fd)
    242 {
    243     struct termios tio;
    244 
    245     if(tcgetattr(fd, &tio)) return;
    246     if(tcgetattr(fd, &tio_save)) return;
    247 
    248     tio.c_lflag = 0; /* disable CANON, ECHO*, etc */
    249 
    250         /* no timeout but request at least one character per read */
    251     tio.c_cc[VTIME] = 0;
    252     tio.c_cc[VMIN] = 1;
    253 
    254     tcsetattr(fd, TCSANOW, &tio);
    255     tcflush(fd, TCIFLUSH);
    256 }
    257 
    258 static void stdin_raw_restore(int fd)
    259 {
    260     tcsetattr(fd, TCSANOW, &tio_save);
    261     tcflush(fd, TCIFLUSH);
    262 }
    263 #endif
    264 
    265 static void read_and_dump(int fd)
    266 {
    267     char buf[4096];
    268     int len;
    269 
    270     while(fd >= 0) {
    271         D("read_and_dump(): pre adb_read(fd=%d)\n", fd);
    272         len = adb_read(fd, buf, 4096);
    273         D("read_and_dump(): post adb_read(fd=%d): len=%d\n", fd, len);
    274         if(len == 0) {
    275             break;
    276         }
    277 
    278         if(len < 0) {
    279             if(errno == EINTR) continue;
    280             break;
    281         }
    282         fwrite(buf, 1, len, stdout);
    283         fflush(stdout);
    284     }
    285 }
    286 
    287 static void read_status_line(int fd, char* buf, size_t count)
    288 {
    289     count--;
    290     while (count > 0) {
    291         int len = adb_read(fd, buf, count);
    292         if (len == 0) {
    293             break;
    294         } else if (len < 0) {
    295             if (errno == EINTR) continue;
    296             break;
    297         }
    298 
    299         buf += len;
    300         count -= len;
    301     }
    302     *buf = '\0';
    303 }
    304 
    305 static void copy_to_file(int inFd, int outFd) {
    306     const size_t BUFSIZE = 32 * 1024;
    307     char* buf = (char*) malloc(BUFSIZE);
    308     int len;
    309     long total = 0;
    310 
    311     D("copy_to_file(%d -> %d)\n", inFd, outFd);
    312 #ifdef HAVE_TERMIO_H
    313     if (inFd == STDIN_FILENO) {
    314         stdin_raw_init(STDIN_FILENO);
    315     }
    316 #endif
    317     for (;;) {
    318         if (inFd == STDIN_FILENO) {
    319             len = unix_read(inFd, buf, BUFSIZE);
    320         } else {
    321             len = adb_read(inFd, buf, BUFSIZE);
    322         }
    323         if (len == 0) {
    324             D("copy_to_file() : read 0 bytes; exiting\n");
    325             break;
    326         }
    327         if (len < 0) {
    328             if (errno == EINTR) {
    329                 D("copy_to_file() : EINTR, retrying\n");
    330                 continue;
    331             }
    332             D("copy_to_file() : error %d\n", errno);
    333             break;
    334         }
    335         if (outFd == STDOUT_FILENO) {
    336             fwrite(buf, 1, len, stdout);
    337             fflush(stdout);
    338         } else {
    339             adb_write(outFd, buf, len);
    340         }
    341         total += len;
    342     }
    343 #ifdef HAVE_TERMIO_H
    344     if (inFd == STDIN_FILENO) {
    345         stdin_raw_restore(STDIN_FILENO);
    346     }
    347 #endif
    348     D("copy_to_file() finished after %lu bytes\n", total);
    349     free(buf);
    350 }
    351 
    352 static void *stdin_read_thread(void *x)
    353 {
    354     int fd, fdi;
    355     unsigned char buf[1024];
    356     int r, n;
    357     int state = 0;
    358 
    359     int *fds = (int*) x;
    360     fd = fds[0];
    361     fdi = fds[1];
    362     free(fds);
    363 
    364     for(;;) {
    365         /* fdi is really the client's stdin, so use read, not adb_read here */
    366         D("stdin_read_thread(): pre unix_read(fdi=%d,...)\n", fdi);
    367         r = unix_read(fdi, buf, 1024);
    368         D("stdin_read_thread(): post unix_read(fdi=%d,...)\n", fdi);
    369         if(r == 0) break;
    370         if(r < 0) {
    371             if(errno == EINTR) continue;
    372             break;
    373         }
    374         for(n = 0; n < r; n++){
    375             switch(buf[n]) {
    376             case '\n':
    377                 state = 1;
    378                 break;
    379             case '\r':
    380                 state = 1;
    381                 break;
    382             case '~':
    383                 if(state == 1) state++;
    384                 break;
    385             case '.':
    386                 if(state == 2) {
    387                     fprintf(stderr,"\n* disconnect *\n");
    388 #ifdef HAVE_TERMIO_H
    389                     stdin_raw_restore(fdi);
    390 #endif
    391                     exit(0);
    392                 }
    393             default:
    394                 state = 0;
    395             }
    396         }
    397         r = adb_write(fd, buf, r);
    398         if(r <= 0) {
    399             break;
    400         }
    401     }
    402     return 0;
    403 }
    404 
    405 int interactive_shell(void)
    406 {
    407     adb_thread_t thr;
    408     int fdi, fd;
    409     int *fds;
    410 
    411     fd = adb_connect("shell:");
    412     if(fd < 0) {
    413         fprintf(stderr,"error: %s\n", adb_error());
    414         return 1;
    415     }
    416     fdi = 0; //dup(0);
    417 
    418     fds = malloc(sizeof(int) * 2);
    419     fds[0] = fd;
    420     fds[1] = fdi;
    421 
    422 #ifdef HAVE_TERMIO_H
    423     stdin_raw_init(fdi);
    424 #endif
    425     adb_thread_create(&thr, stdin_read_thread, fds);
    426     read_and_dump(fd);
    427 #ifdef HAVE_TERMIO_H
    428     stdin_raw_restore(fdi);
    429 #endif
    430     return 0;
    431 }
    432 
    433 
    434 static void format_host_command(char* buffer, size_t  buflen, const char* command, transport_type ttype, const char* serial)
    435 {
    436     if (serial) {
    437         snprintf(buffer, buflen, "host-serial:%s:%s", serial, command);
    438     } else {
    439         const char* prefix = "host";
    440         if (ttype == kTransportUsb)
    441             prefix = "host-usb";
    442         else if (ttype == kTransportLocal)
    443             prefix = "host-local";
    444 
    445         snprintf(buffer, buflen, "%s:%s", prefix, command);
    446     }
    447 }
    448 
    449 int adb_download_buffer(const char *service, const char *fn, const void* data, int sz,
    450                         unsigned progress)
    451 {
    452     char buf[4096];
    453     unsigned total;
    454     int fd;
    455     const unsigned char *ptr;
    456 
    457     sprintf(buf,"%s:%d", service, sz);
    458     fd = adb_connect(buf);
    459     if(fd < 0) {
    460         fprintf(stderr,"error: %s\n", adb_error());
    461         return -1;
    462     }
    463 
    464     int opt = CHUNK_SIZE;
    465     opt = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt));
    466 
    467     total = sz;
    468     ptr = data;
    469 
    470     if(progress) {
    471         char *x = strrchr(service, ':');
    472         if(x) service = x + 1;
    473     }
    474 
    475     while(sz > 0) {
    476         unsigned xfer = (sz > CHUNK_SIZE) ? CHUNK_SIZE : sz;
    477         if(writex(fd, ptr, xfer)) {
    478             adb_status(fd);
    479             fprintf(stderr,"* failed to write data '%s' *\n", adb_error());
    480             return -1;
    481         }
    482         sz -= xfer;
    483         ptr += xfer;
    484         if(progress) {
    485             printf("sending: '%s' %4d%%    \r", fn, (int)(100LL - ((100LL * sz) / (total))));
    486             fflush(stdout);
    487         }
    488     }
    489     if(progress) {
    490         printf("\n");
    491     }
    492 
    493     if(readx(fd, buf, 4)){
    494         fprintf(stderr,"* error reading response *\n");
    495         adb_close(fd);
    496         return -1;
    497     }
    498     if(memcmp(buf, "OKAY", 4)) {
    499         buf[4] = 0;
    500         fprintf(stderr,"* error response '%s' *\n", buf);
    501         adb_close(fd);
    502         return -1;
    503     }
    504 
    505     adb_close(fd);
    506     return 0;
    507 }
    508 
    509 
    510 int adb_download(const char *service, const char *fn, unsigned progress)
    511 {
    512     void *data;
    513     unsigned sz;
    514 
    515     data = load_file(fn, &sz);
    516     if(data == 0) {
    517         fprintf(stderr,"* cannot read '%s' *\n", fn);
    518         return -1;
    519     }
    520 
    521     int status = adb_download_buffer(service, fn, data, sz, progress);
    522     free(data);
    523     return status;
    524 }
    525 
    526 #define SIDELOAD_HOST_BLOCK_SIZE (CHUNK_SIZE)
    527 
    528 /*
    529  * The sideload-host protocol serves the data in a file (given on the
    530  * command line) to the client, using a simple protocol:
    531  *
    532  * - The connect message includes the total number of bytes in the
    533  *   file and a block size chosen by us.
    534  *
    535  * - The other side sends the desired block number as eight decimal
    536  *   digits (eg "00000023" for block 23).  Blocks are numbered from
    537  *   zero.
    538  *
    539  * - We send back the data of the requested block.  The last block is
    540  *   likely to be partial; when the last block is requested we only
    541  *   send the part of the block that exists, it's not padded up to the
    542  *   block size.
    543  *
    544  * - When the other side sends "DONEDONE" instead of a block number,
    545  *   we hang up.
    546  */
    547 int adb_sideload_host(const char* fn) {
    548     uint8_t* data;
    549     unsigned sz;
    550     size_t xfer = 0;
    551     int status;
    552 
    553     printf("loading: '%s'", fn);
    554     fflush(stdout);
    555     data = load_file(fn, &sz);
    556     if (data == 0) {
    557         printf("\n");
    558         fprintf(stderr, "* cannot read '%s' *\n", fn);
    559         return -1;
    560     }
    561 
    562     char buf[100];
    563     sprintf(buf, "sideload-host:%d:%d", sz, SIDELOAD_HOST_BLOCK_SIZE);
    564     int fd = adb_connect(buf);
    565     if (fd < 0) {
    566         // Try falling back to the older sideload method.  Maybe this
    567         // is an older device that doesn't support sideload-host.
    568         printf("\n");
    569         status = adb_download_buffer("sideload", fn, data, sz, 1);
    570         goto done;
    571     }
    572 
    573     int opt = SIDELOAD_HOST_BLOCK_SIZE;
    574     opt = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt));
    575 
    576     int last_percent = -1;
    577     for (;;) {
    578         if (readx(fd, buf, 8)) {
    579             fprintf(stderr, "* failed to read command: %s\n", adb_error());
    580             status = -1;
    581             goto done;
    582         }
    583 
    584         if (strncmp("DONEDONE", buf, 8) == 0) {
    585             status = 0;
    586             break;
    587         }
    588 
    589         buf[8] = '\0';
    590         int block = strtol(buf, NULL, 10);
    591 
    592         size_t offset = block * SIDELOAD_HOST_BLOCK_SIZE;
    593         if (offset >= sz) {
    594             fprintf(stderr, "* attempt to read past end: %s\n", adb_error());
    595             status = -1;
    596             goto done;
    597         }
    598         uint8_t* start = data + offset;
    599         size_t offset_end = offset + SIDELOAD_HOST_BLOCK_SIZE;
    600         size_t to_write = SIDELOAD_HOST_BLOCK_SIZE;
    601         if (offset_end > sz) {
    602             to_write = sz - offset;
    603         }
    604 
    605         if(writex(fd, start, to_write)) {
    606             adb_status(fd);
    607             fprintf(stderr,"* failed to write data '%s' *\n", adb_error());
    608             status = -1;
    609             goto done;
    610         }
    611         xfer += to_write;
    612 
    613         // For normal OTA packages, we expect to transfer every byte
    614         // twice, plus a bit of overhead (one read during
    615         // verification, one read of each byte for installation, plus
    616         // extra access to things like the zip central directory).
    617         // This estimate of the completion becomes 100% when we've
    618         // transferred ~2.13 (=100/47) times the package size.
    619         int percent = (int)(xfer * 47LL / (sz ? sz : 1));
    620         if (percent != last_percent) {
    621             printf("\rserving: '%s'  (~%d%%)    ", fn, percent);
    622             fflush(stdout);
    623             last_percent = percent;
    624         }
    625     }
    626 
    627     printf("\rTotal xfer: %.2fx%*s\n", (double)xfer / (sz ? sz : 1), (int)strlen(fn)+10, "");
    628 
    629   done:
    630     if (fd >= 0) adb_close(fd);
    631     free(data);
    632     return status;
    633 }
    634 
    635 static void status_window(transport_type ttype, const char* serial)
    636 {
    637     char command[4096];
    638     char *state = 0;
    639     char *laststate = 0;
    640 
    641         /* silence stderr */
    642 #ifdef _WIN32
    643     /* XXX: TODO */
    644 #else
    645     int  fd;
    646     fd = unix_open("/dev/null", O_WRONLY);
    647     dup2(fd, 2);
    648     adb_close(fd);
    649 #endif
    650 
    651     format_host_command(command, sizeof command, "get-state", ttype, serial);
    652 
    653     for(;;) {
    654         adb_sleep_ms(250);
    655 
    656         if(state) {
    657             free(state);
    658             state = 0;
    659         }
    660 
    661         state = adb_query(command);
    662 
    663         if(state) {
    664             if(laststate && !strcmp(state,laststate)){
    665                 continue;
    666             } else {
    667                 if(laststate) free(laststate);
    668                 laststate = strdup(state);
    669             }
    670         }
    671 
    672         printf("%c[2J%c[2H", 27, 27);
    673         printf("Android Debug Bridge\n");
    674         printf("State: %s\n", state ? state : "offline");
    675         fflush(stdout);
    676     }
    677 }
    678 
    679 static int should_escape(const char c)
    680 {
    681     return (c == ' ' || c == '\'' || c == '"' || c == '\\' || c == '(' || c == ')');
    682 }
    683 
    684 /* Duplicate and escape given argument. */
    685 static char *escape_arg(const char *s)
    686 {
    687     const char *ts;
    688     size_t alloc_len;
    689     char *ret;
    690     char *dest;
    691 
    692     alloc_len = 0;
    693     for (ts = s; *ts != '\0'; ts++) {
    694         alloc_len++;
    695         if (should_escape(*ts)) {
    696             alloc_len++;
    697         }
    698     }
    699 
    700     if (alloc_len == 0) {
    701         // Preserve empty arguments
    702         ret = (char *) malloc(3);
    703         ret[0] = '\"';
    704         ret[1] = '\"';
    705         ret[2] = '\0';
    706         return ret;
    707     }
    708 
    709     ret = (char *) malloc(alloc_len + 1);
    710     dest = ret;
    711 
    712     for (ts = s; *ts != '\0'; ts++) {
    713         if (should_escape(*ts)) {
    714             *dest++ = '\\';
    715         }
    716         *dest++ = *ts;
    717     }
    718     *dest++ = '\0';
    719 
    720     return ret;
    721 }
    722 
    723 /**
    724  * Run ppp in "notty" mode against a resource listed as the first parameter
    725  * eg:
    726  *
    727  * ppp dev:/dev/omap_csmi_tty0 <ppp options>
    728  *
    729  */
    730 int ppp(int argc, char **argv)
    731 {
    732 #ifdef HAVE_WIN32_PROC
    733     fprintf(stderr, "error: adb %s not implemented on Win32\n", argv[0]);
    734     return -1;
    735 #else
    736     char *adb_service_name;
    737     pid_t pid;
    738     int fd;
    739 
    740     if (argc < 2) {
    741         fprintf(stderr, "usage: adb %s <adb service name> [ppp opts]\n",
    742                 argv[0]);
    743 
    744         return 1;
    745     }
    746 
    747     adb_service_name = argv[1];
    748 
    749     fd = adb_connect(adb_service_name);
    750 
    751     if(fd < 0) {
    752         fprintf(stderr,"Error: Could not open adb service: %s. Error: %s\n",
    753                 adb_service_name, adb_error());
    754         return 1;
    755     }
    756 
    757     pid = fork();
    758 
    759     if (pid < 0) {
    760         perror("from fork()");
    761         return 1;
    762     } else if (pid == 0) {
    763         int err;
    764         int i;
    765         const char **ppp_args;
    766 
    767         // copy args
    768         ppp_args = (const char **) alloca(sizeof(char *) * argc + 1);
    769         ppp_args[0] = "pppd";
    770         for (i = 2 ; i < argc ; i++) {
    771             //argv[2] and beyond become ppp_args[1] and beyond
    772             ppp_args[i - 1] = argv[i];
    773         }
    774         ppp_args[i-1] = NULL;
    775 
    776         // child side
    777 
    778         dup2(fd, STDIN_FILENO);
    779         dup2(fd, STDOUT_FILENO);
    780         adb_close(STDERR_FILENO);
    781         adb_close(fd);
    782 
    783         err = execvp("pppd", (char * const *)ppp_args);
    784 
    785         if (err < 0) {
    786             perror("execing pppd");
    787         }
    788         exit(-1);
    789     } else {
    790         // parent side
    791 
    792         adb_close(fd);
    793         return 0;
    794     }
    795 #endif /* !HAVE_WIN32_PROC */
    796 }
    797 
    798 static int send_shellcommand(transport_type transport, char* serial, char* buf)
    799 {
    800     int fd, ret;
    801 
    802     for(;;) {
    803         fd = adb_connect(buf);
    804         if(fd >= 0)
    805             break;
    806         fprintf(stderr,"- waiting for device -\n");
    807         adb_sleep_ms(1000);
    808         do_cmd(transport, serial, "wait-for-device", 0);
    809     }
    810 
    811     read_and_dump(fd);
    812     ret = adb_close(fd);
    813     if (ret)
    814         perror("close");
    815 
    816     return ret;
    817 }
    818 
    819 static int logcat(transport_type transport, char* serial, int argc, char **argv)
    820 {
    821     char buf[4096];
    822 
    823     char *log_tags;
    824     char *quoted;
    825 
    826     log_tags = getenv("ANDROID_LOG_TAGS");
    827     quoted = escape_arg(log_tags == NULL ? "" : log_tags);
    828     snprintf(buf, sizeof(buf),
    829             "shell:export ANDROID_LOG_TAGS=\"%s\"; exec logcat", quoted);
    830     free(quoted);
    831 
    832     if (!strcmp(argv[0], "longcat")) {
    833         strncat(buf, " -v long", sizeof(buf) - 1);
    834     }
    835 
    836     argc -= 1;
    837     argv += 1;
    838     while(argc-- > 0) {
    839         quoted = escape_arg(*argv++);
    840         strncat(buf, " ", sizeof(buf) - 1);
    841         strncat(buf, quoted, sizeof(buf) - 1);
    842         free(quoted);
    843     }
    844 
    845     send_shellcommand(transport, serial, buf);
    846     return 0;
    847 }
    848 
    849 static int mkdirs(const char *path)
    850 {
    851     int ret;
    852     char *x = (char *)path + 1;
    853 
    854     for(;;) {
    855         x = adb_dirstart(x);
    856         if(x == 0) return 0;
    857         *x = 0;
    858         ret = adb_mkdir(path, 0775);
    859         *x = OS_PATH_SEPARATOR;
    860         if((ret < 0) && (errno != EEXIST)) {
    861             return ret;
    862         }
    863         x++;
    864     }
    865     return 0;
    866 }
    867 
    868 static int backup(int argc, char** argv) {
    869     char buf[4096];
    870     char default_name[32];
    871     const char* filename = strcpy(default_name, "./backup.ab");
    872     int fd, outFd;
    873     int i, j;
    874 
    875     /* find, extract, and use any -f argument */
    876     for (i = 1; i < argc; i++) {
    877         if (!strcmp("-f", argv[i])) {
    878             if (i == argc-1) {
    879                 fprintf(stderr, "adb: -f passed with no filename\n");
    880                 return usage();
    881             }
    882             filename = argv[i+1];
    883             for (j = i+2; j <= argc; ) {
    884                 argv[i++] = argv[j++];
    885             }
    886             argc -= 2;
    887             argv[argc] = NULL;
    888         }
    889     }
    890 
    891     /* bare "adb backup" or "adb backup -f filename" are not valid invocations */
    892     if (argc < 2) return usage();
    893 
    894     adb_unlink(filename);
    895     mkdirs(filename);
    896     outFd = adb_creat(filename, 0640);
    897     if (outFd < 0) {
    898         fprintf(stderr, "adb: unable to open file %s\n", filename);
    899         return -1;
    900     }
    901 
    902     snprintf(buf, sizeof(buf), "backup");
    903     for (argc--, argv++; argc; argc--, argv++) {
    904         strncat(buf, ":", sizeof(buf) - strlen(buf) - 1);
    905         strncat(buf, argv[0], sizeof(buf) - strlen(buf) - 1);
    906     }
    907 
    908     D("backup. filename=%s buf=%s\n", filename, buf);
    909     fd = adb_connect(buf);
    910     if (fd < 0) {
    911         fprintf(stderr, "adb: unable to connect for backup\n");
    912         adb_close(outFd);
    913         return -1;
    914     }
    915 
    916     printf("Now unlock your device and confirm the backup operation.\n");
    917     copy_to_file(fd, outFd);
    918 
    919     adb_close(fd);
    920     adb_close(outFd);
    921     return 0;
    922 }
    923 
    924 static int restore(int argc, char** argv) {
    925     const char* filename;
    926     int fd, tarFd;
    927 
    928     if (argc != 2) return usage();
    929 
    930     filename = argv[1];
    931     tarFd = adb_open(filename, O_RDONLY);
    932     if (tarFd < 0) {
    933         fprintf(stderr, "adb: unable to open file %s\n", filename);
    934         return -1;
    935     }
    936 
    937     fd = adb_connect("restore:");
    938     if (fd < 0) {
    939         fprintf(stderr, "adb: unable to connect for restore\n");
    940         adb_close(tarFd);
    941         return -1;
    942     }
    943 
    944     printf("Now unlock your device and confirm the restore operation.\n");
    945     copy_to_file(tarFd, fd);
    946 
    947     adb_close(fd);
    948     adb_close(tarFd);
    949     return 0;
    950 }
    951 
    952 #define SENTINEL_FILE "config" OS_PATH_SEPARATOR_STR "envsetup.make"
    953 static int top_works(const char *top)
    954 {
    955     if (top != NULL && adb_is_absolute_host_path(top)) {
    956         char path_buf[PATH_MAX];
    957         snprintf(path_buf, sizeof(path_buf),
    958                 "%s" OS_PATH_SEPARATOR_STR SENTINEL_FILE, top);
    959         return access(path_buf, F_OK) == 0;
    960     }
    961     return 0;
    962 }
    963 
    964 static char *find_top_from(const char *indir, char path_buf[PATH_MAX])
    965 {
    966     strcpy(path_buf, indir);
    967     while (1) {
    968         if (top_works(path_buf)) {
    969             return path_buf;
    970         }
    971         char *s = adb_dirstop(path_buf);
    972         if (s != NULL) {
    973             *s = '\0';
    974         } else {
    975             path_buf[0] = '\0';
    976             return NULL;
    977         }
    978     }
    979 }
    980 
    981 static char *find_top(char path_buf[PATH_MAX])
    982 {
    983     char *top = getenv("ANDROID_BUILD_TOP");
    984     if (top != NULL && top[0] != '\0') {
    985         if (!top_works(top)) {
    986             fprintf(stderr, "adb: bad ANDROID_BUILD_TOP value \"%s\"\n", top);
    987             return NULL;
    988         }
    989     } else {
    990         top = getenv("TOP");
    991         if (top != NULL && top[0] != '\0') {
    992             if (!top_works(top)) {
    993                 fprintf(stderr, "adb: bad TOP value \"%s\"\n", top);
    994                 return NULL;
    995             }
    996         } else {
    997             top = NULL;
    998         }
    999     }
   1000 
   1001     if (top != NULL) {
   1002         /* The environment pointed to a top directory that works.
   1003          */
   1004         strcpy(path_buf, top);
   1005         return path_buf;
   1006     }
   1007 
   1008     /* The environment didn't help.  Walk up the tree from the CWD
   1009      * to see if we can find the top.
   1010      */
   1011     char dir[PATH_MAX];
   1012     top = find_top_from(getcwd(dir, sizeof(dir)), path_buf);
   1013     if (top == NULL) {
   1014         /* If the CWD isn't under a good-looking top, see if the
   1015          * executable is.
   1016          */
   1017         get_my_path(dir, PATH_MAX);
   1018         top = find_top_from(dir, path_buf);
   1019     }
   1020     return top;
   1021 }
   1022 
   1023 /* <hint> may be:
   1024  * - A simple product name
   1025  *   e.g., "sooner"
   1026 TODO: debug?  sooner-debug, sooner:debug?
   1027  * - A relative path from the CWD to the ANDROID_PRODUCT_OUT dir
   1028  *   e.g., "out/target/product/sooner"
   1029  * - An absolute path to the PRODUCT_OUT dir
   1030  *   e.g., "/src/device/out/target/product/sooner"
   1031  *
   1032  * Given <hint>, try to construct an absolute path to the
   1033  * ANDROID_PRODUCT_OUT dir.
   1034  */
   1035 static const char *find_product_out_path(const char *hint)
   1036 {
   1037     static char path_buf[PATH_MAX];
   1038 
   1039     if (hint == NULL || hint[0] == '\0') {
   1040         return NULL;
   1041     }
   1042 
   1043     /* If it's already absolute, don't bother doing any work.
   1044      */
   1045     if (adb_is_absolute_host_path(hint)) {
   1046         strcpy(path_buf, hint);
   1047         return path_buf;
   1048     }
   1049 
   1050     /* If there are any slashes in it, assume it's a relative path;
   1051      * make it absolute.
   1052      */
   1053     if (adb_dirstart(hint) != NULL) {
   1054         if (getcwd(path_buf, sizeof(path_buf)) == NULL) {
   1055             fprintf(stderr, "adb: Couldn't get CWD: %s\n", strerror(errno));
   1056             return NULL;
   1057         }
   1058         if (strlen(path_buf) + 1 + strlen(hint) >= sizeof(path_buf)) {
   1059             fprintf(stderr, "adb: Couldn't assemble path\n");
   1060             return NULL;
   1061         }
   1062         strcat(path_buf, OS_PATH_SEPARATOR_STR);
   1063         strcat(path_buf, hint);
   1064         return path_buf;
   1065     }
   1066 
   1067     /* It's a string without any slashes.  Try to do something with it.
   1068      *
   1069      * Try to find the root of the build tree, and build a PRODUCT_OUT
   1070      * path from there.
   1071      */
   1072     char top_buf[PATH_MAX];
   1073     const char *top = find_top(top_buf);
   1074     if (top == NULL) {
   1075         fprintf(stderr, "adb: Couldn't find top of build tree\n");
   1076         return NULL;
   1077     }
   1078 //TODO: if we have a way to indicate debug, look in out/debug/target/...
   1079     snprintf(path_buf, sizeof(path_buf),
   1080             "%s" OS_PATH_SEPARATOR_STR
   1081             "out" OS_PATH_SEPARATOR_STR
   1082             "target" OS_PATH_SEPARATOR_STR
   1083             "product" OS_PATH_SEPARATOR_STR
   1084             "%s", top_buf, hint);
   1085     if (access(path_buf, F_OK) < 0) {
   1086         fprintf(stderr, "adb: Couldn't find a product dir "
   1087                 "based on \"-p %s\"; \"%s\" doesn't exist\n", hint, path_buf);
   1088         return NULL;
   1089     }
   1090     return path_buf;
   1091 }
   1092 
   1093 static void parse_push_pull_args(char **arg, int narg, char const **path1, char const **path2,
   1094                                  int *show_progress, int *copy_attrs) {
   1095     *show_progress = 0;
   1096     *copy_attrs = 0;
   1097 
   1098     while (narg > 0) {
   1099         if (!strcmp(*arg, "-p")) {
   1100             *show_progress = 1;
   1101         } else if (!strcmp(*arg, "-a")) {
   1102             *copy_attrs = 1;
   1103         } else {
   1104             break;
   1105         }
   1106         ++arg;
   1107         --narg;
   1108     }
   1109 
   1110     if (narg > 0) {
   1111         *path1 = *arg;
   1112         ++arg;
   1113         --narg;
   1114     }
   1115 
   1116     if (narg > 0) {
   1117         *path2 = *arg;
   1118     }
   1119 }
   1120 
   1121 int adb_commandline(int argc, char **argv)
   1122 {
   1123     char buf[4096];
   1124     int no_daemon = 0;
   1125     int is_daemon = 0;
   1126     int is_server = 0;
   1127     int persist = 0;
   1128     int r;
   1129     transport_type ttype = kTransportAny;
   1130     char* serial = NULL;
   1131     char* server_port_str = NULL;
   1132 
   1133         /* If defined, this should be an absolute path to
   1134          * the directory containing all of the various system images
   1135          * for a particular product.  If not defined, and the adb
   1136          * command requires this information, then the user must
   1137          * specify the path using "-p".
   1138          */
   1139     gProductOutPath = getenv("ANDROID_PRODUCT_OUT");
   1140     if (gProductOutPath == NULL || gProductOutPath[0] == '\0') {
   1141         gProductOutPath = NULL;
   1142     }
   1143     // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint
   1144 
   1145     serial = getenv("ANDROID_SERIAL");
   1146 
   1147     /* Validate and assign the server port */
   1148     server_port_str = getenv("ANDROID_ADB_SERVER_PORT");
   1149     int server_port = DEFAULT_ADB_PORT;
   1150     if (server_port_str && strlen(server_port_str) > 0) {
   1151         server_port = (int) strtol(server_port_str, NULL, 0);
   1152         if (server_port <= 0 || server_port > 65535) {
   1153             fprintf(stderr,
   1154                     "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number less than 65535. Got \"%s\"\n",
   1155                     server_port_str);
   1156             return usage();
   1157         }
   1158     }
   1159 
   1160     /* modifiers and flags */
   1161     while(argc > 0) {
   1162         if(!strcmp(argv[0],"server")) {
   1163             is_server = 1;
   1164         } else if(!strcmp(argv[0],"nodaemon")) {
   1165             no_daemon = 1;
   1166         } else if (!strcmp(argv[0], "fork-server")) {
   1167             /* this is a special flag used only when the ADB client launches the ADB Server */
   1168             is_daemon = 1;
   1169         } else if(!strcmp(argv[0],"persist")) {
   1170             persist = 1;
   1171         } else if(!strncmp(argv[0], "-p", 2)) {
   1172             const char *product = NULL;
   1173             if (argv[0][2] == '\0') {
   1174                 if (argc < 2) return usage();
   1175                 product = argv[1];
   1176                 argc--;
   1177                 argv++;
   1178             } else {
   1179                 product = argv[0] + 2;
   1180             }
   1181             gProductOutPath = find_product_out_path(product);
   1182             if (gProductOutPath == NULL) {
   1183                 fprintf(stderr, "adb: could not resolve \"-p %s\"\n",
   1184                         product);
   1185                 return usage();
   1186             }
   1187         } else if (argv[0][0]=='-' && argv[0][1]=='s') {
   1188             if (isdigit(argv[0][2])) {
   1189                 serial = argv[0] + 2;
   1190             } else {
   1191                 if(argc < 2 || argv[0][2] != '\0') return usage();
   1192                 serial = argv[1];
   1193                 argc--;
   1194                 argv++;
   1195             }
   1196         } else if (!strcmp(argv[0],"-d")) {
   1197             ttype = kTransportUsb;
   1198         } else if (!strcmp(argv[0],"-e")) {
   1199             ttype = kTransportLocal;
   1200         } else if (!strcmp(argv[0],"-a")) {
   1201             gListenAll = 1;
   1202         } else if(!strncmp(argv[0], "-H", 2)) {
   1203             const char *hostname = NULL;
   1204             if (argv[0][2] == '\0') {
   1205                 if (argc < 2) return usage();
   1206                 hostname = argv[1];
   1207                 argc--;
   1208                 argv++;
   1209             } else {
   1210                 hostname = argv[0] + 2;
   1211             }
   1212             adb_set_tcp_name(hostname);
   1213 
   1214         } else if(!strncmp(argv[0], "-P", 2)) {
   1215             if (argv[0][2] == '\0') {
   1216                 if (argc < 2) return usage();
   1217                 server_port_str = argv[1];
   1218                 argc--;
   1219                 argv++;
   1220             } else {
   1221                 server_port_str = argv[0] + 2;
   1222             }
   1223             if (strlen(server_port_str) > 0) {
   1224                 server_port = (int) strtol(server_port_str, NULL, 0);
   1225                 if (server_port <= 0 || server_port > 65535) {
   1226                     fprintf(stderr,
   1227                             "adb: port number must be a positive number less than 65536. Got \"%s\"\n",
   1228                             server_port_str);
   1229                     return usage();
   1230                 }
   1231             } else {
   1232                 fprintf(stderr,
   1233                 "adb: port number must be a positive number less than 65536. Got empty string.\n");
   1234                 return usage();
   1235             }
   1236         } else {
   1237                 /* out of recognized modifiers and flags */
   1238             break;
   1239         }
   1240         argc--;
   1241         argv++;
   1242     }
   1243 
   1244     adb_set_transport(ttype, serial);
   1245     adb_set_tcp_specifics(server_port);
   1246 
   1247     if (is_server) {
   1248         if (no_daemon || is_daemon) {
   1249             r = adb_main(is_daemon, server_port);
   1250         } else {
   1251             r = launch_server(server_port);
   1252         }
   1253         if(r) {
   1254             fprintf(stderr,"* could not start server *\n");
   1255         }
   1256         return r;
   1257     }
   1258 
   1259 top:
   1260     if(argc == 0) {
   1261         return usage();
   1262     }
   1263 
   1264     /* adb_connect() commands */
   1265 
   1266     if(!strcmp(argv[0], "devices")) {
   1267         char *tmp;
   1268         char *listopt;
   1269         if (argc < 2)
   1270             listopt = "";
   1271         else if (argc == 2 && !strcmp(argv[1], "-l"))
   1272             listopt = argv[1];
   1273         else {
   1274             fprintf(stderr, "Usage: adb devices [-l]\n");
   1275             return 1;
   1276         }
   1277         snprintf(buf, sizeof buf, "host:%s%s", argv[0], listopt);
   1278         tmp = adb_query(buf);
   1279         if(tmp) {
   1280             printf("List of devices attached \n");
   1281             printf("%s\n", tmp);
   1282             return 0;
   1283         } else {
   1284             return 1;
   1285         }
   1286     }
   1287 
   1288     if(!strcmp(argv[0], "connect")) {
   1289         char *tmp;
   1290         if (argc != 2) {
   1291             fprintf(stderr, "Usage: adb connect <host>[:<port>]\n");
   1292             return 1;
   1293         }
   1294         snprintf(buf, sizeof buf, "host:connect:%s", argv[1]);
   1295         tmp = adb_query(buf);
   1296         if(tmp) {
   1297             printf("%s\n", tmp);
   1298             return 0;
   1299         } else {
   1300             return 1;
   1301         }
   1302     }
   1303 
   1304     if(!strcmp(argv[0], "disconnect")) {
   1305         char *tmp;
   1306         if (argc > 2) {
   1307             fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]]\n");
   1308             return 1;
   1309         }
   1310         if (argc == 2) {
   1311             snprintf(buf, sizeof buf, "host:disconnect:%s", argv[1]);
   1312         } else {
   1313             snprintf(buf, sizeof buf, "host:disconnect:");
   1314         }
   1315         tmp = adb_query(buf);
   1316         if(tmp) {
   1317             printf("%s\n", tmp);
   1318             return 0;
   1319         } else {
   1320             return 1;
   1321         }
   1322     }
   1323 
   1324     if (!strcmp(argv[0], "emu")) {
   1325         return adb_send_emulator_command(argc, argv);
   1326     }
   1327 
   1328     if(!strcmp(argv[0], "shell") || !strcmp(argv[0], "hell")) {
   1329         int r;
   1330         int fd;
   1331 
   1332         char h = (argv[0][0] == 'h');
   1333 
   1334         if (h) {
   1335             printf("\x1b[41;33m");
   1336             fflush(stdout);
   1337         }
   1338 
   1339         if(argc < 2) {
   1340             D("starting interactive shell\n");
   1341             r = interactive_shell();
   1342             if (h) {
   1343                 printf("\x1b[0m");
   1344                 fflush(stdout);
   1345             }
   1346             return r;
   1347         }
   1348 
   1349         snprintf(buf, sizeof(buf), "shell:%s", argv[1]);
   1350         argc -= 2;
   1351         argv += 2;
   1352         while (argc-- > 0) {
   1353             char *quoted = escape_arg(*argv++);
   1354             strncat(buf, " ", sizeof(buf) - 1);
   1355             strncat(buf, quoted, sizeof(buf) - 1);
   1356             free(quoted);
   1357         }
   1358 
   1359         for(;;) {
   1360             D("interactive shell loop. buff=%s\n", buf);
   1361             fd = adb_connect(buf);
   1362             if(fd >= 0) {
   1363                 D("about to read_and_dump(fd=%d)\n", fd);
   1364                 read_and_dump(fd);
   1365                 D("read_and_dump() done.\n");
   1366                 adb_close(fd);
   1367                 r = 0;
   1368             } else {
   1369                 fprintf(stderr,"error: %s\n", adb_error());
   1370                 r = -1;
   1371             }
   1372 
   1373             if(persist) {
   1374                 fprintf(stderr,"\n- waiting for device -\n");
   1375                 adb_sleep_ms(1000);
   1376                 do_cmd(ttype, serial, "wait-for-device", 0);
   1377             } else {
   1378                 if (h) {
   1379                     printf("\x1b[0m");
   1380                     fflush(stdout);
   1381                 }
   1382                 D("interactive shell loop. return r=%d\n", r);
   1383                 return r;
   1384             }
   1385         }
   1386     }
   1387 
   1388     if (!strcmp(argv[0], "exec-in") || !strcmp(argv[0], "exec-out")) {
   1389         int exec_in = !strcmp(argv[0], "exec-in");
   1390         int fd;
   1391 
   1392         snprintf(buf, sizeof buf, "exec:%s", argv[1]);
   1393         argc -= 2;
   1394         argv += 2;
   1395         while (argc-- > 0) {
   1396             char *quoted = escape_arg(*argv++);
   1397             strncat(buf, " ", sizeof(buf) - 1);
   1398             strncat(buf, quoted, sizeof(buf) - 1);
   1399             free(quoted);
   1400         }
   1401 
   1402         fd = adb_connect(buf);
   1403         if (fd < 0) {
   1404             fprintf(stderr, "error: %s\n", adb_error());
   1405             return -1;
   1406         }
   1407 
   1408         if (exec_in) {
   1409             copy_to_file(STDIN_FILENO, fd);
   1410         } else {
   1411             copy_to_file(fd, STDOUT_FILENO);
   1412         }
   1413 
   1414         adb_close(fd);
   1415         return 0;
   1416     }
   1417 
   1418     if(!strcmp(argv[0], "kill-server")) {
   1419         int fd;
   1420         fd = _adb_connect("host:kill");
   1421         if(fd == -1) {
   1422             fprintf(stderr,"* server not running *\n");
   1423             return 1;
   1424         }
   1425         return 0;
   1426     }
   1427 
   1428     if(!strcmp(argv[0], "sideload")) {
   1429         if(argc != 2) return usage();
   1430         if (adb_sideload_host(argv[1])) {
   1431             return 1;
   1432         } else {
   1433             return 0;
   1434         }
   1435     }
   1436 
   1437     if(!strcmp(argv[0], "remount") || !strcmp(argv[0], "reboot")
   1438             || !strcmp(argv[0], "reboot-bootloader")
   1439             || !strcmp(argv[0], "tcpip") || !strcmp(argv[0], "usb")
   1440             || !strcmp(argv[0], "root")) {
   1441         char command[100];
   1442         if (!strcmp(argv[0], "reboot-bootloader"))
   1443             snprintf(command, sizeof(command), "reboot:bootloader");
   1444         else if (argc > 1)
   1445             snprintf(command, sizeof(command), "%s:%s", argv[0], argv[1]);
   1446         else
   1447             snprintf(command, sizeof(command), "%s:", argv[0]);
   1448         int fd = adb_connect(command);
   1449         if(fd >= 0) {
   1450             read_and_dump(fd);
   1451             adb_close(fd);
   1452             return 0;
   1453         }
   1454         fprintf(stderr,"error: %s\n", adb_error());
   1455         return 1;
   1456     }
   1457 
   1458     if(!strcmp(argv[0], "bugreport")) {
   1459         if (argc != 1) return usage();
   1460         do_cmd(ttype, serial, "shell", "bugreport", 0);
   1461         return 0;
   1462     }
   1463 
   1464     /* adb_command() wrapper commands */
   1465 
   1466     if(!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) {
   1467         char* service = argv[0];
   1468         if (!strncmp(service, "wait-for-device", strlen("wait-for-device"))) {
   1469             if (ttype == kTransportUsb) {
   1470                 service = "wait-for-usb";
   1471             } else if (ttype == kTransportLocal) {
   1472                 service = "wait-for-local";
   1473             } else {
   1474                 service = "wait-for-any";
   1475             }
   1476         }
   1477 
   1478         format_host_command(buf, sizeof buf, service, ttype, serial);
   1479 
   1480         if (adb_command(buf)) {
   1481             D("failure: %s *\n",adb_error());
   1482             fprintf(stderr,"error: %s\n", adb_error());
   1483             return 1;
   1484         }
   1485 
   1486         /* Allow a command to be run after wait-for-device,
   1487             * e.g. 'adb wait-for-device shell'.
   1488             */
   1489         if(argc > 1) {
   1490             argc--;
   1491             argv++;
   1492             goto top;
   1493         }
   1494         return 0;
   1495     }
   1496 
   1497     if(!strcmp(argv[0], "forward") ||
   1498        !strcmp(argv[0], "reverse"))
   1499     {
   1500         char host_prefix[64];
   1501         char reverse = (char) !strcmp(argv[0], "reverse");
   1502         char remove = 0;
   1503         char remove_all = 0;
   1504         char list = 0;
   1505         char no_rebind = 0;
   1506 
   1507         // Parse options here.
   1508         while (argc > 1 && argv[1][0] == '-') {
   1509             if (!strcmp(argv[1], "--list"))
   1510                 list = 1;
   1511             else if (!strcmp(argv[1], "--remove"))
   1512                 remove = 1;
   1513             else if (!strcmp(argv[1], "--remove-all"))
   1514                 remove_all = 1;
   1515             else if (!strcmp(argv[1], "--no-rebind"))
   1516                 no_rebind = 1;
   1517             else {
   1518                 return usage();
   1519             }
   1520             argc--;
   1521             argv++;
   1522         }
   1523 
   1524         // Ensure we can only use one option at a time.
   1525         if (list + remove + remove_all + no_rebind > 1) {
   1526             return usage();
   1527         }
   1528 
   1529         // Determine the <host-prefix> for this command.
   1530         if (reverse) {
   1531             snprintf(host_prefix, sizeof host_prefix, "reverse");
   1532         } else {
   1533             if (serial) {
   1534                 snprintf(host_prefix, sizeof host_prefix, "host-serial:%s",
   1535                         serial);
   1536             } else if (ttype == kTransportUsb) {
   1537                 snprintf(host_prefix, sizeof host_prefix, "host-usb");
   1538             } else if (ttype == kTransportLocal) {
   1539                 snprintf(host_prefix, sizeof host_prefix, "host-local");
   1540             } else {
   1541                 snprintf(host_prefix, sizeof host_prefix, "host");
   1542             }
   1543         }
   1544 
   1545         // Implement forward --list
   1546         if (list) {
   1547             if (argc != 1)
   1548                 return usage();
   1549             snprintf(buf, sizeof buf, "%s:list-forward", host_prefix);
   1550             char* forwards = adb_query(buf);
   1551             if (forwards == NULL) {
   1552                 fprintf(stderr, "error: %s\n", adb_error());
   1553                 return 1;
   1554             }
   1555             printf("%s", forwards);
   1556             free(forwards);
   1557             return 0;
   1558         }
   1559 
   1560         // Implement forward --remove-all
   1561         else if (remove_all) {
   1562             if (argc != 1)
   1563                 return usage();
   1564             snprintf(buf, sizeof buf, "%s:killforward-all", host_prefix);
   1565         }
   1566 
   1567         // Implement forward --remove <local>
   1568         else if (remove) {
   1569             if (argc != 2)
   1570                 return usage();
   1571             snprintf(buf, sizeof buf, "%s:killforward:%s", host_prefix, argv[1]);
   1572         }
   1573         // Or implement one of:
   1574         //    forward <local> <remote>
   1575         //    forward --no-rebind <local> <remote>
   1576         else
   1577         {
   1578           if (argc != 3)
   1579             return usage();
   1580           const char* command = no_rebind ? "forward:norebind:" : "forward";
   1581           snprintf(buf, sizeof buf, "%s:%s:%s;%s", host_prefix, command, argv[1], argv[2]);
   1582         }
   1583 
   1584         if(adb_command(buf)) {
   1585             fprintf(stderr,"error: %s\n", adb_error());
   1586             return 1;
   1587         }
   1588         return 0;
   1589     }
   1590 
   1591     /* do_sync_*() commands */
   1592 
   1593     if(!strcmp(argv[0], "ls")) {
   1594         if(argc != 2) return usage();
   1595         return do_sync_ls(argv[1]);
   1596     }
   1597 
   1598     if(!strcmp(argv[0], "push")) {
   1599         int show_progress = 0;
   1600         int copy_attrs = 0; // unused
   1601         const char* lpath = NULL, *rpath = NULL;
   1602 
   1603         parse_push_pull_args(&argv[1], argc - 1, &lpath, &rpath, &show_progress, &copy_attrs);
   1604 
   1605         if ((lpath != NULL) && (rpath != NULL)) {
   1606             return do_sync_push(lpath, rpath, show_progress);
   1607         }
   1608 
   1609         return usage();
   1610     }
   1611 
   1612     if(!strcmp(argv[0], "pull")) {
   1613         int show_progress = 0;
   1614         int copy_attrs = 0;
   1615         const char* rpath = NULL, *lpath = ".";
   1616 
   1617         parse_push_pull_args(&argv[1], argc - 1, &rpath, &lpath, &show_progress, &copy_attrs);
   1618 
   1619         if (rpath != NULL) {
   1620             return do_sync_pull(rpath, lpath, show_progress, copy_attrs);
   1621         }
   1622 
   1623         return usage();
   1624     }
   1625 
   1626     if (!strcmp(argv[0], "install")) {
   1627         if (argc < 2) return usage();
   1628         return install_app(ttype, serial, argc, argv);
   1629     }
   1630 
   1631     if (!strcmp(argv[0], "install-multiple")) {
   1632         if (argc < 2) return usage();
   1633         return install_multiple_app(ttype, serial, argc, argv);
   1634     }
   1635 
   1636     if (!strcmp(argv[0], "uninstall")) {
   1637         if (argc < 2) return usage();
   1638         return uninstall_app(ttype, serial, argc, argv);
   1639     }
   1640 
   1641     if(!strcmp(argv[0], "sync")) {
   1642         char *srcarg, *android_srcpath, *data_srcpath, *vendor_srcpath;
   1643         int listonly = 0;
   1644 
   1645         int ret;
   1646         if(argc < 2) {
   1647             /* No local path was specified. */
   1648             srcarg = NULL;
   1649         } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) {
   1650             listonly = 1;
   1651             if (argc == 3) {
   1652                 srcarg = argv[2];
   1653             } else {
   1654                 srcarg = NULL;
   1655             }
   1656         } else if(argc == 2) {
   1657             /* A local path or "android"/"data" arg was specified. */
   1658             srcarg = argv[1];
   1659         } else {
   1660             return usage();
   1661         }
   1662         ret = find_sync_dirs(srcarg, &android_srcpath, &data_srcpath, &vendor_srcpath);
   1663         if(ret != 0) return usage();
   1664 
   1665         if(android_srcpath != NULL)
   1666             ret = do_sync_sync(android_srcpath, "/system", listonly);
   1667         if(ret == 0 && vendor_srcpath != NULL)
   1668             ret = do_sync_sync(vendor_srcpath, "/vendor", listonly);
   1669         if(ret == 0 && data_srcpath != NULL)
   1670             ret = do_sync_sync(data_srcpath, "/data", listonly);
   1671 
   1672         free(android_srcpath);
   1673         free(vendor_srcpath);
   1674         free(data_srcpath);
   1675         return ret;
   1676     }
   1677 
   1678     /* passthrough commands */
   1679 
   1680     if(!strcmp(argv[0],"get-state") ||
   1681         !strcmp(argv[0],"get-serialno") ||
   1682         !strcmp(argv[0],"get-devpath"))
   1683     {
   1684         char *tmp;
   1685 
   1686         format_host_command(buf, sizeof buf, argv[0], ttype, serial);
   1687         tmp = adb_query(buf);
   1688         if(tmp) {
   1689             printf("%s\n", tmp);
   1690             return 0;
   1691         } else {
   1692             return 1;
   1693         }
   1694     }
   1695 
   1696     /* other commands */
   1697 
   1698     if(!strcmp(argv[0],"status-window")) {
   1699         status_window(ttype, serial);
   1700         return 0;
   1701     }
   1702 
   1703     if(!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat") || !strcmp(argv[0],"longcat")) {
   1704         return logcat(ttype, serial, argc, argv);
   1705     }
   1706 
   1707     if(!strcmp(argv[0],"ppp")) {
   1708         return ppp(argc, argv);
   1709     }
   1710 
   1711     if (!strcmp(argv[0], "start-server")) {
   1712         return adb_connect("host:start-server");
   1713     }
   1714 
   1715     if (!strcmp(argv[0], "backup")) {
   1716         return backup(argc, argv);
   1717     }
   1718 
   1719     if (!strcmp(argv[0], "restore")) {
   1720         return restore(argc, argv);
   1721     }
   1722 
   1723     if (!strcmp(argv[0], "jdwp")) {
   1724         int  fd = adb_connect("jdwp");
   1725         if (fd >= 0) {
   1726             read_and_dump(fd);
   1727             adb_close(fd);
   1728             return 0;
   1729         } else {
   1730             fprintf(stderr, "error: %s\n", adb_error());
   1731             return -1;
   1732         }
   1733     }
   1734 
   1735     /* "adb /?" is a common idiom under Windows */
   1736     if(!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) {
   1737         help();
   1738         return 0;
   1739     }
   1740 
   1741     if(!strcmp(argv[0], "version")) {
   1742         version(stdout);
   1743         return 0;
   1744     }
   1745 
   1746     usage();
   1747     return 1;
   1748 }
   1749 
   1750 #define MAX_ARGV_LENGTH 16
   1751 static int do_cmd(transport_type ttype, char* serial, char *cmd, ...)
   1752 {
   1753     char *argv[MAX_ARGV_LENGTH];
   1754     int argc;
   1755     va_list ap;
   1756 
   1757     va_start(ap, cmd);
   1758     argc = 0;
   1759 
   1760     if (serial) {
   1761         argv[argc++] = "-s";
   1762         argv[argc++] = serial;
   1763     } else if (ttype == kTransportUsb) {
   1764         argv[argc++] = "-d";
   1765     } else if (ttype == kTransportLocal) {
   1766         argv[argc++] = "-e";
   1767     }
   1768 
   1769     argv[argc++] = cmd;
   1770     while(argc < MAX_ARGV_LENGTH &&
   1771         (argv[argc] = va_arg(ap, char*)) != 0) argc++;
   1772     assert(argc < MAX_ARGV_LENGTH);
   1773     va_end(ap);
   1774 
   1775 #if 0
   1776     int n;
   1777     fprintf(stderr,"argc = %d\n",argc);
   1778     for(n = 0; n < argc; n++) {
   1779         fprintf(stderr,"argv[%d] = \"%s\"\n", n, argv[n]);
   1780     }
   1781 #endif
   1782 
   1783     return adb_commandline(argc, argv);
   1784 }
   1785 
   1786 int find_sync_dirs(const char *srcarg,
   1787         char **android_srcdir_out, char **data_srcdir_out, char **vendor_srcdir_out)
   1788 {
   1789     char *android_srcdir = NULL, *data_srcdir = NULL, *vendor_srcdir = NULL;
   1790     struct stat st;
   1791 
   1792     if(srcarg == NULL) {
   1793         android_srcdir = product_file("system");
   1794         data_srcdir = product_file("data");
   1795         vendor_srcdir = product_file("vendor");
   1796         /* Check if vendor partition exists */
   1797         if (lstat(vendor_srcdir, &st) || !S_ISDIR(st.st_mode))
   1798             vendor_srcdir = NULL;
   1799     } else {
   1800         /* srcarg may be "data", "system" or NULL.
   1801          * if srcarg is NULL, then both data and system are synced
   1802          */
   1803         if(strcmp(srcarg, "system") == 0) {
   1804             android_srcdir = product_file("system");
   1805         } else if(strcmp(srcarg, "data") == 0) {
   1806             data_srcdir = product_file("data");
   1807         } else if(strcmp(srcarg, "vendor") == 0) {
   1808             vendor_srcdir = product_file("vendor");
   1809         } else {
   1810             /* It's not "system", "vendor", or "data".
   1811              */
   1812             return 1;
   1813         }
   1814     }
   1815 
   1816     if(android_srcdir_out != NULL)
   1817         *android_srcdir_out = android_srcdir;
   1818     else
   1819         free(android_srcdir);
   1820 
   1821     if(vendor_srcdir_out != NULL)
   1822         *vendor_srcdir_out = vendor_srcdir;
   1823     else
   1824         free(vendor_srcdir);
   1825 
   1826     if(data_srcdir_out != NULL)
   1827             *data_srcdir_out = data_srcdir;
   1828         else
   1829             free(data_srcdir);
   1830     return 0;
   1831 }
   1832 
   1833 static int pm_command(transport_type transport, char* serial,
   1834                       int argc, char** argv)
   1835 {
   1836     char buf[4096];
   1837 
   1838     snprintf(buf, sizeof(buf), "shell:pm");
   1839 
   1840     while(argc-- > 0) {
   1841         char *quoted = escape_arg(*argv++);
   1842         strncat(buf, " ", sizeof(buf) - 1);
   1843         strncat(buf, quoted, sizeof(buf) - 1);
   1844         free(quoted);
   1845     }
   1846 
   1847     send_shellcommand(transport, serial, buf);
   1848     return 0;
   1849 }
   1850 
   1851 int uninstall_app(transport_type transport, char* serial, int argc, char** argv)
   1852 {
   1853     /* if the user choose the -k option, we refuse to do it until devices are
   1854        out with the option to uninstall the remaining data somehow (adb/ui) */
   1855     if (argc == 3 && strcmp(argv[1], "-k") == 0)
   1856     {
   1857         printf(
   1858             "The -k option uninstalls the application while retaining the data/cache.\n"
   1859             "At the moment, there is no way to remove the remaining data.\n"
   1860             "You will have to reinstall the application with the same signature, and fully uninstall it.\n"
   1861             "If you truly wish to continue, execute 'adb shell pm uninstall -k %s'\n", argv[2]);
   1862         return -1;
   1863     }
   1864 
   1865     /* 'adb uninstall' takes the same arguments as 'pm uninstall' on device */
   1866     return pm_command(transport, serial, argc, argv);
   1867 }
   1868 
   1869 static int delete_file(transport_type transport, char* serial, char* filename)
   1870 {
   1871     char buf[4096];
   1872     char* quoted;
   1873 
   1874     snprintf(buf, sizeof(buf), "shell:rm -f ");
   1875     quoted = escape_arg(filename);
   1876     strncat(buf, quoted, sizeof(buf)-1);
   1877     free(quoted);
   1878 
   1879     send_shellcommand(transport, serial, buf);
   1880     return 0;
   1881 }
   1882 
   1883 static const char* get_basename(const char* filename)
   1884 {
   1885     const char* basename = adb_dirstop(filename);
   1886     if (basename) {
   1887         basename++;
   1888         return basename;
   1889     } else {
   1890         return filename;
   1891     }
   1892 }
   1893 
   1894 int install_app(transport_type transport, char* serial, int argc, char** argv)
   1895 {
   1896     static const char *const DATA_DEST = "/data/local/tmp/%s";
   1897     static const char *const SD_DEST = "/sdcard/tmp/%s";
   1898     const char* where = DATA_DEST;
   1899     int i;
   1900     struct stat sb;
   1901 
   1902     for (i = 1; i < argc; i++) {
   1903         if (!strcmp(argv[i], "-s")) {
   1904             where = SD_DEST;
   1905         }
   1906     }
   1907 
   1908     // Find last APK argument.
   1909     // All other arguments passed through verbatim.
   1910     int last_apk = -1;
   1911     for (i = argc - 1; i >= 0; i--) {
   1912         char* file = argv[i];
   1913         char* dot = strrchr(file, '.');
   1914         if (dot && !strcasecmp(dot, ".apk")) {
   1915             if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) {
   1916                 fprintf(stderr, "Invalid APK file: %s\n", file);
   1917                 return -1;
   1918             }
   1919 
   1920             last_apk = i;
   1921             break;
   1922         }
   1923     }
   1924 
   1925     if (last_apk == -1) {
   1926         fprintf(stderr, "Missing APK file\n");
   1927         return -1;
   1928     }
   1929 
   1930     char* apk_file = argv[last_apk];
   1931     char apk_dest[PATH_MAX];
   1932     snprintf(apk_dest, sizeof apk_dest, where, get_basename(apk_file));
   1933     int err = do_sync_push(apk_file, apk_dest, 0 /* no show progress */);
   1934     if (err) {
   1935         goto cleanup_apk;
   1936     } else {
   1937         argv[last_apk] = apk_dest; /* destination name, not source location */
   1938     }
   1939 
   1940     pm_command(transport, serial, argc, argv);
   1941 
   1942 cleanup_apk:
   1943     delete_file(transport, serial, apk_dest);
   1944     return err;
   1945 }
   1946 
   1947 int install_multiple_app(transport_type transport, char* serial, int argc, char** argv)
   1948 {
   1949     char buf[1024];
   1950     int i;
   1951     struct stat sb;
   1952     unsigned long long total_size = 0;
   1953 
   1954     // Find all APK arguments starting at end.
   1955     // All other arguments passed through verbatim.
   1956     int first_apk = -1;
   1957     for (i = argc - 1; i >= 0; i--) {
   1958         char* file = argv[i];
   1959         char* dot = strrchr(file, '.');
   1960         if (dot && !strcasecmp(dot, ".apk")) {
   1961             if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) {
   1962                 fprintf(stderr, "Invalid APK file: %s\n", file);
   1963                 return -1;
   1964             }
   1965 
   1966             total_size += sb.st_size;
   1967             first_apk = i;
   1968         } else {
   1969             break;
   1970         }
   1971     }
   1972 
   1973     if (first_apk == -1) {
   1974         fprintf(stderr, "Missing APK file\n");
   1975         return 1;
   1976     }
   1977 
   1978     snprintf(buf, sizeof(buf), "exec:pm install-create -S %lld", total_size);
   1979     for (i = 1; i < first_apk; i++) {
   1980         char *quoted = escape_arg(argv[i]);
   1981         strncat(buf, " ", sizeof(buf) - 1);
   1982         strncat(buf, quoted, sizeof(buf) - 1);
   1983         free(quoted);
   1984     }
   1985 
   1986     // Create install session
   1987     int fd = adb_connect(buf);
   1988     if (fd < 0) {
   1989         fprintf(stderr, "Connect error for create: %s\n", adb_error());
   1990         return -1;
   1991     }
   1992     read_status_line(fd, buf, sizeof(buf));
   1993     adb_close(fd);
   1994 
   1995     int session_id = -1;
   1996     if (!strncmp("Success", buf, 7)) {
   1997         char* start = strrchr(buf, '[');
   1998         char* end = strrchr(buf, ']');
   1999         if (start && end) {
   2000             *end = '\0';
   2001             session_id = strtol(start + 1, NULL, 10);
   2002         }
   2003     }
   2004     if (session_id < 0) {
   2005         fprintf(stderr, "Failed to create session\n");
   2006         fputs(buf, stderr);
   2007         return -1;
   2008     }
   2009 
   2010     // Valid session, now stream the APKs
   2011     int success = 1;
   2012     for (i = first_apk; i < argc; i++) {
   2013         char* file = argv[i];
   2014         if (stat(file, &sb) == -1) {
   2015             fprintf(stderr, "Failed to stat %s\n", file);
   2016             success = 0;
   2017             goto finalize_session;
   2018         }
   2019 
   2020         snprintf(buf, sizeof(buf), "exec:pm install-write -S %lld %d %d_%s -",
   2021                 (long long int) sb.st_size, session_id, i, get_basename(file));
   2022 
   2023         int localFd = adb_open(file, O_RDONLY);
   2024         if (localFd < 0) {
   2025             fprintf(stderr, "Failed to open %s: %s\n", file, adb_error());
   2026             success = 0;
   2027             goto finalize_session;
   2028         }
   2029 
   2030         int remoteFd = adb_connect(buf);
   2031         if (remoteFd < 0) {
   2032             fprintf(stderr, "Connect error for write: %s\n", adb_error());
   2033             adb_close(localFd);
   2034             success = 0;
   2035             goto finalize_session;
   2036         }
   2037 
   2038         copy_to_file(localFd, remoteFd);
   2039         read_status_line(remoteFd, buf, sizeof(buf));
   2040 
   2041         adb_close(localFd);
   2042         adb_close(remoteFd);
   2043 
   2044         if (strncmp("Success", buf, 7)) {
   2045             fprintf(stderr, "Failed to write %s\n", file);
   2046             fputs(buf, stderr);
   2047             success = 0;
   2048             goto finalize_session;
   2049         }
   2050     }
   2051 
   2052 finalize_session:
   2053     // Commit session if we streamed everything okay; otherwise abandon
   2054     if (success) {
   2055         snprintf(buf, sizeof(buf), "exec:pm install-commit %d", session_id);
   2056     } else {
   2057         snprintf(buf, sizeof(buf), "exec:pm install-abandon %d", session_id);
   2058     }
   2059 
   2060     fd = adb_connect(buf);
   2061     if (fd < 0) {
   2062         fprintf(stderr, "Connect error for finalize: %s\n", adb_error());
   2063         return -1;
   2064     }
   2065     read_status_line(fd, buf, sizeof(buf));
   2066     adb_close(fd);
   2067 
   2068     if (!strncmp("Success", buf, 7)) {
   2069         fputs(buf, stderr);
   2070         return 0;
   2071     } else {
   2072         fprintf(stderr, "Failed to finalize session\n");
   2073         fputs(buf, stderr);
   2074         return -1;
   2075     }
   2076 }
   2077