src/sockets.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   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 "sdb.h"
  28
  29 SDB_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     sdb_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     sdb_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     sdb_mutex_lock(&socket_list_lock);
  92
  93     s->id = local_socket_next_id++;
  94     insert_local_socket(s, &local_socket_list);
  95
  96     sdb_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     sdb_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     sdb_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 = sdb_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     sdb_mutex_lock(&socket_list_lock);
 194     local_socket_close_locked(s);
 195     sdb_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     int exit_on_close = s->exit_on_close;
 203
 204     D("LS(%d): destroying fde.fd=%d\n", s->id, s->fde.fd);
 205
 206         /* IMPORTANT: the remove closes the fd
 207         ** that belongs to this socket
 208         */
 209     fdevent_remove(&s->fde);
 210
 211         /* dispose of any unwritten data */
 212     for(p = s->pkt_first; p; p = n) {
 213         D("LS(%d): discarding %d bytes\n", s->id, p->len);
 214         n = p->next;
 215         put_apacket(p);
 216     }
 217     remove_socket(s);
 218     free(s);
 219
 220     if (exit_on_close) {
 221         D("local_socket_destroy: exiting\n");
 222         exit(1);
 223     }
 224 }
 225
 226
 227 static void local_socket_close_locked(asocket *s)
 228 {
 229     D("entered. LS(%d) fd=%d\n", s->id, s->fd);
 230     if(s->peer) {
 231         D("LS(%d): closing peer. peer->id=%d peer->fd=%d\n",
 232           s->id, s->peer->id, s->peer->fd);
 233         s->peer->peer = 0;
 234         // tweak to avoid deadlock
 235         if (s->peer->close == local_socket_close) {
 236             local_socket_close_locked(s->peer);
 237         } else {
 238             s->peer->close(s->peer);
 239         }
 240         s->peer = 0;
 241     }
 242
 243         /* If we are already closing, or if there are no
 244         ** pending packets, destroy immediately
 245         */
 246     if (s->closing || s->pkt_first == NULL) {
 247         int   id = s->id;
 248         local_socket_destroy(s);
 249         D("LS(%d): closed\n", id);
 250         return;
 251     }
 252
 253         /* otherwise, put on the closing list
 254         */
 255     D("LS(%d): closing\n", s->id);
 256     s->closing = 1;
 257     fdevent_del(&s->fde, FDE_READ);
 258     remove_socket(s);
 259     D("LS(%d): put on socket_closing_list fd=%d\n", s->id, s->fd);
 260     insert_local_socket(s, &local_socket_closing_list);
 261 }
 262
 263 static void local_socket_event_func(int fd, unsigned ev, void *_s)
 264 {
 265     asocket *s = _s;
 266
 267     D("LS(%d): event_func(fd=%d(==%d), ev=%04x)\n", s->id, s->fd, fd, ev);
 268
 269     /* put the FDE_WRITE processing before the FDE_READ
 270     ** in order to simplify the code.
 271     */
 272     if(ev & FDE_WRITE){
 273         apacket *p;
 274
 275         while((p = s->pkt_first) != 0) {
 276             while(p->len > 0) {
 277                 int r = sdb_write(fd, p->ptr, p->len);
 278                 if(r > 0) {
 279                     p->ptr += r;
 280                     p->len -= r;
 281                     continue;
 282                 }
 283                 if(r < 0) {
 284                     /* returning here is ok because FDE_READ will
 285                     ** be processed in the next iteration loop
 286                     */
 287                     if(errno == EAGAIN) return;
 288                     if(errno == EINTR) continue;
 289                 }
 290                 D(" closing after write because r=%d and errno is %d\n", r, errno);
 291                 s->close(s);
 292                 return;
 293             }
 294
 295             if(p->len == 0) {
 296                 s->pkt_first = p->next;
 297                 if(s->pkt_first == 0) s->pkt_last = 0;
 298                 put_apacket(p);
 299             }
 300         }
 301
 302             /* if we sent the last packet of a closing socket,
 303             ** we can now destroy it.
 304             */
 305         if (s->closing) {
 306             D(" closing because 'closing' is set after write\n");
 307             s->close(s);
 308             return;
 309         }
 310
 311             /* no more packets queued, so we can ignore
 312             ** writable events again and tell our peer
 313             ** to resume writing
 314             */
 315         fdevent_del(&s->fde, FDE_WRITE);
 316         s->peer->ready(s->peer);
 317     }
 318
 319
 320     if(ev & FDE_READ){
 321         apacket *p = get_apacket();
 322         unsigned char *x = p->data;
 323         size_t avail = MAX_PAYLOAD;
 324         int r;
 325         int is_eof = 0;
 326
 327         while(avail > 0) {
 328             r = sdb_read(fd, x, avail);
 329             D("LS(%d): post sdb_read(fd=%d,...) r=%d (errno=%d) avail=%d\n", s->id, s->fd, r, r<0?errno:0, avail);
 330             if(r > 0) {
 331                 avail -= r;
 332                 x += r;
 333                 continue;
 334             }
 335             if(r < 0) {
 336                 if(errno == EAGAIN) break;
 337                 if(errno == EINTR) continue;
 338             }
 339
 340                 /* r = 0 or unhandled error */
 341             is_eof = 1;
 342             break;
 343         }
 344         D("LS(%d): fd=%d post avail loop. r=%d is_eof=%d forced_eof=%d\n",
 345           s->id, s->fd, r, is_eof, s->fde.force_eof);
 346         if((avail == MAX_PAYLOAD) || (s->peer == 0)) {
 347             put_apacket(p);
 348         } else {
 349             p->len = MAX_PAYLOAD - avail;
 350
 351             r = s->peer->enqueue(s->peer, p);
 352             D("LS(%d): fd=%d post peer->enqueue(). r=%d\n", s->id, s->fd, r);
 353
 354             if(r < 0) {
 355                     /* error return means they closed us as a side-effect
 356                     ** and we must return immediately.
 357                     **
 358                     ** note that if we still have buffered packets, the
 359                     ** socket will be placed on the closing socket list.
 360                     ** this handler function will be called again
 361                     ** to process FDE_WRITE events.
 362                     */
 363                 return;
 364             }
 365
 366             if(r > 0) {
 367                     /* if the remote cannot accept further events,
 368                     ** we disable notification of READs.  They'll
 369                     ** be enabled again when we get a call to ready()
 370                     */
 371                 fdevent_del(&s->fde, FDE_READ);
 372             }
 373         }
 374         /* Don't allow a forced eof if data is still there */
 375         if((s->fde.force_eof && !r) || is_eof) {
 376             D(" closing because is_eof=%d r=%d s->fde.force_eof=%d\n", is_eof, r, s->fde.force_eof);
 377             s->close(s);
 378         }
 379     }
 380
 381     if(ev & FDE_ERROR){
 382             /* this should be caught be the next read or write
 383             ** catching it here means we may skip the last few
 384             ** bytes of readable data.
 385             */
 386 //        s->close(s);
 387         D("LS(%d): FDE_ERROR (fd=%d)\n", s->id, s->fd);
 388
 389         return;
 390     }
 391 }
 392
 393 asocket *create_local_socket(int fd)
 394 {
 395     asocket *s = calloc(1, sizeof(asocket));
 396     if (s == NULL) fatal("cannot allocate socket");
 397     s->fd = fd;
 398     s->enqueue = local_socket_enqueue;
 399     s->ready = local_socket_ready;
 400     s->close = local_socket_close;
 401     install_local_socket(s);
 402
 403     fdevent_install(&s->fde, fd, local_socket_event_func, s);
 404 /*    fdevent_add(&s->fde, FDE_ERROR); */
 405     //fprintf(stderr, "Created local socket in create_local_socket \n");
 406     D("LS(%d): created (fd=%d)\n", s->id, s->fd);
 407     return s;
 408 }
 409
 410 asocket *create_local_service_socket(const char *name)
 411 {
 412     asocket *s;
 413     int fd;
 414
 415 #if 0 /* not support in tizen */
 416 #if !SDB_HOST
 417     if (!strcmp(name,"jdwp")) {
 418         return create_jdwp_service_socket();
 419     }
 420     if (!strcmp(name,"track-jdwp")) {
 421         return create_jdwp_tracker_service_socket();
 422     }
 423 #endif
 424 #endif
 425     fd = service_to_fd(name);
 426     if(fd < 0) return 0;
 427
 428     s = create_local_socket(fd);
 429     D("LS(%d): bound to '%s' via %d\n", s->id, name, fd);
 430
 431 #if !SDB_HOST
 432     if ((!strncmp(name, "root:", 5) && getuid() != 0)
 433         || !strncmp(name, "usb:", 4)
 434         || !strncmp(name, "tcpip:", 6)) {
 435         D("LS(%d): enabling exit_on_close\n", s->id);
 436         s->exit_on_close = 1;
 437     }
 438 #endif
 439
 440     return s;
 441 }
 442
 443 #if SDB_HOST
 444 static asocket *create_host_service_socket(const char *name, const char* serial)
 445 {
 446     asocket *s;
 447
 448     s = host_service_to_socket(name, serial);
 449
 450     if (s != NULL) {
 451         D("LS(%d) bound to '%s'\n", s->id, name);
 452         return s;
 453     }
 454
 455     return s;
 456 }
 457 #endif /* SDB_HOST */
 458
 459 /* a Remote socket is used to send/receive data to/from a given transport object
 460 ** it needs to be closed when the transport is forcibly destroyed by the user
 461 */
 462 typedef struct aremotesocket {
 463     asocket      socket;
 464     adisconnect  disconnect;
 465 } aremotesocket;
 466
 467 static int remote_socket_enqueue(asocket *s, apacket *p)
 468 {
 469     D("entered remote_socket_enqueue RS(%d) WRITE fd=%d peer.fd=%d\n",
 470       s->id, s->fd, s->peer->fd);
 471     p->msg.command = A_WRTE;
 472     p->msg.arg0 = s->peer->id;
 473     p->msg.arg1 = s->id;
 474     p->msg.data_length = p->len;
 475     send_packet(p, s->transport);
 476     return 1;
 477 }
 478
 479 static void remote_socket_ready(asocket *s)
 480 {
 481     D("entered remote_socket_ready RS(%d) OKAY fd=%d peer.fd=%d\n",
 482       s->id, s->fd, s->peer->fd);
 483     apacket *p = get_apacket();
 484     p->msg.command = A_OKAY;
 485     p->msg.arg0 = s->peer->id;
 486     p->msg.arg1 = s->id;
 487     send_packet(p, s->transport);
 488 }
 489
 490 static void remote_socket_close(asocket *s)
 491 {
 492     D("entered remote_socket_close RS(%d) CLOSE fd=%d peer->fd=%d\n",
 493       s->id, s->fd, s->peer?s->peer->fd:-1);
 494     apacket *p = get_apacket();
 495     p->msg.command = A_CLSE;
 496     if(s->peer) {
 497         p->msg.arg0 = s->peer->id;
 498         s->peer->peer = 0;
 499         D("RS(%d) peer->close()ing peer->id=%d peer->fd=%d\n",
 500           s->id, s->peer->id, s->peer->fd);
 501         s->peer->close(s->peer);
 502     }
 503     p->msg.arg1 = s->id;
 504     send_packet(p, s->transport);
 505     D("RS(%d): closed\n", s->id);
 506     remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect );
 507     free(s);
 508 }
 509
 510 static void remote_socket_disconnect(void*  _s, atransport*  t)
 511 {
 512     asocket*  s    = _s;
 513     asocket*  peer = s->peer;
 514
 515     D("remote_socket_disconnect RS(%d)\n", s->id);
 516     if (peer) {
 517         peer->peer = NULL;
 518         peer->close(peer);
 519     }
 520     remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect );
 521     free(s);
 522 }
 523
 524 asocket *create_remote_socket(unsigned id, atransport *t)
 525 {
 526     asocket *s = calloc(1, sizeof(aremotesocket));
 527     adisconnect*  dis = &((aremotesocket*)s)->disconnect;
 528
 529     if (s == NULL) fatal("cannot allocate socket");
 530     s->id = id;
 531     s->enqueue = remote_socket_enqueue;
 532     s->ready = remote_socket_ready;
 533     s->close = remote_socket_close;
 534     s->transport = t;
 535
 536     dis->func   = remote_socket_disconnect;
 537     dis->opaque = s;
 538     add_transport_disconnect( t, dis );
 539     D("RS(%d): created\n", s->id);
 540     return s;
 541 }
 542
 543 void connect_to_remote(asocket *s, const char *destination)
 544 {
 545     D("Connect_to_remote call RS(%d) fd=%d\n", s->id, s->fd);
 546     apacket *p = get_apacket();
 547     int len = strlen(destination) + 1;
 548
 549     if(len > (MAX_PAYLOAD-1)) {
 550         fatal("destination oversized");
 551     }
 552
 553     D("LS(%d): connect('%s')\n", s->id, destination);
 554     p->msg.command = A_OPEN;
 555     p->msg.arg0 = s->id;
 556     p->msg.data_length = len;
 557     strcpy((char*) p->data, destination);
 558     send_packet(p, s->transport);
 559 }
 560
 561
 562 /* this is used by magic sockets to rig local sockets to
 563    send the go-ahead message when they connect */
 564 static void local_socket_ready_notify(asocket *s)
 565 {
 566     s->ready = local_socket_ready;
 567     s->close = local_socket_close;
 568     sdb_write(s->fd, "OKAY", 4);
 569     s->ready(s);
 570 }
 571
 572 /* this is used by magic sockets to rig local sockets to
 573    send the failure message if they are closed before
 574    connected (to avoid closing them without a status message) */
 575 static void local_socket_close_notify(asocket *s)
 576 {
 577     s->ready = local_socket_ready;
 578     s->close = local_socket_close;
 579     sendfailmsg(s->fd, "closed");
 580     s->close(s);
 581 }
 582
 583 unsigned unhex(unsigned char *s, int len)
 584 {
 585     unsigned n = 0, c;
 586
 587     while(len-- > 0) {
 588         switch((c = *s++)) {
 589         case '0': case '1': case '2':
 590         case '3': case '4': case '5':
 591         case '6': case '7': case '8':
 592         case '9':
 593             c -= '0';
 594             break;
 595         case 'a': case 'b': case 'c':
 596         case 'd': case 'e': case 'f':
 597             c = c - 'a' + 10;
 598             break;
 599         case 'A': case 'B': case 'C':
 600         case 'D': case 'E': case 'F':
 601             c = c - 'A' + 10;
 602             break;
 603         default:
 604             return 0xffffffff;
 605         }
 606
 607         n = (n << 4) | c;
 608     }
 609
 610     return n;
 611 }
 612
 613 /* skip_host_serial return the position in a string
 614    skipping over the 'serial' parameter in the SDB protocol,
 615    where parameter string may be a host:port string containing
 616    the protocol delimiter (colon). */
 617 char *skip_host_serial(char *service) {
 618     char *first_colon, *serial_end;
 619
 620     first_colon = strchr(service, ':');
 621     if (!first_colon) {
 622         /* No colon in service string. */
 623         return NULL;
 624     }
 625     serial_end = first_colon;
 626     if (isdigit(serial_end[1])) {
 627         serial_end++;
 628         while ((*serial_end) && isdigit(*serial_end)) {
 629             serial_end++;
 630         }
 631         if ((*serial_end) != ':') {
 632             // Something other than numbers was found, reset the end.
 633             serial_end = first_colon;
 634         }
 635     }
 636     return serial_end;
 637 }
 638
 639 static int smart_socket_enqueue(asocket *s, apacket *p)
 640 {
 641     unsigned len;
 642 #if SDB_HOST
 643     char *service = NULL;
 644     char* serial = NULL;
 645     transport_type ttype = kTransportAny;
 646 #endif
 647
 648     D("SS(%d): enqueue %d\n", s->id, p->len);
 649
 650     if(s->pkt_first == 0) {
 651         s->pkt_first = p;
 652         s->pkt_last = p;
 653     } else {
 654         if((s->pkt_first->len + p->len) > MAX_PAYLOAD) {
 655             D("SS(%d): overflow\n", s->id);
 656             put_apacket(p);
 657             goto fail;
 658         }
 659
 660         memcpy(s->pkt_first->data + s->pkt_first->len,
 661                p->data, p->len);
 662         s->pkt_first->len += p->len;
 663         put_apacket(p);
 664
 665         p = s->pkt_first;
 666     }
 667
 668         /* don't bother if we can't decode the length */
 669     if(p->len < 4) return 0;
 670
 671     len = unhex(p->data, 4);
 672     if((len < 1) ||  (len > 1024)) {
 673         D("SS(%d): bad size (%d)\n", s->id, len);
 674         goto fail;
 675     }
 676
 677     D("SS(%d): len is %d\n", s->id, len );
 678         /* can't do anything until we have the full header */
 679     if((len + 4) > p->len) {
 680         D("SS(%d): waiting for %d more bytes\n", s->id, len+4 - p->len);
 681         return 0;
 682     }
 683
 684     p->data[len + 4] = 0;
 685
 686     D("SS(%d): '%s'\n", s->id, (char*) (p->data + 4));
 687
 688 #if SDB_HOST
 689     service = (char *)p->data + 4;
 690     if(!strncmp(service, "host-serial:", strlen("host-serial:"))) {
 691         char* serial_end;
 692         service += strlen("host-serial:");
 693
 694         // serial number should follow "host:" and could be a host:port string.
 695         serial_end = skip_host_serial(service);
 696         if (serial_end) {
 697             *serial_end = 0; // terminate string
 698             serial = service;
 699             service = serial_end + 1;
 700         }
 701     } else if (!strncmp(service, "host-usb:", strlen("host-usb:"))) {
 702         ttype = kTransportUsb;
 703         service += strlen("host-usb:");
 704     } else if (!strncmp(service, "host-local:", strlen("host-local:"))) {
 705         ttype = kTransportLocal;
 706         service += strlen("host-local:");
 707     } else if (!strncmp(service, "host:", strlen("host:"))) {
 708         ttype = kTransportAny;
 709         service += strlen("host:");
 710     } else {
 711         service = NULL;
 712     }
 713
 714     if (service) {
 715         asocket *s2;
 716
 717             /* some requests are handled immediately -- in that
 718             ** case the handle_host_request() routine has sent
 719             ** the OKAY or FAIL message and all we have to do
 720             ** is clean up.
 721             */
 722         if(handle_host_request(service, ttype, serial, s->peer->fd, s) == 0) {
 723                 /* XXX fail message? */
 724             D( "SS(%d): handled host service '%s'\n", s->id, service );
 725             goto fail;
 726         }
 727         if (!strncmp(service, "transport", strlen("transport"))) {
 728             D( "SS(%d): okay transport\n", s->id );
 729             p->len = 0;
 730             return 0;
 731         }
 732
 733             /* try to find a local service with this name.
 734             ** if no such service exists, we'll fail out
 735             ** and tear down here.
 736             */
 737         s2 = create_host_service_socket(service, serial);
 738         if(s2 == 0) {
 739             D( "SS(%d): couldn't create host service '%s'\n", s->id, service );
 740             sendfailmsg(s->peer->fd, "unknown host service");
 741             goto fail;
 742         }
 743
 744             /* we've connected to a local host service,
 745             ** so we make our peer back into a regular
 746             ** local socket and bind it to the new local
 747             ** service socket, acknowledge the successful
 748             ** connection, and close this smart socket now
 749             ** that its work is done.
 750             */
 751         sdb_write(s->peer->fd, "OKAY", 4);
 752
 753         s->peer->ready = local_socket_ready;
 754         s->peer->close = local_socket_close;
 755         s->peer->peer = s2;
 756         s2->peer = s->peer;
 757         s->peer = 0;
 758         D( "SS(%d): okay\n", s->id );
 759         s->close(s);
 760
 761             /* initial state is "ready" */
 762         s2->ready(s2);
 763         return 0;
 764     }
 765 #else /* !SDB_HOST */
 766     if (s->transport == NULL) {
 767         char* error_string = "unknown failure";
 768         s->transport = acquire_one_transport (CS_ANY,
 769                 kTransportAny, NULL, &error_string);
 770
 771         if (s->transport == NULL) {
 772             sendfailmsg(s->peer->fd, error_string);
 773             goto fail;
 774         }
 775     }
 776 #endif
 777
 778     if(!(s->transport) || (s->transport->connection_state == CS_OFFLINE)) {
 779            /* if there's no remote we fail the connection
 780             ** right here and terminate it
 781             */
 782         sendfailmsg(s->peer->fd, "device offline (x)");
 783         goto fail;
 784     }
 785
 786
 787         /* instrument our peer to pass the success or fail
 788         ** message back once it connects or closes, then
 789         ** detach from it, request the connection, and
 790         ** tear down
 791         */
 792     s->peer->ready = local_socket_ready_notify;
 793     s->peer->close = local_socket_close_notify;
 794     s->peer->peer = 0;
 795         /* give him our transport and upref it */
 796     s->peer->transport = s->transport;
 797
 798     connect_to_remote(s->peer, (char*) (p->data + 4));
 799     s->peer = 0;
 800     s->close(s);
 801     return 1;
 802
 803 fail:
 804         /* we're going to close our peer as a side-effect, so
 805         ** return -1 to signal that state to the local socket
 806         ** who is enqueueing against us
 807         */
 808     s->close(s);
 809     return -1;
 810 }
 811
 812 static void smart_socket_ready(asocket *s)
 813 {
 814     D("SS(%d): ready\n", s->id);
 815 }
 816
 817 static void smart_socket_close(asocket *s)
 818 {
 819     D("SS(%d): closed\n", s->id);
 820     if(s->pkt_first){
 821         put_apacket(s->pkt_first);
 822     }
 823     if(s->peer) {
 824         s->peer->peer = 0;
 825         s->peer->close(s->peer);
 826         s->peer = 0;
 827     }
 828     free(s);
 829 }
 830
 831 asocket *create_smart_socket(void (*action_cb)(asocket *s, const char *act))
 832 {
 833     D("Creating smart socket \n");
 834     asocket *s = calloc(1, sizeof(asocket));
 835     if (s == NULL) fatal("cannot allocate socket");
 836     s->enqueue = smart_socket_enqueue;
 837     s->ready = smart_socket_ready;
 838     s->close = smart_socket_close;
 839     s->extra = action_cb;
 840
 841     D("SS(%d): created %p\n", s->id, action_cb);
 842     return s;
 843 }
 844
 845 void smart_socket_action(asocket *s, const char *act)
 846 {
 847
 848 }
 849
 850 void connect_to_smartsocket(asocket *s)
 851 {
 852     D("Connecting to smart socket \n");
 853     asocket *ss = create_smart_socket(smart_socket_action);
 854     s->peer = ss;
 855     ss->peer = s;
 856     s->ready(s);
 857 }