blob: 0e1859cddc7512c21673d0e1b5389828b9a27885 [file] [log] [blame]
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -08001/*
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
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.h"
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080021
Dan Albertecbd8742015-03-08 21:12:08 -070022#include <ctype.h>
23#include <errno.h>
24#include <stdarg.h>
25#include <stddef.h>
26#include <stdint.h>
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080027#include <stdio.h>
28#include <stdlib.h>
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080029#include <string.h>
Mike Lockwood4ac1e282009-05-25 18:17:55 -040030#include <sys/time.h>
Dan Albertecbd8742015-03-08 21:12:08 -070031#include <time.h>
32
33#include <string>
Dan Albert27929b02015-03-19 13:25:27 -070034#include <vector>
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080035
Dan Albert08d552b2015-05-21 13:58:50 -070036#include <base/logging.h>
Spencer Low6815c072015-05-11 01:08:48 -070037#include <base/macros.h>
Elliott Hughesa585cbd2015-04-20 08:09:20 -070038#include <base/stringprintf.h>
Elliott Hughesfb2ba512015-04-24 23:02:00 -070039#include <base/strings.h>
Elliott Hughesa585cbd2015-04-20 08:09:20 -070040
Benoit Goby2cc19e42012-04-12 12:23:49 -070041#include "adb_auth.h"
Dan Albert66a91b02015-02-24 21:26:58 -080042#include "adb_io.h"
Dan Albert020292b2015-02-18 18:03:26 -080043#include "adb_listeners.h"
Elliott Hughes09ccf1f2015-07-18 12:21:30 -070044#include "adb_utils.h"
Dan Albertb302d122015-02-24 15:51:19 -080045#include "transport.h"
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080046
Scott Andersonfa020922012-05-25 14:10:02 -070047#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
48
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080049#if !ADB_HOST
Nick Kralevich7472d292013-05-23 09:54:13 -070050#include <cutils/properties.h>
Nick Kralevich9de01bd2013-02-28 14:12:58 -080051#include <sys/capability.h>
Jeff Sharkey11987252012-08-14 21:00:22 -070052#include <sys/mount.h>
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080053#endif
54
Elliott Hughesb9f01642015-08-12 08:32:10 -070055std::string adb_version() {
56 // Don't change the format of this --- it's parsed by ddmlib.
57 return android::base::StringPrintf("Android Debug Bridge version %d.%d.%d\n"
58 "Revision %s\n",
59 ADB_VERSION_MAJOR, ADB_VERSION_MINOR, ADB_SERVER_VERSION,
60 ADB_REVISION);
61}
62
Dan Albert08d552b2015-05-21 13:58:50 -070063void fatal(const char *fmt, ...) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080064 va_list ap;
65 va_start(ap, fmt);
66 fprintf(stderr, "error: ");
67 vfprintf(stderr, fmt, ap);
68 fprintf(stderr, "\n");
69 va_end(ap);
70 exit(-1);
71}
72
Dan Albert08d552b2015-05-21 13:58:50 -070073void fatal_errno(const char* fmt, ...) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080074 va_list ap;
75 va_start(ap, fmt);
76 fprintf(stderr, "error: %s: ", strerror(errno));
77 vfprintf(stderr, fmt, ap);
78 fprintf(stderr, "\n");
79 va_end(ap);
80 exit(-1);
81}
82
Dan Albertf30d73c2015-02-25 17:51:28 -080083apacket* get_apacket(void)
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080084{
Dan Albertf30d73c2015-02-25 17:51:28 -080085 apacket* p = reinterpret_cast<apacket*>(malloc(sizeof(apacket)));
86 if (p == nullptr) {
87 fatal("failed to allocate an apacket");
88 }
89
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -080090 memset(p, 0, sizeof(apacket) - MAX_PAYLOAD);
91 return p;
92}
93
94void put_apacket(apacket *p)
95{
96 free(p);
97}
98
Benoit Goby2cc19e42012-04-12 12:23:49 -070099void handle_online(atransport *t)
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800100{
Yabin Cui815ad882015-09-02 17:44:28 -0700101 D("adb: online");
Benoit Goby2cc19e42012-04-12 12:23:49 -0700102 t->online = 1;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800103}
104
105void handle_offline(atransport *t)
106{
Yabin Cui815ad882015-09-02 17:44:28 -0700107 D("adb: offline");
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800108 //Close the associated usb
Benoit Goby2cc19e42012-04-12 12:23:49 -0700109 t->online = 0;
Yabin Cui10dedd82015-08-26 11:18:42 -0700110
Yabin Cui2d4c1982015-08-28 15:09:44 -0700111 // This is necessary to avoid a race condition that occurred when a transport closes
Yabin Cui10dedd82015-08-26 11:18:42 -0700112 // while a client socket is still active.
113 close_all_sockets(t);
114
Yabin Cui2d4c1982015-08-28 15:09:44 -0700115 t->RunDisconnects();
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800116}
117
Benoit Goby2cc19e42012-04-12 12:23:49 -0700118#if DEBUG_PACKETS
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800119#define DUMPMAX 32
120void print_packet(const char *label, apacket *p)
121{
122 char *tag;
123 char *x;
124 unsigned count;
125
126 switch(p->msg.command){
127 case A_SYNC: tag = "SYNC"; break;
128 case A_CNXN: tag = "CNXN" ; break;
129 case A_OPEN: tag = "OPEN"; break;
130 case A_OKAY: tag = "OKAY"; break;
131 case A_CLSE: tag = "CLSE"; break;
132 case A_WRTE: tag = "WRTE"; break;
Benoit Goby2cc19e42012-04-12 12:23:49 -0700133 case A_AUTH: tag = "AUTH"; break;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800134 default: tag = "????"; break;
135 }
136
137 fprintf(stderr, "%s: %s %08x %08x %04x \"",
138 label, tag, p->msg.arg0, p->msg.arg1, p->msg.data_length);
139 count = p->msg.data_length;
140 x = (char*) p->data;
141 if(count > DUMPMAX) {
142 count = DUMPMAX;
143 tag = "\n";
144 } else {
145 tag = "\"\n";
146 }
147 while(count-- > 0){
148 if((*x >= ' ') && (*x < 127)) {
149 fputc(*x, stderr);
150 } else {
151 fputc('.', stderr);
152 }
153 x++;
154 }
Benoit Goby2cc19e42012-04-12 12:23:49 -0700155 fputs(tag, stderr);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800156}
157#endif
158
159static void send_ready(unsigned local, unsigned remote, atransport *t)
160{
Yabin Cui815ad882015-09-02 17:44:28 -0700161 D("Calling send_ready");
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800162 apacket *p = get_apacket();
163 p->msg.command = A_OKAY;
164 p->msg.arg0 = local;
165 p->msg.arg1 = remote;
166 send_packet(p, t);
167}
168
169static void send_close(unsigned local, unsigned remote, atransport *t)
170{
Yabin Cui815ad882015-09-02 17:44:28 -0700171 D("Calling send_close");
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800172 apacket *p = get_apacket();
173 p->msg.command = A_CLSE;
174 p->msg.arg0 = local;
175 p->msg.arg1 = remote;
176 send_packet(p, t);
177}
178
Dan Albertbe8e54b2015-05-18 13:06:53 -0700179std::string get_connection_string() {
180 std::vector<std::string> connection_properties;
181
182#if !ADB_HOST
183 static const char* cnxn_props[] = {
Scott Andersonfa020922012-05-25 14:10:02 -0700184 "ro.product.name",
185 "ro.product.model",
186 "ro.product.device",
187 };
Scott Andersonfa020922012-05-25 14:10:02 -0700188
Dan Albertbe8e54b2015-05-18 13:06:53 -0700189 for (const auto& prop_name : cnxn_props) {
Scott Andersonfa020922012-05-25 14:10:02 -0700190 char value[PROPERTY_VALUE_MAX];
Dan Albertbe8e54b2015-05-18 13:06:53 -0700191 property_get(prop_name, value, "");
192 connection_properties.push_back(
193 android::base::StringPrintf("%s=%s", prop_name, value));
Scott Andersonfa020922012-05-25 14:10:02 -0700194 }
Scott Andersonfa020922012-05-25 14:10:02 -0700195#endif
Dan Albertbe8e54b2015-05-18 13:06:53 -0700196
197 connection_properties.push_back(android::base::StringPrintf(
David Pursella07dbad2015-09-22 10:43:08 -0700198 "features=%s", FeatureSetToString(supported_features()).c_str()));
Dan Albertbe8e54b2015-05-18 13:06:53 -0700199
200 return android::base::StringPrintf(
201 "%s::%s", adb_device_banner,
202 android::base::Join(connection_properties, ';').c_str());
Scott Andersonfa020922012-05-25 14:10:02 -0700203}
204
Dan Albertbe8e54b2015-05-18 13:06:53 -0700205void send_connect(atransport* t) {
Yabin Cui815ad882015-09-02 17:44:28 -0700206 D("Calling send_connect");
Dan Albertbe8e54b2015-05-18 13:06:53 -0700207 apacket* cp = get_apacket();
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800208 cp->msg.command = A_CNXN;
Tamas Berghammera1c60c02015-07-13 19:12:28 +0100209 cp->msg.arg0 = t->get_protocol_version();
210 cp->msg.arg1 = t->get_max_payload();
Dan Albertbe8e54b2015-05-18 13:06:53 -0700211
212 std::string connection_str = get_connection_string();
213 // Connect and auth packets are limited to MAX_PAYLOAD_V1 because we don't
214 // yet know how much data the other size is willing to accept.
215 if (connection_str.length() > MAX_PAYLOAD_V1) {
216 LOG(FATAL) << "Connection banner is too long (length = "
217 << connection_str.length() << ")";
218 }
219
220 memcpy(cp->data, connection_str.c_str(), connection_str.length());
221 cp->msg.data_length = connection_str.length();
222
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800223 send_packet(cp, t);
Benoit Goby2cc19e42012-04-12 12:23:49 -0700224}
225
Elliott Hughesfb2ba512015-04-24 23:02:00 -0700226// qual_overwrite is used to overwrite a qualifier string. dst is a
227// pointer to a char pointer. It is assumed that if *dst is non-NULL, it
228// was malloc'ed and needs to freed. *dst will be set to a dup of src.
229// TODO: switch to std::string for these atransport fields instead.
230static void qual_overwrite(char** dst, const std::string& src) {
Scott Andersonfa020922012-05-25 14:10:02 -0700231 free(*dst);
Elliott Hughesfb2ba512015-04-24 23:02:00 -0700232 *dst = strdup(src.c_str());
Scott Andersonfa020922012-05-25 14:10:02 -0700233}
234
Dan Albertbe8e54b2015-05-18 13:06:53 -0700235void parse_banner(const std::string& banner, atransport* t) {
Yabin Cui815ad882015-09-02 17:44:28 -0700236 D("parse_banner: %s", banner.c_str());
Elliott Hughesfb2ba512015-04-24 23:02:00 -0700237
238 // The format is something like:
239 // "device::ro.product.name=x;ro.product.model=y;ro.product.device=z;".
240 std::vector<std::string> pieces = android::base::Split(banner, ":");
241
David Pursell3d9072b2015-09-25 13:04:21 -0700242 // Reset the features list or else if the server sends no features we may
243 // keep the existing feature set (http://b/24405971).
244 t->SetFeatures("");
245
Elliott Hughesfb2ba512015-04-24 23:02:00 -0700246 if (pieces.size() > 2) {
247 const std::string& props = pieces[2];
248 for (auto& prop : android::base::Split(props, ";")) {
249 // The list of properties was traditionally ;-terminated rather than ;-separated.
250 if (prop.empty()) continue;
251
252 std::vector<std::string> key_value = android::base::Split(prop, "=");
253 if (key_value.size() != 2) continue;
254
255 const std::string& key = key_value[0];
256 const std::string& value = key_value[1];
257 if (key == "ro.product.name") {
258 qual_overwrite(&t->product, value);
259 } else if (key == "ro.product.model") {
260 qual_overwrite(&t->model, value);
261 } else if (key == "ro.product.device") {
262 qual_overwrite(&t->device, value);
Dan Albertbe8e54b2015-05-18 13:06:53 -0700263 } else if (key == "features") {
David Pursella07dbad2015-09-22 10:43:08 -0700264 t->SetFeatures(value);
Scott Andersonfa020922012-05-25 14:10:02 -0700265 }
266 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800267 }
268
Elliott Hughesfb2ba512015-04-24 23:02:00 -0700269 const std::string& type = pieces[0];
270 if (type == "bootloader") {
Yabin Cui815ad882015-09-02 17:44:28 -0700271 D("setting connection_state to kCsBootloader");
Dan Albert9a50f4c2015-05-18 16:43:57 -0700272 t->connection_state = kCsBootloader;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800273 update_transports();
Elliott Hughesfb2ba512015-04-24 23:02:00 -0700274 } else if (type == "device") {
Yabin Cui815ad882015-09-02 17:44:28 -0700275 D("setting connection_state to kCsDevice");
Dan Albert9a50f4c2015-05-18 16:43:57 -0700276 t->connection_state = kCsDevice;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800277 update_transports();
Elliott Hughesfb2ba512015-04-24 23:02:00 -0700278 } else if (type == "recovery") {
Yabin Cui815ad882015-09-02 17:44:28 -0700279 D("setting connection_state to kCsRecovery");
Dan Albert9a50f4c2015-05-18 16:43:57 -0700280 t->connection_state = kCsRecovery;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800281 update_transports();
Elliott Hughesfb2ba512015-04-24 23:02:00 -0700282 } else if (type == "sideload") {
Yabin Cui815ad882015-09-02 17:44:28 -0700283 D("setting connection_state to kCsSideload");
Dan Albert9a50f4c2015-05-18 16:43:57 -0700284 t->connection_state = kCsSideload;
Doug Zongker6b217ed2012-01-09 14:54:53 -0800285 update_transports();
Elliott Hughesb27e2412015-04-29 22:37:25 -0700286 } else {
Yabin Cui815ad882015-09-02 17:44:28 -0700287 D("setting connection_state to kCsHost");
Dan Albert9a50f4c2015-05-18 16:43:57 -0700288 t->connection_state = kCsHost;
Doug Zongker6b217ed2012-01-09 14:54:53 -0800289 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800290}
291
Dan Albertbe8e54b2015-05-18 13:06:53 -0700292static void handle_new_connection(atransport* t, apacket* p) {
293 if (t->connection_state != kCsOffline) {
294 t->connection_state = kCsOffline;
295 handle_offline(t);
296 }
297
298 t->update_version(p->msg.arg0, p->msg.arg1);
299 std::string banner(reinterpret_cast<const char*>(p->data),
300 p->msg.data_length);
301 parse_banner(banner, t);
302
303#if ADB_HOST
304 handle_online(t);
305#else
306 if (!auth_required) {
307 handle_online(t);
308 send_connect(t);
309 } else {
310 send_auth_request(t);
311 }
312#endif
313}
314
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800315void handle_packet(apacket *p, atransport *t)
316{
317 asocket *s;
318
Yabin Cui815ad882015-09-02 17:44:28 -0700319 D("handle_packet() %c%c%c%c", ((char*) (&(p->msg.command)))[0],
Viral Mehta841f9a72010-06-16 18:41:28 +0530320 ((char*) (&(p->msg.command)))[1],
321 ((char*) (&(p->msg.command)))[2],
322 ((char*) (&(p->msg.command)))[3]);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800323 print_packet("recv", p);
324
325 switch(p->msg.command){
326 case A_SYNC:
327 if(p->msg.arg0){
328 send_packet(p, t);
Yabin Cui5fe6d0d2015-08-11 13:40:42 -0700329#if ADB_HOST
330 send_connect(t);
331#endif
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800332 } else {
Dan Albert9a50f4c2015-05-18 16:43:57 -0700333 t->connection_state = kCsOffline;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800334 handle_offline(t);
335 send_packet(p, t);
336 }
337 return;
338
Dan Albertbe8e54b2015-05-18 13:06:53 -0700339 case A_CNXN: // CONNECT(version, maxdata, "system-id-string")
340 handle_new_connection(t, p);
Benoit Goby2cc19e42012-04-12 12:23:49 -0700341 break;
342
343 case A_AUTH:
344 if (p->msg.arg0 == ADB_AUTH_TOKEN) {
Dan Albert9a50f4c2015-05-18 16:43:57 -0700345 t->connection_state = kCsUnauthorized;
Benoit Goby2cc19e42012-04-12 12:23:49 -0700346 t->key = adb_auth_nextkey(t->key);
347 if (t->key) {
348 send_auth_response(p->data, p->msg.data_length, t);
349 } else {
350 /* No more private keys to try, send the public key */
351 send_auth_publickey(t);
352 }
353 } else if (p->msg.arg0 == ADB_AUTH_SIGNATURE) {
354 if (adb_auth_verify(t->token, p->data, p->msg.data_length)) {
355 adb_auth_verified(t);
356 t->failed_auth_attempts = 0;
357 } else {
358 if (t->failed_auth_attempts++ > 10)
359 adb_sleep_ms(1000);
360 send_auth_request(t);
361 }
362 } else if (p->msg.arg0 == ADB_AUTH_RSAPUBLICKEY) {
363 adb_auth_confirm_key(p->data, p->msg.data_length, t);
364 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800365 break;
366
367 case A_OPEN: /* OPEN(local-id, 0, "destination") */
David 'Digit' Turnere92344d2013-12-13 14:09:44 +0100368 if (t->online && p->msg.arg0 != 0 && p->msg.arg1 == 0) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800369 char *name = (char*) p->data;
370 name[p->msg.data_length > 0 ? p->msg.data_length - 1 : 0] = 0;
David Pursell8da19a42015-08-31 10:42:13 -0700371 s = create_local_service_socket(name, t);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800372 if(s == 0) {
373 send_close(0, p->msg.arg0, t);
374 } else {
375 s->peer = create_remote_socket(p->msg.arg0, t);
376 s->peer->peer = s;
377 send_ready(s->id, s->peer->id, t);
378 s->ready(s);
379 }
380 }
381 break;
382
383 case A_OKAY: /* READY(local-id, remote-id, "") */
David 'Digit' Turnere92344d2013-12-13 14:09:44 +0100384 if (t->online && p->msg.arg0 != 0 && p->msg.arg1 != 0) {
385 if((s = find_local_socket(p->msg.arg1, 0))) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800386 if(s->peer == 0) {
David 'Digit' Turnere92344d2013-12-13 14:09:44 +0100387 /* On first READY message, create the connection. */
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800388 s->peer = create_remote_socket(p->msg.arg0, t);
389 s->peer->peer = s;
David 'Digit' Turnere92344d2013-12-13 14:09:44 +0100390 s->ready(s);
391 } else if (s->peer->id == p->msg.arg0) {
392 /* Other READY messages must use the same local-id */
393 s->ready(s);
394 } else {
Yabin Cui815ad882015-09-02 17:44:28 -0700395 D("Invalid A_OKAY(%d,%d), expected A_OKAY(%d,%d) on transport %s",
David 'Digit' Turnere92344d2013-12-13 14:09:44 +0100396 p->msg.arg0, p->msg.arg1, s->peer->id, p->msg.arg1, t->serial);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800397 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800398 }
399 }
400 break;
401
David 'Digit' Turnere92344d2013-12-13 14:09:44 +0100402 case A_CLSE: /* CLOSE(local-id, remote-id, "") or CLOSE(0, remote-id, "") */
403 if (t->online && p->msg.arg1 != 0) {
404 if((s = find_local_socket(p->msg.arg1, p->msg.arg0))) {
405 /* According to protocol.txt, p->msg.arg0 might be 0 to indicate
406 * a failed OPEN only. However, due to a bug in previous ADB
407 * versions, CLOSE(0, remote-id, "") was also used for normal
408 * CLOSE() operations.
409 *
410 * This is bad because it means a compromised adbd could
411 * send packets to close connections between the host and
412 * other devices. To avoid this, only allow this if the local
413 * socket has a peer on the same transport.
414 */
415 if (p->msg.arg0 == 0 && s->peer && s->peer->transport != t) {
Yabin Cui815ad882015-09-02 17:44:28 -0700416 D("Invalid A_CLSE(0, %u) from transport %s, expected transport %s",
David 'Digit' Turnere92344d2013-12-13 14:09:44 +0100417 p->msg.arg1, t->serial, s->peer->transport->serial);
418 } else {
419 s->close(s);
420 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800421 }
422 }
423 break;
424
David 'Digit' Turnere92344d2013-12-13 14:09:44 +0100425 case A_WRTE: /* WRITE(local-id, remote-id, <data>) */
426 if (t->online && p->msg.arg0 != 0 && p->msg.arg1 != 0) {
427 if((s = find_local_socket(p->msg.arg1, p->msg.arg0))) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800428 unsigned rid = p->msg.arg0;
429 p->len = p->msg.data_length;
430
431 if(s->enqueue(s, p) == 0) {
Yabin Cui815ad882015-09-02 17:44:28 -0700432 D("Enqueue the socket");
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800433 send_ready(s->id, rid, t);
434 }
435 return;
436 }
437 }
438 break;
439
440 default:
441 printf("handle_packet: what is %08x?!\n", p->msg.command);
442 }
443
444 put_apacket(p);
445}
446
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800447#if ADB_HOST
Nick Kralevich23b39f02013-02-15 10:22:08 -0800448
Spencer Low2bbb3a92015-08-26 18:46:09 -0700449#ifdef _WIN32
450
Spencer Lowb77fc722015-09-16 16:40:06 -0700451// Try to make a handle non-inheritable and if there is an error, don't output
452// any error info, but leave GetLastError() for the caller to read. This is
453// convenient if the caller is expecting that this may fail and they'd like to
454// ignore such a failure.
455static bool _try_make_handle_noninheritable(HANDLE h) {
Spencer Low2bbb3a92015-08-26 18:46:09 -0700456 if (h != INVALID_HANDLE_VALUE && h != NULL) {
Spencer Lowb77fc722015-09-16 16:40:06 -0700457 return SetHandleInformation(h, HANDLE_FLAG_INHERIT, 0) ? true : false;
458 }
459
460 return true;
461}
462
463// Try to make a handle non-inheritable with the expectation that this should
464// succeed, so if this fails, output error info.
465static bool _make_handle_noninheritable(HANDLE h) {
466 if (!_try_make_handle_noninheritable(h)) {
467 // Show the handle value to give us a clue in case we have problems
468 // with pseudo-handle values.
469 fprintf(stderr, "Cannot make handle 0x%p non-inheritable: %s\n",
470 h, SystemErrorCodeToString(GetLastError()).c_str());
471 return false;
Spencer Low2bbb3a92015-08-26 18:46:09 -0700472 }
473
474 return true;
475}
476
477// Create anonymous pipe, preventing inheritance of the read pipe and setting
478// security of the write pipe to sa.
479static bool _create_anonymous_pipe(unique_handle* pipe_read_out,
480 unique_handle* pipe_write_out,
481 SECURITY_ATTRIBUTES* sa) {
482 HANDLE pipe_read_raw = NULL;
483 HANDLE pipe_write_raw = NULL;
484 if (!CreatePipe(&pipe_read_raw, &pipe_write_raw, sa, 0)) {
485 fprintf(stderr, "Cannot create pipe: %s\n",
486 SystemErrorCodeToString(GetLastError()).c_str());
487 return false;
488 }
489
490 unique_handle pipe_read(pipe_read_raw);
491 pipe_read_raw = NULL;
492 unique_handle pipe_write(pipe_write_raw);
493 pipe_write_raw = NULL;
494
495 if (!_make_handle_noninheritable(pipe_read.get())) {
496 return false;
497 }
498
499 *pipe_read_out = std::move(pipe_read);
500 *pipe_write_out = std::move(pipe_write);
501
502 return true;
503}
504
505// Read from a pipe (that we take ownership of) and write what is returned to
506// GetStdHandle(nStdHandle). Return on error or when the pipe is closed.
507static unsigned _redirect_pipe_thread(HANDLE h, DWORD nStdHandle) {
508 // Take ownership of the HANDLE and close when we're done.
509 unique_handle read_pipe(h);
510 const HANDLE write_handle = GetStdHandle(nStdHandle);
511 const char* output_name = nStdHandle == STD_OUTPUT_HANDLE ?
512 "stdout" : "stderr";
513
514 while (true) {
515 char buf[64 * 1024];
516 DWORD bytes_read = 0;
517 if (!ReadFile(read_pipe.get(), buf, sizeof(buf), &bytes_read, NULL)) {
518 const DWORD err = GetLastError();
519 // ERROR_BROKEN_PIPE is expected when the subprocess closes
520 // the other end of the pipe.
521 if (err == ERROR_BROKEN_PIPE) {
522 return EXIT_SUCCESS;
523 } else {
524 fprintf(stderr, "Failed to read from %s: %s\n", output_name,
525 SystemErrorCodeToString(err).c_str());
526 return EXIT_FAILURE;
527 }
528 }
529
530 // Don't try to write if our stdout/stderr was not setup by the
531 // parent process.
532 if (write_handle != NULL && write_handle != INVALID_HANDLE_VALUE) {
533 DWORD bytes_written = 0;
534 if (!WriteFile(write_handle, buf, bytes_read, &bytes_written,
535 NULL)) {
536 fprintf(stderr, "Failed to write to %s: %s\n", output_name,
537 SystemErrorCodeToString(GetLastError()).c_str());
538 return EXIT_FAILURE;
539 }
540
541 if (bytes_written != bytes_read) {
542 fprintf(stderr, "Only wrote %lu of %lu bytes to %s\n",
543 bytes_written, bytes_read, output_name);
544 return EXIT_FAILURE;
545 }
546 }
547 }
548}
549
550static unsigned __stdcall _redirect_stdout_thread(HANDLE h) {
Siva Velusamy2669cf92015-08-28 16:37:29 -0700551 adb_thread_setname("stdout redirect");
Spencer Low2bbb3a92015-08-26 18:46:09 -0700552 return _redirect_pipe_thread(h, STD_OUTPUT_HANDLE);
553}
554
555static unsigned __stdcall _redirect_stderr_thread(HANDLE h) {
Siva Velusamy2669cf92015-08-28 16:37:29 -0700556 adb_thread_setname("stderr redirect");
Spencer Low2bbb3a92015-08-26 18:46:09 -0700557 return _redirect_pipe_thread(h, STD_ERROR_HANDLE);
558}
559
560#endif
561
Stefan Hilzinger92ca4fa2010-04-19 12:21:12 +0100562int launch_server(int server_port)
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800563{
Yabin Cui2fa43212014-11-11 09:24:11 -0800564#if defined(_WIN32)
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800565 /* we need to start the server in the background */
566 /* we create a PIPE that will be used to wait for the server's "OK" */
567 /* message since the pipe handles must be inheritable, we use a */
568 /* security attribute */
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800569 SECURITY_ATTRIBUTES sa;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800570 sa.nLength = sizeof(sa);
571 sa.lpSecurityDescriptor = NULL;
572 sa.bInheritHandle = TRUE;
573
Spencer Low2bbb3a92015-08-26 18:46:09 -0700574 // Redirect stdin to Windows /dev/null. If we instead pass an original
575 // stdin/stdout/stderr handle and it is a console handle, when the adb
576 // server starts up, the C Runtime will see a console handle for a process
577 // that isn't connected to a console and it will configure
578 // stdin/stdout/stderr to be closed. At that point, freopen() could be used
579 // to reopen stderr/out, but it would take more massaging to fixup the file
580 // descriptor number that freopen() uses. It's simplest to avoid all of this
581 // complexity by just redirecting stdin to `nul' and then the C Runtime acts
582 // as expected.
583 unique_handle nul_read(CreateFileW(L"nul", GENERIC_READ,
584 FILE_SHARE_READ | FILE_SHARE_WRITE, &sa, OPEN_EXISTING,
585 FILE_ATTRIBUTE_NORMAL, NULL));
586 if (nul_read.get() == INVALID_HANDLE_VALUE) {
587 fprintf(stderr, "Cannot open 'nul': %s\n",
Spencer Low1711e012015-08-02 18:50:17 -0700588 SystemErrorCodeToString(GetLastError()).c_str());
Spencer Low4911f4b2015-05-20 23:17:26 -0700589 return -1;
590 }
591
Spencer Low2bbb3a92015-08-26 18:46:09 -0700592 // create pipes with non-inheritable read handle, inheritable write handle
593 unique_handle ack_read, ack_write;
594 if (!_create_anonymous_pipe(&ack_read, &ack_write, &sa)) {
Spencer Low4911f4b2015-05-20 23:17:26 -0700595 return -1;
596 }
Spencer Low2bbb3a92015-08-26 18:46:09 -0700597 unique_handle stdout_read, stdout_write;
598 if (!_create_anonymous_pipe(&stdout_read, &stdout_write, &sa)) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800599 return -1;
600 }
Spencer Low2bbb3a92015-08-26 18:46:09 -0700601 unique_handle stderr_read, stderr_write;
602 if (!_create_anonymous_pipe(&stderr_read, &stderr_write, &sa)) {
603 return -1;
604 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800605
Ray Donnellyc0324702012-11-29 01:18:50 +0000606 /* Some programs want to launch an adb command and collect its output by
607 * calling CreateProcess with inheritable stdout/stderr handles, then
608 * using read() to get its output. When this happens, the stdout/stderr
609 * handles passed to the adb client process will also be inheritable.
610 * When starting the adb server here, care must be taken to reset them
611 * to non-inheritable.
612 * Otherwise, something bad happens: even if the adb command completes,
613 * the calling process is stuck while read()-ing from the stdout/stderr
614 * descriptors, because they're connected to corresponding handles in the
615 * adb server process (even if the latter never uses/writes to them).
Spencer Low2bbb3a92015-08-26 18:46:09 -0700616 * Note that even if we don't pass these handles in the STARTUPINFO struct,
617 * if they're marked inheritable, they're still inherited, requiring us to
618 * deal with this.
619 *
620 * If we're still having problems with inheriting random handles in the
621 * future, consider using PROC_THREAD_ATTRIBUTE_HANDLE_LIST to explicitly
622 * specify which handles should be inherited: http://blogs.msdn.com/b/oldnewthing/archive/2011/12/16/10248328.aspx
Spencer Lowb77fc722015-09-16 16:40:06 -0700623 *
624 * Older versions of Windows return console pseudo-handles that cannot be
625 * made non-inheritable, so ignore those failures.
Ray Donnellyc0324702012-11-29 01:18:50 +0000626 */
Spencer Lowb77fc722015-09-16 16:40:06 -0700627 _try_make_handle_noninheritable(GetStdHandle(STD_INPUT_HANDLE));
628 _try_make_handle_noninheritable(GetStdHandle(STD_OUTPUT_HANDLE));
629 _try_make_handle_noninheritable(GetStdHandle(STD_ERROR_HANDLE));
Ray Donnellyc0324702012-11-29 01:18:50 +0000630
Spencer Low2bbb3a92015-08-26 18:46:09 -0700631 STARTUPINFOW startup;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800632 ZeroMemory( &startup, sizeof(startup) );
633 startup.cb = sizeof(startup);
Spencer Low2bbb3a92015-08-26 18:46:09 -0700634 startup.hStdInput = nul_read.get();
635 startup.hStdOutput = stdout_write.get();
636 startup.hStdError = stderr_write.get();
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800637 startup.dwFlags = STARTF_USESTDHANDLES;
638
Spencer Low2bbb3a92015-08-26 18:46:09 -0700639 // Verify that the pipe_write handle value can be passed on the command line
640 // as %d and that the rest of adb code can pass it around in an int.
641 const int ack_write_as_int = cast_handle_to_int(ack_write.get());
642 if (cast_int_to_handle(ack_write_as_int) != ack_write.get()) {
643 // If this fires, either handle values are larger than 32-bits or else
644 // there is a bug in our casting.
645 // https://msdn.microsoft.com/en-us/library/windows/desktop/aa384203%28v=vs.85%29.aspx
646 fprintf(stderr, "Cannot fit pipe handle value into 32-bits: 0x%p\n",
647 ack_write.get());
648 return -1;
649 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800650
Spencer Low2bbb3a92015-08-26 18:46:09 -0700651 // get path of current program
652 WCHAR program_path[MAX_PATH];
653 const DWORD module_result = GetModuleFileNameW(NULL, program_path,
654 arraysize(program_path));
655 if ((module_result >= arraysize(program_path)) || (module_result == 0)) {
Spencer Low6815c072015-05-11 01:08:48 -0700656 // String truncation or some other error.
Spencer Low2bbb3a92015-08-26 18:46:09 -0700657 fprintf(stderr, "Cannot get executable path: %s\n",
Spencer Low1711e012015-08-02 18:50:17 -0700658 SystemErrorCodeToString(GetLastError()).c_str());
Spencer Low6815c072015-05-11 01:08:48 -0700659 return -1;
660 }
Spencer Lowb28812f2015-08-08 15:07:07 -0700661
Spencer Low2bbb3a92015-08-26 18:46:09 -0700662 WCHAR args[64];
Spencer Low6815c072015-05-11 01:08:48 -0700663 snwprintf(args, arraysize(args),
Spencer Lowb28812f2015-08-08 15:07:07 -0700664 L"adb -P %d fork-server server --reply-fd %d", server_port,
Spencer Low2bbb3a92015-08-26 18:46:09 -0700665 ack_write_as_int);
666
667 PROCESS_INFORMATION pinfo;
668 ZeroMemory(&pinfo, sizeof(pinfo));
669
670 if (!CreateProcessW(
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800671 program_path, /* program path */
Wenhao Lie0fa2c52013-11-13 16:23:37 +0800672 args,
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800673 /* the fork-server argument will set the
674 debug = 2 in the child */
675 NULL, /* process handle is not inheritable */
676 NULL, /* thread handle is not inheritable */
677 TRUE, /* yes, inherit some handles */
678 DETACHED_PROCESS, /* the new process doesn't have a console */
679 NULL, /* use parent's environment block */
680 NULL, /* use parent's starting directory */
681 &startup, /* startup info, i.e. std handles */
Spencer Low2bbb3a92015-08-26 18:46:09 -0700682 &pinfo )) {
683 fprintf(stderr, "Cannot create process: %s\n",
Spencer Low1711e012015-08-02 18:50:17 -0700684 SystemErrorCodeToString(GetLastError()).c_str());
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800685 return -1;
686 }
687
Spencer Low2bbb3a92015-08-26 18:46:09 -0700688 unique_handle process_handle(pinfo.hProcess);
689 pinfo.hProcess = NULL;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800690
Spencer Low2bbb3a92015-08-26 18:46:09 -0700691 // Close handles that we no longer need to complete the rest.
692 CloseHandle(pinfo.hThread);
693 pinfo.hThread = NULL;
694
695 nul_read.reset();
696 ack_write.reset();
697 stdout_write.reset();
698 stderr_write.reset();
699
700 // Start threads to read from subprocess stdout/stderr and write to ours
701 // to make subprocess errors easier to diagnose.
702
703 // In the past, reading from a pipe before the child process's C Runtime
704 // started up and called GetFileType() caused a hang: http://blogs.msdn.com/b/oldnewthing/archive/2011/12/02/10243553.aspx#10244216
705 // This is reportedly fixed in Windows Vista: https://support.microsoft.com/en-us/kb/2009703
706 // I was unable to reproduce the problem on Windows XP. It sounds like a
707 // Windows Update may have fixed this: https://www.duckware.com/tech/peeknamedpipe.html
708 unique_handle stdout_thread(reinterpret_cast<HANDLE>(
709 _beginthreadex(NULL, 0, _redirect_stdout_thread, stdout_read.get(),
710 0, NULL)));
711 if (stdout_thread.get() == nullptr) {
712 fprintf(stderr, "Cannot create thread: %s\n", strerror(errno));
713 return -1;
714 }
715 stdout_read.release(); // Transfer ownership to new thread
716
717 unique_handle stderr_thread(reinterpret_cast<HANDLE>(
718 _beginthreadex(NULL, 0, _redirect_stderr_thread, stderr_read.get(),
719 0, NULL)));
720 if (stderr_thread.get() == nullptr) {
721 fprintf(stderr, "Cannot create thread: %s\n", strerror(errno));
722 return -1;
723 }
724 stderr_read.release(); // Transfer ownership to new thread
725
726 bool got_ack = false;
727
728 // Wait for the "OK\n" message, for the pipe to be closed, or other error.
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800729 {
Spencer Low2bbb3a92015-08-26 18:46:09 -0700730 char temp[3];
731 DWORD count = 0;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800732
Spencer Low2bbb3a92015-08-26 18:46:09 -0700733 if (ReadFile(ack_read.get(), temp, sizeof(temp), &count, NULL)) {
734 const CHAR expected[] = "OK\n";
735 const DWORD expected_length = arraysize(expected) - 1;
736 if (count == expected_length &&
737 memcmp(temp, expected, expected_length) == 0) {
738 got_ack = true;
739 } else {
740 fprintf(stderr, "ADB server didn't ACK\n");
741 }
742 } else {
743 const DWORD err = GetLastError();
744 // If the ACK was not written and the process exited, GetLastError()
745 // is probably ERROR_BROKEN_PIPE, in which case that info is not
746 // useful to the user.
747 fprintf(stderr, "could not read ok from ADB Server%s\n",
748 err == ERROR_BROKEN_PIPE ? "" :
749 android::base::StringPrintf(": %s",
750 SystemErrorCodeToString(err).c_str()).c_str());
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800751 }
Spencer Low2bbb3a92015-08-26 18:46:09 -0700752 }
753
754 // Always try to wait a bit for threads reading stdout/stderr to finish.
755 // If the process started ok, it should close the pipes causing the threads
756 // to finish. If the process had an error, it should exit, also causing
757 // the pipes to be closed. In that case we want to read all of the output
758 // and write it out so that the user can diagnose failures.
759 const DWORD thread_timeout_ms = 15 * 1000;
760 const HANDLE threads[] = { stdout_thread.get(), stderr_thread.get() };
761 const DWORD wait_result = WaitForMultipleObjects(arraysize(threads),
762 threads, TRUE, thread_timeout_ms);
763 if (wait_result == WAIT_TIMEOUT) {
764 // Threads did not finish after waiting a little while. Perhaps the
765 // server didn't close pipes, or it is hung.
766 fprintf(stderr, "Timed-out waiting for threads to finish reading from "
767 "ADB Server\n");
768 // Process handles are signaled when the process exits, so if we wait
769 // on the handle for 0 seconds and it returns 'timeout', that means that
770 // the process is still running.
771 if (WaitForSingleObject(process_handle.get(), 0) == WAIT_TIMEOUT) {
772 // We could TerminateProcess(), but that seems somewhat presumptive.
773 fprintf(stderr, "ADB Server is running: process id %lu\n",
774 pinfo.dwProcessId);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800775 }
Spencer Low2bbb3a92015-08-26 18:46:09 -0700776 return -1;
777 }
778
779 if (wait_result != WAIT_OBJECT_0) {
780 fprintf(stderr, "Unexpected result waiting for threads: %lu: %s\n",
781 wait_result, SystemErrorCodeToString(GetLastError()).c_str());
782 return -1;
783 }
784
785 // For now ignore the thread exit codes and assume they worked properly.
786
787 if (!got_ack) {
788 return -1;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800789 }
Yabin Cui2fa43212014-11-11 09:24:11 -0800790#else /* !defined(_WIN32) */
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800791 char path[PATH_MAX];
792 int fd[2];
793
794 // set up a pipe so the child can tell us when it is ready.
Siva Velusamya55dbd82015-08-07 10:10:29 -0700795 // fd[0] will be parent's end, and the child will write on fd[1]
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800796 if (pipe(fd)) {
797 fprintf(stderr, "pipe failed in launch_server, errno: %d\n", errno);
798 return -1;
799 }
Alexey Tarasov857f17a2009-10-22 02:55:00 +1100800 get_my_path(path, PATH_MAX);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800801 pid_t pid = fork();
802 if(pid < 0) return -1;
803
804 if (pid == 0) {
805 // child side of the fork
806
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800807 adb_close(fd[0]);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800808
Matt Gumbel411775c2012-11-14 10:16:17 -0800809 char str_port[30];
Siva Velusamya55dbd82015-08-07 10:10:29 -0700810 snprintf(str_port, sizeof(str_port), "%d", server_port);
811 char reply_fd[30];
812 snprintf(reply_fd, sizeof(reply_fd), "%d", fd[1]);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800813 // child process
Siva Velusamya55dbd82015-08-07 10:10:29 -0700814 int result = execl(path, "adb", "-P", str_port, "fork-server", "server", "--reply-fd", reply_fd, NULL);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800815 // this should not return
816 fprintf(stderr, "OOPS! execl returned %d, errno: %d\n", result, errno);
817 } else {
818 // parent side of the fork
819
820 char temp[3];
821
822 temp[0] = 'A'; temp[1] = 'B'; temp[2] = 'C';
823 // wait for the "OK\n" message
824 adb_close(fd[1]);
825 int ret = adb_read(fd[0], temp, 3);
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700826 int saved_errno = errno;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800827 adb_close(fd[0]);
828 if (ret < 0) {
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700829 fprintf(stderr, "could not read ok from ADB Server, errno = %d\n", saved_errno);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800830 return -1;
831 }
832 if (ret != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] != '\n') {
833 fprintf(stderr, "ADB server didn't ACK\n" );
834 return -1;
835 }
836
837 setsid();
838 }
Yabin Cui2fa43212014-11-11 09:24:11 -0800839#endif /* !defined(_WIN32) */
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800840 return 0;
841}
Yabin Cui2fa43212014-11-11 09:24:11 -0800842#endif /* ADB_HOST */
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800843
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100844// Try to handle a network forwarding request.
845// This returns 1 on success, 0 on failure, and -1 to indicate this is not
846// a forwarding-related request.
Elliott Hughes9d07fee2015-05-07 21:38:41 -0700847int handle_forward_request(const char* service, TransportType type, const char* serial, int reply_fd)
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100848{
849 if (!strcmp(service, "list-forward")) {
850 // Create the list of forward redirections.
Elliott Hughes88b4c852015-04-30 17:32:03 -0700851 std::string listeners = format_listeners();
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100852#if ADB_HOST
Elliott Hughes88b4c852015-04-30 17:32:03 -0700853 SendOkay(reply_fd);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100854#endif
Elliott Hughes88b4c852015-04-30 17:32:03 -0700855 SendProtocolString(reply_fd, listeners);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100856 return 1;
857 }
858
859 if (!strcmp(service, "killforward-all")) {
860 remove_all_listeners();
861#if ADB_HOST
862 /* On the host: 1st OKAY is connect, 2nd OKAY is status */
Elliott Hughes88b4c852015-04-30 17:32:03 -0700863 SendOkay(reply_fd);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100864#endif
Elliott Hughes88b4c852015-04-30 17:32:03 -0700865 SendOkay(reply_fd);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100866 return 1;
867 }
868
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700869 if (!strncmp(service, "forward:", 8) || !strncmp(service, "killforward:", 12)) {
870 // killforward:local
871 // forward:(norebind:)?local;remote
872 bool kill_forward = false;
873 bool no_rebind = false;
874 if (android::base::StartsWith(service, "killforward:")) {
875 kill_forward = true;
876 service += 12;
Spencer Low95365132015-07-29 17:21:21 -0700877 } else {
878 service += 8; // skip past "forward:"
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700879 if (android::base::StartsWith(service, "norebind:")) {
880 no_rebind = true;
881 service += 9;
882 }
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100883 }
884
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700885 std::vector<std::string> pieces = android::base::Split(service, ";");
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100886
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700887 if (kill_forward) {
888 // Check killforward: parameter format: '<local>'
889 if (pieces.size() != 1 || pieces[0].empty()) {
890 SendFail(reply_fd, android::base::StringPrintf("bad killforward: %s", service));
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100891 return 1;
892 }
893 } else {
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700894 // Check forward: parameter format: '<local>;<remote>'
895 if (pieces.size() != 2 || pieces[0].empty() || pieces[1].empty() || pieces[1][0] == '*') {
896 SendFail(reply_fd, android::base::StringPrintf("bad forward: %s", service));
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100897 return 1;
898 }
899 }
900
Elliott Hughesab882422015-04-16 22:54:44 -0700901 std::string error_msg;
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700902 atransport* transport = acquire_one_transport(kCsAny, type, serial, &error_msg);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100903 if (!transport) {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700904 SendFail(reply_fd, error_msg);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100905 return 1;
906 }
907
Spencer Low753d4852015-07-30 23:07:55 -0700908 std::string error;
Elliott Hughes3aec2ba2015-05-05 13:10:43 -0700909 InstallStatus r;
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700910 if (kill_forward) {
911 r = remove_listener(pieces[0].c_str(), transport);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100912 } else {
Spencer Low753d4852015-07-30 23:07:55 -0700913 r = install_listener(pieces[0], pieces[1].c_str(), transport,
914 no_rebind, &error);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100915 }
Elliott Hughesa585cbd2015-04-20 08:09:20 -0700916 if (r == INSTALL_STATUS_OK) {
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100917#if ADB_HOST
918 /* On the host: 1st OKAY is connect, 2nd OKAY is status */
Elliott Hughes88b4c852015-04-30 17:32:03 -0700919 SendOkay(reply_fd);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100920#endif
Elliott Hughes88b4c852015-04-30 17:32:03 -0700921 SendOkay(reply_fd);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100922 return 1;
923 }
924
Elliott Hughesa585cbd2015-04-20 08:09:20 -0700925 std::string message;
926 switch (r) {
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700927 case INSTALL_STATUS_OK: message = "success (!)"; break;
Elliott Hughesa585cbd2015-04-20 08:09:20 -0700928 case INSTALL_STATUS_INTERNAL_ERROR: message = "internal error"; break;
929 case INSTALL_STATUS_CANNOT_BIND:
Spencer Low32625852015-08-11 16:45:32 -0700930 message = android::base::StringPrintf("cannot bind listener: %s",
Spencer Low753d4852015-07-30 23:07:55 -0700931 error.c_str());
Elliott Hughesa585cbd2015-04-20 08:09:20 -0700932 break;
933 case INSTALL_STATUS_CANNOT_REBIND:
Spencer Low95365132015-07-29 17:21:21 -0700934 message = android::base::StringPrintf("cannot rebind existing socket");
Elliott Hughesa585cbd2015-04-20 08:09:20 -0700935 break;
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700936 case INSTALL_STATUS_LISTENER_NOT_FOUND:
937 message = android::base::StringPrintf("listener '%s' not found", service);
938 break;
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100939 }
Elliott Hughes88b4c852015-04-30 17:32:03 -0700940 SendFail(reply_fd, message);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100941 return 1;
942 }
943 return 0;
944}
945
Elliott Hughes24f52762015-06-23 13:00:32 -0700946#if ADB_HOST
947static int SendOkay(int fd, const std::string& s) {
948 SendOkay(fd);
949 SendProtocolString(fd, s);
950 return 0;
951}
952#endif
953
Dan Albert53a37442015-05-08 16:13:53 -0700954int handle_host_request(const char* service, TransportType type,
955 const char* serial, int reply_fd, asocket* s) {
956 if (strcmp(service, "kill") == 0) {
957 fprintf(stderr, "adb server killed by remote request\n");
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800958 fflush(stdout);
Elliott Hughes88b4c852015-04-30 17:32:03 -0700959 SendOkay(reply_fd);
Spencer Low85ee64b2015-08-11 17:05:02 -0700960
961 // At least on Windows, if we exit() without shutdown(SD_SEND) or
962 // closesocket(), the client's next recv() will error-out with
963 // WSAECONNRESET and they'll never read the OKAY.
964 adb_shutdown(reply_fd);
965
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800966 exit(0);
967 }
968
969#if ADB_HOST
970 // "transport:" is used for switching transport with a specified serial number
971 // "transport-usb:" is used for switching transport to the only USB transport
972 // "transport-local:" is used for switching transport to the only local transport
973 // "transport-any:" is used for switching transport to the only transport
974 if (!strncmp(service, "transport", strlen("transport"))) {
Elliott Hughes3aec2ba2015-05-05 13:10:43 -0700975 TransportType type = kTransportAny;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800976
977 if (!strncmp(service, "transport-usb", strlen("transport-usb"))) {
978 type = kTransportUsb;
979 } else if (!strncmp(service, "transport-local", strlen("transport-local"))) {
980 type = kTransportLocal;
981 } else if (!strncmp(service, "transport-any", strlen("transport-any"))) {
982 type = kTransportAny;
983 } else if (!strncmp(service, "transport:", strlen("transport:"))) {
984 service += strlen("transport:");
Tom Marlin851ee3a2011-07-27 12:56:14 -0500985 serial = service;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800986 }
987
Elliott Hughes24f52762015-06-23 13:00:32 -0700988 std::string error_msg;
989 atransport* t = acquire_one_transport(kCsAny, type, serial, &error_msg);
990 if (t != nullptr) {
991 s->transport = t;
Elliott Hughes88b4c852015-04-30 17:32:03 -0700992 SendOkay(reply_fd);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800993 } else {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700994 SendFail(reply_fd, error_msg);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800995 }
996 return 1;
997 }
998
999 // return a list of all connected devices
Scott Anderson6dfaf4b2012-04-20 11:21:14 -07001000 if (!strncmp(service, "devices", 7)) {
Elliott Hughes88b4c852015-04-30 17:32:03 -07001001 bool long_listing = (strcmp(service+7, "-l") == 0);
1002 if (long_listing || service[7] == 0) {
Yabin Cui815ad882015-09-02 17:44:28 -07001003 D("Getting device list...");
Elliott Hughes88b4c852015-04-30 17:32:03 -07001004 std::string device_list = list_transports(long_listing);
Yabin Cui815ad882015-09-02 17:44:28 -07001005 D("Sending device list...");
Elliott Hughes24f52762015-06-23 13:00:32 -07001006 return SendOkay(reply_fd, device_list);
Scott Anderson6dfaf4b2012-04-20 11:21:14 -07001007 }
Elliott Hughes88b4c852015-04-30 17:32:03 -07001008 return 1;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -08001009 }
1010
Dan Albert996c12e2015-05-20 18:58:41 -07001011 if (!strcmp(service, "features")) {
David Pursell2e9f0322015-09-04 16:40:30 -07001012 std::string error_msg;
1013 atransport* t = acquire_one_transport(kCsAny, type, serial, &error_msg);
1014 if (t != nullptr) {
David Pursella07dbad2015-09-22 10:43:08 -07001015 SendOkay(reply_fd, FeatureSetToString(t->features()));
David Pursell2e9f0322015-09-04 16:40:30 -07001016 } else {
1017 SendFail(reply_fd, error_msg);
1018 }
1019 return 0;
1020 }
1021
Mike Lockwood5f2c4a12009-10-11 23:04:18 -04001022 // remove TCP transport
1023 if (!strncmp(service, "disconnect:", 11)) {
Elliott Hughes09ccf1f2015-07-18 12:21:30 -07001024 const std::string address(service + 11);
1025 if (address.empty()) {
Yabin Cui4d64fd82015-08-27 12:03:11 -07001026 kick_all_tcp_devices();
Elliott Hughes09ccf1f2015-07-18 12:21:30 -07001027 return SendOkay(reply_fd, "disconnected everything");
Mike Lockwood5f2c4a12009-10-11 23:04:18 -04001028 }
1029
Elliott Hughes09ccf1f2015-07-18 12:21:30 -07001030 std::string serial;
1031 std::string host;
1032 int port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT;
1033 std::string error;
1034 if (!parse_host_and_port(address, &serial, &host, &port, &error)) {
1035 return SendFail(reply_fd, android::base::StringPrintf("couldn't parse '%s': %s",
1036 address.c_str(), error.c_str()));
1037 }
1038 atransport* t = find_transport(serial.c_str());
1039 if (t == nullptr) {
1040 return SendFail(reply_fd, android::base::StringPrintf("no such device '%s'",
1041 serial.c_str()));
1042 }
Yabin Cui4d64fd82015-08-27 12:03:11 -07001043 kick_transport(t);
Elliott Hughes09ccf1f2015-07-18 12:21:30 -07001044 return SendOkay(reply_fd, android::base::StringPrintf("disconnected %s", address.c_str()));
Mike Lockwoodb51ae572009-08-24 15:58:40 -07001045 }
1046
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -08001047 // returns our value for ADB_SERVER_VERSION
1048 if (!strcmp(service, "version")) {
Elliott Hughes24f52762015-06-23 13:00:32 -07001049 return SendOkay(reply_fd, android::base::StringPrintf("%04x", ADB_SERVER_VERSION));
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -08001050 }
1051
Elliott Hughes24f52762015-06-23 13:00:32 -07001052 // These always report "unknown" rather than the actual error, for scripts.
1053 if (!strcmp(service, "get-serialno")) {
1054 std::string ignored;
1055 atransport* t = acquire_one_transport(kCsAny, type, serial, &ignored);
1056 return SendOkay(reply_fd, (t && t->serial) ? t->serial : "unknown");
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -08001057 }
Elliott Hughes24f52762015-06-23 13:00:32 -07001058 if (!strcmp(service, "get-devpath")) {
1059 std::string ignored;
1060 atransport* t = acquire_one_transport(kCsAny, type, serial, &ignored);
1061 return SendOkay(reply_fd, (t && t->devpath) ? t->devpath : "unknown");
Scott Anderson6dfaf4b2012-04-20 11:21:14 -07001062 }
Elliott Hughes24f52762015-06-23 13:00:32 -07001063 if (!strcmp(service, "get-state")) {
1064 std::string ignored;
1065 atransport* t = acquire_one_transport(kCsAny, type, serial, &ignored);
1066 return SendOkay(reply_fd, t ? t->connection_state_name() : "unknown");
1067 }
1068
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -08001069 // indicates a new emulator instance has started
Elliott Hughes24f52762015-06-23 13:00:32 -07001070 if (!strncmp(service, "emulator:", 9)) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -08001071 int port = atoi(service+9);
1072 local_connect(port);
1073 /* we don't even need to send a reply */
1074 return 0;
1075 }
Simon Yee51c11e2014-07-14 17:23:06 -07001076#endif // ADB_HOST
1077
Elliott Hughes3aec2ba2015-05-05 13:10:43 -07001078 int ret = handle_forward_request(service, type, serial, reply_fd);
Simon Yee51c11e2014-07-14 17:23:06 -07001079 if (ret >= 0)
1080 return ret - 1;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -08001081 return -1;
1082}