blob: 12bc8d8acb297d92dc0316041c95dc758bdf2b6d [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 Albert76649012015-02-24 15:51:19 -080017#include <ctype.h>
18#include <errno.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080019#include <stdio.h>
20#include <stdlib.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080021#include <string.h>
Dan Albert76649012015-02-24 15:51:19 -080022#include <unistd.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080023
24#include "sysdeps.h"
25
26#define TRACE_TAG TRACE_SOCKETS
27#include "adb.h"
Dan Albertcc731cc2015-02-24 21:26:58 -080028#include "adb_io.h"
Dan Albert76649012015-02-24 15:51:19 -080029#if !ADB_HOST
30#include "cutils/properties.h"
31#endif
32#include "transport.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080033
34ADB_MUTEX_DEFINE( socket_list_lock );
35
36static void local_socket_close_locked(asocket *s);
37
38int sendfailmsg(int fd, const char *reason)
39{
40 char buf[9];
41 int len;
42 len = strlen(reason);
Dan Albertcc731cc2015-02-24 21:26:58 -080043 if (len > 0xffff) {
44 len = 0xffff;
45 }
46
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080047 snprintf(buf, sizeof buf, "FAIL%04x", len);
Dan Albertcc731cc2015-02-24 21:26:58 -080048 if (!WriteFdExactly(fd, buf, 8)) {
49 return -1;
50 }
51
52 return WriteFdExactly(fd, reason, len) ? 0 : -1;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080053}
54
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080055static unsigned local_socket_next_id = 1;
56
57static asocket local_socket_list = {
58 .next = &local_socket_list,
59 .prev = &local_socket_list,
60};
61
62/* the the list of currently closing local sockets.
63** these have no peer anymore, but still packets to
64** write to their fd.
65*/
66static asocket local_socket_closing_list = {
67 .next = &local_socket_closing_list,
68 .prev = &local_socket_closing_list,
69};
70
David 'Digit' Turner818d6412013-12-13 14:09:44 +010071// Parse the global list of sockets to find one with id |local_id|.
72// If |peer_id| is not 0, also check that it is connected to a peer
73// with id |peer_id|. Returns an asocket handle on success, NULL on failure.
74asocket *find_local_socket(unsigned local_id, unsigned peer_id)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080075{
76 asocket *s;
77 asocket *result = NULL;
78
79 adb_mutex_lock(&socket_list_lock);
André Goddard Rosa81828292010-06-12 11:40:20 -030080 for (s = local_socket_list.next; s != &local_socket_list; s = s->next) {
David 'Digit' Turner818d6412013-12-13 14:09:44 +010081 if (s->id != local_id)
82 continue;
83 if (peer_id == 0 || (s->peer && s->peer->id == peer_id)) {
André Goddard Rosa81828292010-06-12 11:40:20 -030084 result = s;
André Goddard Rosa81828292010-06-12 11:40:20 -030085 }
David 'Digit' Turner818d6412013-12-13 14:09:44 +010086 break;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080087 }
88 adb_mutex_unlock(&socket_list_lock);
89
90 return result;
91}
92
93static void
94insert_local_socket(asocket* s, asocket* list)
95{
96 s->next = list;
97 s->prev = s->next->prev;
98 s->prev->next = s;
99 s->next->prev = s;
100}
101
102
103void install_local_socket(asocket *s)
104{
105 adb_mutex_lock(&socket_list_lock);
106
107 s->id = local_socket_next_id++;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100108
109 // Socket ids should never be 0.
110 if (local_socket_next_id == 0)
111 local_socket_next_id = 1;
112
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800113 insert_local_socket(s, &local_socket_list);
114
115 adb_mutex_unlock(&socket_list_lock);
116}
117
118void remove_socket(asocket *s)
119{
120 // socket_list_lock should already be held
121 if (s->prev && s->next)
122 {
123 s->prev->next = s->next;
124 s->next->prev = s->prev;
125 s->next = 0;
126 s->prev = 0;
127 s->id = 0;
128 }
129}
130
131void close_all_sockets(atransport *t)
132{
133 asocket *s;
134
135 /* this is a little gross, but since s->close() *will* modify
136 ** the list out from under you, your options are limited.
137 */
138 adb_mutex_lock(&socket_list_lock);
139restart:
140 for(s = local_socket_list.next; s != &local_socket_list; s = s->next){
141 if(s->transport == t || (s->peer && s->peer->transport == t)) {
142 local_socket_close_locked(s);
143 goto restart;
144 }
145 }
146 adb_mutex_unlock(&socket_list_lock);
147}
148
149static int local_socket_enqueue(asocket *s, apacket *p)
150{
151 D("LS(%d): enqueue %d\n", s->id, p->len);
152
153 p->ptr = p->data;
154
155 /* if there is already data queue'd, we will receive
156 ** events when it's time to write. just add this to
157 ** the tail
158 */
159 if(s->pkt_first) {
160 goto enqueue;
161 }
162
163 /* write as much as we can, until we
164 ** would block or there is an error/eof
165 */
166 while(p->len > 0) {
167 int r = adb_write(s->fd, p->ptr, p->len);
168 if(r > 0) {
169 p->len -= r;
170 p->ptr += r;
171 continue;
172 }
173 if((r == 0) || (errno != EAGAIN)) {
174 D( "LS(%d): not ready, errno=%d: %s\n", s->id, errno, strerror(errno) );
175 s->close(s);
176 return 1; /* not ready (error) */
177 } else {
178 break;
179 }
180 }
181
182 if(p->len == 0) {
183 put_apacket(p);
184 return 0; /* ready for more data */
185 }
186
187enqueue:
188 p->next = 0;
189 if(s->pkt_first) {
190 s->pkt_last->next = p;
191 } else {
192 s->pkt_first = p;
193 }
194 s->pkt_last = p;
195
196 /* make sure we are notified when we can drain the queue */
197 fdevent_add(&s->fde, FDE_WRITE);
198
199 return 1; /* not ready (backlog) */
200}
201
202static void local_socket_ready(asocket *s)
203{
Nanik Tolaramb627a0e2015-02-18 22:53:37 +1100204 /* far side is ready for data, pay attention to
205 readable events */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800206 fdevent_add(&s->fde, FDE_READ);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800207}
208
209static void local_socket_close(asocket *s)
210{
211 adb_mutex_lock(&socket_list_lock);
212 local_socket_close_locked(s);
213 adb_mutex_unlock(&socket_list_lock);
214}
215
216// be sure to hold the socket list lock when calling this
217static void local_socket_destroy(asocket *s)
218{
219 apacket *p, *n;
Benoit Gobyf366b362012-03-16 14:50:07 -0700220 int exit_on_close = s->exit_on_close;
221
JP Abgrall408fa572011-03-16 15:57:42 -0700222 D("LS(%d): destroying fde.fd=%d\n", s->id, s->fde.fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800223
224 /* IMPORTANT: the remove closes the fd
225 ** that belongs to this socket
226 */
227 fdevent_remove(&s->fde);
228
229 /* dispose of any unwritten data */
230 for(p = s->pkt_first; p; p = n) {
231 D("LS(%d): discarding %d bytes\n", s->id, p->len);
232 n = p->next;
233 put_apacket(p);
234 }
235 remove_socket(s);
236 free(s);
Benoit Gobyf366b362012-03-16 14:50:07 -0700237
238 if (exit_on_close) {
239 D("local_socket_destroy: exiting\n");
240 exit(1);
241 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800242}
243
244
245static void local_socket_close_locked(asocket *s)
246{
Nanik Tolaramb627a0e2015-02-18 22:53:37 +1100247 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 -0800248 if(s->peer) {
JP Abgrall408fa572011-03-16 15:57:42 -0700249 D("LS(%d): closing peer. peer->id=%d peer->fd=%d\n",
250 s->id, s->peer->id, s->peer->fd);
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100251 /* Note: it's important to call shutdown before disconnecting from
252 * the peer, this ensures that remote sockets can still get the id
253 * of the local socket they're connected to, to send a CLOSE()
254 * protocol event. */
255 if (s->peer->shutdown)
256 s->peer->shutdown(s->peer);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800257 s->peer->peer = 0;
258 // tweak to avoid deadlock
Tom Marlin49f18572011-05-13 13:24:55 -0500259 if (s->peer->close == local_socket_close) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800260 local_socket_close_locked(s->peer);
Tom Marlin49f18572011-05-13 13:24:55 -0500261 } else {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800262 s->peer->close(s->peer);
Tom Marlin49f18572011-05-13 13:24:55 -0500263 }
264 s->peer = 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800265 }
266
267 /* If we are already closing, or if there are no
268 ** pending packets, destroy immediately
269 */
270 if (s->closing || s->pkt_first == NULL) {
271 int id = s->id;
272 local_socket_destroy(s);
273 D("LS(%d): closed\n", id);
274 return;
275 }
276
277 /* otherwise, put on the closing list
278 */
279 D("LS(%d): closing\n", s->id);
280 s->closing = 1;
281 fdevent_del(&s->fde, FDE_READ);
282 remove_socket(s);
JP Abgrall408fa572011-03-16 15:57:42 -0700283 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 -0800284 insert_local_socket(s, &local_socket_closing_list);
285}
286
Dan Albertbac34742015-02-25 17:51:28 -0800287static void local_socket_event_func(int fd, unsigned ev, void* _s)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800288{
Dan Albertbac34742015-02-25 17:51:28 -0800289 asocket* s = reinterpret_cast<asocket*>(_s);
JP Abgrall408fa572011-03-16 15:57:42 -0700290 D("LS(%d): event_func(fd=%d(==%d), ev=%04x)\n", s->id, s->fd, fd, ev);
291
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800292 /* put the FDE_WRITE processing before the FDE_READ
293 ** in order to simplify the code.
294 */
Dan Albertbac34742015-02-25 17:51:28 -0800295 if (ev & FDE_WRITE) {
296 apacket* p;
297 while ((p = s->pkt_first) != nullptr) {
298 while (p->len > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800299 int r = adb_write(fd, p->ptr, p->len);
Dan Albertbac34742015-02-25 17:51:28 -0800300 if (r == -1) {
301 /* returning here is ok because FDE_READ will
302 ** be processed in the next iteration loop
303 */
304 if (errno == EAGAIN) {
305 return;
306 }
307 } else if (r > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800308 p->ptr += r;
309 p->len -= r;
310 continue;
311 }
Dan Albertbac34742015-02-25 17:51:28 -0800312
Christopher Tate5b811fa2011-06-10 11:38:37 -0700313 D(" closing after write because r=%d and errno is %d\n", r, errno);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800314 s->close(s);
315 return;
316 }
317
Dan Albertbac34742015-02-25 17:51:28 -0800318 if (p->len == 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800319 s->pkt_first = p->next;
Dan Albertbac34742015-02-25 17:51:28 -0800320 if (s->pkt_first == 0) {
321 s->pkt_last = 0;
322 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800323 put_apacket(p);
324 }
325 }
326
Dan Albertbac34742015-02-25 17:51:28 -0800327 /* if we sent the last packet of a closing socket,
328 ** we can now destroy it.
329 */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800330 if (s->closing) {
Christopher Tate5b811fa2011-06-10 11:38:37 -0700331 D(" closing because 'closing' is set after write\n");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800332 s->close(s);
333 return;
334 }
335
Dan Albertbac34742015-02-25 17:51:28 -0800336 /* no more packets queued, so we can ignore
337 ** writable events again and tell our peer
338 ** to resume writing
339 */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800340 fdevent_del(&s->fde, FDE_WRITE);
341 s->peer->ready(s->peer);
342 }
343
344
Dan Albertbac34742015-02-25 17:51:28 -0800345 if (ev & FDE_READ) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800346 apacket *p = get_apacket();
347 unsigned char *x = p->data;
348 size_t avail = MAX_PAYLOAD;
349 int r;
350 int is_eof = 0;
351
Dan Albertbac34742015-02-25 17:51:28 -0800352 while (avail > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800353 r = adb_read(fd, x, avail);
Dan Albertbac34742015-02-25 17:51:28 -0800354 D("LS(%d): post adb_read(fd=%d,...) r=%d (errno=%d) avail=%zu\n",
355 s->id, s->fd, r, r < 0 ? errno : 0, avail);
356 if (r == -1) {
357 if (errno == EAGAIN) {
358 break;
359 }
360 } else if (r > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800361 avail -= r;
362 x += r;
363 continue;
364 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800365
Dan Albertbac34742015-02-25 17:51:28 -0800366 /* r = 0 or unhandled error */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800367 is_eof = 1;
368 break;
369 }
JP Abgrall408fa572011-03-16 15:57:42 -0700370 D("LS(%d): fd=%d post avail loop. r=%d is_eof=%d forced_eof=%d\n",
371 s->id, s->fd, r, is_eof, s->fde.force_eof);
Dan Albertbac34742015-02-25 17:51:28 -0800372 if ((avail == MAX_PAYLOAD) || (s->peer == 0)) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800373 put_apacket(p);
374 } else {
375 p->len = MAX_PAYLOAD - avail;
376
377 r = s->peer->enqueue(s->peer, p);
Dan Albertbac34742015-02-25 17:51:28 -0800378 D("LS(%d): fd=%d post peer->enqueue(). r=%d\n", s->id, s->fd,
379 r);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800380
Dan Albertbac34742015-02-25 17:51:28 -0800381 if (r < 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800382 /* error return means they closed us as a side-effect
383 ** and we must return immediately.
384 **
385 ** note that if we still have buffered packets, the
386 ** socket will be placed on the closing socket list.
387 ** this handler function will be called again
388 ** to process FDE_WRITE events.
389 */
390 return;
391 }
392
Dan Albertbac34742015-02-25 17:51:28 -0800393 if (r > 0) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800394 /* if the remote cannot accept further events,
395 ** we disable notification of READs. They'll
396 ** be enabled again when we get a call to ready()
397 */
398 fdevent_del(&s->fde, FDE_READ);
399 }
400 }
JP Abgrall112445b2011-04-12 22:01:58 -0700401 /* Don't allow a forced eof if data is still there */
Dan Albertbac34742015-02-25 17:51:28 -0800402 if ((s->fde.force_eof && !r) || is_eof) {
403 D(" closing because is_eof=%d r=%d s->fde.force_eof=%d\n",
404 is_eof, r, s->fde.force_eof);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800405 s->close(s);
406 }
407 }
408
Dan Albertbac34742015-02-25 17:51:28 -0800409 if (ev & FDE_ERROR){
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800410 /* this should be caught be the next read or write
411 ** catching it here means we may skip the last few
412 ** bytes of readable data.
413 */
JP Abgrall408fa572011-03-16 15:57:42 -0700414 D("LS(%d): FDE_ERROR (fd=%d)\n", s->id, s->fd);
415
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800416 return;
417 }
418}
419
420asocket *create_local_socket(int fd)
421{
Dan Albertbac34742015-02-25 17:51:28 -0800422 asocket *s = reinterpret_cast<asocket*>(calloc(1, sizeof(asocket)));
André Goddard Rosac419e2a2010-06-10 20:48:19 -0300423 if (s == NULL) fatal("cannot allocate socket");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800424 s->fd = fd;
425 s->enqueue = local_socket_enqueue;
426 s->ready = local_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100427 s->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800428 s->close = local_socket_close;
JP Abgrall408fa572011-03-16 15:57:42 -0700429 install_local_socket(s);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800430
431 fdevent_install(&s->fde, fd, local_socket_event_func, s);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800432 D("LS(%d): created (fd=%d)\n", s->id, s->fd);
433 return s;
434}
435
436asocket *create_local_service_socket(const char *name)
437{
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800438#if !ADB_HOST
439 if (!strcmp(name,"jdwp")) {
440 return create_jdwp_service_socket();
441 }
442 if (!strcmp(name,"track-jdwp")) {
443 return create_jdwp_tracker_service_socket();
444 }
445#endif
Dan Pasanen98858812014-10-06 12:57:20 -0500446 int fd = service_to_fd(name);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800447 if(fd < 0) return 0;
448
Dan Pasanen98858812014-10-06 12:57:20 -0500449 asocket* s = create_local_socket(fd);
JP Abgrall408fa572011-03-16 15:57:42 -0700450 D("LS(%d): bound to '%s' via %d\n", s->id, name, fd);
Benoit Gobyf366b362012-03-16 14:50:07 -0700451
JP Abgrallf91259a2012-03-30 13:19:11 -0700452#if !ADB_HOST
Dan Pasanen98858812014-10-06 12:57:20 -0500453 char debug[PROPERTY_VALUE_MAX];
jzhuan51297d222013-05-24 17:40:15 -0400454 if (!strncmp(name, "root:", 5))
455 property_get("ro.debuggable", debug, "");
456
Dan Pasanen98858812014-10-06 12:57:20 -0500457 if ((!strncmp(name, "root:", 5) && getuid() != 0 && strcmp(debug, "1") == 0)
458 || (!strncmp(name, "unroot:", 7) && getuid() == 0)
Benoit Gobyaeceb512012-06-12 12:12:18 -0700459 || !strncmp(name, "usb:", 4)
460 || !strncmp(name, "tcpip:", 6)) {
Benoit Gobyf366b362012-03-16 14:50:07 -0700461 D("LS(%d): enabling exit_on_close\n", s->id);
462 s->exit_on_close = 1;
463 }
JP Abgrallf91259a2012-03-30 13:19:11 -0700464#endif
Benoit Gobyf366b362012-03-16 14:50:07 -0700465
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800466 return s;
467}
468
469#if ADB_HOST
470static asocket *create_host_service_socket(const char *name, const char* serial)
471{
472 asocket *s;
473
474 s = host_service_to_socket(name, serial);
475
476 if (s != NULL) {
477 D("LS(%d) bound to '%s'\n", s->id, name);
478 return s;
479 }
480
481 return s;
482}
483#endif /* ADB_HOST */
484
485/* a Remote socket is used to send/receive data to/from a given transport object
486** it needs to be closed when the transport is forcibly destroyed by the user
487*/
488typedef struct aremotesocket {
489 asocket socket;
490 adisconnect disconnect;
491} aremotesocket;
492
493static int remote_socket_enqueue(asocket *s, apacket *p)
494{
JP Abgrall408fa572011-03-16 15:57:42 -0700495 D("entered remote_socket_enqueue RS(%d) WRITE fd=%d peer.fd=%d\n",
496 s->id, s->fd, s->peer->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800497 p->msg.command = A_WRTE;
498 p->msg.arg0 = s->peer->id;
499 p->msg.arg1 = s->id;
500 p->msg.data_length = p->len;
501 send_packet(p, s->transport);
502 return 1;
503}
504
505static void remote_socket_ready(asocket *s)
506{
JP Abgrall408fa572011-03-16 15:57:42 -0700507 D("entered remote_socket_ready RS(%d) OKAY fd=%d peer.fd=%d\n",
508 s->id, s->fd, s->peer->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800509 apacket *p = get_apacket();
510 p->msg.command = A_OKAY;
511 p->msg.arg0 = s->peer->id;
512 p->msg.arg1 = s->id;
513 send_packet(p, s->transport);
514}
515
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100516static void remote_socket_shutdown(asocket *s)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800517{
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100518 D("entered remote_socket_shutdown RS(%d) CLOSE fd=%d peer->fd=%d\n",
JP Abgrall408fa572011-03-16 15:57:42 -0700519 s->id, s->fd, s->peer?s->peer->fd:-1);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800520 apacket *p = get_apacket();
521 p->msg.command = A_CLSE;
522 if(s->peer) {
523 p->msg.arg0 = s->peer->id;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100524 }
525 p->msg.arg1 = s->id;
526 send_packet(p, s->transport);
527}
528
529static void remote_socket_close(asocket *s)
530{
531 if (s->peer) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800532 s->peer->peer = 0;
JP Abgrall408fa572011-03-16 15:57:42 -0700533 D("RS(%d) peer->close()ing peer->id=%d peer->fd=%d\n",
534 s->id, s->peer->id, s->peer->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800535 s->peer->close(s->peer);
536 }
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100537 D("entered remote_socket_close RS(%d) CLOSE fd=%d peer->fd=%d\n",
538 s->id, s->fd, s->peer?s->peer->fd:-1);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800539 D("RS(%d): closed\n", s->id);
540 remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect );
541 free(s);
542}
543
544static void remote_socket_disconnect(void* _s, atransport* t)
545{
Dan Albertbac34742015-02-25 17:51:28 -0800546 asocket* s = reinterpret_cast<asocket*>(_s);
547 asocket* peer = s->peer;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800548
549 D("remote_socket_disconnect RS(%d)\n", s->id);
550 if (peer) {
551 peer->peer = NULL;
552 peer->close(peer);
553 }
554 remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect );
555 free(s);
556}
557
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100558/* Create an asocket to exchange packets with a remote service through transport
559 |t|. Where |id| is the socket id of the corresponding service on the other
560 side of the transport (it is allocated by the remote side and _cannot_ be 0).
561 Returns a new non-NULL asocket handle. */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800562asocket *create_remote_socket(unsigned id, atransport *t)
563{
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100564 if (id == 0) fatal("invalid remote socket id (0)");
Dan Albertbac34742015-02-25 17:51:28 -0800565 asocket* s = reinterpret_cast<asocket*>(calloc(1, sizeof(aremotesocket)));
566 adisconnect* dis = &reinterpret_cast<aremotesocket*>(s)->disconnect;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800567
André Goddard Rosac419e2a2010-06-10 20:48:19 -0300568 if (s == NULL) fatal("cannot allocate socket");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800569 s->id = id;
570 s->enqueue = remote_socket_enqueue;
571 s->ready = remote_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100572 s->shutdown = remote_socket_shutdown;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800573 s->close = remote_socket_close;
574 s->transport = t;
575
576 dis->func = remote_socket_disconnect;
577 dis->opaque = s;
578 add_transport_disconnect( t, dis );
579 D("RS(%d): created\n", s->id);
580 return s;
581}
582
583void connect_to_remote(asocket *s, const char *destination)
584{
JP Abgrall408fa572011-03-16 15:57:42 -0700585 D("Connect_to_remote call RS(%d) fd=%d\n", s->id, s->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800586 apacket *p = get_apacket();
587 int len = strlen(destination) + 1;
588
589 if(len > (MAX_PAYLOAD-1)) {
590 fatal("destination oversized");
591 }
592
593 D("LS(%d): connect('%s')\n", s->id, destination);
594 p->msg.command = A_OPEN;
595 p->msg.arg0 = s->id;
596 p->msg.data_length = len;
597 strcpy((char*) p->data, destination);
598 send_packet(p, s->transport);
599}
600
601
602/* this is used by magic sockets to rig local sockets to
603 send the go-ahead message when they connect */
604static void local_socket_ready_notify(asocket *s)
605{
606 s->ready = local_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100607 s->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800608 s->close = local_socket_close;
609 adb_write(s->fd, "OKAY", 4);
610 s->ready(s);
611}
612
613/* this is used by magic sockets to rig local sockets to
614 send the failure message if they are closed before
615 connected (to avoid closing them without a status message) */
616static void local_socket_close_notify(asocket *s)
617{
618 s->ready = local_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100619 s->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800620 s->close = local_socket_close;
621 sendfailmsg(s->fd, "closed");
622 s->close(s);
623}
624
625unsigned unhex(unsigned char *s, int len)
626{
627 unsigned n = 0, c;
628
629 while(len-- > 0) {
630 switch((c = *s++)) {
631 case '0': case '1': case '2':
632 case '3': case '4': case '5':
633 case '6': case '7': case '8':
634 case '9':
635 c -= '0';
636 break;
637 case 'a': case 'b': case 'c':
638 case 'd': case 'e': case 'f':
639 c = c - 'a' + 10;
640 break;
641 case 'A': case 'B': case 'C':
642 case 'D': case 'E': case 'F':
643 c = c - 'A' + 10;
644 break;
645 default:
646 return 0xffffffff;
647 }
648
649 n = (n << 4) | c;
650 }
651
652 return n;
653}
654
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700655#define PREFIX(str) { str, sizeof(str) - 1 }
656static const struct prefix_struct {
657 const char *str;
658 const size_t len;
659} prefixes[] = {
660 PREFIX("usb:"),
661 PREFIX("product:"),
662 PREFIX("model:"),
663 PREFIX("device:"),
664};
665static const int num_prefixes = (sizeof(prefixes) / sizeof(prefixes[0]));
666
Terence Haddock28e13902011-03-16 09:43:56 +0100667/* skip_host_serial return the position in a string
668 skipping over the 'serial' parameter in the ADB protocol,
669 where parameter string may be a host:port string containing
670 the protocol delimiter (colon). */
671char *skip_host_serial(char *service) {
672 char *first_colon, *serial_end;
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700673 int i;
Terence Haddock28e13902011-03-16 09:43:56 +0100674
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700675 for (i = 0; i < num_prefixes; i++) {
676 if (!strncmp(service, prefixes[i].str, prefixes[i].len))
677 return strchr(service + prefixes[i].len, ':');
Scott Anderson3608d832012-05-31 12:04:23 -0700678 }
679
Terence Haddock28e13902011-03-16 09:43:56 +0100680 first_colon = strchr(service, ':');
681 if (!first_colon) {
682 /* No colon in service string. */
683 return NULL;
684 }
685 serial_end = first_colon;
686 if (isdigit(serial_end[1])) {
687 serial_end++;
688 while ((*serial_end) && isdigit(*serial_end)) {
689 serial_end++;
690 }
691 if ((*serial_end) != ':') {
692 // Something other than numbers was found, reset the end.
693 serial_end = first_colon;
694 }
695 }
696 return serial_end;
697}
698
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800699static int smart_socket_enqueue(asocket *s, apacket *p)
700{
701 unsigned len;
702#if ADB_HOST
703 char *service = NULL;
704 char* serial = NULL;
705 transport_type ttype = kTransportAny;
706#endif
707
708 D("SS(%d): enqueue %d\n", s->id, p->len);
709
710 if(s->pkt_first == 0) {
711 s->pkt_first = p;
712 s->pkt_last = p;
713 } else {
714 if((s->pkt_first->len + p->len) > MAX_PAYLOAD) {
715 D("SS(%d): overflow\n", s->id);
716 put_apacket(p);
717 goto fail;
718 }
719
720 memcpy(s->pkt_first->data + s->pkt_first->len,
721 p->data, p->len);
722 s->pkt_first->len += p->len;
723 put_apacket(p);
724
725 p = s->pkt_first;
726 }
727
728 /* don't bother if we can't decode the length */
729 if(p->len < 4) return 0;
730
731 len = unhex(p->data, 4);
732 if((len < 1) || (len > 1024)) {
733 D("SS(%d): bad size (%d)\n", s->id, len);
734 goto fail;
735 }
736
737 D("SS(%d): len is %d\n", s->id, len );
738 /* can't do anything until we have the full header */
739 if((len + 4) > p->len) {
740 D("SS(%d): waiting for %d more bytes\n", s->id, len+4 - p->len);
741 return 0;
742 }
743
744 p->data[len + 4] = 0;
745
746 D("SS(%d): '%s'\n", s->id, (char*) (p->data + 4));
747
748#if ADB_HOST
749 service = (char *)p->data + 4;
750 if(!strncmp(service, "host-serial:", strlen("host-serial:"))) {
751 char* serial_end;
752 service += strlen("host-serial:");
753
Terence Haddock28e13902011-03-16 09:43:56 +0100754 // serial number should follow "host:" and could be a host:port string.
755 serial_end = skip_host_serial(service);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800756 if (serial_end) {
757 *serial_end = 0; // terminate string
758 serial = service;
759 service = serial_end + 1;
760 }
761 } else if (!strncmp(service, "host-usb:", strlen("host-usb:"))) {
762 ttype = kTransportUsb;
763 service += strlen("host-usb:");
764 } else if (!strncmp(service, "host-local:", strlen("host-local:"))) {
765 ttype = kTransportLocal;
766 service += strlen("host-local:");
767 } else if (!strncmp(service, "host:", strlen("host:"))) {
768 ttype = kTransportAny;
769 service += strlen("host:");
770 } else {
771 service = NULL;
772 }
773
774 if (service) {
775 asocket *s2;
776
777 /* some requests are handled immediately -- in that
778 ** case the handle_host_request() routine has sent
779 ** the OKAY or FAIL message and all we have to do
780 ** is clean up.
781 */
782 if(handle_host_request(service, ttype, serial, s->peer->fd, s) == 0) {
783 /* XXX fail message? */
784 D( "SS(%d): handled host service '%s'\n", s->id, service );
785 goto fail;
786 }
787 if (!strncmp(service, "transport", strlen("transport"))) {
788 D( "SS(%d): okay transport\n", s->id );
789 p->len = 0;
790 return 0;
791 }
792
793 /* try to find a local service with this name.
794 ** if no such service exists, we'll fail out
795 ** and tear down here.
796 */
797 s2 = create_host_service_socket(service, serial);
798 if(s2 == 0) {
799 D( "SS(%d): couldn't create host service '%s'\n", s->id, service );
800 sendfailmsg(s->peer->fd, "unknown host service");
801 goto fail;
802 }
803
804 /* we've connected to a local host service,
805 ** so we make our peer back into a regular
806 ** local socket and bind it to the new local
807 ** service socket, acknowledge the successful
808 ** connection, and close this smart socket now
809 ** that its work is done.
810 */
811 adb_write(s->peer->fd, "OKAY", 4);
812
813 s->peer->ready = local_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100814 s->peer->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800815 s->peer->close = local_socket_close;
816 s->peer->peer = s2;
817 s2->peer = s->peer;
818 s->peer = 0;
819 D( "SS(%d): okay\n", s->id );
820 s->close(s);
821
822 /* initial state is "ready" */
823 s2->ready(s2);
824 return 0;
825 }
826#else /* !ADB_HOST */
827 if (s->transport == NULL) {
Dan Albertbac34742015-02-25 17:51:28 -0800828 const char* error_string = "unknown failure";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800829 s->transport = acquire_one_transport (CS_ANY,
830 kTransportAny, NULL, &error_string);
831
832 if (s->transport == NULL) {
833 sendfailmsg(s->peer->fd, error_string);
834 goto fail;
835 }
836 }
837#endif
838
839 if(!(s->transport) || (s->transport->connection_state == CS_OFFLINE)) {
840 /* if there's no remote we fail the connection
841 ** right here and terminate it
842 */
843 sendfailmsg(s->peer->fd, "device offline (x)");
844 goto fail;
845 }
846
847
848 /* instrument our peer to pass the success or fail
849 ** message back once it connects or closes, then
850 ** detach from it, request the connection, and
851 ** tear down
852 */
853 s->peer->ready = local_socket_ready_notify;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100854 s->peer->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800855 s->peer->close = local_socket_close_notify;
856 s->peer->peer = 0;
857 /* give him our transport and upref it */
858 s->peer->transport = s->transport;
859
860 connect_to_remote(s->peer, (char*) (p->data + 4));
861 s->peer = 0;
862 s->close(s);
863 return 1;
864
865fail:
866 /* we're going to close our peer as a side-effect, so
867 ** return -1 to signal that state to the local socket
868 ** who is enqueueing against us
869 */
870 s->close(s);
871 return -1;
872}
873
874static void smart_socket_ready(asocket *s)
875{
876 D("SS(%d): ready\n", s->id);
877}
878
879static void smart_socket_close(asocket *s)
880{
881 D("SS(%d): closed\n", s->id);
882 if(s->pkt_first){
883 put_apacket(s->pkt_first);
884 }
885 if(s->peer) {
886 s->peer->peer = 0;
887 s->peer->close(s->peer);
Tom Marlin49f18572011-05-13 13:24:55 -0500888 s->peer = 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800889 }
890 free(s);
891}
892
Benoit Goby9470c2f2013-02-20 15:04:53 -0800893static asocket *create_smart_socket(void)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800894{
895 D("Creating smart socket \n");
Dan Albertbac34742015-02-25 17:51:28 -0800896 asocket *s = reinterpret_cast<asocket*>(calloc(1, sizeof(asocket)));
André Goddard Rosac419e2a2010-06-10 20:48:19 -0300897 if (s == NULL) fatal("cannot allocate socket");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800898 s->enqueue = smart_socket_enqueue;
899 s->ready = smart_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100900 s->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800901 s->close = smart_socket_close;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800902
Benoit Goby9470c2f2013-02-20 15:04:53 -0800903 D("SS(%d)\n", s->id);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800904 return s;
905}
906
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800907void connect_to_smartsocket(asocket *s)
908{
909 D("Connecting to smart socket \n");
Benoit Goby9470c2f2013-02-20 15:04:53 -0800910 asocket *ss = create_smart_socket();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800911 s->peer = ss;
912 ss->peer = s;
913 s->ready(s);
914}