blob: a85d5addf1a8676061eb931c6234134de11c85e4 [file] [log] [blame]
The Android Open Source Projectdd7bc332009-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
Dan Albert33134262015-03-19 15:21:08 -070017#define TRACE_TAG TRACE_SOCKETS
18
19#include "sysdeps.h"
20
Dan Albert76649012015-02-24 15:51:19 -080021#include <ctype.h>
22#include <errno.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080023#include <stdio.h>
24#include <stdlib.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080025#include <string.h>
Dan Albert76649012015-02-24 15:51:19 -080026#include <unistd.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080027
Dan Albert76649012015-02-24 15:51:19 -080028#if !ADB_HOST
29#include "cutils/properties.h"
30#endif
Dan Albert33134262015-03-19 15:21:08 -070031
32#include "adb.h"
33#include "adb_io.h"
Dan Albert76649012015-02-24 15:51:19 -080034#include "transport.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080035
36ADB_MUTEX_DEFINE( socket_list_lock );
37
38static void local_socket_close_locked(asocket *s);
39
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080040static unsigned local_socket_next_id = 1;
41
42static asocket local_socket_list = {
43 .next = &local_socket_list,
44 .prev = &local_socket_list,
45};
46
47/* the the list of currently closing local sockets.
48** these have no peer anymore, but still packets to
49** write to their fd.
50*/
51static asocket local_socket_closing_list = {
52 .next = &local_socket_closing_list,
53 .prev = &local_socket_closing_list,
54};
55
David 'Digit' Turner818d6412013-12-13 14:09:44 +010056// Parse the global list of sockets to find one with id |local_id|.
57// If |peer_id| is not 0, also check that it is connected to a peer
58// with id |peer_id|. Returns an asocket handle on success, NULL on failure.
59asocket *find_local_socket(unsigned local_id, unsigned peer_id)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080060{
61 asocket *s;
62 asocket *result = NULL;
63
64 adb_mutex_lock(&socket_list_lock);
André Goddard Rosa81828292010-06-12 11:40:20 -030065 for (s = local_socket_list.next; s != &local_socket_list; s = s->next) {
David 'Digit' Turner818d6412013-12-13 14:09:44 +010066 if (s->id != local_id)
67 continue;
68 if (peer_id == 0 || (s->peer && s->peer->id == peer_id)) {
André Goddard Rosa81828292010-06-12 11:40:20 -030069 result = s;
André Goddard Rosa81828292010-06-12 11:40:20 -030070 }
David 'Digit' Turner818d6412013-12-13 14:09:44 +010071 break;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080072 }
73 adb_mutex_unlock(&socket_list_lock);
74
75 return result;
76}
77
78static void
79insert_local_socket(asocket* s, asocket* list)
80{
81 s->next = list;
82 s->prev = s->next->prev;
83 s->prev->next = s;
84 s->next->prev = s;
85}
86
87
88void install_local_socket(asocket *s)
89{
90 adb_mutex_lock(&socket_list_lock);
91
92 s->id = local_socket_next_id++;
David 'Digit' Turner818d6412013-12-13 14:09:44 +010093
94 // Socket ids should never be 0.
95 if (local_socket_next_id == 0)
96 local_socket_next_id = 1;
97
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080098 insert_local_socket(s, &local_socket_list);
99
100 adb_mutex_unlock(&socket_list_lock);
101}
102
103void remove_socket(asocket *s)
104{
105 // socket_list_lock should already be held
106 if (s->prev && s->next)
107 {
108 s->prev->next = s->next;
109 s->next->prev = s->prev;
110 s->next = 0;
111 s->prev = 0;
112 s->id = 0;
113 }
114}
115
116void close_all_sockets(atransport *t)
117{
118 asocket *s;
119
120 /* this is a little gross, but since s->close() *will* modify
121 ** the list out from under you, your options are limited.
122 */
123 adb_mutex_lock(&socket_list_lock);
124restart:
125 for(s = local_socket_list.next; s != &local_socket_list; s = s->next){
126 if(s->transport == t || (s->peer && s->peer->transport == t)) {
127 local_socket_close_locked(s);
128 goto restart;
129 }
130 }
131 adb_mutex_unlock(&socket_list_lock);
132}
133
134static int local_socket_enqueue(asocket *s, apacket *p)
135{
136 D("LS(%d): enqueue %d\n", s->id, p->len);
137
138 p->ptr = p->data;
139
140 /* if there is already data queue'd, we will receive
141 ** events when it's time to write. just add this to
142 ** the tail
143 */
144 if(s->pkt_first) {
145 goto enqueue;
146 }
147
148 /* write as much as we can, until we
149 ** would block or there is an error/eof
150 */
151 while(p->len > 0) {
152 int r = adb_write(s->fd, p->ptr, p->len);
153 if(r > 0) {
154 p->len -= r;
155 p->ptr += r;
156 continue;
157 }
158 if((r == 0) || (errno != EAGAIN)) {
159 D( "LS(%d): not ready, errno=%d: %s\n", s->id, errno, strerror(errno) );
160 s->close(s);
161 return 1; /* not ready (error) */
162 } else {
163 break;
164 }
165 }
166
167 if(p->len == 0) {
168 put_apacket(p);
169 return 0; /* ready for more data */
170 }
171
172enqueue:
173 p->next = 0;
174 if(s->pkt_first) {
175 s->pkt_last->next = p;
176 } else {
177 s->pkt_first = p;
178 }
179 s->pkt_last = p;
180
181 /* make sure we are notified when we can drain the queue */
182 fdevent_add(&s->fde, FDE_WRITE);
183
184 return 1; /* not ready (backlog) */
185}
186
187static void local_socket_ready(asocket *s)
188{
Nanik Tolaramb627a0e2015-02-18 22:53:37 +1100189 /* far side is ready for data, pay attention to
190 readable events */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800191 fdevent_add(&s->fde, FDE_READ);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800192}
193
194static void local_socket_close(asocket *s)
195{
196 adb_mutex_lock(&socket_list_lock);
197 local_socket_close_locked(s);
198 adb_mutex_unlock(&socket_list_lock);
199}
200
201// be sure to hold the socket list lock when calling this
202static void local_socket_destroy(asocket *s)
203{
204 apacket *p, *n;
Benoit Gobyf366b362012-03-16 14:50:07 -0700205 int exit_on_close = s->exit_on_close;
206
JP Abgrall408fa572011-03-16 15:57:42 -0700207 D("LS(%d): destroying fde.fd=%d\n", s->id, s->fde.fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800208
209 /* IMPORTANT: the remove closes the fd
210 ** that belongs to this socket
211 */
212 fdevent_remove(&s->fde);
213
214 /* dispose of any unwritten data */
215 for(p = s->pkt_first; p; p = n) {
216 D("LS(%d): discarding %d bytes\n", s->id, p->len);
217 n = p->next;
218 put_apacket(p);
219 }
220 remove_socket(s);
221 free(s);
Benoit Gobyf366b362012-03-16 14:50:07 -0700222
223 if (exit_on_close) {
224 D("local_socket_destroy: exiting\n");
225 exit(1);
226 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800227}
228
229
230static void local_socket_close_locked(asocket *s)
231{
Nanik Tolaramb627a0e2015-02-18 22:53:37 +1100232 D("entered local_socket_close_locked. LS(%d) fd=%d\n", s->id, s->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800233 if(s->peer) {
JP Abgrall408fa572011-03-16 15:57:42 -0700234 D("LS(%d): closing peer. peer->id=%d peer->fd=%d\n",
235 s->id, s->peer->id, s->peer->fd);
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100236 /* Note: it's important to call shutdown before disconnecting from
237 * the peer, this ensures that remote sockets can still get the id
238 * of the local socket they're connected to, to send a CLOSE()
239 * protocol event. */
240 if (s->peer->shutdown)
241 s->peer->shutdown(s->peer);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800242 s->peer->peer = 0;
243 // tweak to avoid deadlock
Tom Marlin49f18572011-05-13 13:24:55 -0500244 if (s->peer->close == local_socket_close) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800245 local_socket_close_locked(s->peer);
Tom Marlin49f18572011-05-13 13:24:55 -0500246 } else {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800247 s->peer->close(s->peer);
Tom Marlin49f18572011-05-13 13:24:55 -0500248 }
249 s->peer = 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800250 }
251
252 /* If we are already closing, or if there are no
253 ** pending packets, destroy immediately
254 */
255 if (s->closing || s->pkt_first == NULL) {
256 int id = s->id;
257 local_socket_destroy(s);
258 D("LS(%d): closed\n", id);
259 return;
260 }
261
262 /* otherwise, put on the closing list
263 */
264 D("LS(%d): closing\n", s->id);
265 s->closing = 1;
266 fdevent_del(&s->fde, FDE_READ);
267 remove_socket(s);
JP Abgrall408fa572011-03-16 15:57:42 -0700268 D("LS(%d): put on socket_closing_list fd=%d\n", s->id, s->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800269 insert_local_socket(s, &local_socket_closing_list);
270}
271
Dan Albertbac34742015-02-25 17:51:28 -0800272static void local_socket_event_func(int fd, unsigned ev, void* _s)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800273{
Dan Albertbac34742015-02-25 17:51:28 -0800274 asocket* s = reinterpret_cast<asocket*>(_s);
JP Abgrall408fa572011-03-16 15:57:42 -0700275 D("LS(%d): event_func(fd=%d(==%d), ev=%04x)\n", s->id, s->fd, fd, ev);
276
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800277 /* put the FDE_WRITE processing before the FDE_READ
278 ** in order to simplify the code.
279 */
Dan Albertbac34742015-02-25 17:51:28 -0800280 if (ev & FDE_WRITE) {
281 apacket* p;
282 while ((p = s->pkt_first) != nullptr) {
283 while (p->len > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800284 int r = adb_write(fd, p->ptr, p->len);
Dan Albertbac34742015-02-25 17:51:28 -0800285 if (r == -1) {
286 /* returning here is ok because FDE_READ will
287 ** be processed in the next iteration loop
288 */
289 if (errno == EAGAIN) {
290 return;
291 }
292 } else if (r > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800293 p->ptr += r;
294 p->len -= r;
295 continue;
296 }
Dan Albertbac34742015-02-25 17:51:28 -0800297
Christopher Tate5b811fa2011-06-10 11:38:37 -0700298 D(" closing after write because r=%d and errno is %d\n", r, errno);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800299 s->close(s);
300 return;
301 }
302
Dan Albertbac34742015-02-25 17:51:28 -0800303 if (p->len == 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800304 s->pkt_first = p->next;
Dan Albertbac34742015-02-25 17:51:28 -0800305 if (s->pkt_first == 0) {
306 s->pkt_last = 0;
307 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800308 put_apacket(p);
309 }
310 }
311
Dan Albertbac34742015-02-25 17:51:28 -0800312 /* if we sent the last packet of a closing socket,
313 ** we can now destroy it.
314 */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800315 if (s->closing) {
Christopher Tate5b811fa2011-06-10 11:38:37 -0700316 D(" closing because 'closing' is set after write\n");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800317 s->close(s);
318 return;
319 }
320
Dan Albertbac34742015-02-25 17:51:28 -0800321 /* no more packets queued, so we can ignore
322 ** writable events again and tell our peer
323 ** to resume writing
324 */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800325 fdevent_del(&s->fde, FDE_WRITE);
326 s->peer->ready(s->peer);
327 }
328
329
Dan Albertbac34742015-02-25 17:51:28 -0800330 if (ev & FDE_READ) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800331 apacket *p = get_apacket();
332 unsigned char *x = p->data;
Tamas Berghammer3d2904c2015-07-13 19:12:28 +0100333 const size_t max_payload = s->get_max_payload();
334 size_t avail = max_payload;
335 int r = 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800336 int is_eof = 0;
337
Dan Albertbac34742015-02-25 17:51:28 -0800338 while (avail > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800339 r = adb_read(fd, x, avail);
Dan Albertbac34742015-02-25 17:51:28 -0800340 D("LS(%d): post adb_read(fd=%d,...) r=%d (errno=%d) avail=%zu\n",
341 s->id, s->fd, r, r < 0 ? errno : 0, avail);
342 if (r == -1) {
343 if (errno == EAGAIN) {
344 break;
345 }
346 } else if (r > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800347 avail -= r;
348 x += r;
349 continue;
350 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800351
Dan Albertbac34742015-02-25 17:51:28 -0800352 /* r = 0 or unhandled error */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800353 is_eof = 1;
354 break;
355 }
JP Abgrall408fa572011-03-16 15:57:42 -0700356 D("LS(%d): fd=%d post avail loop. r=%d is_eof=%d forced_eof=%d\n",
357 s->id, s->fd, r, is_eof, s->fde.force_eof);
Tamas Berghammer3d2904c2015-07-13 19:12:28 +0100358 if ((avail == max_payload) || (s->peer == 0)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800359 put_apacket(p);
360 } else {
Tamas Berghammer3d2904c2015-07-13 19:12:28 +0100361 p->len = max_payload - avail;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800362
Yabin Cui00674122015-08-26 12:27:40 -0700363 // s->peer->enqueue() may call s->close() and free s,
364 // so save variables for debug printing below.
365 unsigned saved_id = s->id;
366 int saved_fd = s->fd;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800367 r = s->peer->enqueue(s->peer, p);
Yabin Cui00674122015-08-26 12:27:40 -0700368 D("LS(%u): fd=%d post peer->enqueue(). r=%d\n", saved_id, saved_fd, r);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800369
Dan Albertbac34742015-02-25 17:51:28 -0800370 if (r < 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800371 /* error return means they closed us as a side-effect
372 ** and we must return immediately.
373 **
374 ** note that if we still have buffered packets, the
375 ** socket will be placed on the closing socket list.
376 ** this handler function will be called again
377 ** to process FDE_WRITE events.
378 */
379 return;
380 }
381
Dan Albertbac34742015-02-25 17:51:28 -0800382 if (r > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800383 /* if the remote cannot accept further events,
384 ** we disable notification of READs. They'll
385 ** be enabled again when we get a call to ready()
386 */
387 fdevent_del(&s->fde, FDE_READ);
388 }
389 }
JP Abgrall112445b2011-04-12 22:01:58 -0700390 /* Don't allow a forced eof if data is still there */
Dan Albertbac34742015-02-25 17:51:28 -0800391 if ((s->fde.force_eof && !r) || is_eof) {
392 D(" closing because is_eof=%d r=%d s->fde.force_eof=%d\n",
393 is_eof, r, s->fde.force_eof);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800394 s->close(s);
395 }
396 }
397
Dan Albertbac34742015-02-25 17:51:28 -0800398 if (ev & FDE_ERROR){
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800399 /* this should be caught be the next read or write
400 ** catching it here means we may skip the last few
401 ** bytes of readable data.
402 */
JP Abgrall408fa572011-03-16 15:57:42 -0700403 D("LS(%d): FDE_ERROR (fd=%d)\n", s->id, s->fd);
404
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800405 return;
406 }
407}
408
409asocket *create_local_socket(int fd)
410{
Dan Albertbac34742015-02-25 17:51:28 -0800411 asocket *s = reinterpret_cast<asocket*>(calloc(1, sizeof(asocket)));
André Goddard Rosac419e2a2010-06-10 20:48:19 -0300412 if (s == NULL) fatal("cannot allocate socket");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800413 s->fd = fd;
414 s->enqueue = local_socket_enqueue;
415 s->ready = local_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100416 s->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800417 s->close = local_socket_close;
JP Abgrall408fa572011-03-16 15:57:42 -0700418 install_local_socket(s);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800419
420 fdevent_install(&s->fde, fd, local_socket_event_func, s);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800421 D("LS(%d): created (fd=%d)\n", s->id, s->fd);
422 return s;
423}
424
425asocket *create_local_service_socket(const char *name)
426{
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800427#if !ADB_HOST
428 if (!strcmp(name,"jdwp")) {
429 return create_jdwp_service_socket();
430 }
431 if (!strcmp(name,"track-jdwp")) {
432 return create_jdwp_tracker_service_socket();
433 }
434#endif
Dan Pasanen98858812014-10-06 12:57:20 -0500435 int fd = service_to_fd(name);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800436 if(fd < 0) return 0;
437
Dan Pasanen98858812014-10-06 12:57:20 -0500438 asocket* s = create_local_socket(fd);
JP Abgrall408fa572011-03-16 15:57:42 -0700439 D("LS(%d): bound to '%s' via %d\n", s->id, name, fd);
Benoit Gobyf366b362012-03-16 14:50:07 -0700440
JP Abgrallf91259a2012-03-30 13:19:11 -0700441#if !ADB_HOST
Dan Pasanen98858812014-10-06 12:57:20 -0500442 char debug[PROPERTY_VALUE_MAX];
jzhuan51297d222013-05-24 17:40:15 -0400443 if (!strncmp(name, "root:", 5))
444 property_get("ro.debuggable", debug, "");
445
Dan Pasanen98858812014-10-06 12:57:20 -0500446 if ((!strncmp(name, "root:", 5) && getuid() != 0 && strcmp(debug, "1") == 0)
447 || (!strncmp(name, "unroot:", 7) && getuid() == 0)
Benoit Gobyaeceb512012-06-12 12:12:18 -0700448 || !strncmp(name, "usb:", 4)
449 || !strncmp(name, "tcpip:", 6)) {
Benoit Gobyf366b362012-03-16 14:50:07 -0700450 D("LS(%d): enabling exit_on_close\n", s->id);
451 s->exit_on_close = 1;
452 }
JP Abgrallf91259a2012-03-30 13:19:11 -0700453#endif
Benoit Gobyf366b362012-03-16 14:50:07 -0700454
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800455 return s;
456}
457
458#if ADB_HOST
459static asocket *create_host_service_socket(const char *name, const char* serial)
460{
461 asocket *s;
462
463 s = host_service_to_socket(name, serial);
464
465 if (s != NULL) {
466 D("LS(%d) bound to '%s'\n", s->id, name);
467 return s;
468 }
469
470 return s;
471}
472#endif /* ADB_HOST */
473
474/* a Remote socket is used to send/receive data to/from a given transport object
475** it needs to be closed when the transport is forcibly destroyed by the user
476*/
Elliott Hughes2d4121c2015-04-17 09:47:42 -0700477struct aremotesocket {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800478 asocket socket;
479 adisconnect disconnect;
Elliott Hughes2d4121c2015-04-17 09:47:42 -0700480};
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800481
482static int remote_socket_enqueue(asocket *s, apacket *p)
483{
JP Abgrall408fa572011-03-16 15:57:42 -0700484 D("entered remote_socket_enqueue RS(%d) WRITE fd=%d peer.fd=%d\n",
485 s->id, s->fd, s->peer->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800486 p->msg.command = A_WRTE;
487 p->msg.arg0 = s->peer->id;
488 p->msg.arg1 = s->id;
489 p->msg.data_length = p->len;
490 send_packet(p, s->transport);
491 return 1;
492}
493
494static void remote_socket_ready(asocket *s)
495{
JP Abgrall408fa572011-03-16 15:57:42 -0700496 D("entered remote_socket_ready RS(%d) OKAY fd=%d peer.fd=%d\n",
497 s->id, s->fd, s->peer->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800498 apacket *p = get_apacket();
499 p->msg.command = A_OKAY;
500 p->msg.arg0 = s->peer->id;
501 p->msg.arg1 = s->id;
502 send_packet(p, s->transport);
503}
504
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100505static void remote_socket_shutdown(asocket *s)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800506{
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100507 D("entered remote_socket_shutdown RS(%d) CLOSE fd=%d peer->fd=%d\n",
JP Abgrall408fa572011-03-16 15:57:42 -0700508 s->id, s->fd, s->peer?s->peer->fd:-1);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800509 apacket *p = get_apacket();
510 p->msg.command = A_CLSE;
511 if(s->peer) {
512 p->msg.arg0 = s->peer->id;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100513 }
514 p->msg.arg1 = s->id;
515 send_packet(p, s->transport);
516}
517
518static void remote_socket_close(asocket *s)
519{
520 if (s->peer) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800521 s->peer->peer = 0;
JP Abgrall408fa572011-03-16 15:57:42 -0700522 D("RS(%d) peer->close()ing peer->id=%d peer->fd=%d\n",
523 s->id, s->peer->id, s->peer->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800524 s->peer->close(s->peer);
525 }
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100526 D("entered remote_socket_close RS(%d) CLOSE fd=%d peer->fd=%d\n",
527 s->id, s->fd, s->peer?s->peer->fd:-1);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800528 D("RS(%d): closed\n", s->id);
529 remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect );
530 free(s);
531}
532
533static void remote_socket_disconnect(void* _s, atransport* t)
534{
Dan Albertbac34742015-02-25 17:51:28 -0800535 asocket* s = reinterpret_cast<asocket*>(_s);
536 asocket* peer = s->peer;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800537
538 D("remote_socket_disconnect RS(%d)\n", s->id);
539 if (peer) {
540 peer->peer = NULL;
541 peer->close(peer);
542 }
543 remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect );
544 free(s);
545}
546
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100547/* Create an asocket to exchange packets with a remote service through transport
548 |t|. Where |id| is the socket id of the corresponding service on the other
549 side of the transport (it is allocated by the remote side and _cannot_ be 0).
550 Returns a new non-NULL asocket handle. */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800551asocket *create_remote_socket(unsigned id, atransport *t)
552{
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100553 if (id == 0) fatal("invalid remote socket id (0)");
Dan Albertbac34742015-02-25 17:51:28 -0800554 asocket* s = reinterpret_cast<asocket*>(calloc(1, sizeof(aremotesocket)));
555 adisconnect* dis = &reinterpret_cast<aremotesocket*>(s)->disconnect;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800556
André Goddard Rosac419e2a2010-06-10 20:48:19 -0300557 if (s == NULL) fatal("cannot allocate socket");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800558 s->id = id;
559 s->enqueue = remote_socket_enqueue;
560 s->ready = remote_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100561 s->shutdown = remote_socket_shutdown;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800562 s->close = remote_socket_close;
563 s->transport = t;
564
565 dis->func = remote_socket_disconnect;
566 dis->opaque = s;
567 add_transport_disconnect( t, dis );
568 D("RS(%d): created\n", s->id);
569 return s;
570}
571
572void connect_to_remote(asocket *s, const char *destination)
573{
JP Abgrall408fa572011-03-16 15:57:42 -0700574 D("Connect_to_remote call RS(%d) fd=%d\n", s->id, s->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800575 apacket *p = get_apacket();
Tamas Berghammer3d2904c2015-07-13 19:12:28 +0100576 size_t len = strlen(destination) + 1;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800577
Tamas Berghammer3d2904c2015-07-13 19:12:28 +0100578 if(len > (s->get_max_payload()-1)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800579 fatal("destination oversized");
580 }
581
582 D("LS(%d): connect('%s')\n", s->id, destination);
583 p->msg.command = A_OPEN;
584 p->msg.arg0 = s->id;
585 p->msg.data_length = len;
586 strcpy((char*) p->data, destination);
587 send_packet(p, s->transport);
588}
589
590
591/* this is used by magic sockets to rig local sockets to
592 send the go-ahead message when they connect */
593static void local_socket_ready_notify(asocket *s)
594{
595 s->ready = local_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100596 s->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800597 s->close = local_socket_close;
Elliott Hughese67f1f82015-04-30 17:32:03 -0700598 SendOkay(s->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800599 s->ready(s);
600}
601
602/* this is used by magic sockets to rig local sockets to
603 send the failure message if they are closed before
604 connected (to avoid closing them without a status message) */
605static void local_socket_close_notify(asocket *s)
606{
607 s->ready = local_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100608 s->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800609 s->close = local_socket_close;
Elliott Hughese67f1f82015-04-30 17:32:03 -0700610 SendFail(s->fd, "closed");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800611 s->close(s);
612}
613
Elliott Hughese67f1f82015-04-30 17:32:03 -0700614static unsigned unhex(unsigned char *s, int len)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800615{
616 unsigned n = 0, c;
617
618 while(len-- > 0) {
619 switch((c = *s++)) {
620 case '0': case '1': case '2':
621 case '3': case '4': case '5':
622 case '6': case '7': case '8':
623 case '9':
624 c -= '0';
625 break;
626 case 'a': case 'b': case 'c':
627 case 'd': case 'e': case 'f':
628 c = c - 'a' + 10;
629 break;
630 case 'A': case 'B': case 'C':
631 case 'D': case 'E': case 'F':
632 c = c - 'A' + 10;
633 break;
634 default:
635 return 0xffffffff;
636 }
637
638 n = (n << 4) | c;
639 }
640
641 return n;
642}
643
Elliott Hughese67f1f82015-04-30 17:32:03 -0700644#if ADB_HOST
645
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700646#define PREFIX(str) { str, sizeof(str) - 1 }
647static const struct prefix_struct {
648 const char *str;
649 const size_t len;
650} prefixes[] = {
651 PREFIX("usb:"),
652 PREFIX("product:"),
653 PREFIX("model:"),
654 PREFIX("device:"),
655};
656static const int num_prefixes = (sizeof(prefixes) / sizeof(prefixes[0]));
657
Terence Haddock28e13902011-03-16 09:43:56 +0100658/* skip_host_serial return the position in a string
659 skipping over the 'serial' parameter in the ADB protocol,
660 where parameter string may be a host:port string containing
661 the protocol delimiter (colon). */
Elliott Hughese67f1f82015-04-30 17:32:03 -0700662static char *skip_host_serial(char *service) {
Terence Haddock28e13902011-03-16 09:43:56 +0100663 char *first_colon, *serial_end;
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700664 int i;
Terence Haddock28e13902011-03-16 09:43:56 +0100665
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700666 for (i = 0; i < num_prefixes; i++) {
667 if (!strncmp(service, prefixes[i].str, prefixes[i].len))
668 return strchr(service + prefixes[i].len, ':');
Scott Anderson3608d832012-05-31 12:04:23 -0700669 }
670
Terence Haddock28e13902011-03-16 09:43:56 +0100671 first_colon = strchr(service, ':');
672 if (!first_colon) {
673 /* No colon in service string. */
674 return NULL;
675 }
676 serial_end = first_colon;
677 if (isdigit(serial_end[1])) {
678 serial_end++;
679 while ((*serial_end) && isdigit(*serial_end)) {
680 serial_end++;
681 }
682 if ((*serial_end) != ':') {
683 // Something other than numbers was found, reset the end.
684 serial_end = first_colon;
685 }
686 }
687 return serial_end;
688}
689
Elliott Hughese67f1f82015-04-30 17:32:03 -0700690#endif // ADB_HOST
691
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800692static int smart_socket_enqueue(asocket *s, apacket *p)
693{
694 unsigned len;
695#if ADB_HOST
696 char *service = NULL;
697 char* serial = NULL;
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700698 TransportType type = kTransportAny;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800699#endif
700
701 D("SS(%d): enqueue %d\n", s->id, p->len);
702
703 if(s->pkt_first == 0) {
704 s->pkt_first = p;
705 s->pkt_last = p;
706 } else {
Tamas Berghammer3d2904c2015-07-13 19:12:28 +0100707 if((s->pkt_first->len + p->len) > s->get_max_payload()) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800708 D("SS(%d): overflow\n", s->id);
709 put_apacket(p);
710 goto fail;
711 }
712
713 memcpy(s->pkt_first->data + s->pkt_first->len,
714 p->data, p->len);
715 s->pkt_first->len += p->len;
716 put_apacket(p);
717
718 p = s->pkt_first;
719 }
720
721 /* don't bother if we can't decode the length */
722 if(p->len < 4) return 0;
723
724 len = unhex(p->data, 4);
725 if((len < 1) || (len > 1024)) {
726 D("SS(%d): bad size (%d)\n", s->id, len);
727 goto fail;
728 }
729
730 D("SS(%d): len is %d\n", s->id, len );
731 /* can't do anything until we have the full header */
732 if((len + 4) > p->len) {
733 D("SS(%d): waiting for %d more bytes\n", s->id, len+4 - p->len);
734 return 0;
735 }
736
737 p->data[len + 4] = 0;
738
739 D("SS(%d): '%s'\n", s->id, (char*) (p->data + 4));
740
741#if ADB_HOST
742 service = (char *)p->data + 4;
743 if(!strncmp(service, "host-serial:", strlen("host-serial:"))) {
744 char* serial_end;
745 service += strlen("host-serial:");
746
Terence Haddock28e13902011-03-16 09:43:56 +0100747 // serial number should follow "host:" and could be a host:port string.
748 serial_end = skip_host_serial(service);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800749 if (serial_end) {
750 *serial_end = 0; // terminate string
751 serial = service;
752 service = serial_end + 1;
753 }
754 } else if (!strncmp(service, "host-usb:", strlen("host-usb:"))) {
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700755 type = kTransportUsb;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800756 service += strlen("host-usb:");
757 } else if (!strncmp(service, "host-local:", strlen("host-local:"))) {
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700758 type = kTransportLocal;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800759 service += strlen("host-local:");
760 } else if (!strncmp(service, "host:", strlen("host:"))) {
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700761 type = kTransportAny;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800762 service += strlen("host:");
763 } else {
764 service = NULL;
765 }
766
767 if (service) {
768 asocket *s2;
769
770 /* some requests are handled immediately -- in that
771 ** case the handle_host_request() routine has sent
772 ** the OKAY or FAIL message and all we have to do
773 ** is clean up.
774 */
Elliott Hughes3bd73c12015-05-05 13:10:43 -0700775 if(handle_host_request(service, type, serial, s->peer->fd, s) == 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800776 /* XXX fail message? */
777 D( "SS(%d): handled host service '%s'\n", s->id, service );
778 goto fail;
779 }
780 if (!strncmp(service, "transport", strlen("transport"))) {
781 D( "SS(%d): okay transport\n", s->id );
782 p->len = 0;
783 return 0;
784 }
785
786 /* try to find a local service with this name.
787 ** if no such service exists, we'll fail out
788 ** and tear down here.
789 */
790 s2 = create_host_service_socket(service, serial);
791 if(s2 == 0) {
792 D( "SS(%d): couldn't create host service '%s'\n", s->id, service );
Elliott Hughese67f1f82015-04-30 17:32:03 -0700793 SendFail(s->peer->fd, "unknown host service");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800794 goto fail;
795 }
796
797 /* we've connected to a local host service,
798 ** so we make our peer back into a regular
799 ** local socket and bind it to the new local
800 ** service socket, acknowledge the successful
801 ** connection, and close this smart socket now
802 ** that its work is done.
803 */
Elliott Hughese67f1f82015-04-30 17:32:03 -0700804 SendOkay(s->peer->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800805
806 s->peer->ready = local_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100807 s->peer->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800808 s->peer->close = local_socket_close;
809 s->peer->peer = s2;
810 s2->peer = s->peer;
811 s->peer = 0;
812 D( "SS(%d): okay\n", s->id );
813 s->close(s);
814
815 /* initial state is "ready" */
816 s2->ready(s2);
817 return 0;
818 }
819#else /* !ADB_HOST */
820 if (s->transport == NULL) {
Elliott Hughes7be29c82015-04-16 22:54:44 -0700821 std::string error_msg = "unknown failure";
Dan Albertdcd78a12015-05-18 16:43:57 -0700822 s->transport =
823 acquire_one_transport(kCsAny, kTransportAny, NULL, &error_msg);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800824
825 if (s->transport == NULL) {
Elliott Hughese67f1f82015-04-30 17:32:03 -0700826 SendFail(s->peer->fd, error_msg);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800827 goto fail;
828 }
829 }
830#endif
831
Dan Albertdcd78a12015-05-18 16:43:57 -0700832 if(!(s->transport) || (s->transport->connection_state == kCsOffline)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800833 /* if there's no remote we fail the connection
834 ** right here and terminate it
835 */
Elliott Hughese67f1f82015-04-30 17:32:03 -0700836 SendFail(s->peer->fd, "device offline (x)");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800837 goto fail;
838 }
839
840
841 /* instrument our peer to pass the success or fail
842 ** message back once it connects or closes, then
843 ** detach from it, request the connection, and
844 ** tear down
845 */
846 s->peer->ready = local_socket_ready_notify;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100847 s->peer->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800848 s->peer->close = local_socket_close_notify;
849 s->peer->peer = 0;
850 /* give him our transport and upref it */
851 s->peer->transport = s->transport;
852
853 connect_to_remote(s->peer, (char*) (p->data + 4));
854 s->peer = 0;
855 s->close(s);
856 return 1;
857
858fail:
859 /* we're going to close our peer as a side-effect, so
860 ** return -1 to signal that state to the local socket
861 ** who is enqueueing against us
862 */
863 s->close(s);
864 return -1;
865}
866
867static void smart_socket_ready(asocket *s)
868{
869 D("SS(%d): ready\n", s->id);
870}
871
872static void smart_socket_close(asocket *s)
873{
874 D("SS(%d): closed\n", s->id);
875 if(s->pkt_first){
876 put_apacket(s->pkt_first);
877 }
878 if(s->peer) {
879 s->peer->peer = 0;
880 s->peer->close(s->peer);
Tom Marlin49f18572011-05-13 13:24:55 -0500881 s->peer = 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800882 }
883 free(s);
884}
885
Benoit Goby9470c2f2013-02-20 15:04:53 -0800886static asocket *create_smart_socket(void)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800887{
888 D("Creating smart socket \n");
Dan Albertbac34742015-02-25 17:51:28 -0800889 asocket *s = reinterpret_cast<asocket*>(calloc(1, sizeof(asocket)));
André Goddard Rosac419e2a2010-06-10 20:48:19 -0300890 if (s == NULL) fatal("cannot allocate socket");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800891 s->enqueue = smart_socket_enqueue;
892 s->ready = smart_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100893 s->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800894 s->close = smart_socket_close;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800895
Benoit Goby9470c2f2013-02-20 15:04:53 -0800896 D("SS(%d)\n", s->id);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800897 return s;
898}
899
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800900void connect_to_smartsocket(asocket *s)
901{
902 D("Connecting to smart socket \n");
Benoit Goby9470c2f2013-02-20 15:04:53 -0800903 asocket *ss = create_smart_socket();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800904 s->peer = ss;
905 ss->peer = s;
906 s->ready(s);
907}
Tamas Berghammer3d2904c2015-07-13 19:12:28 +0100908
909size_t asocket::get_max_payload() const {
910 size_t max_payload = MAX_PAYLOAD;
911 if (transport) {
912 max_payload = std::min(max_payload, transport->get_max_payload());
913 }
914 if (peer && peer->transport) {
915 max_payload = std::min(max_payload, peer->transport->get_max_payload());
916 }
917 return max_payload;
918}