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