blob: 0b1ba32be19f83968ba58a0e28ca7c5c2b0aeb4c [file] [log] [blame]
Dan Albertb302d122015-02-24 15:51:19 -08001/*
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
Yabin Cui19bec5b2015-09-22 15:52:57 -070017#define TRACE_TAG ADB
Dan Albertdb6fe642015-03-19 15:21:08 -070018
19#include "sysdeps.h"
20#include "adb_client.h"
21
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080022#include <errno.h>
23#include <limits.h>
24#include <stdarg.h>
Dan Albertb302d122015-02-24 15:51:19 -080025#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080028#include <sys/stat.h>
Dan Albertb302d122015-02-24 15:51:19 -080029#include <sys/types.h>
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080030
Elliott Hughes949f2622015-04-27 14:20:17 -070031#include <string>
Elliott Hughes73925982016-11-15 12:37:32 -080032#include <thread>
Elliott Hughes04a98c22015-04-29 08:35:59 -070033#include <vector>
34
Elliott Hughesf55ead92015-12-04 22:00:26 -080035#include <android-base/stringprintf.h>
36#include <android-base/strings.h>
Elliott Hughes43df1092015-07-23 17:12:58 -070037#include <cutils/sockets.h>
Elliott Hughes949f2622015-04-27 14:20:17 -070038
Dan Albert66a91b02015-02-24 21:26:58 -080039#include "adb_io.h"
Elliott Hughes43df1092015-07-23 17:12:58 -070040#include "adb_utils.h"
Josh Gaobb4f8602016-08-25 16:00:22 -070041#include "socket_spec.h"
Josh Gao70267e42016-11-15 18:55:47 -080042#include "sysdeps/chrono.h"
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080043
Elliott Hughes3aec2ba2015-05-05 13:10:43 -070044static TransportType __adb_transport = kTransportAny;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080045static const char* __adb_serial = NULL;
46
Josh Gaobb4f8602016-08-25 16:00:22 -070047static const char* __adb_server_socket_spec;
Stefan Hilzingerfb798d92010-04-19 12:21:12 +010048
Elliott Hughes3aec2ba2015-05-05 13:10:43 -070049void adb_set_transport(TransportType type, const char* serial)
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080050{
51 __adb_transport = type;
52 __adb_serial = serial;
53}
54
Josh Gaob1a71ce2016-03-04 15:16:18 -080055void adb_get_transport(TransportType* type, const char** serial) {
56 if (type) {
57 *type = __adb_transport;
58 }
59 if (serial) {
60 *serial = __adb_serial;
61 }
62}
63
Josh Gaobb4f8602016-08-25 16:00:22 -070064void adb_set_socket_spec(const char* socket_spec) {
Elliott Hughes6d959d12016-09-01 20:48:45 -070065 if (__adb_server_socket_spec) {
66 LOG(FATAL) << "attempted to reinitialize adb_server_socket_spec " << socket_spec << " (was " << __adb_server_socket_spec << ")";
Josh Gaobb4f8602016-08-25 16:00:22 -070067 }
68 __adb_server_socket_spec = socket_spec;
Matt Gumbel411775c2012-11-14 10:16:17 -080069}
70
Elliott Hughes04a98c22015-04-29 08:35:59 -070071static int switch_socket_transport(int fd, std::string* error) {
Elliott Hughes949f2622015-04-27 14:20:17 -070072 std::string service;
73 if (__adb_serial) {
74 service += "host:transport:";
75 service += __adb_serial;
76 } else {
Dan Albertf30d73c2015-02-25 17:51:28 -080077 const char* transport_type = "???";
Elliott Hughes949f2622015-04-27 14:20:17 -070078 switch (__adb_transport) {
79 case kTransportUsb:
80 transport_type = "transport-usb";
81 break;
82 case kTransportLocal:
83 transport_type = "transport-local";
84 break;
85 case kTransportAny:
86 transport_type = "transport-any";
87 break;
88 case kTransportHost:
89 // no switch necessary
90 return 0;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080091 }
Elliott Hughes949f2622015-04-27 14:20:17 -070092 service += "host:";
93 service += transport_type;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080094 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080095
Elliott Hughes88b4c852015-04-30 17:32:03 -070096 if (!SendProtocolString(fd, service)) {
Elliott Hughes04a98c22015-04-29 08:35:59 -070097 *error = perror_str("write failure during connection");
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080098 adb_close(fd);
99 return -1;
100 }
Yabin Cui815ad882015-09-02 17:44:28 -0700101 D("Switch transport in progress");
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800102
Elliott Hughes04a98c22015-04-29 08:35:59 -0700103 if (!adb_status(fd, error)) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800104 adb_close(fd);
Yabin Cui815ad882015-09-02 17:44:28 -0700105 D("Switch transport failed: %s", error->c_str());
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800106 return -1;
107 }
Yabin Cui815ad882015-09-02 17:44:28 -0700108 D("Switch transport success");
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800109 return 0;
110}
111
Elliott Hughes04a98c22015-04-29 08:35:59 -0700112bool adb_status(int fd, std::string* error) {
113 char buf[5];
Elliott Hughes04a98c22015-04-29 08:35:59 -0700114 if (!ReadFdExactly(fd, buf, 4)) {
115 *error = perror_str("protocol fault (couldn't read status)");
116 return false;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800117 }
118
Elliott Hughes04a98c22015-04-29 08:35:59 -0700119 if (!memcmp(buf, "OKAY", 4)) {
120 return true;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800121 }
122
Elliott Hughes04a98c22015-04-29 08:35:59 -0700123 if (memcmp(buf, "FAIL", 4)) {
124 *error = android::base::StringPrintf("protocol fault (status %02x %02x %02x %02x?!)",
125 buf[0], buf[1], buf[2], buf[3]);
126 return false;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800127 }
128
Elliott Hughesda945812015-04-29 12:28:13 -0700129 ReadProtocolString(fd, error, error);
Elliott Hughes04a98c22015-04-29 08:35:59 -0700130 return false;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800131}
132
Elliott Hughesda945812015-04-29 12:28:13 -0700133int _adb_connect(const std::string& service, std::string* error) {
Yabin Cui815ad882015-09-02 17:44:28 -0700134 D("_adb_connect: %s", service.c_str());
Josh Gao9055a582016-01-15 14:35:54 -0800135 if (service.empty() || service.size() > MAX_PAYLOAD_V1) {
Spencer Low803451e2015-05-13 00:02:55 -0700136 *error = android::base::StringPrintf("bad service name length (%zd)",
137 service.size());
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800138 return -1;
139 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800140
Spencer Low753d4852015-07-30 23:07:55 -0700141 std::string reason;
Josh Gaobb4f8602016-08-25 16:00:22 -0700142 int fd = socket_spec_connect(__adb_server_socket_spec, &reason);
143 if (fd < 0) {
144 *error = android::base::StringPrintf("cannot connect to daemon at %s: %s",
145 __adb_server_socket_spec, reason.c_str());
146 return -2;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800147 }
148
Yabin Cuid78ed222016-04-05 13:50:44 -0700149 if ((memcmp(&service[0],"host",4) != 0 || service == "host:reconnect") &&
150 switch_socket_transport(fd, error)) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800151 return -1;
152 }
153
Elliott Hughesb628cb12015-08-03 10:38:08 -0700154 if (!SendProtocolString(fd, service)) {
Elliott Hughes04a98c22015-04-29 08:35:59 -0700155 *error = perror_str("write failure during connection");
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800156 adb_close(fd);
157 return -1;
158 }
159
Yabin Cuid78ed222016-04-05 13:50:44 -0700160 if (service != "reconnect") {
161 if (!adb_status(fd, error)) {
162 adb_close(fd);
163 return -1;
164 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800165 }
166
Yabin Cui815ad882015-09-02 17:44:28 -0700167 D("_adb_connect: return fd %d", fd);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800168 return fd;
169}
170
Elliott Hughesda945812015-04-29 12:28:13 -0700171int adb_connect(const std::string& service, std::string* error) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800172 // first query the adb server's version
Elliott Hughes04a98c22015-04-29 08:35:59 -0700173 int fd = _adb_connect("host:version", error);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800174
Yabin Cui815ad882015-09-02 17:44:28 -0700175 D("adb_connect: service %s", service.c_str());
Josh Gaobb4f8602016-08-25 16:00:22 -0700176 if (fd == -2 && !is_local_socket_spec(__adb_server_socket_spec)) {
Matt Gumbel411775c2012-11-14 10:16:17 -0800177 fprintf(stderr,"** Cannot start server on remote host\n");
Spencer Low85ee64b2015-08-11 17:05:02 -0700178 // error is the original network connection error
Matt Gumbel411775c2012-11-14 10:16:17 -0800179 return fd;
Elliott Hughes04a98c22015-04-29 08:35:59 -0700180 } else if (fd == -2) {
Josh Gaobb4f8602016-08-25 16:00:22 -0700181 fprintf(stdout, "* daemon not running. starting it now at %s *\n", __adb_server_socket_spec);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800182 start_server:
Josh Gaobb4f8602016-08-25 16:00:22 -0700183 if (launch_server(__adb_server_socket_spec)) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800184 fprintf(stderr,"* failed to start daemon *\n");
Spencer Low85ee64b2015-08-11 17:05:02 -0700185 // launch_server() has already printed detailed error info, so just
186 // return a generic error string about the overall adb_connect()
187 // that the caller requested.
188 *error = "cannot connect to daemon";
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800189 return -1;
190 } else {
191 fprintf(stdout,"* daemon started successfully *\n");
192 }
Elliott Hughes73925982016-11-15 12:37:32 -0800193 // Give the server some time to start properly and detect devices.
Josh Gao70267e42016-11-15 18:55:47 -0800194 std::this_thread::sleep_for(3s);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800195 // fall through to _adb_connect
196 } else {
Elliott Hughesa1452ab2015-10-02 19:49:10 -0700197 // If a server is already running, check its version matches.
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800198 int version = ADB_SERVER_VERSION - 1;
199
Elliott Hughesa1452ab2015-10-02 19:49:10 -0700200 // If we have a file descriptor, then parse version result.
Elliott Hughes04a98c22015-04-29 08:35:59 -0700201 if (fd >= 0) {
Elliott Hughesda945812015-04-29 12:28:13 -0700202 std::string version_string;
203 if (!ReadProtocolString(fd, &version_string, error)) {
Elliott Hughesa1452ab2015-10-02 19:49:10 -0700204 adb_close(fd);
205 return -1;
Elliott Hughesda945812015-04-29 12:28:13 -0700206 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800207
Spencer Lowcc4a4b12015-10-14 17:32:44 -0700208 ReadOrderlyShutdown(fd);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800209 adb_close(fd);
210
Elliott Hughesda945812015-04-29 12:28:13 -0700211 if (sscanf(&version_string[0], "%04x", &version) != 1) {
Elliott Hughes67943d12015-10-07 14:55:10 -0700212 *error = android::base::StringPrintf("cannot parse version string: %s",
213 version_string.c_str());
Spencer Low85ee64b2015-08-11 17:05:02 -0700214 return -1;
Elliott Hughesda945812015-04-29 12:28:13 -0700215 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800216 } else {
Elliott Hughesa1452ab2015-10-02 19:49:10 -0700217 // If fd is -1 check for "unknown host service" which would
218 // indicate a version of adb that does not support the
Spencer Low2218c752015-08-05 19:26:50 -0700219 // version command, in which case we should fall-through to kill it.
220 if (*error != "unknown host service") {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800221 return fd;
Elliott Hughes04a98c22015-04-29 08:35:59 -0700222 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800223 }
224
Elliott Hughesda945812015-04-29 12:28:13 -0700225 if (version != ADB_SERVER_VERSION) {
Elliott Hughesa1452ab2015-10-02 19:49:10 -0700226 printf("adb server version (%d) doesn't match this client (%d); killing...\n",
227 version, ADB_SERVER_VERSION);
Elliott Hughes04a98c22015-04-29 08:35:59 -0700228 fd = _adb_connect("host:kill", error);
Spencer Low85ee64b2015-08-11 17:05:02 -0700229 if (fd >= 0) {
Spencer Lowcc4a4b12015-10-14 17:32:44 -0700230 ReadOrderlyShutdown(fd);
Spencer Low85ee64b2015-08-11 17:05:02 -0700231 adb_close(fd);
232 } else {
233 // If we couldn't connect to the server or had some other error,
234 // report it, but still try to start the server.
235 fprintf(stderr, "error: %s\n", error->c_str());
236 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800237
238 /* XXX can we better detect its death? */
Josh Gao70267e42016-11-15 18:55:47 -0800239 std::this_thread::sleep_for(2s);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800240 goto start_server;
241 }
242 }
243
244 // if the command is start-server, we are done.
Elliott Hughesda945812015-04-29 12:28:13 -0700245 if (service == "host:start-server") {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800246 return 0;
Elliott Hughes04a98c22015-04-29 08:35:59 -0700247 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800248
Elliott Hughes04a98c22015-04-29 08:35:59 -0700249 fd = _adb_connect(service, error);
250 if (fd == -1) {
Yabin Cui815ad882015-09-02 17:44:28 -0700251 D("_adb_connect error: %s", error->c_str());
Brian Carlstromcad81322013-10-18 13:58:48 -0700252 } else if(fd == -2) {
Matt Gumbel411775c2012-11-14 10:16:17 -0800253 fprintf(stderr,"** daemon still not running\n");
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800254 }
Yabin Cui815ad882015-09-02 17:44:28 -0700255 D("adb_connect: return fd %d", fd);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800256
257 return fd;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800258}
259
260
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700261bool adb_command(const std::string& service) {
262 std::string error;
263 int fd = adb_connect(service, &error);
Elliott Hughes04a98c22015-04-29 08:35:59 -0700264 if (fd < 0) {
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700265 fprintf(stderr, "error: %s\n", error.c_str());
266 return false;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800267 }
268
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700269 if (!adb_status(fd, &error)) {
270 fprintf(stderr, "error: %s\n", error.c_str());
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800271 adb_close(fd);
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700272 return false;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800273 }
274
Spencer Lowcc4a4b12015-10-14 17:32:44 -0700275 ReadOrderlyShutdown(fd);
276 adb_close(fd);
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700277 return true;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800278}
279
Elliott Hughesda945812015-04-29 12:28:13 -0700280bool adb_query(const std::string& service, std::string* result, std::string* error) {
Yabin Cui815ad882015-09-02 17:44:28 -0700281 D("adb_query: %s", service.c_str());
Elliott Hughes04a98c22015-04-29 08:35:59 -0700282 int fd = adb_connect(service, error);
283 if (fd < 0) {
Elliott Hughes09ccf1f2015-07-18 12:21:30 -0700284 return false;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800285 }
286
Elliott Hughesda945812015-04-29 12:28:13 -0700287 result->clear();
288 if (!ReadProtocolString(fd, result, error)) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800289 adb_close(fd);
Elliott Hughesda945812015-04-29 12:28:13 -0700290 return false;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800291 }
Spencer Lowcc4a4b12015-10-14 17:32:44 -0700292
293 ReadOrderlyShutdown(fd);
294 adb_close(fd);
Elliott Hughesda945812015-04-29 12:28:13 -0700295 return true;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800296}
Josh Gao91d53b52016-01-31 19:12:26 -0800297
298std::string format_host_command(const char* command, TransportType type, const char* serial) {
299 if (serial) {
300 return android::base::StringPrintf("host-serial:%s:%s", serial, command);
301 }
302
303 const char* prefix = "host";
304 if (type == kTransportUsb) {
305 prefix = "host-usb";
306 } else if (type == kTransportLocal) {
307 prefix = "host-local";
308 }
309 return android::base::StringPrintf("%s:%s", prefix, command);
310}
311
312bool adb_get_feature_set(FeatureSet* feature_set, std::string* error) {
313 std::string result;
314 if (adb_query(format_host_command("features", __adb_transport, __adb_serial), &result, error)) {
315 *feature_set = StringToFeatureSet(result);
316 return true;
317 }
318 feature_set->clear();
319 return false;
320}