blob: 6cdde978ea7390672c50cebfa317683e7ccd648b [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
17#include <stdio.h>
18#include <stdlib.h>
19#include <unistd.h>
20#include <errno.h>
21#include <string.h>
22#include <ctype.h>
23
24#include "sysdeps.h"
25
jzhuan51297d222013-05-24 17:40:15 -040026#if !ADB_HOST
27#include <cutils/properties.h>
28#endif
29
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080030#define TRACE_TAG TRACE_SOCKETS
31#include "adb.h"
32
33ADB_MUTEX_DEFINE( socket_list_lock );
34
35static void local_socket_close_locked(asocket *s);
36
37int sendfailmsg(int fd, const char *reason)
38{
39 char buf[9];
40 int len;
41 len = strlen(reason);
42 if(len > 0xffff) len = 0xffff;
43 snprintf(buf, sizeof buf, "FAIL%04x", len);
44 if(writex(fd, buf, 8)) return -1;
45 return writex(fd, reason, len);
46}
47
48//extern int online;
49
50static unsigned local_socket_next_id = 1;
51
52static asocket local_socket_list = {
53 .next = &local_socket_list,
54 .prev = &local_socket_list,
55};
56
57/* the the list of currently closing local sockets.
58** these have no peer anymore, but still packets to
59** write to their fd.
60*/
61static asocket local_socket_closing_list = {
62 .next = &local_socket_closing_list,
63 .prev = &local_socket_closing_list,
64};
65
David 'Digit' Turner818d6412013-12-13 14:09:44 +010066// Parse the global list of sockets to find one with id |local_id|.
67// If |peer_id| is not 0, also check that it is connected to a peer
68// with id |peer_id|. Returns an asocket handle on success, NULL on failure.
69asocket *find_local_socket(unsigned local_id, unsigned peer_id)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080070{
71 asocket *s;
72 asocket *result = NULL;
73
74 adb_mutex_lock(&socket_list_lock);
André Goddard Rosa81828292010-06-12 11:40:20 -030075 for (s = local_socket_list.next; s != &local_socket_list; s = s->next) {
David 'Digit' Turner818d6412013-12-13 14:09:44 +010076 if (s->id != local_id)
77 continue;
78 if (peer_id == 0 || (s->peer && s->peer->id == peer_id)) {
André Goddard Rosa81828292010-06-12 11:40:20 -030079 result = s;
André Goddard Rosa81828292010-06-12 11:40:20 -030080 }
David 'Digit' Turner818d6412013-12-13 14:09:44 +010081 break;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080082 }
83 adb_mutex_unlock(&socket_list_lock);
84
85 return result;
86}
87
88static void
89insert_local_socket(asocket* s, asocket* list)
90{
91 s->next = list;
92 s->prev = s->next->prev;
93 s->prev->next = s;
94 s->next->prev = s;
95}
96
97
98void install_local_socket(asocket *s)
99{
100 adb_mutex_lock(&socket_list_lock);
101
102 s->id = local_socket_next_id++;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100103
104 // Socket ids should never be 0.
105 if (local_socket_next_id == 0)
106 local_socket_next_id = 1;
107
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800108 insert_local_socket(s, &local_socket_list);
109
110 adb_mutex_unlock(&socket_list_lock);
111}
112
113void remove_socket(asocket *s)
114{
115 // socket_list_lock should already be held
116 if (s->prev && s->next)
117 {
118 s->prev->next = s->next;
119 s->next->prev = s->prev;
120 s->next = 0;
121 s->prev = 0;
122 s->id = 0;
123 }
124}
125
126void close_all_sockets(atransport *t)
127{
128 asocket *s;
129
130 /* this is a little gross, but since s->close() *will* modify
131 ** the list out from under you, your options are limited.
132 */
133 adb_mutex_lock(&socket_list_lock);
134restart:
135 for(s = local_socket_list.next; s != &local_socket_list; s = s->next){
136 if(s->transport == t || (s->peer && s->peer->transport == t)) {
137 local_socket_close_locked(s);
138 goto restart;
139 }
140 }
141 adb_mutex_unlock(&socket_list_lock);
142}
143
144static int local_socket_enqueue(asocket *s, apacket *p)
145{
146 D("LS(%d): enqueue %d\n", s->id, p->len);
147
148 p->ptr = p->data;
149
150 /* if there is already data queue'd, we will receive
151 ** events when it's time to write. just add this to
152 ** the tail
153 */
154 if(s->pkt_first) {
155 goto enqueue;
156 }
157
158 /* write as much as we can, until we
159 ** would block or there is an error/eof
160 */
161 while(p->len > 0) {
162 int r = adb_write(s->fd, p->ptr, p->len);
163 if(r > 0) {
164 p->len -= r;
165 p->ptr += r;
166 continue;
167 }
168 if((r == 0) || (errno != EAGAIN)) {
169 D( "LS(%d): not ready, errno=%d: %s\n", s->id, errno, strerror(errno) );
170 s->close(s);
171 return 1; /* not ready (error) */
172 } else {
173 break;
174 }
175 }
176
177 if(p->len == 0) {
178 put_apacket(p);
179 return 0; /* ready for more data */
180 }
181
182enqueue:
183 p->next = 0;
184 if(s->pkt_first) {
185 s->pkt_last->next = p;
186 } else {
187 s->pkt_first = p;
188 }
189 s->pkt_last = p;
190
191 /* make sure we are notified when we can drain the queue */
192 fdevent_add(&s->fde, FDE_WRITE);
193
194 return 1; /* not ready (backlog) */
195}
196
197static void local_socket_ready(asocket *s)
198{
199 /* far side is ready for data, pay attention to
200 readable events */
201 fdevent_add(&s->fde, FDE_READ);
202// D("LS(%d): ready()\n", s->id);
203}
204
205static void local_socket_close(asocket *s)
206{
207 adb_mutex_lock(&socket_list_lock);
208 local_socket_close_locked(s);
209 adb_mutex_unlock(&socket_list_lock);
210}
211
212// be sure to hold the socket list lock when calling this
213static void local_socket_destroy(asocket *s)
214{
215 apacket *p, *n;
Benoit Gobyf366b362012-03-16 14:50:07 -0700216 int exit_on_close = s->exit_on_close;
217
JP Abgrall408fa572011-03-16 15:57:42 -0700218 D("LS(%d): destroying fde.fd=%d\n", s->id, s->fde.fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800219
220 /* IMPORTANT: the remove closes the fd
221 ** that belongs to this socket
222 */
223 fdevent_remove(&s->fde);
224
225 /* dispose of any unwritten data */
226 for(p = s->pkt_first; p; p = n) {
227 D("LS(%d): discarding %d bytes\n", s->id, p->len);
228 n = p->next;
229 put_apacket(p);
230 }
231 remove_socket(s);
232 free(s);
Benoit Gobyf366b362012-03-16 14:50:07 -0700233
234 if (exit_on_close) {
235 D("local_socket_destroy: exiting\n");
236 exit(1);
237 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800238}
239
240
241static void local_socket_close_locked(asocket *s)
242{
JP Abgrall408fa572011-03-16 15:57:42 -0700243 D("entered. LS(%d) fd=%d\n", s->id, s->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800244 if(s->peer) {
JP Abgrall408fa572011-03-16 15:57:42 -0700245 D("LS(%d): closing peer. peer->id=%d peer->fd=%d\n",
246 s->id, s->peer->id, s->peer->fd);
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100247 /* Note: it's important to call shutdown before disconnecting from
248 * the peer, this ensures that remote sockets can still get the id
249 * of the local socket they're connected to, to send a CLOSE()
250 * protocol event. */
251 if (s->peer->shutdown)
252 s->peer->shutdown(s->peer);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800253 s->peer->peer = 0;
254 // tweak to avoid deadlock
Tom Marlin49f18572011-05-13 13:24:55 -0500255 if (s->peer->close == local_socket_close) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800256 local_socket_close_locked(s->peer);
Tom Marlin49f18572011-05-13 13:24:55 -0500257 } else {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800258 s->peer->close(s->peer);
Tom Marlin49f18572011-05-13 13:24:55 -0500259 }
260 s->peer = 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800261 }
262
263 /* If we are already closing, or if there are no
264 ** pending packets, destroy immediately
265 */
266 if (s->closing || s->pkt_first == NULL) {
267 int id = s->id;
268 local_socket_destroy(s);
269 D("LS(%d): closed\n", id);
270 return;
271 }
272
273 /* otherwise, put on the closing list
274 */
275 D("LS(%d): closing\n", s->id);
276 s->closing = 1;
277 fdevent_del(&s->fde, FDE_READ);
278 remove_socket(s);
JP Abgrall408fa572011-03-16 15:57:42 -0700279 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 -0800280 insert_local_socket(s, &local_socket_closing_list);
281}
282
283static void local_socket_event_func(int fd, unsigned ev, void *_s)
284{
285 asocket *s = _s;
286
JP Abgrall408fa572011-03-16 15:57:42 -0700287 D("LS(%d): event_func(fd=%d(==%d), ev=%04x)\n", s->id, s->fd, fd, ev);
288
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800289 /* put the FDE_WRITE processing before the FDE_READ
290 ** in order to simplify the code.
291 */
292 if(ev & FDE_WRITE){
293 apacket *p;
294
295 while((p = s->pkt_first) != 0) {
296 while(p->len > 0) {
297 int r = adb_write(fd, p->ptr, p->len);
298 if(r > 0) {
299 p->ptr += r;
300 p->len -= r;
301 continue;
302 }
303 if(r < 0) {
304 /* returning here is ok because FDE_READ will
305 ** be processed in the next iteration loop
306 */
307 if(errno == EAGAIN) return;
308 if(errno == EINTR) continue;
309 }
Christopher Tate5b811fa2011-06-10 11:38:37 -0700310 D(" closing after write because r=%d and errno is %d\n", r, errno);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800311 s->close(s);
312 return;
313 }
314
315 if(p->len == 0) {
316 s->pkt_first = p->next;
317 if(s->pkt_first == 0) s->pkt_last = 0;
318 put_apacket(p);
319 }
320 }
321
322 /* if we sent the last packet of a closing socket,
323 ** we can now destroy it.
324 */
325 if (s->closing) {
Christopher Tate5b811fa2011-06-10 11:38:37 -0700326 D(" closing because 'closing' is set after write\n");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800327 s->close(s);
328 return;
329 }
330
331 /* no more packets queued, so we can ignore
332 ** writable events again and tell our peer
333 ** to resume writing
334 */
335 fdevent_del(&s->fde, FDE_WRITE);
336 s->peer->ready(s->peer);
337 }
338
339
340 if(ev & FDE_READ){
341 apacket *p = get_apacket();
342 unsigned char *x = p->data;
343 size_t avail = MAX_PAYLOAD;
344 int r;
345 int is_eof = 0;
346
347 while(avail > 0) {
348 r = adb_read(fd, x, avail);
Elliott Hughesccecf142014-01-16 10:53:11 -0800349 D("LS(%d): post adb_read(fd=%d,...) r=%d (errno=%d) avail=%zu\n", s->id, s->fd, r, r<0?errno:0, avail);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800350 if(r > 0) {
351 avail -= r;
352 x += r;
353 continue;
354 }
355 if(r < 0) {
356 if(errno == EAGAIN) break;
357 if(errno == EINTR) continue;
358 }
359
360 /* r = 0 or unhandled error */
361 is_eof = 1;
362 break;
363 }
JP Abgrall408fa572011-03-16 15:57:42 -0700364 D("LS(%d): fd=%d post avail loop. r=%d is_eof=%d forced_eof=%d\n",
365 s->id, s->fd, r, is_eof, s->fde.force_eof);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800366 if((avail == MAX_PAYLOAD) || (s->peer == 0)) {
367 put_apacket(p);
368 } else {
369 p->len = MAX_PAYLOAD - avail;
370
371 r = s->peer->enqueue(s->peer, p);
JP Abgrall408fa572011-03-16 15:57:42 -0700372 D("LS(%d): fd=%d post peer->enqueue(). r=%d\n", s->id, s->fd, r);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800373
374 if(r < 0) {
375 /* error return means they closed us as a side-effect
376 ** and we must return immediately.
377 **
378 ** note that if we still have buffered packets, the
379 ** socket will be placed on the closing socket list.
380 ** this handler function will be called again
381 ** to process FDE_WRITE events.
382 */
383 return;
384 }
385
386 if(r > 0) {
387 /* if the remote cannot accept further events,
388 ** we disable notification of READs. They'll
389 ** be enabled again when we get a call to ready()
390 */
391 fdevent_del(&s->fde, FDE_READ);
392 }
393 }
JP Abgrall112445b2011-04-12 22:01:58 -0700394 /* Don't allow a forced eof if data is still there */
395 if((s->fde.force_eof && !r) || is_eof) {
Christopher Tate5b811fa2011-06-10 11:38:37 -0700396 D(" closing because is_eof=%d r=%d s->fde.force_eof=%d\n", is_eof, r, s->fde.force_eof);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800397 s->close(s);
398 }
399 }
400
401 if(ev & FDE_ERROR){
402 /* this should be caught be the next read or write
403 ** catching it here means we may skip the last few
404 ** bytes of readable data.
405 */
406// s->close(s);
JP Abgrall408fa572011-03-16 15:57:42 -0700407 D("LS(%d): FDE_ERROR (fd=%d)\n", s->id, s->fd);
408
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800409 return;
410 }
411}
412
413asocket *create_local_socket(int fd)
414{
415 asocket *s = calloc(1, sizeof(asocket));
André Goddard Rosac419e2a2010-06-10 20:48:19 -0300416 if (s == NULL) fatal("cannot allocate socket");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800417 s->fd = fd;
418 s->enqueue = local_socket_enqueue;
419 s->ready = local_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100420 s->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800421 s->close = local_socket_close;
JP Abgrall408fa572011-03-16 15:57:42 -0700422 install_local_socket(s);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800423
424 fdevent_install(&s->fde, fd, local_socket_event_func, s);
425/* fdevent_add(&s->fde, FDE_ERROR); */
426 //fprintf(stderr, "Created local socket in create_local_socket \n");
427 D("LS(%d): created (fd=%d)\n", s->id, s->fd);
428 return s;
429}
430
431asocket *create_local_service_socket(const char *name)
432{
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800433#if !ADB_HOST
434 if (!strcmp(name,"jdwp")) {
435 return create_jdwp_service_socket();
436 }
437 if (!strcmp(name,"track-jdwp")) {
438 return create_jdwp_tracker_service_socket();
439 }
440#endif
Dan Pasanen98858812014-10-06 12:57:20 -0500441 int fd = service_to_fd(name);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800442 if(fd < 0) return 0;
443
Dan Pasanen98858812014-10-06 12:57:20 -0500444 asocket* s = create_local_socket(fd);
JP Abgrall408fa572011-03-16 15:57:42 -0700445 D("LS(%d): bound to '%s' via %d\n", s->id, name, fd);
Benoit Gobyf366b362012-03-16 14:50:07 -0700446
JP Abgrallf91259a2012-03-30 13:19:11 -0700447#if !ADB_HOST
Dan Pasanen98858812014-10-06 12:57:20 -0500448 char debug[PROPERTY_VALUE_MAX];
jzhuan51297d222013-05-24 17:40:15 -0400449 if (!strncmp(name, "root:", 5))
450 property_get("ro.debuggable", debug, "");
451
Dan Pasanen98858812014-10-06 12:57:20 -0500452 if ((!strncmp(name, "root:", 5) && getuid() != 0 && strcmp(debug, "1") == 0)
453 || (!strncmp(name, "unroot:", 7) && getuid() == 0)
Benoit Gobyaeceb512012-06-12 12:12:18 -0700454 || !strncmp(name, "usb:", 4)
455 || !strncmp(name, "tcpip:", 6)) {
Benoit Gobyf366b362012-03-16 14:50:07 -0700456 D("LS(%d): enabling exit_on_close\n", s->id);
457 s->exit_on_close = 1;
458 }
JP Abgrallf91259a2012-03-30 13:19:11 -0700459#endif
Benoit Gobyf366b362012-03-16 14:50:07 -0700460
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800461 return s;
462}
463
464#if ADB_HOST
465static asocket *create_host_service_socket(const char *name, const char* serial)
466{
467 asocket *s;
468
469 s = host_service_to_socket(name, serial);
470
471 if (s != NULL) {
472 D("LS(%d) bound to '%s'\n", s->id, name);
473 return s;
474 }
475
476 return s;
477}
478#endif /* ADB_HOST */
479
480/* a Remote socket is used to send/receive data to/from a given transport object
481** it needs to be closed when the transport is forcibly destroyed by the user
482*/
483typedef struct aremotesocket {
484 asocket socket;
485 adisconnect disconnect;
486} aremotesocket;
487
488static int remote_socket_enqueue(asocket *s, apacket *p)
489{
JP Abgrall408fa572011-03-16 15:57:42 -0700490 D("entered remote_socket_enqueue RS(%d) WRITE fd=%d peer.fd=%d\n",
491 s->id, s->fd, s->peer->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800492 p->msg.command = A_WRTE;
493 p->msg.arg0 = s->peer->id;
494 p->msg.arg1 = s->id;
495 p->msg.data_length = p->len;
496 send_packet(p, s->transport);
497 return 1;
498}
499
500static void remote_socket_ready(asocket *s)
501{
JP Abgrall408fa572011-03-16 15:57:42 -0700502 D("entered remote_socket_ready RS(%d) OKAY fd=%d peer.fd=%d\n",
503 s->id, s->fd, s->peer->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800504 apacket *p = get_apacket();
505 p->msg.command = A_OKAY;
506 p->msg.arg0 = s->peer->id;
507 p->msg.arg1 = s->id;
508 send_packet(p, s->transport);
509}
510
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100511static void remote_socket_shutdown(asocket *s)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800512{
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100513 D("entered remote_socket_shutdown RS(%d) CLOSE fd=%d peer->fd=%d\n",
JP Abgrall408fa572011-03-16 15:57:42 -0700514 s->id, s->fd, s->peer?s->peer->fd:-1);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800515 apacket *p = get_apacket();
516 p->msg.command = A_CLSE;
517 if(s->peer) {
518 p->msg.arg0 = s->peer->id;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100519 }
520 p->msg.arg1 = s->id;
521 send_packet(p, s->transport);
522}
523
524static void remote_socket_close(asocket *s)
525{
526 if (s->peer) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800527 s->peer->peer = 0;
JP Abgrall408fa572011-03-16 15:57:42 -0700528 D("RS(%d) peer->close()ing peer->id=%d peer->fd=%d\n",
529 s->id, s->peer->id, s->peer->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800530 s->peer->close(s->peer);
531 }
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100532 D("entered remote_socket_close RS(%d) CLOSE fd=%d peer->fd=%d\n",
533 s->id, s->fd, s->peer?s->peer->fd:-1);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800534 D("RS(%d): closed\n", s->id);
535 remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect );
536 free(s);
537}
538
539static void remote_socket_disconnect(void* _s, atransport* t)
540{
541 asocket* s = _s;
542 asocket* peer = s->peer;
543
544 D("remote_socket_disconnect RS(%d)\n", s->id);
545 if (peer) {
546 peer->peer = NULL;
547 peer->close(peer);
548 }
549 remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect );
550 free(s);
551}
552
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100553/* Create an asocket to exchange packets with a remote service through transport
554 |t|. Where |id| is the socket id of the corresponding service on the other
555 side of the transport (it is allocated by the remote side and _cannot_ be 0).
556 Returns a new non-NULL asocket handle. */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800557asocket *create_remote_socket(unsigned id, atransport *t)
558{
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100559 asocket* s;
560 adisconnect* dis;
561
562 if (id == 0) fatal("invalid remote socket id (0)");
563 s = calloc(1, sizeof(aremotesocket));
564 dis = &((aremotesocket*)s)->disconnect;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800565
André Goddard Rosac419e2a2010-06-10 20:48:19 -0300566 if (s == NULL) fatal("cannot allocate socket");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800567 s->id = id;
568 s->enqueue = remote_socket_enqueue;
569 s->ready = remote_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100570 s->shutdown = remote_socket_shutdown;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800571 s->close = remote_socket_close;
572 s->transport = t;
573
574 dis->func = remote_socket_disconnect;
575 dis->opaque = s;
576 add_transport_disconnect( t, dis );
577 D("RS(%d): created\n", s->id);
578 return s;
579}
580
581void connect_to_remote(asocket *s, const char *destination)
582{
JP Abgrall408fa572011-03-16 15:57:42 -0700583 D("Connect_to_remote call RS(%d) fd=%d\n", s->id, s->fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800584 apacket *p = get_apacket();
585 int len = strlen(destination) + 1;
586
587 if(len > (MAX_PAYLOAD-1)) {
588 fatal("destination oversized");
589 }
590
591 D("LS(%d): connect('%s')\n", s->id, destination);
592 p->msg.command = A_OPEN;
593 p->msg.arg0 = s->id;
594 p->msg.data_length = len;
595 strcpy((char*) p->data, destination);
596 send_packet(p, s->transport);
597}
598
599
600/* this is used by magic sockets to rig local sockets to
601 send the go-ahead message when they connect */
602static void local_socket_ready_notify(asocket *s)
603{
604 s->ready = local_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100605 s->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800606 s->close = local_socket_close;
607 adb_write(s->fd, "OKAY", 4);
608 s->ready(s);
609}
610
611/* this is used by magic sockets to rig local sockets to
612 send the failure message if they are closed before
613 connected (to avoid closing them without a status message) */
614static void local_socket_close_notify(asocket *s)
615{
616 s->ready = local_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100617 s->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800618 s->close = local_socket_close;
619 sendfailmsg(s->fd, "closed");
620 s->close(s);
621}
622
623unsigned unhex(unsigned char *s, int len)
624{
625 unsigned n = 0, c;
626
627 while(len-- > 0) {
628 switch((c = *s++)) {
629 case '0': case '1': case '2':
630 case '3': case '4': case '5':
631 case '6': case '7': case '8':
632 case '9':
633 c -= '0';
634 break;
635 case 'a': case 'b': case 'c':
636 case 'd': case 'e': case 'f':
637 c = c - 'a' + 10;
638 break;
639 case 'A': case 'B': case 'C':
640 case 'D': case 'E': case 'F':
641 c = c - 'A' + 10;
642 break;
643 default:
644 return 0xffffffff;
645 }
646
647 n = (n << 4) | c;
648 }
649
650 return n;
651}
652
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700653#define PREFIX(str) { str, sizeof(str) - 1 }
654static const struct prefix_struct {
655 const char *str;
656 const size_t len;
657} prefixes[] = {
658 PREFIX("usb:"),
659 PREFIX("product:"),
660 PREFIX("model:"),
661 PREFIX("device:"),
662};
663static const int num_prefixes = (sizeof(prefixes) / sizeof(prefixes[0]));
664
Terence Haddock28e13902011-03-16 09:43:56 +0100665/* skip_host_serial return the position in a string
666 skipping over the 'serial' parameter in the ADB protocol,
667 where parameter string may be a host:port string containing
668 the protocol delimiter (colon). */
669char *skip_host_serial(char *service) {
670 char *first_colon, *serial_end;
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700671 int i;
Terence Haddock28e13902011-03-16 09:43:56 +0100672
Scott Anderson2ca3e6b2012-05-30 18:11:27 -0700673 for (i = 0; i < num_prefixes; i++) {
674 if (!strncmp(service, prefixes[i].str, prefixes[i].len))
675 return strchr(service + prefixes[i].len, ':');
Scott Anderson3608d832012-05-31 12:04:23 -0700676 }
677
Terence Haddock28e13902011-03-16 09:43:56 +0100678 first_colon = strchr(service, ':');
679 if (!first_colon) {
680 /* No colon in service string. */
681 return NULL;
682 }
683 serial_end = first_colon;
684 if (isdigit(serial_end[1])) {
685 serial_end++;
686 while ((*serial_end) && isdigit(*serial_end)) {
687 serial_end++;
688 }
689 if ((*serial_end) != ':') {
690 // Something other than numbers was found, reset the end.
691 serial_end = first_colon;
692 }
693 }
694 return serial_end;
695}
696
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800697static int smart_socket_enqueue(asocket *s, apacket *p)
698{
699 unsigned len;
700#if ADB_HOST
701 char *service = NULL;
702 char* serial = NULL;
703 transport_type ttype = kTransportAny;
704#endif
705
706 D("SS(%d): enqueue %d\n", s->id, p->len);
707
708 if(s->pkt_first == 0) {
709 s->pkt_first = p;
710 s->pkt_last = p;
711 } else {
712 if((s->pkt_first->len + p->len) > MAX_PAYLOAD) {
713 D("SS(%d): overflow\n", s->id);
714 put_apacket(p);
715 goto fail;
716 }
717
718 memcpy(s->pkt_first->data + s->pkt_first->len,
719 p->data, p->len);
720 s->pkt_first->len += p->len;
721 put_apacket(p);
722
723 p = s->pkt_first;
724 }
725
726 /* don't bother if we can't decode the length */
727 if(p->len < 4) return 0;
728
729 len = unhex(p->data, 4);
730 if((len < 1) || (len > 1024)) {
731 D("SS(%d): bad size (%d)\n", s->id, len);
732 goto fail;
733 }
734
735 D("SS(%d): len is %d\n", s->id, len );
736 /* can't do anything until we have the full header */
737 if((len + 4) > p->len) {
738 D("SS(%d): waiting for %d more bytes\n", s->id, len+4 - p->len);
739 return 0;
740 }
741
742 p->data[len + 4] = 0;
743
744 D("SS(%d): '%s'\n", s->id, (char*) (p->data + 4));
745
746#if ADB_HOST
747 service = (char *)p->data + 4;
748 if(!strncmp(service, "host-serial:", strlen("host-serial:"))) {
749 char* serial_end;
750 service += strlen("host-serial:");
751
Terence Haddock28e13902011-03-16 09:43:56 +0100752 // serial number should follow "host:" and could be a host:port string.
753 serial_end = skip_host_serial(service);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800754 if (serial_end) {
755 *serial_end = 0; // terminate string
756 serial = service;
757 service = serial_end + 1;
758 }
759 } else if (!strncmp(service, "host-usb:", strlen("host-usb:"))) {
760 ttype = kTransportUsb;
761 service += strlen("host-usb:");
762 } else if (!strncmp(service, "host-local:", strlen("host-local:"))) {
763 ttype = kTransportLocal;
764 service += strlen("host-local:");
765 } else if (!strncmp(service, "host:", strlen("host:"))) {
766 ttype = kTransportAny;
767 service += strlen("host:");
768 } else {
769 service = NULL;
770 }
771
772 if (service) {
773 asocket *s2;
774
775 /* some requests are handled immediately -- in that
776 ** case the handle_host_request() routine has sent
777 ** the OKAY or FAIL message and all we have to do
778 ** is clean up.
779 */
780 if(handle_host_request(service, ttype, serial, s->peer->fd, s) == 0) {
781 /* XXX fail message? */
782 D( "SS(%d): handled host service '%s'\n", s->id, service );
783 goto fail;
784 }
785 if (!strncmp(service, "transport", strlen("transport"))) {
786 D( "SS(%d): okay transport\n", s->id );
787 p->len = 0;
788 return 0;
789 }
790
791 /* try to find a local service with this name.
792 ** if no such service exists, we'll fail out
793 ** and tear down here.
794 */
795 s2 = create_host_service_socket(service, serial);
796 if(s2 == 0) {
797 D( "SS(%d): couldn't create host service '%s'\n", s->id, service );
798 sendfailmsg(s->peer->fd, "unknown host service");
799 goto fail;
800 }
801
802 /* we've connected to a local host service,
803 ** so we make our peer back into a regular
804 ** local socket and bind it to the new local
805 ** service socket, acknowledge the successful
806 ** connection, and close this smart socket now
807 ** that its work is done.
808 */
809 adb_write(s->peer->fd, "OKAY", 4);
810
811 s->peer->ready = local_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100812 s->peer->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800813 s->peer->close = local_socket_close;
814 s->peer->peer = s2;
815 s2->peer = s->peer;
816 s->peer = 0;
817 D( "SS(%d): okay\n", s->id );
818 s->close(s);
819
820 /* initial state is "ready" */
821 s2->ready(s2);
822 return 0;
823 }
824#else /* !ADB_HOST */
825 if (s->transport == NULL) {
826 char* error_string = "unknown failure";
827 s->transport = acquire_one_transport (CS_ANY,
828 kTransportAny, NULL, &error_string);
829
830 if (s->transport == NULL) {
831 sendfailmsg(s->peer->fd, error_string);
832 goto fail;
833 }
834 }
835#endif
836
837 if(!(s->transport) || (s->transport->connection_state == CS_OFFLINE)) {
838 /* if there's no remote we fail the connection
839 ** right here and terminate it
840 */
841 sendfailmsg(s->peer->fd, "device offline (x)");
842 goto fail;
843 }
844
845
846 /* instrument our peer to pass the success or fail
847 ** message back once it connects or closes, then
848 ** detach from it, request the connection, and
849 ** tear down
850 */
851 s->peer->ready = local_socket_ready_notify;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100852 s->peer->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800853 s->peer->close = local_socket_close_notify;
854 s->peer->peer = 0;
855 /* give him our transport and upref it */
856 s->peer->transport = s->transport;
857
858 connect_to_remote(s->peer, (char*) (p->data + 4));
859 s->peer = 0;
860 s->close(s);
861 return 1;
862
863fail:
864 /* we're going to close our peer as a side-effect, so
865 ** return -1 to signal that state to the local socket
866 ** who is enqueueing against us
867 */
868 s->close(s);
869 return -1;
870}
871
872static void smart_socket_ready(asocket *s)
873{
874 D("SS(%d): ready\n", s->id);
875}
876
877static void smart_socket_close(asocket *s)
878{
879 D("SS(%d): closed\n", s->id);
880 if(s->pkt_first){
881 put_apacket(s->pkt_first);
882 }
883 if(s->peer) {
884 s->peer->peer = 0;
885 s->peer->close(s->peer);
Tom Marlin49f18572011-05-13 13:24:55 -0500886 s->peer = 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800887 }
888 free(s);
889}
890
Benoit Goby9470c2f2013-02-20 15:04:53 -0800891static asocket *create_smart_socket(void)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800892{
893 D("Creating smart socket \n");
894 asocket *s = calloc(1, sizeof(asocket));
André Goddard Rosac419e2a2010-06-10 20:48:19 -0300895 if (s == NULL) fatal("cannot allocate socket");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800896 s->enqueue = smart_socket_enqueue;
897 s->ready = smart_socket_ready;
David 'Digit' Turner818d6412013-12-13 14:09:44 +0100898 s->shutdown = NULL;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800899 s->close = smart_socket_close;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800900
Benoit Goby9470c2f2013-02-20 15:04:53 -0800901 D("SS(%d)\n", s->id);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800902 return s;
903}
904
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800905void connect_to_smartsocket(asocket *s)
906{
907 D("Connecting to smart socket \n");
Benoit Goby9470c2f2013-02-20 15:04:53 -0800908 asocket *ss = create_smart_socket();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800909 s->peer = ss;
910 ss->peer = s;
911 s->ready(s);
912}