Home | History | Annotate | Download | only in minadbd
      1 /*
      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 
     26 #define  TRACE_TAG  TRACE_SOCKETS
     27 #include "adb.h"
     28 
     29 ADB_MUTEX_DEFINE( socket_list_lock );
     30 
     31 static void local_socket_close_locked(asocket *s);
     32 
     33 int sendfailmsg(int fd, const char *reason)
     34 {
     35     char buf[9];
     36     int len;
     37     len = strlen(reason);
     38     if(len > 0xffff) len = 0xffff;
     39     snprintf(buf, sizeof buf, "FAIL%04x", len);
     40     if(writex(fd, buf, 8)) return -1;
     41     return writex(fd, reason, len);
     42 }
     43 
     44 //extern int online;
     45 
     46 static unsigned local_socket_next_id = 1;
     47 
     48 static asocket local_socket_list = {
     49     .next = &local_socket_list,
     50     .prev = &local_socket_list,
     51 };
     52 
     53 /* the the list of currently closing local sockets.
     54 ** these have no peer anymore, but still packets to
     55 ** write to their fd.
     56 */
     57 static asocket local_socket_closing_list = {
     58     .next = &local_socket_closing_list,
     59     .prev = &local_socket_closing_list,
     60 };
     61 
     62 asocket *find_local_socket(unsigned id)
     63 {
     64     asocket *s;
     65     asocket *result = NULL;
     66 
     67     adb_mutex_lock(&socket_list_lock);
     68     for (s = local_socket_list.next; s != &local_socket_list; s = s->next) {
     69         if (s->id == id) {
     70             result = s;
     71             break;
     72         }
     73     }
     74     adb_mutex_unlock(&socket_list_lock);
     75 
     76     return result;
     77 }
     78 
     79 static void
     80 insert_local_socket(asocket*  s, asocket*  list)
     81 {
     82     s->next       = list;
     83     s->prev       = s->next->prev;
     84     s->prev->next = s;
     85     s->next->prev = s;
     86 }
     87 
     88 
     89 void install_local_socket(asocket *s)
     90 {
     91     adb_mutex_lock(&socket_list_lock);
     92 
     93     s->id = local_socket_next_id++;
     94     insert_local_socket(s, &local_socket_list);
     95 
     96     adb_mutex_unlock(&socket_list_lock);
     97 }
     98 
     99 void remove_socket(asocket *s)
    100 {
    101     // socket_list_lock should already be held
    102     if (s->prev && s->next)
    103     {
    104         s->prev->next = s->next;
    105         s->next->prev = s->prev;
    106         s->next = 0;
    107         s->prev = 0;
    108         s->id = 0;
    109     }
    110 }
    111 
    112 void close_all_sockets(atransport *t)
    113 {
    114     asocket *s;
    115 
    116         /* this is a little gross, but since s->close() *will* modify
    117         ** the list out from under you, your options are limited.
    118         */
    119     adb_mutex_lock(&socket_list_lock);
    120 restart:
    121     for(s = local_socket_list.next; s != &local_socket_list; s = s->next){
    122         if(s->transport == t || (s->peer && s->peer->transport == t)) {
    123             local_socket_close_locked(s);
    124             goto restart;
    125         }
    126     }
    127     adb_mutex_unlock(&socket_list_lock);
    128 }
    129 
    130 static int local_socket_enqueue(asocket *s, apacket *p)
    131 {
    132     D("LS(%d): enqueue %d\n", s->id, p->len);
    133 
    134     p->ptr = p->data;
    135 
    136         /* if there is already data queue'd, we will receive
    137         ** events when it's time to write.  just add this to
    138         ** the tail
    139         */
    140     if(s->pkt_first) {
    141         goto enqueue;
    142     }
    143 
    144         /* write as much as we can, until we
    145         ** would block or there is an error/eof
    146         */
    147     while(p->len > 0) {
    148         int r = adb_write(s->fd, p->ptr, p->len);
    149         if(r > 0) {
    150             p->len -= r;
    151             p->ptr += r;
    152             continue;
    153         }
    154         if((r == 0) || (errno != EAGAIN)) {
    155             D( "LS(%d): not ready, errno=%d: %s\n", s->id, errno, strerror(errno) );
    156             s->close(s);
    157             return 1; /* not ready (error) */
    158         } else {
    159             break;
    160         }
    161     }
    162 
    163     if(p->len == 0) {
    164         put_apacket(p);
    165         return 0; /* ready for more data */
    166     }
    167 
    168 enqueue:
    169     p->next = 0;
    170     if(s->pkt_first) {
    171         s->pkt_last->next = p;
    172     } else {
    173         s->pkt_first = p;
    174     }
    175     s->pkt_last = p;
    176 
    177         /* make sure we are notified when we can drain the queue */
    178     fdevent_add(&s->fde, FDE_WRITE);
    179 
    180     return 1; /* not ready (backlog) */
    181 }
    182 
    183 static void local_socket_ready(asocket *s)
    184 {
    185         /* far side is ready for data, pay attention to
    186            readable events */
    187     fdevent_add(&s->fde, FDE_READ);
    188 //    D("LS(%d): ready()\n", s->id);
    189 }
    190 
    191 static void local_socket_close(asocket *s)
    192 {
    193     adb_mutex_lock(&socket_list_lock);
    194     local_socket_close_locked(s);
    195     adb_mutex_unlock(&socket_list_lock);
    196 }
    197 
    198 // be sure to hold the socket list lock when calling this
    199 static void local_socket_destroy(asocket  *s)
    200 {
    201     apacket *p, *n;
    202     D("LS(%d): destroying fde.fd=%d\n", s->id, s->fde.fd);
    203 
    204         /* IMPORTANT: the remove closes the fd
    205         ** that belongs to this socket
    206         */
    207     fdevent_remove(&s->fde);
    208 
    209         /* dispose of any unwritten data */
    210     for(p = s->pkt_first; p; p = n) {
    211         D("LS(%d): discarding %d bytes\n", s->id, p->len);
    212         n = p->next;
    213         put_apacket(p);
    214     }
    215     remove_socket(s);
    216     free(s);
    217 }
    218 
    219 
    220 static void local_socket_close_locked(asocket *s)
    221 {
    222     D("entered. LS(%d) fd=%d\n", s->id, s->fd);
    223     if(s->peer) {
    224         D("LS(%d): closing peer. peer->id=%d peer->fd=%d\n",
    225           s->id, s->peer->id, s->peer->fd);
    226         s->peer->peer = 0;
    227         // tweak to avoid deadlock
    228         if (s->peer->close == local_socket_close) {
    229             local_socket_close_locked(s->peer);
    230         } else {
    231             s->peer->close(s->peer);
    232         }
    233         s->peer = 0;
    234     }
    235 
    236         /* If we are already closing, or if there are no
    237         ** pending packets, destroy immediately
    238         */
    239     if (s->closing || s->pkt_first == NULL) {
    240         int   id = s->id;
    241         local_socket_destroy(s);
    242         D("LS(%d): closed\n", id);
    243         return;
    244     }
    245 
    246         /* otherwise, put on the closing list
    247         */
    248     D("LS(%d): closing\n", s->id);
    249     s->closing = 1;
    250     fdevent_del(&s->fde, FDE_READ);
    251     remove_socket(s);
    252     D("LS(%d): put on socket_closing_list fd=%d\n", s->id, s->fd);
    253     insert_local_socket(s, &local_socket_closing_list);
    254 }
    255 
    256 static void local_socket_event_func(int fd, unsigned ev, void *_s)
    257 {
    258     asocket *s = _s;
    259 
    260     D("LS(%d): event_func(fd=%d(==%d), ev=%04x)\n", s->id, s->fd, fd, ev);
    261 
    262     /* put the FDE_WRITE processing before the FDE_READ
    263     ** in order to simplify the code.
    264     */
    265     if(ev & FDE_WRITE){
    266         apacket *p;
    267 
    268         while((p = s->pkt_first) != 0) {
    269             while(p->len > 0) {
    270                 int r = adb_write(fd, p->ptr, p->len);
    271                 if(r > 0) {
    272                     p->ptr += r;
    273                     p->len -= r;
    274                     continue;
    275                 }
    276                 if(r < 0) {
    277                     /* returning here is ok because FDE_READ will
    278                     ** be processed in the next iteration loop
    279                     */
    280                     if(errno == EAGAIN) return;
    281                     if(errno == EINTR) continue;
    282                 }
    283                 D(" closing after write because r=%d and errno is %d\n", r, errno);
    284                 s->close(s);
    285                 return;
    286             }
    287 
    288             if(p->len == 0) {
    289                 s->pkt_first = p->next;
    290                 if(s->pkt_first == 0) s->pkt_last = 0;
    291                 put_apacket(p);
    292             }
    293         }
    294 
    295             /* if we sent the last packet of a closing socket,
    296             ** we can now destroy it.
    297             */
    298         if (s->closing) {
    299             D(" closing because 'closing' is set after write\n");
    300             s->close(s);
    301             return;
    302         }
    303 
    304             /* no more packets queued, so we can ignore
    305             ** writable events again and tell our peer
    306             ** to resume writing
    307             */
    308         fdevent_del(&s->fde, FDE_WRITE);
    309         s->peer->ready(s->peer);
    310     }
    311 
    312 
    313     if(ev & FDE_READ){
    314         apacket *p = get_apacket();
    315         unsigned char *x = p->data;
    316         size_t avail = MAX_PAYLOAD;
    317         int r;
    318         int is_eof = 0;
    319 
    320         while(avail > 0) {
    321             r = adb_read(fd, x, avail);
    322             D("LS(%d): post adb_read(fd=%d,...) r=%d (errno=%d) avail=%zu\n",
    323               s->id, s->fd, r, r<0?errno:0, avail);
    324             if(r > 0) {
    325                 avail -= r;
    326                 x += r;
    327                 continue;
    328             }
    329             if(r < 0) {
    330                 if(errno == EAGAIN) break;
    331                 if(errno == EINTR) continue;
    332             }
    333 
    334                 /* r = 0 or unhandled error */
    335             is_eof = 1;
    336             break;
    337         }
    338         D("LS(%d): fd=%d post avail loop. r=%d is_eof=%d forced_eof=%d\n",
    339           s->id, s->fd, r, is_eof, s->fde.force_eof);
    340         if((avail == MAX_PAYLOAD) || (s->peer == 0)) {
    341             put_apacket(p);
    342         } else {
    343             p->len = MAX_PAYLOAD - avail;
    344 
    345             r = s->peer->enqueue(s->peer, p);
    346             D("LS(%d): fd=%d post peer->enqueue(). r=%d\n", s->id, s->fd, r);
    347 
    348             if(r < 0) {
    349                     /* error return means they closed us as a side-effect
    350                     ** and we must return immediately.
    351                     **
    352                     ** note that if we still have buffered packets, the
    353                     ** socket will be placed on the closing socket list.
    354                     ** this handler function will be called again
    355                     ** to process FDE_WRITE events.
    356                     */
    357                 return;
    358             }
    359 
    360             if(r > 0) {
    361                     /* if the remote cannot accept further events,
    362                     ** we disable notification of READs.  They'll
    363                     ** be enabled again when we get a call to ready()
    364                     */
    365                 fdevent_del(&s->fde, FDE_READ);
    366             }
    367         }
    368         /* Don't allow a forced eof if data is still there */
    369         if((s->fde.force_eof && !r) || is_eof) {
    370             D(" closing because is_eof=%d r=%d s->fde.force_eof=%d\n", is_eof, r, s->fde.force_eof);
    371             s->close(s);
    372         }
    373     }
    374 
    375     if(ev & FDE_ERROR){
    376             /* this should be caught be the next read or write
    377             ** catching it here means we may skip the last few
    378             ** bytes of readable data.
    379             */
    380 //        s->close(s);
    381         D("LS(%d): FDE_ERROR (fd=%d)\n", s->id, s->fd);
    382 
    383         return;
    384     }
    385 }
    386 
    387 asocket *create_local_socket(int fd)
    388 {
    389     asocket *s = calloc(1, sizeof(asocket));
    390     if (s == NULL) fatal("cannot allocate socket");
    391     s->fd = fd;
    392     s->enqueue = local_socket_enqueue;
    393     s->ready = local_socket_ready;
    394     s->close = local_socket_close;
    395     install_local_socket(s);
    396 
    397     fdevent_install(&s->fde, fd, local_socket_event_func, s);
    398 /*    fdevent_add(&s->fde, FDE_ERROR); */
    399     //fprintf(stderr, "Created local socket in create_local_socket \n");
    400     D("LS(%d): created (fd=%d)\n", s->id, s->fd);
    401     return s;
    402 }
    403 
    404 asocket *create_local_service_socket(const char *name)
    405 {
    406     asocket *s;
    407     int fd;
    408 
    409     fd = service_to_fd(name);
    410     if(fd < 0) return 0;
    411 
    412     s = create_local_socket(fd);
    413     D("LS(%d): bound to '%s' via %d\n", s->id, name, fd);
    414     return s;
    415 }
    416 
    417 /* a Remote socket is used to send/receive data to/from a given transport object
    418 ** it needs to be closed when the transport is forcibly destroyed by the user
    419 */
    420 typedef struct aremotesocket {
    421     asocket      socket;
    422     adisconnect  disconnect;
    423 } aremotesocket;
    424 
    425 static int remote_socket_enqueue(asocket *s, apacket *p)
    426 {
    427     D("entered remote_socket_enqueue RS(%d) WRITE fd=%d peer.fd=%d\n",
    428       s->id, s->fd, s->peer->fd);
    429     p->msg.command = A_WRTE;
    430     p->msg.arg0 = s->peer->id;
    431     p->msg.arg1 = s->id;
    432     p->msg.data_length = p->len;
    433     send_packet(p, s->transport);
    434     return 1;
    435 }
    436 
    437 static void remote_socket_ready(asocket *s)
    438 {
    439     D("entered remote_socket_ready RS(%d) OKAY fd=%d peer.fd=%d\n",
    440       s->id, s->fd, s->peer->fd);
    441     apacket *p = get_apacket();
    442     p->msg.command = A_OKAY;
    443     p->msg.arg0 = s->peer->id;
    444     p->msg.arg1 = s->id;
    445     send_packet(p, s->transport);
    446 }
    447 
    448 static void remote_socket_close(asocket *s)
    449 {
    450     D("entered remote_socket_close RS(%d) CLOSE fd=%d peer->fd=%d\n",
    451       s->id, s->fd, s->peer?s->peer->fd:-1);
    452     apacket *p = get_apacket();
    453     p->msg.command = A_CLSE;
    454     if(s->peer) {
    455         p->msg.arg0 = s->peer->id;
    456         s->peer->peer = 0;
    457         D("RS(%d) peer->close()ing peer->id=%d peer->fd=%d\n",
    458           s->id, s->peer->id, s->peer->fd);
    459         s->peer->close(s->peer);
    460     }
    461     p->msg.arg1 = s->id;
    462     send_packet(p, s->transport);
    463     D("RS(%d): closed\n", s->id);
    464     remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect );
    465     free(s);
    466 }
    467 
    468 static void remote_socket_disconnect(void*  _s, atransport*  t)
    469 {
    470     asocket*  s    = _s;
    471     asocket*  peer = s->peer;
    472 
    473     D("remote_socket_disconnect RS(%d)\n", s->id);
    474     if (peer) {
    475         peer->peer = NULL;
    476         peer->close(peer);
    477     }
    478     remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect );
    479     free(s);
    480 }
    481 
    482 asocket *create_remote_socket(unsigned id, atransport *t)
    483 {
    484     asocket *s = calloc(1, sizeof(aremotesocket));
    485     adisconnect*  dis = &((aremotesocket*)s)->disconnect;
    486 
    487     if (s == NULL) fatal("cannot allocate socket");
    488     s->id = id;
    489     s->enqueue = remote_socket_enqueue;
    490     s->ready = remote_socket_ready;
    491     s->close = remote_socket_close;
    492     s->transport = t;
    493 
    494     dis->func   = remote_socket_disconnect;
    495     dis->opaque = s;
    496     add_transport_disconnect( t, dis );
    497     D("RS(%d): created\n", s->id);
    498     return s;
    499 }
    500 
    501 void connect_to_remote(asocket *s, const char *destination)
    502 {
    503     D("Connect_to_remote call RS(%d) fd=%d\n", s->id, s->fd);
    504     apacket *p = get_apacket();
    505     int len = strlen(destination) + 1;
    506 
    507     if(len > (MAX_PAYLOAD-1)) {
    508         fatal("destination oversized");
    509     }
    510 
    511     D("LS(%d): connect('%s')\n", s->id, destination);
    512     p->msg.command = A_OPEN;
    513     p->msg.arg0 = s->id;
    514     p->msg.data_length = len;
    515     strcpy((char*) p->data, destination);
    516     send_packet(p, s->transport);
    517 }
    518 
    519 
    520 /* this is used by magic sockets to rig local sockets to
    521    send the go-ahead message when they connect */
    522 static void local_socket_ready_notify(asocket *s)
    523 {
    524     s->ready = local_socket_ready;
    525     s->close = local_socket_close;
    526     adb_write(s->fd, "OKAY", 4);
    527     s->ready(s);
    528 }
    529 
    530 /* this is used by magic sockets to rig local sockets to
    531    send the failure message if they are closed before
    532    connected (to avoid closing them without a status message) */
    533 static void local_socket_close_notify(asocket *s)
    534 {
    535     s->ready = local_socket_ready;
    536     s->close = local_socket_close;
    537     sendfailmsg(s->fd, "closed");
    538     s->close(s);
    539 }
    540 
    541 unsigned unhex(unsigned char *s, int len)
    542 {
    543     unsigned n = 0, c;
    544 
    545     while(len-- > 0) {
    546         switch((c = *s++)) {
    547         case '0': case '1': case '2':
    548         case '3': case '4': case '5':
    549         case '6': case '7': case '8':
    550         case '9':
    551             c -= '0';
    552             break;
    553         case 'a': case 'b': case 'c':
    554         case 'd': case 'e': case 'f':
    555             c = c - 'a' + 10;
    556             break;
    557         case 'A': case 'B': case 'C':
    558         case 'D': case 'E': case 'F':
    559             c = c - 'A' + 10;
    560             break;
    561         default:
    562             return 0xffffffff;
    563         }
    564 
    565         n = (n << 4) | c;
    566     }
    567 
    568     return n;
    569 }
    570 
    571 /* skip_host_serial return the position in a string
    572    skipping over the 'serial' parameter in the ADB protocol,
    573    where parameter string may be a host:port string containing
    574    the protocol delimiter (colon). */
    575 char *skip_host_serial(char *service) {
    576     char *first_colon, *serial_end;
    577 
    578     first_colon = strchr(service, ':');
    579     if (!first_colon) {
    580         /* No colon in service string. */
    581         return NULL;
    582     }
    583     serial_end = first_colon;
    584     if (isdigit(serial_end[1])) {
    585         serial_end++;
    586         while ((*serial_end) && isdigit(*serial_end)) {
    587             serial_end++;
    588         }
    589         if ((*serial_end) != ':') {
    590             // Something other than numbers was found, reset the end.
    591             serial_end = first_colon;
    592         }
    593     }
    594     return serial_end;
    595 }
    596 
    597 static int smart_socket_enqueue(asocket *s, apacket *p)
    598 {
    599     unsigned len;
    600 
    601     D("SS(%d): enqueue %d\n", s->id, p->len);
    602 
    603     if(s->pkt_first == 0) {
    604         s->pkt_first = p;
    605         s->pkt_last = p;
    606     } else {
    607         if((s->pkt_first->len + p->len) > MAX_PAYLOAD) {
    608             D("SS(%d): overflow\n", s->id);
    609             put_apacket(p);
    610             goto fail;
    611         }
    612 
    613         memcpy(s->pkt_first->data + s->pkt_first->len,
    614                p->data, p->len);
    615         s->pkt_first->len += p->len;
    616         put_apacket(p);
    617 
    618         p = s->pkt_first;
    619     }
    620 
    621         /* don't bother if we can't decode the length */
    622     if(p->len < 4) return 0;
    623 
    624     len = unhex(p->data, 4);
    625     if((len < 1) ||  (len > 1024)) {
    626         D("SS(%d): bad size (%d)\n", s->id, len);
    627         goto fail;
    628     }
    629 
    630     D("SS(%d): len is %d\n", s->id, len );
    631         /* can't do anything until we have the full header */
    632     if((len + 4) > p->len) {
    633         D("SS(%d): waiting for %d more bytes\n", s->id, len+4 - p->len);
    634         return 0;
    635     }
    636 
    637     p->data[len + 4] = 0;
    638 
    639     D("SS(%d): '%s'\n", s->id, (char*) (p->data + 4));
    640 
    641     if (s->transport == NULL) {
    642         char* error_string = "unknown failure";
    643         s->transport = acquire_one_transport (CS_ANY,
    644                 kTransportAny, NULL, &error_string);
    645 
    646         if (s->transport == NULL) {
    647             sendfailmsg(s->peer->fd, error_string);
    648             goto fail;
    649         }
    650     }
    651 
    652     if(!(s->transport) || (s->transport->connection_state == CS_OFFLINE)) {
    653            /* if there's no remote we fail the connection
    654             ** right here and terminate it
    655             */
    656         sendfailmsg(s->peer->fd, "device offline (x)");
    657         goto fail;
    658     }
    659 
    660 
    661         /* instrument our peer to pass the success or fail
    662         ** message back once it connects or closes, then
    663         ** detach from it, request the connection, and
    664         ** tear down
    665         */
    666     s->peer->ready = local_socket_ready_notify;
    667     s->peer->close = local_socket_close_notify;
    668     s->peer->peer = 0;
    669         /* give him our transport and upref it */
    670     s->peer->transport = s->transport;
    671 
    672     connect_to_remote(s->peer, (char*) (p->data + 4));
    673     s->peer = 0;
    674     s->close(s);
    675     return 1;
    676 
    677 fail:
    678         /* we're going to close our peer as a side-effect, so
    679         ** return -1 to signal that state to the local socket
    680         ** who is enqueueing against us
    681         */
    682     s->close(s);
    683     return -1;
    684 }
    685 
    686 static void smart_socket_ready(asocket *s)
    687 {
    688     D("SS(%d): ready\n", s->id);
    689 }
    690 
    691 static void smart_socket_close(asocket *s)
    692 {
    693     D("SS(%d): closed\n", s->id);
    694     if(s->pkt_first){
    695         put_apacket(s->pkt_first);
    696     }
    697     if(s->peer) {
    698         s->peer->peer = 0;
    699         s->peer->close(s->peer);
    700         s->peer = 0;
    701     }
    702     free(s);
    703 }
    704 
    705 asocket *create_smart_socket(void (*action_cb)(asocket *s, const char *act))
    706 {
    707     D("Creating smart socket \n");
    708     asocket *s = calloc(1, sizeof(asocket));
    709     if (s == NULL) fatal("cannot allocate socket");
    710     s->enqueue = smart_socket_enqueue;
    711     s->ready = smart_socket_ready;
    712     s->close = smart_socket_close;
    713     s->extra = action_cb;
    714 
    715     D("SS(%d): created %p\n", s->id, action_cb);
    716     return s;
    717 }
    718 
    719 void smart_socket_action(asocket *s, const char *act)
    720 {
    721 
    722 }
    723 
    724 void connect_to_smartsocket(asocket *s)
    725 {
    726     D("Connecting to smart socket \n");
    727     asocket *ss = create_smart_socket(smart_socket_action);
    728     s->peer = ss;
    729     ss->peer = s;
    730     s->ready(s);
    731 }
    732