src/transport.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 <string.h>
  21 #include <errno.h>
  22
  23 #include "sysdeps.h"
  24
  25 #define   TRACE_TAG  TRACE_TRANSPORT
  26 #include "sdb.h"
  27
  28 static void transport_unref(atransport *t);
  29
  30 static atransport transport_list = {
  31     .next = &transport_list,
  32     .prev = &transport_list,
  33 };
  34
  35 SDB_MUTEX_DEFINE( transport_lock );
  36
  37 #if SDB_TRACE
  38 #define MAX_DUMP_HEX_LEN 16
  39 static void  dump_hex( const unsigned char*  ptr, size_t  len )
  40 {
  41     int  nn, len2 = len;
  42     // Build a string instead of logging each character.
  43     // MAX chars in 2 digit hex, one space, MAX chars, one '\0'.
  44     char buffer[MAX_DUMP_HEX_LEN *2 + 1 + MAX_DUMP_HEX_LEN + 1 ], *pb = buffer;
  45
  46     if (len2 > MAX_DUMP_HEX_LEN) len2 = MAX_DUMP_HEX_LEN;
  47
  48     int pbSize = sizeof(buffer);
  49     for (nn = 0; nn < len2; nn++) {
  50         snprintf(pb, pbSize,  "%02x", ptr[nn]);
  51         pb += 2;
  52         pbSize -= 2;
  53     }
  54     *pb++ = ' ';
  55
  56     for (nn = 0; nn < len2; nn++) {
  57         int  c = ptr[nn];
  58         if (c < 32 || c > 127)
  59             c = '.';
  60         *pb++ =  c;
  61     }
  62     *pb++ = '\0';
  63     DR("%s\n", buffer);
  64 }
  65 #endif
  66
  67 void
  68 kick_transport(atransport*  t)
  69 {
  70     if (t && !t->kicked)
  71     {
  72         int  kicked;
  73
  74         sdb_mutex_lock(&transport_lock);
  75         kicked = t->kicked;
  76         if (!kicked)
  77             t->kicked = 1;
  78         sdb_mutex_unlock(&transport_lock);
  79
  80         if (!kicked)
  81             t->kick(t);
  82     }
  83 }
  84
  85 void
  86 run_transport_disconnects(atransport*  t)
  87 {
  88     adisconnect*  dis = t->disconnects.next;
  89
  90     D("%s: run_transport_disconnects\n", t->serial);
  91     while (dis != &t->disconnects) {
  92         adisconnect*  next = dis->next;
  93         dis->func( dis->opaque, t );
  94         dis = next;
  95     }
  96 }
  97
  98 #if SDB_TRACE
  99 static void
 100 dump_packet(const char* name, const char* func, apacket* p)
 101 {
 102     unsigned  command = p->msg.command;
 103     int       len     = p->msg.data_length;
 104     char      cmd[9];
 105     char      arg0[12], arg1[12];
 106     int       n;
 107
 108     for (n = 0; n < 4; n++) {
 109         int  b = (command >> (n*8)) & 255;
 110         if (b < 32 || b >= 127)
 111             break;
 112         cmd[n] = (char)b;
 113     }
 114     if (n == 4) {
 115         cmd[4] = 0;
 116     } else {
 117         /* There is some non-ASCII name in the command, so dump
 118             * the hexadecimal value instead */
 119         snprintf(cmd, sizeof cmd, "%08x", command);
 120     }
 121
 122     if (p->msg.arg0 < 256U)
 123         snprintf(arg0, sizeof arg0, "%d", p->msg.arg0);
 124     else
 125         snprintf(arg0, sizeof arg0, "0x%x", p->msg.arg0);
 126
 127     if (p->msg.arg1 < 256U)
 128         snprintf(arg1, sizeof arg1, "%d", p->msg.arg1);
 129     else
 130         snprintf(arg1, sizeof arg1, "0x%x", p->msg.arg1);
 131
 132     D("%s: %s: [%s] arg0=%s arg1=%s (len=%d) ",
 133         name, func, cmd, arg0, arg1, len);
 134     dump_hex(p->data, len);
 135 }
 136 #endif /* SDB_TRACE */
 137
 138 static int
 139 read_packet(int  fd, const char* name, apacket** ppacket)
 140 {
 141     char *p = (char*)ppacket;  /* really read a packet address */
 142     int   r;
 143     int   len = sizeof(*ppacket);
 144     char  buff[8];
 145     if (!name) {
 146         snprintf(buff, sizeof buff, "fd=%d", fd);
 147         name = buff;
 148     }
 149     while(len > 0) {
 150         r = sdb_read(fd, p, len);
 151         if(r > 0) {
 152             len -= r;
 153             p   += r;
 154         } else {
 155             D("%s: read_packet (fd=%d), error ret=%d errno=%d\n", name, fd, r, errno);
 156             if((r < 0) && (errno == EINTR)) continue;
 157             return -1;
 158         }
 159     }
 160
 161 #if SDB_TRACE
 162     if (SDB_TRACING) {
 163         dump_packet(name, "from remote", *ppacket);
 164     }
 165 #endif
 166     return 0;
 167 }
 168
 169 static int
 170 write_packet(int  fd, const char* name, apacket** ppacket)
 171 {
 172     char *p = (char*) ppacket;  /* we really write the packet address */
 173     int r, len = sizeof(ppacket);
 174     char buff[8];
 175     if (!name) {
 176         snprintf(buff, sizeof buff, "fd=%d", fd);
 177         name = buff;
 178     }
 179
 180 #if SDB_TRACE
 181     if (SDB_TRACING) {
 182         dump_packet(name, "to remote", *ppacket);
 183     }
 184 #endif
 185     len = sizeof(ppacket);
 186     while(len > 0) {
 187         r = sdb_write(fd, p, len);
 188         if(r > 0) {
 189             len -= r;
 190             p += r;
 191         } else {
 192             D("%s: write_packet (fd=%d) error ret=%d errno=%d\n", name, fd, r, errno);
 193             if((r < 0) && (errno == EINTR)) continue;
 194             return -1;
 195         }
 196     }
 197     return 0;
 198 }
 199
 200 static void transport_socket_events(int fd, unsigned events, void *_t)
 201 {
 202     atransport *t = _t;
 203     D("transport_socket_events(fd=%d, events=%04x,...)\n", fd, events);
 204     if(events & FDE_READ){
 205         apacket *p = 0;
 206         if(read_packet(fd, t->serial, &p)){
 207             D("%s: failed to read packet from transport socket on fd %d\n", t->serial, fd);
 208         } else {
 209             handle_packet(p, (atransport *) _t);
 210         }
 211     }
 212 }
 213
 214 void send_packet(apacket *p, atransport *t)
 215 {
 216     unsigned char *x;
 217     unsigned sum;
 218     unsigned count;
 219
 220     p->msg.magic = p->msg.command ^ 0xffffffff;
 221
 222     count = p->msg.data_length;
 223     x = (unsigned char *) p->data;
 224     sum = 0;
 225     while(count-- > 0){
 226         sum += *x++;
 227     }
 228     p->msg.data_check = sum;
 229
 230     print_packet("send", p);
 231
 232     if (t == NULL) {
 233         D("Transport is null \n");
 234         // Zap errno because print_packet() and other stuff have errno effect.
 235         errno = 0;
 236         fatal_errno("Transport is null");
 237     }
 238
 239     if(write_packet(t->transport_socket, t->serial, &p)){
 240         fatal_errno("cannot enqueue packet on transport socket");
 241     }
 242 }
 243
 244 /* The transport is opened by transport_register_func before
 245 ** the input and output threads are started.
 246 **
 247 ** The output thread issues a SYNC(1, token) message to let
 248 ** the input thread know to start things up.  In the event
 249 ** of transport IO failure, the output thread will post a
 250 ** SYNC(0,0) message to ensure shutdown.
 251 **
 252 ** The transport will not actually be closed until both
 253 ** threads exit, but the input thread will kick the transport
 254 ** on its way out to disconnect the underlying device.
 255 */
 256
 257 static void *output_thread(void *_t)
 258 {
 259     atransport *t = _t;
 260     apacket *p;
 261
 262     D("%s: starting transport output thread on fd %d, SYNC online (%d)\n",
 263        t->serial, t->fd, t->sync_token + 1);
 264     p = get_apacket();
 265     p->msg.command = A_SYNC;
 266     p->msg.arg0 = 1;
 267     p->msg.arg1 = ++(t->sync_token);
 268     p->msg.magic = A_SYNC ^ 0xffffffff;
 269     if(write_packet(t->fd, t->serial, &p)) {
 270         put_apacket(p);
 271         D("%s: failed to write SYNC packet\n", t->serial);
 272         goto oops;
 273     }
 274
 275     D("%s: data pump started\n", t->serial);
 276     for(;;) {
 277         p = get_apacket();
 278
 279         if(t->read_from_remote(p, t) == 0){
 280             D("%s: received remote packet, sending to transport\n",
 281               t->serial);
 282             if(write_packet(t->fd, t->serial, &p)){
 283                 put_apacket(p);
 284                 D("%s: failed to write apacket to transport\n", t->serial);
 285                 goto oops;
 286             }
 287         } else {
 288             D("%s: remote read failed for transport\n", t->serial);
 289             put_apacket(p);
 290             break;
 291         }
 292     }
 293
 294     D("%s: SYNC offline for transport\n", t->serial);
 295     p = get_apacket();
 296     p->msg.command = A_SYNC;
 297     p->msg.arg0 = 0;
 298     p->msg.arg1 = 0;
 299     p->msg.magic = A_SYNC ^ 0xffffffff;
 300     if(write_packet(t->fd, t->serial, &p)) {
 301         put_apacket(p);
 302         D("%s: failed to write SYNC apacket to transport", t->serial);
 303     }
 304
 305 oops:
 306     D("%s: transport output thread is exiting\n", t->serial);
 307     kick_transport(t);
 308     transport_unref(t);
 309     return 0;
 310 }
 311
 312 static void *input_thread(void *_t)
 313 {
 314     atransport *t = _t;
 315     apacket *p;
 316     int active = 0;
 317
 318     D("%s: starting transport input thread, reading from fd %d\n",
 319        t->serial, t->fd);
 320
 321     for(;;){
 322         if(read_packet(t->fd, t->serial, &p)) {
 323             D("%s: failed to read apacket from transport on fd %d\n",
 324                t->serial, t->fd );
 325             break;
 326         }
 327         if(p->msg.command == A_SYNC){
 328             if(p->msg.arg0 == 0) {
 329                 D("%s: transport SYNC offline\n", t->serial);
 330                 put_apacket(p);
 331                 break;
 332             } else {
 333                 if(p->msg.arg1 == t->sync_token) {
 334                     D("%s: transport SYNC online\n", t->serial);
 335                     active = 1;
 336                 } else {
 337                     D("%s: transport ignoring SYNC %d != %d\n",
 338                       t->serial, p->msg.arg1, t->sync_token);
 339                 }
 340             }
 341         } else {
 342             if(active) {
 343                 D("%s: transport got packet, sending to remote\n", t->serial);
 344                 t->write_to_remote(p, t);
 345             } else {
 346                 D("%s: transport ignoring packet while offline\n", t->serial);
 347             }
 348         }
 349
 350         put_apacket(p);
 351     }
 352
 353     // this is necessary to avoid a race condition that occured when a transport closes
 354     // while a client socket is still active.
 355     close_all_sockets(t);
 356
 357     D("%s: transport input thread is exiting, fd %d\n", t->serial, t->fd);
 358     kick_transport(t);
 359     transport_unref(t);
 360     return 0;
 361 }
 362
 363
 364 static int transport_registration_send = -1;
 365 static int transport_registration_recv = -1;
 366 static fdevent transport_registration_fde;
 367
 368
 369 #if SDB_HOST
 370 static int list_transports_msg(char*  buffer, size_t  bufferlen)
 371 {
 372     char  head[5];
 373     int   len;
 374
 375     len = list_transports(buffer+4, bufferlen-4);
 376     snprintf(head, sizeof(head), "%04x", len);
 377     memcpy(buffer, head, 4);
 378     len += 4;
 379     return len;
 380 }
 381
 382 /* this adds support required by the 'track-devices' service.
 383  * this is used to send the content of "list_transport" to any
 384  * number of client connections that want it through a single
 385  * live TCP connection
 386  */
 387 typedef struct device_tracker  device_tracker;
 388 struct device_tracker {
 389     asocket          socket;
 390     int              update_needed;
 391     device_tracker*  next;
 392 };
 393
 394 /* linked list of all device trackers */
 395 static device_tracker*   device_tracker_list;
 396
 397 static void
 398 device_tracker_remove( device_tracker*  tracker )
 399 {
 400     device_tracker**  pnode = &device_tracker_list;
 401     device_tracker*   node  = *pnode;
 402
 403     sdb_mutex_lock( &transport_lock );
 404     while (node) {
 405         if (node == tracker) {
 406             *pnode = node->next;
 407             break;
 408         }
 409         pnode = &node->next;
 410         node  = *pnode;
 411     }
 412     sdb_mutex_unlock( &transport_lock );
 413 }
 414
 415 static void
 416 device_tracker_close( asocket*  socket )
 417 {
 418     device_tracker*  tracker = (device_tracker*) socket;
 419     asocket*         peer    = socket->peer;
 420
 421     D( "device tracker %p removed\n", tracker);
 422     if (peer) {
 423         peer->peer = NULL;
 424         peer->close(peer);
 425     }
 426     device_tracker_remove(tracker);
 427     free(tracker);
 428 }
 429
 430 static int
 431 device_tracker_enqueue( asocket*  socket, apacket*  p )
 432 {
 433     /* you can't read from a device tracker, close immediately */
 434     put_apacket(p);
 435     device_tracker_close(socket);
 436     return -1;
 437 }
 438
 439 static int
 440 device_tracker_send( device_tracker*  tracker,
 441                      const char*      buffer,
 442                      int              len )
 443 {
 444     apacket*  p = get_apacket();
 445     asocket*  peer = tracker->socket.peer;
 446
 447     memcpy(p->data, buffer, len);
 448     p->len = len;
 449     return peer->enqueue( peer, p );
 450 }
 451
 452
 453 static void
 454 device_tracker_ready( asocket*  socket )
 455 {
 456     device_tracker*  tracker = (device_tracker*) socket;
 457
 458     /* we want to send the device list when the tracker connects
 459     * for the first time, even if no update occured */
 460     if (tracker->update_needed > 0) {
 461         char  buffer[1024];
 462         int   len;
 463
 464         tracker->update_needed = 0;
 465
 466         len = list_transports_msg(buffer, sizeof(buffer));
 467         device_tracker_send(tracker, buffer, len);
 468     }
 469 }
 470
 471
 472 asocket*
 473 create_device_tracker(void)
 474 {
 475     device_tracker*  tracker = calloc(1,sizeof(*tracker));
 476
 477     if(tracker == 0) fatal("cannot allocate device tracker");
 478
 479     D( "device tracker %p created\n", tracker);
 480
 481     tracker->socket.enqueue = device_tracker_enqueue;
 482     tracker->socket.ready   = device_tracker_ready;
 483     tracker->socket.close   = device_tracker_close;
 484     tracker->update_needed  = 1;
 485
 486     tracker->next       = device_tracker_list;
 487     device_tracker_list = tracker;
 488
 489     return &tracker->socket;
 490 }
 491
 492
 493 /* call this function each time the transport list has changed */
 494 void  update_transports(void)
 495 {
 496     char             buffer[1024];
 497     int              len;
 498     device_tracker*  tracker;
 499
 500     len = list_transports_msg(buffer, sizeof(buffer));
 501
 502     tracker = device_tracker_list;
 503     while (tracker != NULL) {
 504         device_tracker*  next = tracker->next;
 505         /* note: this may destroy the tracker if the connection is closed */
 506         device_tracker_send(tracker, buffer, len);
 507         tracker = next;
 508     }
 509 }
 510 #else
 511 void  update_transports(void)
 512 {
 513     // nothing to do on the device side
 514 }
 515 #endif // SDB_HOST
 516
 517 typedef struct tmsg tmsg;
 518 struct tmsg
 519 {
 520     atransport *transport;
 521     int         action;
 522 };
 523
 524 static int
 525 transport_read_action(int  fd, struct tmsg*  m)
 526 {
 527     char *p   = (char*)m;
 528     int   len = sizeof(*m);
 529     int   r;
 530
 531     while(len > 0) {
 532         r = sdb_read(fd, p, len);
 533         if(r > 0) {
 534             len -= r;
 535             p   += r;
 536         } else {
 537             if((r < 0) && (errno == EINTR)) continue;
 538             D("transport_read_action: on fd %d, error %d\n",
 539               fd, errno);
 540             return -1;
 541         }
 542     }
 543     return 0;
 544 }
 545
 546 static int
 547 transport_write_action(int  fd, struct tmsg*  m)
 548 {
 549     char *p   = (char*)m;
 550     int   len = sizeof(*m);
 551     int   r;
 552
 553     while(len > 0) {
 554         r = sdb_write(fd, p, len);
 555         if(r > 0) {
 556             len -= r;
 557             p   += r;
 558         } else {
 559             if((r < 0) && (errno == EINTR)) continue;
 560             D("transport_write_action: on fd %d, error %d\n",
 561               fd, errno);
 562             return -1;
 563         }
 564     }
 565     return 0;
 566 }
 567
 568 static void transport_registration_func(int _fd, unsigned ev, void *data)
 569 {
 570     tmsg m;
 571     sdb_thread_t output_thread_ptr;
 572     sdb_thread_t input_thread_ptr;
 573     int s[2];
 574     atransport *t;
 575
 576     if(!(ev & FDE_READ)) {
 577         return;
 578     }
 579
 580     if(transport_read_action(_fd, &m)) {
 581         fatal_errno("cannot read transport registration socket");
 582     }
 583
 584     t = m.transport;
 585
 586     if(m.action == 0){
 587         D("transport: %s removing and free'ing %d\n", t->serial, t->transport_socket);
 588
 589             /* IMPORTANT: the remove closes one half of the
 590             ** socket pair.  The close closes the other half.
 591             */
 592         fdevent_remove(&(t->transport_fde));
 593         sdb_close(t->fd);
 594
 595         sdb_mutex_lock(&transport_lock);
 596         t->next->prev = t->prev;
 597         t->prev->next = t->next;
 598         sdb_mutex_unlock(&transport_lock);
 599
 600         run_transport_disconnects(t);
 601
 602         if (t->product)
 603             free(t->product);
 604         if (t->serial)
 605             free(t->serial);
 606         if (t->device_name)
 607             free(t->device_name);
 608
 609         memset(t,0xee,sizeof(atransport));
 610         free(t);
 611
 612         update_transports();
 613         return;
 614     }
 615
 616     /* don't create transport threads for inaccessible devices */
 617     if (t->connection_state != CS_NOPERM) {
 618         /* initial references are the two threads */
 619         t->ref_count = 2;
 620
 621         if(sdb_socketpair(s)) {
 622             fatal_errno("cannot open transport socketpair");
 623         }
 624
 625         D("transport: %s (%d,%d) starting\n", t->serial, s[0], s[1]);
 626
 627         t->transport_socket = s[0];
 628         t->fd = s[1];
 629
 630         fdevent_install(&(t->transport_fde),
 631                         t->transport_socket,
 632                         transport_socket_events,
 633                         t);
 634
 635         fdevent_set(&(t->transport_fde), FDE_READ);
 636
 637         if(sdb_thread_create(&input_thread_ptr, input_thread, t)){
 638             fatal_errno("cannot create input thread");
 639         }
 640
 641         if(sdb_thread_create(&output_thread_ptr, output_thread, t)){
 642             fatal_errno("cannot create output thread");
 643         }
 644     }
 645
 646         /* put us on the master device list */
 647     sdb_mutex_lock(&transport_lock);
 648     t->next = &transport_list;
 649     t->prev = transport_list.prev;
 650     t->next->prev = t;
 651     t->prev->next = t;
 652     sdb_mutex_unlock(&transport_lock);
 653
 654     t->disconnects.next = t->disconnects.prev = &t->disconnects;
 655
 656     update_transports();
 657 }
 658
 659 void init_transport_registration(void)
 660 {
 661     int s[2];
 662
 663     if(sdb_socketpair(s)){
 664         fatal_errno("cannot open transport registration socketpair");
 665     }
 666
 667     transport_registration_send = s[0];
 668     transport_registration_recv = s[1];
 669
 670     fdevent_install(&transport_registration_fde,
 671                     transport_registration_recv,
 672                     transport_registration_func,
 673                     0);
 674
 675     fdevent_set(&transport_registration_fde, FDE_READ);
 676 }
 677
 678 /* the fdevent select pump is single threaded */
 679 static void register_transport(atransport *transport)
 680 {
 681     tmsg m;
 682     m.transport = transport;
 683     m.action = 1;
 684     D("transport: %s registered\n", transport->serial);
 685     if(transport_write_action(transport_registration_send, &m)) {
 686         fatal_errno("cannot write transport registration socket\n");
 687     }
 688 }
 689
 690 static void remove_transport(atransport *transport)
 691 {
 692     tmsg m;
 693     m.transport = transport;
 694     m.action = 0;
 695     D("transport: %s removed\n", transport->serial);
 696     if(transport_write_action(transport_registration_send, &m)) {
 697         fatal_errno("cannot write transport registration socket\n");
 698     }
 699 }
 700
 701
 702 static void transport_unref_locked(atransport *t)
 703 {
 704     t->ref_count--;
 705     if (t->ref_count == 0) {
 706         D("transport: %s unref (kicking and closing)\n", t->serial);
 707         if (!t->kicked) {
 708             t->kicked = 1;
 709             t->kick(t);
 710         }
 711         t->close(t);
 712         remove_transport(t);
 713     } else {
 714         D("transport: %s unref (count=%d)\n", t->serial, t->ref_count);
 715     }
 716 }
 717
 718 static void transport_unref(atransport *t)
 719 {
 720     if (t) {
 721         sdb_mutex_lock(&transport_lock);
 722         transport_unref_locked(t);
 723         sdb_mutex_unlock(&transport_lock);
 724     }
 725 }
 726
 727 void add_transport_disconnect(atransport*  t, adisconnect*  dis)
 728 {
 729     sdb_mutex_lock(&transport_lock);
 730     dis->next       = &t->disconnects;
 731     dis->prev       = dis->next->prev;
 732     dis->prev->next = dis;
 733     dis->next->prev = dis;
 734     sdb_mutex_unlock(&transport_lock);
 735 }
 736
 737 void remove_transport_disconnect(atransport*  t, adisconnect*  dis)
 738 {
 739     dis->prev->next = dis->next;
 740     dis->next->prev = dis->prev;
 741     dis->next = dis->prev = dis;
 742 }
 743
 744
 745 atransport *acquire_one_transport(int state, transport_type ttype, const char* serial, char** error_out)
 746 {
 747     atransport *t;
 748     atransport *result = NULL;
 749     int ambiguous = 0;
 750
 751 retry:
 752     if (error_out)
 753         *error_out = "device not found";
 754
 755     sdb_mutex_lock(&transport_lock);
 756     for (t = transport_list.next; t != &transport_list; t = t->next) {
 757         if (t->connection_state == CS_NOPERM) {
 758         if (error_out)
 759             *error_out = "insufficient permissions for device";
 760             continue;
 761         }
 762
 763         /* check for matching serial number */
 764         if (serial) {
 765             if (t->serial && !strcmp(serial, t->serial)) {
 766                 result = t;
 767                 break;
 768             }
 769         } else {
 770             if (ttype == kTransportUsb && t->type == kTransportUsb) {
 771                 if (result) {
 772                     if (error_out)
 773                         *error_out = "more than one device";
 774                     ambiguous = 1;
 775                     result = NULL;
 776                     break;
 777                 }
 778                 result = t;
 779             } else if (ttype == kTransportLocal && t->type == kTransportLocal) {
 780                 if (result) {
 781                     if (error_out)
 782                         *error_out = "more than one emulator";
 783                     ambiguous = 1;
 784                     result = NULL;
 785                     break;
 786                 }
 787                 result = t;
 788             } else if (ttype == kTransportAny) {
 789                 if (result) {
 790                     if (error_out)
 791                         *error_out = "more than one device and emulator";
 792                     ambiguous = 1;
 793                     result = NULL;
 794                     break;
 795                 }
 796                 result = t;
 797             }
 798         }
 799     }
 800     sdb_mutex_unlock(&transport_lock);
 801
 802     if (result) {
 803          /* offline devices are ignored -- they are either being born or dying */
 804         if (result && result->connection_state == CS_OFFLINE) {
 805             if (error_out)
 806                 *error_out = "device offline";
 807             result = NULL;
 808         }
 809          /* check for required connection state */
 810         if (result && state != CS_ANY && result->connection_state != state) {
 811             if (error_out)
 812                 *error_out = "invalid device state";
 813             result = NULL;
 814         }
 815     }
 816
 817     if (result) {
 818         /* found one that we can take */
 819         if (error_out)
 820             *error_out = NULL;
 821     } else if (state != CS_ANY && (serial || !ambiguous)) {
 822         sdb_sleep_ms(1000);
 823         goto retry;
 824     }
 825
 826     return result;
 827 }
 828
 829 #if SDB_HOST
 830 static const char *statename(atransport *t)
 831 {
 832     switch(t->connection_state){
 833     case CS_OFFLINE: return "offline";
 834     case CS_BOOTLOADER: return "bootloader";
 835     case CS_DEVICE: return "device";
 836     case CS_HOST: return "host";
 837     case CS_RECOVERY: return "recovery";
 838     case CS_SIDELOAD: return "sideload";
 839     case CS_NOPERM: return "no permissions";
 840     default: return "unknown";
 841     }
 842 }
 843
 844 int list_transports(char *buf, size_t  bufsize)
 845 {
 846     char*       p   = buf;
 847     char*       end = buf + bufsize;
 848     int         len;
 849     atransport *t;
 850
 851         /* XXX OVERRUN PROBLEMS XXX */
 852     sdb_mutex_lock(&transport_lock);
 853     for(t = transport_list.next; t != &transport_list; t = t->next) {
 854         const char* serial = t->serial;
 855         const char* devicename = (t->device_name == NULL) ? DEFAULT_DEVICENAME : t->device_name; /* tizen specific */
 856         if (!serial || !serial[0])
 857             serial = "????????????";
 858         len = snprintf(p, end - p, "%s\t%s\t%s\n", serial, statename(t), devicename);
 859
 860         if (p + len >= end) {
 861             /* discard last line if buffer is too short */
 862             break;
 863         }
 864         p += len;
 865     }
 866     p[0] = 0;
 867     sdb_mutex_unlock(&transport_lock);
 868     return p - buf;
 869 }
 870
 871
 872 /* hack for osx */
 873 void close_usb_devices()
 874 {
 875     atransport *t;
 876
 877     sdb_mutex_lock(&transport_lock);
 878     for(t = transport_list.next; t != &transport_list; t = t->next) {
 879         if ( !t->kicked ) {
 880             t->kicked = 1;
 881             t->kick(t);
 882         }
 883     }
 884     sdb_mutex_unlock(&transport_lock);
 885 }
 886 #endif // SDB_HOST
 887
 888 void register_socket_transport(int s, const char *serial, int port, int local, const char *device_name)
 889 {
 890     atransport *t = calloc(1, sizeof(atransport));
 891     if (t == NULL) {
 892         D("could not allocate atransport'\n");
 893         return;
 894     }
 895     char buff[32];
 896
 897     if (!serial) {
 898         snprintf(buff, sizeof buff, "T-%p", t);
 899         serial = buff;
 900     }
 901     D("transport: %s init'ing for socket %d, on port %d (%s)\n", serial, s, port, device_name);
 902     if ( init_socket_transport(t, s, port, local) < 0 ) {
 903         sdb_close(s);
 904         free(t);
 905 #if SDB_HOST /* tizen specific */
 906         atransport *old_t = find_transport(serial);
 907         if (old_t) {
 908            unregister_transport(old_t);
 909         } else {
 910            D("No such device %s", serial);
 911         }
 912 #endif
 913         return;
 914     }
 915     if(serial) {
 916         t->serial = strdup(serial);
 917     }
 918 #if SDB_HOST /* tizen specific */
 919     if (device_name) {/* tizen specific */
 920         t->device_name = strdup(device_name);
 921     } else { // device_name could be null when sdb server was forked before qemu has sent the connect message.
 922         char device_name[DEVICENAME_MAX];
 923         if (get_devicename_from_shdmem(port, device_name) == 0) {
 924             t->device_name = strdup(device_name);
 925         }
 926     }
 927 #endif
 928     register_transport(t);
 929 }
 930
 931 #if SDB_HOST
 932 atransport *find_transport(const char *serial)
 933 {
 934     atransport *t;
 935
 936     sdb_mutex_lock(&transport_lock);
 937     for(t = transport_list.next; t != &transport_list; t = t->next) {
 938         if (t->serial && !strcmp(serial, t->serial)) {
 939             break;
 940         }
 941      }
 942     sdb_mutex_unlock(&transport_lock);
 943
 944     if (t != &transport_list)
 945         return t;
 946     else
 947         return 0;
 948 }
 949
 950 void unregister_transport(atransport *t)
 951 {
 952     sdb_mutex_lock(&transport_lock);
 953     t->next->prev = t->prev;
 954     t->prev->next = t->next;
 955     sdb_mutex_unlock(&transport_lock);
 956
 957     kick_transport(t);
 958     transport_unref(t);
 959 }
 960
 961 // unregisters all non-emulator TCP transports
 962 void unregister_all_tcp_transports()
 963 {
 964     atransport *t, *next;
 965     sdb_mutex_lock(&transport_lock);
 966     for (t = transport_list.next; t != &transport_list; t = next) {
 967         next = t->next;
 968         if (t->type == kTransportLocal && t->sdb_port == 0) {
 969             t->next->prev = t->prev;
 970             t->prev->next = next;
 971             // we cannot call kick_transport when holding transport_lock
 972             if (!t->kicked)
 973             {
 974                 t->kicked = 1;
 975                 t->kick(t);
 976             }
 977             transport_unref_locked(t);
 978         }
 979      }
 980
 981     sdb_mutex_unlock(&transport_lock);
 982 }
 983
 984 #endif
 985
 986 int get_connected_count(transport_type type) /* tizen specific */
 987 {
 988     int cnt = 0;
 989     atransport *t;
 990     sdb_mutex_lock(&transport_lock);
 991     for(t = transport_list.next; t != &transport_list; t = t->next) {
 992         if (type == kTransportAny || type == t->type)
 993             cnt++;
 994      }
 995     sdb_mutex_unlock(&transport_lock);
 996     if (type == kTransportUsb) {
 997         D("connected device count:%d\n",cnt);
 998     }
 999     return cnt;
1000 }
1001
1002 void broadcast_transport(apacket *p)
1003 {
1004     atransport *t;
1005     sdb_mutex_lock(&transport_lock);
1006     for(t = transport_list.next; t != &transport_list; t = t->next) {
1007         D("broadcast device transport:%d\n", t->connection_state);
1008         apacket* ap = get_apacket();
1009         copy_packet(ap, p);
1010
1011         send_packet(ap, t);
1012         if (is_pwlocked()) {
1013             t->connection_state = CS_PWLOCK;
1014         } else {
1015             t->connection_state = CS_DEVICE;
1016         }
1017      }
1018     sdb_mutex_unlock(&transport_lock);
1019 }
1020
1021 void register_usb_transport(usb_handle *usb, const char *serial, unsigned writeable)
1022 {
1023     atransport *t = calloc(1, sizeof(atransport));
1024     if (t == NULL) {
1025         D("cannot allocate atransport");
1026         return;
1027     }
1028     char device_name[256];
1029
1030     D("transport: %p init'ing for usb_handle %p (sn='%s')\n", t, usb,
1031       serial ? serial : "");
1032     init_usb_transport(t, usb, (writeable ? CS_OFFLINE : CS_NOPERM));
1033     if(serial) {
1034         t->serial = strdup(serial);
1035     }
1036
1037     /* tizen specific */
1038     snprintf(device_name, sizeof(device_name), "device-%d",get_connected_count(kTransportUsb)+1);
1039     t->device_name = strdup(device_name);
1040     register_transport(t);
1041 }
1042
1043 /* this should only be used for transports with connection_state == CS_NOPERM */
1044 void unregister_usb_transport(usb_handle *usb)
1045 {
1046     atransport *t;
1047     sdb_mutex_lock(&transport_lock);
1048     for(t = transport_list.next; t != &transport_list; t = t->next) {
1049         if (t->usb == usb && t->connection_state == CS_NOPERM) {
1050             t->next->prev = t->prev;
1051             t->prev->next = t->next;
1052             break;
1053         }
1054      }
1055     sdb_mutex_unlock(&transport_lock);
1056 }
1057
1058 #undef TRACE_TAG
1059 #define TRACE_TAG  TRACE_RWX
1060
1061 int readx(int fd, void *ptr, size_t len)
1062 {
1063     char *p = ptr;
1064     int r;
1065 #if SDB_TRACE
1066     int  len0 = len;
1067 #endif
1068     D("readx: fd=%d wanted=%d\n", fd, (int)len);
1069     while(len > 0) {
1070         r = sdb_read(fd, p, len);
1071         if(r > 0) {
1072             len -= r;
1073             p += r;
1074         } else {
1075             if (r < 0) {
1076                 D("readx: fd=%d (errno:%d)\n", fd, errno);
1077                 if (errno == EINTR)
1078                     continue;
1079             } else {
1080                 D("readx: fd=%d disconnected\n", fd);
1081             }
1082             return -1;
1083         }
1084     }
1085
1086 #if SDB_TRACE
1087     D("readx: fd=%d wanted=%d got=%d\n", fd, len0, len0 - len);
1088     dump_hex( ptr, len0 );
1089 #endif
1090     return 0;
1091 }
1092
1093 int writex(int fd, const void *ptr, size_t len)
1094 {
1095     char *p = (char*) ptr;
1096     int r;
1097
1098 #if SDB_TRACE
1099     D("writex: fd=%d len=%d: ", fd, (int)len);
1100     dump_hex( ptr, len );
1101 #endif
1102     while(len > 0) {
1103         r = sdb_write(fd, p, len);
1104         if(r > 0) {
1105             len -= r;
1106             p += r;
1107         } else {
1108             if (r < 0) {
1109                 D("writex: fd=%d error %d\n", fd, errno);
1110                 if (errno == EINTR)
1111                     continue;
1112             } else {
1113                 D("writex: fd=%d disconnected\n", fd);
1114             }
1115             return -1;
1116         }
1117     }
1118     return 0;
1119 }
1120
1121 int check_header(apacket *p)
1122 {
1123     if(p->msg.magic != (p->msg.command ^ 0xffffffff)) {
1124         D("check_header(): invalid magic\n");
1125         return -1;
1126     }
1127
1128     if(p->msg.data_length > MAX_PAYLOAD) {
1129         D("check_header(): %d > MAX_PAYLOAD\n", p->msg.data_length);
1130         return -1;
1131     }
1132
1133     return 0;
1134 }
1135
1136 int check_data(apacket *p)
1137 {
1138     unsigned count, sum;
1139     unsigned char *x;
1140
1141     count = p->msg.data_length;
1142     x = p->data;
1143     sum = 0;
1144     while(count-- > 0) {
1145         sum += *x++;
1146     }
1147
1148     if(sum != p->msg.data_check) {
1149         return -1;
1150     } else {
1151         return 0;
1152     }
1153 }