Home | History | Annotate | Download | only in adb
      1 /*
      2  * Copyright (C) 2015 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 #include "adb_client.h"
     21 
     22 #include <errno.h>
     23 #include <inttypes.h>
     24 #include <limits.h>
     25 #include <stdarg.h>
     26 #include <stdio.h>
     27 #include <stdlib.h>
     28 #include <string.h>
     29 #include <sys/stat.h>
     30 #include <sys/types.h>
     31 
     32 #include <condition_variable>
     33 #include <mutex>
     34 #include <string>
     35 #include <thread>
     36 #include <vector>
     37 
     38 #include <android-base/stringprintf.h>
     39 #include <android-base/strings.h>
     40 #include <android-base/thread_annotations.h>
     41 #include <cutils/sockets.h>
     42 
     43 #include "adb_io.h"
     44 #include "adb_utils.h"
     45 #include "socket_spec.h"
     46 #include "sysdeps/chrono.h"
     47 
     48 static TransportType __adb_transport = kTransportAny;
     49 static const char* __adb_serial = NULL;
     50 static TransportId __adb_transport_id = 0;
     51 
     52 static const char* __adb_server_socket_spec;
     53 
     54 void adb_set_transport(TransportType type, const char* serial, TransportId transport_id) {
     55     __adb_transport = type;
     56     __adb_serial = serial;
     57     __adb_transport_id = transport_id;
     58 }
     59 
     60 void adb_get_transport(TransportType* type, const char** serial, TransportId* transport_id) {
     61     if (type) *type = __adb_transport;
     62     if (serial) *serial = __adb_serial;
     63     if (transport_id) *transport_id = __adb_transport_id;
     64 }
     65 
     66 void adb_set_socket_spec(const char* socket_spec) {
     67     if (__adb_server_socket_spec) {
     68         LOG(FATAL) << "attempted to reinitialize adb_server_socket_spec " << socket_spec << " (was " << __adb_server_socket_spec << ")";
     69     }
     70     __adb_server_socket_spec = socket_spec;
     71 }
     72 
     73 static int switch_socket_transport(int fd, std::string* error) {
     74     std::string service;
     75     if (__adb_transport_id) {
     76         service += "host:transport-id:";
     77         service += std::to_string(__adb_transport_id);
     78     } else if (__adb_serial) {
     79         service += "host:transport:";
     80         service += __adb_serial;
     81     } else {
     82         const char* transport_type = "???";
     83         switch (__adb_transport) {
     84           case kTransportUsb:
     85             transport_type = "transport-usb";
     86             break;
     87           case kTransportLocal:
     88             transport_type = "transport-local";
     89             break;
     90           case kTransportAny:
     91             transport_type = "transport-any";
     92             break;
     93           case kTransportHost:
     94             // no switch necessary
     95             return 0;
     96         }
     97         service += "host:";
     98         service += transport_type;
     99     }
    100 
    101     if (!SendProtocolString(fd, service)) {
    102         *error = perror_str("write failure during connection");
    103         adb_close(fd);
    104         return -1;
    105     }
    106     D("Switch transport in progress");
    107 
    108     if (!adb_status(fd, error)) {
    109         adb_close(fd);
    110         D("Switch transport failed: %s", error->c_str());
    111         return -1;
    112     }
    113     D("Switch transport success");
    114     return 0;
    115 }
    116 
    117 bool adb_status(int fd, std::string* error) {
    118     char buf[5];
    119     if (!ReadFdExactly(fd, buf, 4)) {
    120         *error = perror_str("protocol fault (couldn't read status)");
    121         return false;
    122     }
    123 
    124     if (!memcmp(buf, "OKAY", 4)) {
    125         return true;
    126     }
    127 
    128     if (memcmp(buf, "FAIL", 4)) {
    129         *error = android::base::StringPrintf("protocol fault (status %02x %02x %02x %02x?!)",
    130                                              buf[0], buf[1], buf[2], buf[3]);
    131         return false;
    132     }
    133 
    134     ReadProtocolString(fd, error, error);
    135     return false;
    136 }
    137 
    138 static int _adb_connect(const std::string& service, std::string* error) {
    139     D("_adb_connect: %s", service.c_str());
    140     if (service.empty() || service.size() > MAX_PAYLOAD) {
    141         *error = android::base::StringPrintf("bad service name length (%zd)",
    142                                              service.size());
    143         return -1;
    144     }
    145 
    146     std::string reason;
    147     int fd = socket_spec_connect(__adb_server_socket_spec, &reason);
    148     if (fd < 0) {
    149         *error = android::base::StringPrintf("cannot connect to daemon at %s: %s",
    150                                              __adb_server_socket_spec, reason.c_str());
    151         return -2;
    152     }
    153 
    154     if (memcmp(&service[0], "host", 4) != 0 && switch_socket_transport(fd, error)) {
    155         return -1;
    156     }
    157 
    158     if (!SendProtocolString(fd, service)) {
    159         *error = perror_str("write failure during connection");
    160         adb_close(fd);
    161         return -1;
    162     }
    163 
    164     if (!adb_status(fd, error)) {
    165         adb_close(fd);
    166         return -1;
    167     }
    168 
    169     D("_adb_connect: return fd %d", fd);
    170     return fd;
    171 }
    172 
    173 bool adb_kill_server() {
    174     D("adb_kill_server");
    175     std::string reason;
    176     int fd = socket_spec_connect(__adb_server_socket_spec, &reason);
    177     if (fd < 0) {
    178         fprintf(stderr, "cannot connect to daemon at %s: %s\n", __adb_server_socket_spec,
    179                 reason.c_str());
    180         return true;
    181     }
    182 
    183     if (!SendProtocolString(fd, "host:kill")) {
    184         fprintf(stderr, "error: write failure during connection: %s\n", strerror(errno));
    185         return false;
    186     }
    187 
    188     ReadOrderlyShutdown(fd);
    189     return true;
    190 }
    191 
    192 int adb_connect(const std::string& service, std::string* error) {
    193     // first query the adb server's version
    194     int fd = _adb_connect("host:version", error);
    195 
    196     D("adb_connect: service %s", service.c_str());
    197     if (fd == -2 && !is_local_socket_spec(__adb_server_socket_spec)) {
    198         fprintf(stderr, "* cannot start server on remote host\n");
    199         // error is the original network connection error
    200         return fd;
    201     } else if (fd == -2) {
    202         fprintf(stderr, "* daemon not running; starting now at %s\n", __adb_server_socket_spec);
    203     start_server:
    204         if (launch_server(__adb_server_socket_spec)) {
    205             fprintf(stderr, "* failed to start daemon\n");
    206             // launch_server() has already printed detailed error info, so just
    207             // return a generic error string about the overall adb_connect()
    208             // that the caller requested.
    209             *error = "cannot connect to daemon";
    210             return -1;
    211         } else {
    212             fprintf(stderr, "* daemon started successfully\n");
    213         }
    214         // The server will wait until it detects all of its connected devices before acking.
    215         // Fall through to _adb_connect.
    216     } else {
    217         // If a server is already running, check its version matches.
    218         int version = ADB_SERVER_VERSION - 1;
    219 
    220         // If we have a file descriptor, then parse version result.
    221         if (fd >= 0) {
    222             std::string version_string;
    223             if (!ReadProtocolString(fd, &version_string, error)) {
    224                 adb_close(fd);
    225                 return -1;
    226             }
    227 
    228             ReadOrderlyShutdown(fd);
    229             adb_close(fd);
    230 
    231             if (sscanf(&version_string[0], "%04x", &version) != 1) {
    232                 *error = android::base::StringPrintf("cannot parse version string: %s",
    233                                                      version_string.c_str());
    234                 return -1;
    235             }
    236         } else {
    237             // If fd is -1 check for "unknown host service" which would
    238             // indicate a version of adb that does not support the
    239             // version command, in which case we should fall-through to kill it.
    240             if (*error != "unknown host service") {
    241                 return fd;
    242             }
    243         }
    244 
    245         if (version != ADB_SERVER_VERSION) {
    246             fprintf(stderr, "adb server version (%d) doesn't match this client (%d); killing...\n",
    247                     version, ADB_SERVER_VERSION);
    248             adb_kill_server();
    249             goto start_server;
    250         }
    251     }
    252 
    253     // if the command is start-server, we are done.
    254     if (service == "host:start-server") {
    255         return 0;
    256     }
    257 
    258     fd = _adb_connect(service, error);
    259     if (fd == -1) {
    260         D("_adb_connect error: %s", error->c_str());
    261     } else if(fd == -2) {
    262         fprintf(stderr, "* daemon still not running\n");
    263     }
    264     D("adb_connect: return fd %d", fd);
    265 
    266     return fd;
    267 }
    268 
    269 
    270 bool adb_command(const std::string& service) {
    271     std::string error;
    272     int fd = adb_connect(service, &error);
    273     if (fd < 0) {
    274         fprintf(stderr, "error: %s\n", error.c_str());
    275         return false;
    276     }
    277 
    278     if (!adb_status(fd, &error)) {
    279         fprintf(stderr, "error: %s\n", error.c_str());
    280         adb_close(fd);
    281         return false;
    282     }
    283 
    284     ReadOrderlyShutdown(fd);
    285     adb_close(fd);
    286     return true;
    287 }
    288 
    289 bool adb_query(const std::string& service, std::string* result, std::string* error) {
    290     D("adb_query: %s", service.c_str());
    291     int fd = adb_connect(service, error);
    292     if (fd < 0) {
    293         return false;
    294     }
    295 
    296     result->clear();
    297     if (!ReadProtocolString(fd, result, error)) {
    298         adb_close(fd);
    299         return false;
    300     }
    301 
    302     ReadOrderlyShutdown(fd);
    303     adb_close(fd);
    304     return true;
    305 }
    306 
    307 std::string format_host_command(const char* command) {
    308     if (__adb_transport_id) {
    309         return android::base::StringPrintf("host-transport-id:%" PRIu64 ":%s", __adb_transport_id,
    310                                            command);
    311     } else if (__adb_serial) {
    312         return android::base::StringPrintf("host-serial:%s:%s", __adb_serial, command);
    313     }
    314 
    315     const char* prefix = "host";
    316     if (__adb_transport == kTransportUsb) {
    317         prefix = "host-usb";
    318     } else if (__adb_transport == kTransportLocal) {
    319         prefix = "host-local";
    320     }
    321     return android::base::StringPrintf("%s:%s", prefix, command);
    322 }
    323 
    324 bool adb_get_feature_set(FeatureSet* feature_set, std::string* error) {
    325     std::string result;
    326     if (adb_query(format_host_command("features"), &result, error)) {
    327         *feature_set = StringToFeatureSet(result);
    328         return true;
    329     }
    330     feature_set->clear();
    331     return false;
    332 }
    333