blob: 484e5616532fc660154563d6be6407d2d0d476c8 [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
Elliott Hughesf55ead92015-12-04 22:00:26 -080036#include <android-base/logging.h>
37#include <android-base/macros.h>
38#include <android-base/stringprintf.h>
39#include <android-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];
Elliott Hughes85952832015-10-07 15:59:35 -0700248 for (const auto& prop : android::base::Split(props, ";")) {
Elliott Hughesfb2ba512015-04-24 23:02:00 -0700249 // 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 }
Yabin Cuiec2e7d82015-09-29 12:25:33 -0700398 } else {
399 // When receiving A_OKAY from device for A_OPEN request, the host server may
400 // have closed the local socket because of client disconnection. Then we need
401 // to send A_CLSE back to device to close the service on device.
402 send_close(p->msg.arg1, p->msg.arg0, t);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800403 }
404 }
405 break;
406
David 'Digit' Turnere92344d2013-12-13 14:09:44 +0100407 case A_CLSE: /* CLOSE(local-id, remote-id, "") or CLOSE(0, remote-id, "") */
408 if (t->online && p->msg.arg1 != 0) {
409 if((s = find_local_socket(p->msg.arg1, p->msg.arg0))) {
410 /* According to protocol.txt, p->msg.arg0 might be 0 to indicate
411 * a failed OPEN only. However, due to a bug in previous ADB
412 * versions, CLOSE(0, remote-id, "") was also used for normal
413 * CLOSE() operations.
414 *
415 * This is bad because it means a compromised adbd could
416 * send packets to close connections between the host and
417 * other devices. To avoid this, only allow this if the local
418 * socket has a peer on the same transport.
419 */
420 if (p->msg.arg0 == 0 && s->peer && s->peer->transport != t) {
Yabin Cui815ad882015-09-02 17:44:28 -0700421 D("Invalid A_CLSE(0, %u) from transport %s, expected transport %s",
David 'Digit' Turnere92344d2013-12-13 14:09:44 +0100422 p->msg.arg1, t->serial, s->peer->transport->serial);
423 } else {
424 s->close(s);
425 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800426 }
427 }
428 break;
429
David 'Digit' Turnere92344d2013-12-13 14:09:44 +0100430 case A_WRTE: /* WRITE(local-id, remote-id, <data>) */
431 if (t->online && p->msg.arg0 != 0 && p->msg.arg1 != 0) {
432 if((s = find_local_socket(p->msg.arg1, p->msg.arg0))) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800433 unsigned rid = p->msg.arg0;
434 p->len = p->msg.data_length;
435
436 if(s->enqueue(s, p) == 0) {
Yabin Cui815ad882015-09-02 17:44:28 -0700437 D("Enqueue the socket");
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800438 send_ready(s->id, rid, t);
439 }
440 return;
441 }
442 }
443 break;
444
445 default:
446 printf("handle_packet: what is %08x?!\n", p->msg.command);
447 }
448
449 put_apacket(p);
450}
451
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800452#if ADB_HOST
Nick Kralevich23b39f02013-02-15 10:22:08 -0800453
Spencer Low2bbb3a92015-08-26 18:46:09 -0700454#ifdef _WIN32
455
Spencer Lowb77fc722015-09-16 16:40:06 -0700456// Try to make a handle non-inheritable and if there is an error, don't output
457// any error info, but leave GetLastError() for the caller to read. This is
458// convenient if the caller is expecting that this may fail and they'd like to
459// ignore such a failure.
460static bool _try_make_handle_noninheritable(HANDLE h) {
Spencer Low2bbb3a92015-08-26 18:46:09 -0700461 if (h != INVALID_HANDLE_VALUE && h != NULL) {
Spencer Lowb77fc722015-09-16 16:40:06 -0700462 return SetHandleInformation(h, HANDLE_FLAG_INHERIT, 0) ? true : false;
463 }
464
465 return true;
466}
467
468// Try to make a handle non-inheritable with the expectation that this should
469// succeed, so if this fails, output error info.
470static bool _make_handle_noninheritable(HANDLE h) {
471 if (!_try_make_handle_noninheritable(h)) {
472 // Show the handle value to give us a clue in case we have problems
473 // with pseudo-handle values.
474 fprintf(stderr, "Cannot make handle 0x%p non-inheritable: %s\n",
475 h, SystemErrorCodeToString(GetLastError()).c_str());
476 return false;
Spencer Low2bbb3a92015-08-26 18:46:09 -0700477 }
478
479 return true;
480}
481
482// Create anonymous pipe, preventing inheritance of the read pipe and setting
483// security of the write pipe to sa.
484static bool _create_anonymous_pipe(unique_handle* pipe_read_out,
485 unique_handle* pipe_write_out,
486 SECURITY_ATTRIBUTES* sa) {
487 HANDLE pipe_read_raw = NULL;
488 HANDLE pipe_write_raw = NULL;
489 if (!CreatePipe(&pipe_read_raw, &pipe_write_raw, sa, 0)) {
490 fprintf(stderr, "Cannot create pipe: %s\n",
491 SystemErrorCodeToString(GetLastError()).c_str());
492 return false;
493 }
494
495 unique_handle pipe_read(pipe_read_raw);
496 pipe_read_raw = NULL;
497 unique_handle pipe_write(pipe_write_raw);
498 pipe_write_raw = NULL;
499
500 if (!_make_handle_noninheritable(pipe_read.get())) {
501 return false;
502 }
503
504 *pipe_read_out = std::move(pipe_read);
505 *pipe_write_out = std::move(pipe_write);
506
507 return true;
508}
509
510// Read from a pipe (that we take ownership of) and write what is returned to
511// GetStdHandle(nStdHandle). Return on error or when the pipe is closed.
512static unsigned _redirect_pipe_thread(HANDLE h, DWORD nStdHandle) {
513 // Take ownership of the HANDLE and close when we're done.
514 unique_handle read_pipe(h);
515 const HANDLE write_handle = GetStdHandle(nStdHandle);
516 const char* output_name = nStdHandle == STD_OUTPUT_HANDLE ?
517 "stdout" : "stderr";
518
519 while (true) {
520 char buf[64 * 1024];
521 DWORD bytes_read = 0;
522 if (!ReadFile(read_pipe.get(), buf, sizeof(buf), &bytes_read, NULL)) {
523 const DWORD err = GetLastError();
524 // ERROR_BROKEN_PIPE is expected when the subprocess closes
525 // the other end of the pipe.
526 if (err == ERROR_BROKEN_PIPE) {
527 return EXIT_SUCCESS;
528 } else {
529 fprintf(stderr, "Failed to read from %s: %s\n", output_name,
530 SystemErrorCodeToString(err).c_str());
531 return EXIT_FAILURE;
532 }
533 }
534
535 // Don't try to write if our stdout/stderr was not setup by the
536 // parent process.
537 if (write_handle != NULL && write_handle != INVALID_HANDLE_VALUE) {
538 DWORD bytes_written = 0;
539 if (!WriteFile(write_handle, buf, bytes_read, &bytes_written,
540 NULL)) {
541 fprintf(stderr, "Failed to write to %s: %s\n", output_name,
542 SystemErrorCodeToString(GetLastError()).c_str());
543 return EXIT_FAILURE;
544 }
545
546 if (bytes_written != bytes_read) {
547 fprintf(stderr, "Only wrote %lu of %lu bytes to %s\n",
548 bytes_written, bytes_read, output_name);
549 return EXIT_FAILURE;
550 }
551 }
552 }
553}
554
555static unsigned __stdcall _redirect_stdout_thread(HANDLE h) {
Siva Velusamy2669cf92015-08-28 16:37:29 -0700556 adb_thread_setname("stdout redirect");
Spencer Low2bbb3a92015-08-26 18:46:09 -0700557 return _redirect_pipe_thread(h, STD_OUTPUT_HANDLE);
558}
559
560static unsigned __stdcall _redirect_stderr_thread(HANDLE h) {
Siva Velusamy2669cf92015-08-28 16:37:29 -0700561 adb_thread_setname("stderr redirect");
Spencer Low2bbb3a92015-08-26 18:46:09 -0700562 return _redirect_pipe_thread(h, STD_ERROR_HANDLE);
563}
564
565#endif
566
Stefan Hilzinger92ca4fa2010-04-19 12:21:12 +0100567int launch_server(int server_port)
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800568{
Yabin Cui2fa43212014-11-11 09:24:11 -0800569#if defined(_WIN32)
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800570 /* we need to start the server in the background */
571 /* we create a PIPE that will be used to wait for the server's "OK" */
572 /* message since the pipe handles must be inheritable, we use a */
573 /* security attribute */
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800574 SECURITY_ATTRIBUTES sa;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800575 sa.nLength = sizeof(sa);
576 sa.lpSecurityDescriptor = NULL;
577 sa.bInheritHandle = TRUE;
578
Spencer Low2bbb3a92015-08-26 18:46:09 -0700579 // Redirect stdin to Windows /dev/null. If we instead pass an original
580 // stdin/stdout/stderr handle and it is a console handle, when the adb
581 // server starts up, the C Runtime will see a console handle for a process
582 // that isn't connected to a console and it will configure
583 // stdin/stdout/stderr to be closed. At that point, freopen() could be used
584 // to reopen stderr/out, but it would take more massaging to fixup the file
585 // descriptor number that freopen() uses. It's simplest to avoid all of this
586 // complexity by just redirecting stdin to `nul' and then the C Runtime acts
587 // as expected.
588 unique_handle nul_read(CreateFileW(L"nul", GENERIC_READ,
589 FILE_SHARE_READ | FILE_SHARE_WRITE, &sa, OPEN_EXISTING,
590 FILE_ATTRIBUTE_NORMAL, NULL));
591 if (nul_read.get() == INVALID_HANDLE_VALUE) {
592 fprintf(stderr, "Cannot open 'nul': %s\n",
Spencer Low1711e012015-08-02 18:50:17 -0700593 SystemErrorCodeToString(GetLastError()).c_str());
Spencer Low4911f4b2015-05-20 23:17:26 -0700594 return -1;
595 }
596
Spencer Low2bbb3a92015-08-26 18:46:09 -0700597 // create pipes with non-inheritable read handle, inheritable write handle
598 unique_handle ack_read, ack_write;
599 if (!_create_anonymous_pipe(&ack_read, &ack_write, &sa)) {
Spencer Low4911f4b2015-05-20 23:17:26 -0700600 return -1;
601 }
Spencer Low2bbb3a92015-08-26 18:46:09 -0700602 unique_handle stdout_read, stdout_write;
603 if (!_create_anonymous_pipe(&stdout_read, &stdout_write, &sa)) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800604 return -1;
605 }
Spencer Low2bbb3a92015-08-26 18:46:09 -0700606 unique_handle stderr_read, stderr_write;
607 if (!_create_anonymous_pipe(&stderr_read, &stderr_write, &sa)) {
608 return -1;
609 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800610
Ray Donnellyc0324702012-11-29 01:18:50 +0000611 /* Some programs want to launch an adb command and collect its output by
612 * calling CreateProcess with inheritable stdout/stderr handles, then
613 * using read() to get its output. When this happens, the stdout/stderr
614 * handles passed to the adb client process will also be inheritable.
615 * When starting the adb server here, care must be taken to reset them
616 * to non-inheritable.
617 * Otherwise, something bad happens: even if the adb command completes,
618 * the calling process is stuck while read()-ing from the stdout/stderr
619 * descriptors, because they're connected to corresponding handles in the
620 * adb server process (even if the latter never uses/writes to them).
Spencer Low2bbb3a92015-08-26 18:46:09 -0700621 * Note that even if we don't pass these handles in the STARTUPINFO struct,
622 * if they're marked inheritable, they're still inherited, requiring us to
623 * deal with this.
624 *
625 * If we're still having problems with inheriting random handles in the
626 * future, consider using PROC_THREAD_ATTRIBUTE_HANDLE_LIST to explicitly
627 * 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 -0700628 *
629 * Older versions of Windows return console pseudo-handles that cannot be
630 * made non-inheritable, so ignore those failures.
Ray Donnellyc0324702012-11-29 01:18:50 +0000631 */
Spencer Lowb77fc722015-09-16 16:40:06 -0700632 _try_make_handle_noninheritable(GetStdHandle(STD_INPUT_HANDLE));
633 _try_make_handle_noninheritable(GetStdHandle(STD_OUTPUT_HANDLE));
634 _try_make_handle_noninheritable(GetStdHandle(STD_ERROR_HANDLE));
Ray Donnellyc0324702012-11-29 01:18:50 +0000635
Spencer Low2bbb3a92015-08-26 18:46:09 -0700636 STARTUPINFOW startup;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800637 ZeroMemory( &startup, sizeof(startup) );
638 startup.cb = sizeof(startup);
Spencer Low2bbb3a92015-08-26 18:46:09 -0700639 startup.hStdInput = nul_read.get();
640 startup.hStdOutput = stdout_write.get();
641 startup.hStdError = stderr_write.get();
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800642 startup.dwFlags = STARTF_USESTDHANDLES;
643
Spencer Low2bbb3a92015-08-26 18:46:09 -0700644 // Verify that the pipe_write handle value can be passed on the command line
645 // as %d and that the rest of adb code can pass it around in an int.
646 const int ack_write_as_int = cast_handle_to_int(ack_write.get());
647 if (cast_int_to_handle(ack_write_as_int) != ack_write.get()) {
648 // If this fires, either handle values are larger than 32-bits or else
649 // there is a bug in our casting.
650 // https://msdn.microsoft.com/en-us/library/windows/desktop/aa384203%28v=vs.85%29.aspx
651 fprintf(stderr, "Cannot fit pipe handle value into 32-bits: 0x%p\n",
652 ack_write.get());
653 return -1;
654 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800655
Spencer Low2bbb3a92015-08-26 18:46:09 -0700656 // get path of current program
657 WCHAR program_path[MAX_PATH];
658 const DWORD module_result = GetModuleFileNameW(NULL, program_path,
659 arraysize(program_path));
660 if ((module_result >= arraysize(program_path)) || (module_result == 0)) {
Spencer Low6815c072015-05-11 01:08:48 -0700661 // String truncation or some other error.
Spencer Low2bbb3a92015-08-26 18:46:09 -0700662 fprintf(stderr, "Cannot get executable path: %s\n",
Spencer Low1711e012015-08-02 18:50:17 -0700663 SystemErrorCodeToString(GetLastError()).c_str());
Spencer Low6815c072015-05-11 01:08:48 -0700664 return -1;
665 }
Spencer Lowb28812f2015-08-08 15:07:07 -0700666
Spencer Low2bbb3a92015-08-26 18:46:09 -0700667 WCHAR args[64];
Spencer Low6815c072015-05-11 01:08:48 -0700668 snwprintf(args, arraysize(args),
Spencer Lowb28812f2015-08-08 15:07:07 -0700669 L"adb -P %d fork-server server --reply-fd %d", server_port,
Spencer Low2bbb3a92015-08-26 18:46:09 -0700670 ack_write_as_int);
671
672 PROCESS_INFORMATION pinfo;
673 ZeroMemory(&pinfo, sizeof(pinfo));
674
675 if (!CreateProcessW(
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800676 program_path, /* program path */
Wenhao Lie0fa2c52013-11-13 16:23:37 +0800677 args,
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800678 /* the fork-server argument will set the
679 debug = 2 in the child */
680 NULL, /* process handle is not inheritable */
681 NULL, /* thread handle is not inheritable */
682 TRUE, /* yes, inherit some handles */
683 DETACHED_PROCESS, /* the new process doesn't have a console */
684 NULL, /* use parent's environment block */
685 NULL, /* use parent's starting directory */
686 &startup, /* startup info, i.e. std handles */
Spencer Low2bbb3a92015-08-26 18:46:09 -0700687 &pinfo )) {
688 fprintf(stderr, "Cannot create process: %s\n",
Spencer Low1711e012015-08-02 18:50:17 -0700689 SystemErrorCodeToString(GetLastError()).c_str());
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800690 return -1;
691 }
692
Spencer Low2bbb3a92015-08-26 18:46:09 -0700693 unique_handle process_handle(pinfo.hProcess);
694 pinfo.hProcess = NULL;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800695
Spencer Low2bbb3a92015-08-26 18:46:09 -0700696 // Close handles that we no longer need to complete the rest.
697 CloseHandle(pinfo.hThread);
698 pinfo.hThread = NULL;
699
700 nul_read.reset();
701 ack_write.reset();
702 stdout_write.reset();
703 stderr_write.reset();
704
705 // Start threads to read from subprocess stdout/stderr and write to ours
706 // to make subprocess errors easier to diagnose.
707
708 // In the past, reading from a pipe before the child process's C Runtime
709 // started up and called GetFileType() caused a hang: http://blogs.msdn.com/b/oldnewthing/archive/2011/12/02/10243553.aspx#10244216
710 // This is reportedly fixed in Windows Vista: https://support.microsoft.com/en-us/kb/2009703
711 // I was unable to reproduce the problem on Windows XP. It sounds like a
712 // Windows Update may have fixed this: https://www.duckware.com/tech/peeknamedpipe.html
713 unique_handle stdout_thread(reinterpret_cast<HANDLE>(
714 _beginthreadex(NULL, 0, _redirect_stdout_thread, stdout_read.get(),
715 0, NULL)));
716 if (stdout_thread.get() == nullptr) {
717 fprintf(stderr, "Cannot create thread: %s\n", strerror(errno));
718 return -1;
719 }
720 stdout_read.release(); // Transfer ownership to new thread
721
722 unique_handle stderr_thread(reinterpret_cast<HANDLE>(
723 _beginthreadex(NULL, 0, _redirect_stderr_thread, stderr_read.get(),
724 0, NULL)));
725 if (stderr_thread.get() == nullptr) {
726 fprintf(stderr, "Cannot create thread: %s\n", strerror(errno));
727 return -1;
728 }
729 stderr_read.release(); // Transfer ownership to new thread
730
731 bool got_ack = false;
732
733 // 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 -0800734 {
Spencer Low2bbb3a92015-08-26 18:46:09 -0700735 char temp[3];
736 DWORD count = 0;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800737
Spencer Low2bbb3a92015-08-26 18:46:09 -0700738 if (ReadFile(ack_read.get(), temp, sizeof(temp), &count, NULL)) {
739 const CHAR expected[] = "OK\n";
740 const DWORD expected_length = arraysize(expected) - 1;
741 if (count == expected_length &&
742 memcmp(temp, expected, expected_length) == 0) {
743 got_ack = true;
744 } else {
745 fprintf(stderr, "ADB server didn't ACK\n");
746 }
747 } else {
748 const DWORD err = GetLastError();
749 // If the ACK was not written and the process exited, GetLastError()
750 // is probably ERROR_BROKEN_PIPE, in which case that info is not
751 // useful to the user.
752 fprintf(stderr, "could not read ok from ADB Server%s\n",
753 err == ERROR_BROKEN_PIPE ? "" :
754 android::base::StringPrintf(": %s",
755 SystemErrorCodeToString(err).c_str()).c_str());
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800756 }
Spencer Low2bbb3a92015-08-26 18:46:09 -0700757 }
758
759 // Always try to wait a bit for threads reading stdout/stderr to finish.
760 // If the process started ok, it should close the pipes causing the threads
761 // to finish. If the process had an error, it should exit, also causing
762 // the pipes to be closed. In that case we want to read all of the output
763 // and write it out so that the user can diagnose failures.
764 const DWORD thread_timeout_ms = 15 * 1000;
765 const HANDLE threads[] = { stdout_thread.get(), stderr_thread.get() };
766 const DWORD wait_result = WaitForMultipleObjects(arraysize(threads),
767 threads, TRUE, thread_timeout_ms);
768 if (wait_result == WAIT_TIMEOUT) {
769 // Threads did not finish after waiting a little while. Perhaps the
770 // server didn't close pipes, or it is hung.
771 fprintf(stderr, "Timed-out waiting for threads to finish reading from "
772 "ADB Server\n");
773 // Process handles are signaled when the process exits, so if we wait
774 // on the handle for 0 seconds and it returns 'timeout', that means that
775 // the process is still running.
776 if (WaitForSingleObject(process_handle.get(), 0) == WAIT_TIMEOUT) {
777 // We could TerminateProcess(), but that seems somewhat presumptive.
778 fprintf(stderr, "ADB Server is running: process id %lu\n",
779 pinfo.dwProcessId);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800780 }
Spencer Low2bbb3a92015-08-26 18:46:09 -0700781 return -1;
782 }
783
784 if (wait_result != WAIT_OBJECT_0) {
785 fprintf(stderr, "Unexpected result waiting for threads: %lu: %s\n",
786 wait_result, SystemErrorCodeToString(GetLastError()).c_str());
787 return -1;
788 }
789
790 // For now ignore the thread exit codes and assume they worked properly.
791
792 if (!got_ack) {
793 return -1;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800794 }
Yabin Cui2fa43212014-11-11 09:24:11 -0800795#else /* !defined(_WIN32) */
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800796 char path[PATH_MAX];
797 int fd[2];
798
799 // set up a pipe so the child can tell us when it is ready.
Siva Velusamya55dbd82015-08-07 10:10:29 -0700800 // 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 -0800801 if (pipe(fd)) {
802 fprintf(stderr, "pipe failed in launch_server, errno: %d\n", errno);
803 return -1;
804 }
Alexey Tarasov857f17a2009-10-22 02:55:00 +1100805 get_my_path(path, PATH_MAX);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800806 pid_t pid = fork();
807 if(pid < 0) return -1;
808
809 if (pid == 0) {
810 // child side of the fork
811
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800812 adb_close(fd[0]);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800813
Matt Gumbel411775c2012-11-14 10:16:17 -0800814 char str_port[30];
Siva Velusamya55dbd82015-08-07 10:10:29 -0700815 snprintf(str_port, sizeof(str_port), "%d", server_port);
816 char reply_fd[30];
817 snprintf(reply_fd, sizeof(reply_fd), "%d", fd[1]);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800818 // child process
Siva Velusamya55dbd82015-08-07 10:10:29 -0700819 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 -0800820 // this should not return
821 fprintf(stderr, "OOPS! execl returned %d, errno: %d\n", result, errno);
822 } else {
823 // parent side of the fork
824
825 char temp[3];
826
827 temp[0] = 'A'; temp[1] = 'B'; temp[2] = 'C';
828 // wait for the "OK\n" message
829 adb_close(fd[1]);
830 int ret = adb_read(fd[0], temp, 3);
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700831 int saved_errno = errno;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800832 adb_close(fd[0]);
833 if (ret < 0) {
JP Abgrall2e5dd6e2011-03-16 15:57:42 -0700834 fprintf(stderr, "could not read ok from ADB Server, errno = %d\n", saved_errno);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800835 return -1;
836 }
837 if (ret != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] != '\n') {
838 fprintf(stderr, "ADB server didn't ACK\n" );
839 return -1;
840 }
841
842 setsid();
843 }
Yabin Cui2fa43212014-11-11 09:24:11 -0800844#endif /* !defined(_WIN32) */
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800845 return 0;
846}
Yabin Cui2fa43212014-11-11 09:24:11 -0800847#endif /* ADB_HOST */
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800848
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100849// Try to handle a network forwarding request.
850// This returns 1 on success, 0 on failure, and -1 to indicate this is not
851// a forwarding-related request.
Elliott Hughes9d07fee2015-05-07 21:38:41 -0700852int handle_forward_request(const char* service, TransportType type, const char* serial, int reply_fd)
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100853{
854 if (!strcmp(service, "list-forward")) {
855 // Create the list of forward redirections.
Elliott Hughes88b4c852015-04-30 17:32:03 -0700856 std::string listeners = format_listeners();
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100857#if ADB_HOST
Elliott Hughes88b4c852015-04-30 17:32:03 -0700858 SendOkay(reply_fd);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100859#endif
Josh Gao9055a582016-01-15 14:35:54 -0800860 return SendProtocolString(reply_fd, listeners);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100861 }
862
863 if (!strcmp(service, "killforward-all")) {
864 remove_all_listeners();
865#if ADB_HOST
866 /* On the host: 1st OKAY is connect, 2nd OKAY is status */
Elliott Hughes88b4c852015-04-30 17:32:03 -0700867 SendOkay(reply_fd);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100868#endif
Elliott Hughes88b4c852015-04-30 17:32:03 -0700869 SendOkay(reply_fd);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100870 return 1;
871 }
872
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700873 if (!strncmp(service, "forward:", 8) || !strncmp(service, "killforward:", 12)) {
874 // killforward:local
875 // forward:(norebind:)?local;remote
876 bool kill_forward = false;
877 bool no_rebind = false;
878 if (android::base::StartsWith(service, "killforward:")) {
879 kill_forward = true;
880 service += 12;
Spencer Low95365132015-07-29 17:21:21 -0700881 } else {
882 service += 8; // skip past "forward:"
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700883 if (android::base::StartsWith(service, "norebind:")) {
884 no_rebind = true;
885 service += 9;
886 }
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100887 }
888
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700889 std::vector<std::string> pieces = android::base::Split(service, ";");
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100890
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700891 if (kill_forward) {
892 // Check killforward: parameter format: '<local>'
893 if (pieces.size() != 1 || pieces[0].empty()) {
894 SendFail(reply_fd, android::base::StringPrintf("bad killforward: %s", service));
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100895 return 1;
896 }
897 } else {
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700898 // Check forward: parameter format: '<local>;<remote>'
899 if (pieces.size() != 2 || pieces[0].empty() || pieces[1].empty() || pieces[1][0] == '*') {
900 SendFail(reply_fd, android::base::StringPrintf("bad forward: %s", service));
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100901 return 1;
902 }
903 }
904
Elliott Hughesab882422015-04-16 22:54:44 -0700905 std::string error_msg;
Elliott Hughes67943d12015-10-07 14:55:10 -0700906 atransport* transport = acquire_one_transport(type, serial, nullptr, &error_msg);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100907 if (!transport) {
Elliott Hughes88b4c852015-04-30 17:32:03 -0700908 SendFail(reply_fd, error_msg);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100909 return 1;
910 }
911
Spencer Low753d4852015-07-30 23:07:55 -0700912 std::string error;
Elliott Hughes3aec2ba2015-05-05 13:10:43 -0700913 InstallStatus r;
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700914 if (kill_forward) {
915 r = remove_listener(pieces[0].c_str(), transport);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100916 } else {
Spencer Low753d4852015-07-30 23:07:55 -0700917 r = install_listener(pieces[0], pieces[1].c_str(), transport,
918 no_rebind, &error);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100919 }
Elliott Hughesa585cbd2015-04-20 08:09:20 -0700920 if (r == INSTALL_STATUS_OK) {
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100921#if ADB_HOST
922 /* On the host: 1st OKAY is connect, 2nd OKAY is status */
Elliott Hughes88b4c852015-04-30 17:32:03 -0700923 SendOkay(reply_fd);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100924#endif
Elliott Hughes88b4c852015-04-30 17:32:03 -0700925 SendOkay(reply_fd);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100926 return 1;
927 }
928
Elliott Hughesa585cbd2015-04-20 08:09:20 -0700929 std::string message;
930 switch (r) {
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700931 case INSTALL_STATUS_OK: message = "success (!)"; break;
Elliott Hughesa585cbd2015-04-20 08:09:20 -0700932 case INSTALL_STATUS_INTERNAL_ERROR: message = "internal error"; break;
933 case INSTALL_STATUS_CANNOT_BIND:
Spencer Low32625852015-08-11 16:45:32 -0700934 message = android::base::StringPrintf("cannot bind listener: %s",
Spencer Low753d4852015-07-30 23:07:55 -0700935 error.c_str());
Elliott Hughesa585cbd2015-04-20 08:09:20 -0700936 break;
937 case INSTALL_STATUS_CANNOT_REBIND:
Spencer Low95365132015-07-29 17:21:21 -0700938 message = android::base::StringPrintf("cannot rebind existing socket");
Elliott Hughesa585cbd2015-04-20 08:09:20 -0700939 break;
Elliott Hughesd98ca8a2015-05-29 17:55:19 -0700940 case INSTALL_STATUS_LISTENER_NOT_FOUND:
941 message = android::base::StringPrintf("listener '%s' not found", service);
942 break;
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100943 }
Elliott Hughes88b4c852015-04-30 17:32:03 -0700944 SendFail(reply_fd, message);
David 'Digit' Turner963a4492013-03-21 21:07:42 +0100945 return 1;
946 }
947 return 0;
948}
949
Elliott Hughes24f52762015-06-23 13:00:32 -0700950#if ADB_HOST
951static int SendOkay(int fd, const std::string& s) {
952 SendOkay(fd);
953 SendProtocolString(fd, s);
954 return 0;
955}
956#endif
957
Dan Albert53a37442015-05-08 16:13:53 -0700958int handle_host_request(const char* service, TransportType type,
959 const char* serial, int reply_fd, asocket* s) {
960 if (strcmp(service, "kill") == 0) {
961 fprintf(stderr, "adb server killed by remote request\n");
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800962 fflush(stdout);
Elliott Hughes88b4c852015-04-30 17:32:03 -0700963 SendOkay(reply_fd);
Spencer Low85ee64b2015-08-11 17:05:02 -0700964
Spencer Lowcc4a4b12015-10-14 17:32:44 -0700965 // On Windows, if the process exits with open sockets that
966 // shutdown(SD_SEND) has not been called on, TCP RST segments will be
967 // sent to the peers which will cause their next recv() to error-out
968 // with WSAECONNRESET. In the case of this code, that means the client
969 // may not read the OKAY sent above.
Spencer Low85ee64b2015-08-11 17:05:02 -0700970 adb_shutdown(reply_fd);
971
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800972 exit(0);
973 }
974
975#if ADB_HOST
976 // "transport:" is used for switching transport with a specified serial number
977 // "transport-usb:" is used for switching transport to the only USB transport
978 // "transport-local:" is used for switching transport to the only local transport
979 // "transport-any:" is used for switching transport to the only transport
980 if (!strncmp(service, "transport", strlen("transport"))) {
Elliott Hughes3aec2ba2015-05-05 13:10:43 -0700981 TransportType type = kTransportAny;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800982
983 if (!strncmp(service, "transport-usb", strlen("transport-usb"))) {
984 type = kTransportUsb;
985 } else if (!strncmp(service, "transport-local", strlen("transport-local"))) {
986 type = kTransportLocal;
987 } else if (!strncmp(service, "transport-any", strlen("transport-any"))) {
988 type = kTransportAny;
989 } else if (!strncmp(service, "transport:", strlen("transport:"))) {
990 service += strlen("transport:");
Tom Marlin851ee3a2011-07-27 12:56:14 -0500991 serial = service;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800992 }
993
Elliott Hughes67943d12015-10-07 14:55:10 -0700994 std::string error;
995 atransport* t = acquire_one_transport(type, serial, nullptr, &error);
Elliott Hughes24f52762015-06-23 13:00:32 -0700996 if (t != nullptr) {
997 s->transport = t;
Elliott Hughes88b4c852015-04-30 17:32:03 -0700998 SendOkay(reply_fd);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -0800999 } else {
Elliott Hughes67943d12015-10-07 14:55:10 -07001000 SendFail(reply_fd, error);
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -08001001 }
1002 return 1;
1003 }
1004
1005 // return a list of all connected devices
Scott Anderson6dfaf4b2012-04-20 11:21:14 -07001006 if (!strncmp(service, "devices", 7)) {
Elliott Hughes88b4c852015-04-30 17:32:03 -07001007 bool long_listing = (strcmp(service+7, "-l") == 0);
1008 if (long_listing || service[7] == 0) {
Yabin Cui815ad882015-09-02 17:44:28 -07001009 D("Getting device list...");
Elliott Hughes88b4c852015-04-30 17:32:03 -07001010 std::string device_list = list_transports(long_listing);
Yabin Cui815ad882015-09-02 17:44:28 -07001011 D("Sending device list...");
Elliott Hughes24f52762015-06-23 13:00:32 -07001012 return SendOkay(reply_fd, device_list);
Scott Anderson6dfaf4b2012-04-20 11:21:14 -07001013 }
Elliott Hughes88b4c852015-04-30 17:32:03 -07001014 return 1;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -08001015 }
1016
Dan Albert996c12e2015-05-20 18:58:41 -07001017 if (!strcmp(service, "features")) {
Elliott Hughes67943d12015-10-07 14:55:10 -07001018 std::string error;
1019 atransport* t = acquire_one_transport(type, serial, nullptr, &error);
David Pursell2e9f0322015-09-04 16:40:30 -07001020 if (t != nullptr) {
David Pursella07dbad2015-09-22 10:43:08 -07001021 SendOkay(reply_fd, FeatureSetToString(t->features()));
David Pursell2e9f0322015-09-04 16:40:30 -07001022 } else {
Elliott Hughes67943d12015-10-07 14:55:10 -07001023 SendFail(reply_fd, error);
David Pursell2e9f0322015-09-04 16:40:30 -07001024 }
1025 return 0;
1026 }
1027
Mike Lockwood5f2c4a12009-10-11 23:04:18 -04001028 // remove TCP transport
1029 if (!strncmp(service, "disconnect:", 11)) {
Elliott Hughes09ccf1f2015-07-18 12:21:30 -07001030 const std::string address(service + 11);
1031 if (address.empty()) {
Yabin Cui4d64fd82015-08-27 12:03:11 -07001032 kick_all_tcp_devices();
Elliott Hughes09ccf1f2015-07-18 12:21:30 -07001033 return SendOkay(reply_fd, "disconnected everything");
Mike Lockwood5f2c4a12009-10-11 23:04:18 -04001034 }
1035
Elliott Hughes09ccf1f2015-07-18 12:21:30 -07001036 std::string serial;
1037 std::string host;
1038 int port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT;
1039 std::string error;
1040 if (!parse_host_and_port(address, &serial, &host, &port, &error)) {
1041 return SendFail(reply_fd, android::base::StringPrintf("couldn't parse '%s': %s",
1042 address.c_str(), error.c_str()));
1043 }
1044 atransport* t = find_transport(serial.c_str());
1045 if (t == nullptr) {
1046 return SendFail(reply_fd, android::base::StringPrintf("no such device '%s'",
1047 serial.c_str()));
1048 }
Yabin Cui4d64fd82015-08-27 12:03:11 -07001049 kick_transport(t);
Elliott Hughes09ccf1f2015-07-18 12:21:30 -07001050 return SendOkay(reply_fd, android::base::StringPrintf("disconnected %s", address.c_str()));
Mike Lockwoodb51ae572009-08-24 15:58:40 -07001051 }
1052
Elliott Hughes67943d12015-10-07 14:55:10 -07001053 // Returns our value for ADB_SERVER_VERSION.
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -08001054 if (!strcmp(service, "version")) {
Elliott Hughes24f52762015-06-23 13:00:32 -07001055 return SendOkay(reply_fd, android::base::StringPrintf("%04x", ADB_SERVER_VERSION));
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -08001056 }
1057
Elliott Hughes24f52762015-06-23 13:00:32 -07001058 // These always report "unknown" rather than the actual error, for scripts.
1059 if (!strcmp(service, "get-serialno")) {
Elliott Hughes67943d12015-10-07 14:55:10 -07001060 std::string error;
1061 atransport* t = acquire_one_transport(type, serial, nullptr, &error);
1062 if (t) {
1063 return SendOkay(reply_fd, t->serial ? t->serial : "unknown");
1064 } else {
1065 return SendFail(reply_fd, error);
1066 }
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -08001067 }
Elliott Hughes24f52762015-06-23 13:00:32 -07001068 if (!strcmp(service, "get-devpath")) {
Elliott Hughes67943d12015-10-07 14:55:10 -07001069 std::string error;
1070 atransport* t = acquire_one_transport(type, serial, nullptr, &error);
1071 if (t) {
1072 return SendOkay(reply_fd, t->devpath ? t->devpath : "unknown");
1073 } else {
1074 return SendFail(reply_fd, error);
1075 }
Scott Anderson6dfaf4b2012-04-20 11:21:14 -07001076 }
Elliott Hughes24f52762015-06-23 13:00:32 -07001077 if (!strcmp(service, "get-state")) {
Elliott Hughes67943d12015-10-07 14:55:10 -07001078 std::string error;
1079 atransport* t = acquire_one_transport(type, serial, nullptr, &error);
1080 if (t) {
1081 return SendOkay(reply_fd, t->connection_state_name());
1082 } else {
1083 return SendFail(reply_fd, error);
1084 }
Elliott Hughes24f52762015-06-23 13:00:32 -07001085 }
1086
Elliott Hughes67943d12015-10-07 14:55:10 -07001087 // Indicates a new emulator instance has started.
Elliott Hughes24f52762015-06-23 13:00:32 -07001088 if (!strncmp(service, "emulator:", 9)) {
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -08001089 int port = atoi(service+9);
1090 local_connect(port);
1091 /* we don't even need to send a reply */
1092 return 0;
1093 }
Simon Yee51c11e2014-07-14 17:23:06 -07001094#endif // ADB_HOST
1095
Elliott Hughes3aec2ba2015-05-05 13:10:43 -07001096 int ret = handle_forward_request(service, type, serial, reply_fd);
Simon Yee51c11e2014-07-14 17:23:06 -07001097 if (ret >= 0)
1098 return ret - 1;
The Android Open Source Project9ca14dc2009-03-03 19:32:55 -08001099 return -1;
1100}