Home | History | Annotate | Download | only in adb
      1 #include "sysdeps.h"
      2 #include <windows.h>
      3 #include <winsock2.h>
      4 #include <stdio.h>
      5 #include <errno.h>
      6 #define  TRACE_TAG  TRACE_SYSDEPS
      7 #include "adb.h"
      8 
      9 extern void fatal(const char *fmt, ...);
     10 
     11 #define assert(cond)  do { if (!(cond)) fatal( "assertion failed '%s' on %s:%ld\n", #cond, __FILE__, __LINE__ ); } while (0)
     12 
     13 /**************************************************************************/
     14 /**************************************************************************/
     15 /*****                                                                *****/
     16 /*****      replaces libs/cutils/load_file.c                          *****/
     17 /*****                                                                *****/
     18 /**************************************************************************/
     19 /**************************************************************************/
     20 
     21 void *load_file(const char *fn, unsigned *_sz)
     22 {
     23     HANDLE    file;
     24     char     *data;
     25     DWORD     file_size;
     26 
     27     file = CreateFile( fn,
     28                        GENERIC_READ,
     29                        FILE_SHARE_READ,
     30                        NULL,
     31                        OPEN_EXISTING,
     32                        0,
     33                        NULL );
     34 
     35     if (file == INVALID_HANDLE_VALUE)
     36         return NULL;
     37 
     38     file_size = GetFileSize( file, NULL );
     39     data      = NULL;
     40 
     41     if (file_size > 0) {
     42         data = (char*) malloc( file_size + 1 );
     43         if (data == NULL) {
     44             D("load_file: could not allocate %ld bytes\n", file_size );
     45             file_size = 0;
     46         } else {
     47             DWORD  out_bytes;
     48 
     49             if ( !ReadFile( file, data, file_size, &out_bytes, NULL ) ||
     50                  out_bytes != file_size )
     51             {
     52                 D("load_file: could not read %ld bytes from '%s'\n", file_size, fn);
     53                 free(data);
     54                 data      = NULL;
     55                 file_size = 0;
     56             }
     57         }
     58     }
     59     CloseHandle( file );
     60 
     61     *_sz = (unsigned) file_size;
     62     return  data;
     63 }
     64 
     65 /**************************************************************************/
     66 /**************************************************************************/
     67 /*****                                                                *****/
     68 /*****    common file descriptor handling                             *****/
     69 /*****                                                                *****/
     70 /**************************************************************************/
     71 /**************************************************************************/
     72 
     73 typedef const struct FHClassRec_*   FHClass;
     74 
     75 typedef struct FHRec_*          FH;
     76 
     77 typedef struct EventHookRec_*  EventHook;
     78 
     79 typedef struct FHClassRec_
     80 {
     81     void (*_fh_init) ( FH  f );
     82     int  (*_fh_close)( FH  f );
     83     int  (*_fh_lseek)( FH  f, int  pos, int  origin );
     84     int  (*_fh_read) ( FH  f, void*  buf, int  len );
     85     int  (*_fh_write)( FH  f, const void*  buf, int  len );
     86     void (*_fh_hook) ( FH  f, int  events, EventHook  hook );
     87 
     88 } FHClassRec;
     89 
     90 /* used to emulate unix-domain socket pairs */
     91 typedef struct SocketPairRec_*  SocketPair;
     92 
     93 typedef struct FHRec_
     94 {
     95     FHClass    clazz;
     96     int        used;
     97     int        eof;
     98     union {
     99         HANDLE      handle;
    100         SOCKET      socket;
    101         SocketPair  pair;
    102     } u;
    103 
    104     HANDLE    event;
    105     int       mask;
    106 
    107     char  name[32];
    108 
    109 } FHRec;
    110 
    111 #define  fh_handle  u.handle
    112 #define  fh_socket  u.socket
    113 #define  fh_pair    u.pair
    114 
    115 #define  WIN32_FH_BASE    100
    116 
    117 #define  WIN32_MAX_FHS    128
    118 
    119 static adb_mutex_t   _win32_lock;
    120 static  FHRec        _win32_fhs[ WIN32_MAX_FHS ];
    121 static  int          _win32_fh_count;
    122 
    123 static FH
    124 _fh_from_int( int   fd )
    125 {
    126     FH  f;
    127 
    128     fd -= WIN32_FH_BASE;
    129 
    130     if (fd < 0 || fd >= _win32_fh_count) {
    131         D( "_fh_from_int: invalid fd %d\n", fd + WIN32_FH_BASE );
    132         errno = EBADF;
    133         return NULL;
    134     }
    135 
    136     f = &_win32_fhs[fd];
    137 
    138     if (f->used == 0) {
    139         D( "_fh_from_int: invalid fd %d\n", fd + WIN32_FH_BASE );
    140         errno = EBADF;
    141         return NULL;
    142     }
    143 
    144     return f;
    145 }
    146 
    147 
    148 static int
    149 _fh_to_int( FH  f )
    150 {
    151     if (f && f->used && f >= _win32_fhs && f < _win32_fhs + WIN32_MAX_FHS)
    152         return (int)(f - _win32_fhs) + WIN32_FH_BASE;
    153 
    154     return -1;
    155 }
    156 
    157 static FH
    158 _fh_alloc( FHClass  clazz )
    159 {
    160     int  nn;
    161     FH   f = NULL;
    162 
    163     adb_mutex_lock( &_win32_lock );
    164 
    165     if (_win32_fh_count < WIN32_MAX_FHS) {
    166         f = &_win32_fhs[ _win32_fh_count++ ];
    167         goto Exit;
    168     }
    169 
    170     for (nn = 0; nn < WIN32_MAX_FHS; nn++) {
    171         if ( _win32_fhs[nn].clazz == NULL) {
    172             f = &_win32_fhs[nn];
    173             goto Exit;
    174         }
    175     }
    176     D( "_fh_alloc: no more free file descriptors\n" );
    177 Exit:
    178     if (f) {
    179         f->clazz = clazz;
    180         f->used  = 1;
    181         f->eof   = 0;
    182         clazz->_fh_init(f);
    183     }
    184     adb_mutex_unlock( &_win32_lock );
    185     return f;
    186 }
    187 
    188 
    189 static int
    190 _fh_close( FH   f )
    191 {
    192     if ( f->used ) {
    193         f->clazz->_fh_close( f );
    194         f->used = 0;
    195         f->eof  = 0;
    196         f->clazz = NULL;
    197     }
    198     return 0;
    199 }
    200 
    201 /* forward definitions */
    202 static const FHClassRec   _fh_file_class;
    203 static const FHClassRec   _fh_socket_class;
    204 
    205 /**************************************************************************/
    206 /**************************************************************************/
    207 /*****                                                                *****/
    208 /*****    file-based descriptor handling                              *****/
    209 /*****                                                                *****/
    210 /**************************************************************************/
    211 /**************************************************************************/
    212 
    213 static void
    214 _fh_file_init( FH  f )
    215 {
    216     f->fh_handle = INVALID_HANDLE_VALUE;
    217 }
    218 
    219 static int
    220 _fh_file_close( FH  f )
    221 {
    222     CloseHandle( f->fh_handle );
    223     f->fh_handle = INVALID_HANDLE_VALUE;
    224     return 0;
    225 }
    226 
    227 static int
    228 _fh_file_read( FH  f,  void*  buf, int   len )
    229 {
    230     DWORD  read_bytes;
    231 
    232     if ( !ReadFile( f->fh_handle, buf, (DWORD)len, &read_bytes, NULL ) ) {
    233         D( "adb_read: could not read %d bytes from %s\n", len, f->name );
    234         errno = EIO;
    235         return -1;
    236     } else if (read_bytes < (DWORD)len) {
    237         f->eof = 1;
    238     }
    239     return (int)read_bytes;
    240 }
    241 
    242 static int
    243 _fh_file_write( FH  f,  const void*  buf, int   len )
    244 {
    245     DWORD  wrote_bytes;
    246 
    247     if ( !WriteFile( f->fh_handle, buf, (DWORD)len, &wrote_bytes, NULL ) ) {
    248         D( "adb_file_write: could not write %d bytes from %s\n", len, f->name );
    249         errno = EIO;
    250         return -1;
    251     } else if (wrote_bytes < (DWORD)len) {
    252         f->eof = 1;
    253     }
    254     return  (int)wrote_bytes;
    255 }
    256 
    257 static int
    258 _fh_file_lseek( FH  f, int  pos, int  origin )
    259 {
    260     DWORD  method;
    261     DWORD  result;
    262 
    263     switch (origin)
    264     {
    265         case SEEK_SET:  method = FILE_BEGIN; break;
    266         case SEEK_CUR:  method = FILE_CURRENT; break;
    267         case SEEK_END:  method = FILE_END; break;
    268         default:
    269             errno = EINVAL;
    270             return -1;
    271     }
    272 
    273     result = SetFilePointer( f->fh_handle, pos, NULL, method );
    274     if (result == INVALID_SET_FILE_POINTER) {
    275         errno = EIO;
    276         return -1;
    277     } else {
    278         f->eof = 0;
    279     }
    280     return (int)result;
    281 }
    282 
    283 static void  _fh_file_hook( FH  f, int  event, EventHook  eventhook );  /* forward */
    284 
    285 static const FHClassRec  _fh_file_class =
    286 {
    287     _fh_file_init,
    288     _fh_file_close,
    289     _fh_file_lseek,
    290     _fh_file_read,
    291     _fh_file_write,
    292     _fh_file_hook
    293 };
    294 
    295 /**************************************************************************/
    296 /**************************************************************************/
    297 /*****                                                                *****/
    298 /*****    file-based descriptor handling                              *****/
    299 /*****                                                                *****/
    300 /**************************************************************************/
    301 /**************************************************************************/
    302 
    303 int  adb_open(const char*  path, int  options)
    304 {
    305     FH  f;
    306 
    307     DWORD  desiredAccess       = 0;
    308     DWORD  shareMode           = FILE_SHARE_READ | FILE_SHARE_WRITE;
    309 
    310     switch (options) {
    311         case O_RDONLY:
    312             desiredAccess = GENERIC_READ;
    313             break;
    314         case O_WRONLY:
    315             desiredAccess = GENERIC_WRITE;
    316             break;
    317         case O_RDWR:
    318             desiredAccess = GENERIC_READ | GENERIC_WRITE;
    319             break;
    320         default:
    321             D("adb_open: invalid options (0x%0x)\n", options);
    322             errno = EINVAL;
    323             return -1;
    324     }
    325 
    326     f = _fh_alloc( &_fh_file_class );
    327     if ( !f ) {
    328         errno = ENOMEM;
    329         return -1;
    330     }
    331 
    332     f->fh_handle = CreateFile( path, desiredAccess, shareMode, NULL, OPEN_EXISTING,
    333                                0, NULL );
    334 
    335     if ( f->fh_handle == INVALID_HANDLE_VALUE ) {
    336         _fh_close(f);
    337         D( "adb_open: could not open '%s':", path );
    338         switch (GetLastError()) {
    339             case ERROR_FILE_NOT_FOUND:
    340                 D( "file not found\n" );
    341                 errno = ENOENT;
    342                 return -1;
    343 
    344             case ERROR_PATH_NOT_FOUND:
    345                 D( "path not found\n" );
    346                 errno = ENOTDIR;
    347                 return -1;
    348 
    349             default:
    350                 D( "unknown error\n" );
    351                 errno = ENOENT;
    352                 return -1;
    353         }
    354     }
    355 
    356     snprintf( f->name, sizeof(f->name), "%d(%s)", _fh_to_int(f), path );
    357     D( "adb_open: '%s' => fd %d\n", path, _fh_to_int(f) );
    358     return _fh_to_int(f);
    359 }
    360 
    361 /* ignore mode on Win32 */
    362 int  adb_creat(const char*  path, int  mode)
    363 {
    364     FH  f;
    365 
    366     f = _fh_alloc( &_fh_file_class );
    367     if ( !f ) {
    368         errno = ENOMEM;
    369         return -1;
    370     }
    371 
    372     f->fh_handle = CreateFile( path, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
    373                                NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,
    374                                NULL );
    375 
    376     if ( f->fh_handle == INVALID_HANDLE_VALUE ) {
    377         _fh_close(f);
    378         D( "adb_creat: could not open '%s':", path );
    379         switch (GetLastError()) {
    380             case ERROR_FILE_NOT_FOUND:
    381                 D( "file not found\n" );
    382                 errno = ENOENT;
    383                 return -1;
    384 
    385             case ERROR_PATH_NOT_FOUND:
    386                 D( "path not found\n" );
    387                 errno = ENOTDIR;
    388                 return -1;
    389 
    390             default:
    391                 D( "unknown error\n" );
    392                 errno = ENOENT;
    393                 return -1;
    394         }
    395     }
    396     snprintf( f->name, sizeof(f->name), "%d(%s)", _fh_to_int(f), path );
    397     D( "adb_creat: '%s' => fd %d\n", path, _fh_to_int(f) );
    398     return _fh_to_int(f);
    399 }
    400 
    401 
    402 int  adb_read(int  fd, void* buf, int len)
    403 {
    404     FH     f = _fh_from_int(fd);
    405 
    406     if (f == NULL) {
    407         return -1;
    408     }
    409 
    410     return f->clazz->_fh_read( f, buf, len );
    411 }
    412 
    413 
    414 int  adb_write(int  fd, const void*  buf, int  len)
    415 {
    416     FH     f = _fh_from_int(fd);
    417 
    418     if (f == NULL) {
    419         return -1;
    420     }
    421 
    422     return f->clazz->_fh_write(f, buf, len);
    423 }
    424 
    425 
    426 int  adb_lseek(int  fd, int  pos, int  where)
    427 {
    428     FH     f = _fh_from_int(fd);
    429 
    430     if (!f) {
    431         return -1;
    432     }
    433 
    434     return f->clazz->_fh_lseek(f, pos, where);
    435 }
    436 
    437 
    438 int  adb_shutdown(int  fd)
    439 {
    440     FH   f = _fh_from_int(fd);
    441 
    442     if (!f) {
    443         return -1;
    444     }
    445 
    446     D( "adb_shutdown: %s\n", f->name);
    447     shutdown( f->fh_socket, SD_BOTH );
    448     return 0;
    449 }
    450 
    451 
    452 int  adb_close(int  fd)
    453 {
    454     FH   f = _fh_from_int(fd);
    455 
    456     if (!f) {
    457         return -1;
    458     }
    459 
    460     D( "adb_close: %s\n", f->name);
    461     _fh_close(f);
    462     return 0;
    463 }
    464 
    465 /**************************************************************************/
    466 /**************************************************************************/
    467 /*****                                                                *****/
    468 /*****    socket-based file descriptors                               *****/
    469 /*****                                                                *****/
    470 /**************************************************************************/
    471 /**************************************************************************/
    472 
    473 static void
    474 _socket_set_errno( void )
    475 {
    476     switch (WSAGetLastError()) {
    477     case 0:              errno = 0; break;
    478     case WSAEWOULDBLOCK: errno = EAGAIN; break;
    479     case WSAEINTR:       errno = EINTR; break;
    480     default:
    481         D( "_socket_set_errno: unhandled value %d\n", WSAGetLastError() );
    482         errno = EINVAL;
    483     }
    484 }
    485 
    486 static void
    487 _fh_socket_init( FH  f )
    488 {
    489     f->fh_socket = INVALID_SOCKET;
    490     f->event     = WSACreateEvent();
    491     f->mask      = 0;
    492 }
    493 
    494 static int
    495 _fh_socket_close( FH  f )
    496 {
    497     /* gently tell any peer that we're closing the socket */
    498     shutdown( f->fh_socket, SD_BOTH );
    499     closesocket( f->fh_socket );
    500     f->fh_socket = INVALID_SOCKET;
    501     CloseHandle( f->event );
    502     f->mask = 0;
    503     return 0;
    504 }
    505 
    506 static int
    507 _fh_socket_lseek( FH  f, int pos, int origin )
    508 {
    509     errno = EPIPE;
    510     return -1;
    511 }
    512 
    513 static int
    514 _fh_socket_read( FH  f, void*  buf, int  len )
    515 {
    516     int  result = recv( f->fh_socket, buf, len, 0 );
    517     if (result == SOCKET_ERROR) {
    518         _socket_set_errno();
    519         result = -1;
    520     }
    521     return  result;
    522 }
    523 
    524 static int
    525 _fh_socket_write( FH  f, const void*  buf, int  len )
    526 {
    527     int  result = send( f->fh_socket, buf, len, 0 );
    528     if (result == SOCKET_ERROR) {
    529         _socket_set_errno();
    530         result = -1;
    531     }
    532     return result;
    533 }
    534 
    535 static void  _fh_socket_hook( FH  f, int  event, EventHook  hook );  /* forward */
    536 
    537 static const FHClassRec  _fh_socket_class =
    538 {
    539     _fh_socket_init,
    540     _fh_socket_close,
    541     _fh_socket_lseek,
    542     _fh_socket_read,
    543     _fh_socket_write,
    544     _fh_socket_hook
    545 };
    546 
    547 /**************************************************************************/
    548 /**************************************************************************/
    549 /*****                                                                *****/
    550 /*****    replacement for libs/cutils/socket_xxxx.c                   *****/
    551 /*****                                                                *****/
    552 /**************************************************************************/
    553 /**************************************************************************/
    554 
    555 #include <winsock2.h>
    556 
    557 static int  _winsock_init;
    558 
    559 static void
    560 _cleanup_winsock( void )
    561 {
    562     WSACleanup();
    563 }
    564 
    565 static void
    566 _init_winsock( void )
    567 {
    568     if (!_winsock_init) {
    569         WSADATA  wsaData;
    570         int      rc = WSAStartup( MAKEWORD(2,2), &wsaData);
    571         if (rc != 0) {
    572             fatal( "adb: could not initialize Winsock\n" );
    573         }
    574         atexit( _cleanup_winsock );
    575         _winsock_init = 1;
    576     }
    577 }
    578 
    579 int socket_loopback_client(int port, int type)
    580 {
    581     FH  f = _fh_alloc( &_fh_socket_class );
    582     struct sockaddr_in addr;
    583     SOCKET  s;
    584 
    585     if (!f)
    586         return -1;
    587 
    588     if (!_winsock_init)
    589         _init_winsock();
    590 
    591     memset(&addr, 0, sizeof(addr));
    592     addr.sin_family = AF_INET;
    593     addr.sin_port = htons(port);
    594     addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    595 
    596     s = socket(AF_INET, type, 0);
    597     if(s == INVALID_SOCKET) {
    598         D("socket_loopback_client: could not create socket\n" );
    599         _fh_close(f);
    600         return -1;
    601     }
    602 
    603     f->fh_socket = s;
    604     if(connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
    605         D("socket_loopback_client: could not connect to %s:%d\n", type != SOCK_STREAM ? "udp" : "tcp", port );
    606         _fh_close(f);
    607         return -1;
    608     }
    609     snprintf( f->name, sizeof(f->name), "%d(lo-client:%s%d)", _fh_to_int(f), type != SOCK_STREAM ? "udp:" : "", port );
    610     D( "socket_loopback_client: port %d type %s => fd %d\n", port, type != SOCK_STREAM ? "udp" : "tcp", _fh_to_int(f) );
    611     return _fh_to_int(f);
    612 }
    613 
    614 #define LISTEN_BACKLOG 4
    615 
    616 int socket_loopback_server(int port, int type)
    617 {
    618     FH   f = _fh_alloc( &_fh_socket_class );
    619     struct sockaddr_in addr;
    620     SOCKET  s;
    621     int  n;
    622 
    623     if (!f) {
    624         return -1;
    625     }
    626 
    627     if (!_winsock_init)
    628         _init_winsock();
    629 
    630     memset(&addr, 0, sizeof(addr));
    631     addr.sin_family = AF_INET;
    632     addr.sin_port = htons(port);
    633     addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    634 
    635     s = socket(AF_INET, type, 0);
    636     if(s == INVALID_SOCKET) return -1;
    637 
    638     f->fh_socket = s;
    639 
    640     n = 1;
    641     setsockopt(s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (const char*)&n, sizeof(n));
    642 
    643     if(bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
    644         _fh_close(f);
    645         return -1;
    646     }
    647     if (type == SOCK_STREAM) {
    648         int ret;
    649 
    650         ret = listen(s, LISTEN_BACKLOG);
    651         if (ret < 0) {
    652             _fh_close(f);
    653             return -1;
    654         }
    655     }
    656     snprintf( f->name, sizeof(f->name), "%d(lo-server:%s%d)", _fh_to_int(f), type != SOCK_STREAM ? "udp:" : "", port );
    657     D( "socket_loopback_server: port %d type %s => fd %d\n", port, type != SOCK_STREAM ? "udp" : "tcp", _fh_to_int(f) );
    658     return _fh_to_int(f);
    659 }
    660 
    661 
    662 int socket_network_client(const char *host, int port, int type)
    663 {
    664     FH  f = _fh_alloc( &_fh_socket_class );
    665     struct hostent *hp;
    666     struct sockaddr_in addr;
    667     SOCKET s;
    668 
    669     if (!f)
    670         return -1;
    671 
    672     if (!_winsock_init)
    673         _init_winsock();
    674 
    675     hp = gethostbyname(host);
    676     if(hp == 0) {
    677         _fh_close(f);
    678         return -1;
    679     }
    680 
    681     memset(&addr, 0, sizeof(addr));
    682     addr.sin_family = hp->h_addrtype;
    683     addr.sin_port = htons(port);
    684     memcpy(&addr.sin_addr, hp->h_addr, hp->h_length);
    685 
    686     s = socket(hp->h_addrtype, type, 0);
    687     if(s == INVALID_SOCKET) {
    688         _fh_close(f);
    689         return -1;
    690     }
    691     f->fh_socket = s;
    692 
    693     if(connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
    694         _fh_close(f);
    695         return -1;
    696     }
    697 
    698     snprintf( f->name, sizeof(f->name), "%d(net-client:%s%d)", _fh_to_int(f), type != SOCK_STREAM ? "udp:" : "", port );
    699     D( "socket_network_client: host '%s' port %d type %s => fd %d\n", host, port, type != SOCK_STREAM ? "udp" : "tcp", _fh_to_int(f) );
    700     return _fh_to_int(f);
    701 }
    702 
    703 
    704 int socket_inaddr_any_server(int port, int type)
    705 {
    706     FH  f = _fh_alloc( &_fh_socket_class );
    707     struct sockaddr_in addr;
    708     SOCKET  s;
    709     int n;
    710 
    711     if (!f)
    712         return -1;
    713 
    714     if (!_winsock_init)
    715         _init_winsock();
    716 
    717     memset(&addr, 0, sizeof(addr));
    718     addr.sin_family = AF_INET;
    719     addr.sin_port = htons(port);
    720     addr.sin_addr.s_addr = htonl(INADDR_ANY);
    721 
    722     s = socket(AF_INET, type, 0);
    723     if(s == INVALID_SOCKET) {
    724         _fh_close(f);
    725         return -1;
    726     }
    727 
    728     f->fh_socket = s;
    729     n = 1;
    730     setsockopt(s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (const char*)&n, sizeof(n));
    731 
    732     if(bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
    733         _fh_close(f);
    734         return -1;
    735     }
    736 
    737     if (type == SOCK_STREAM) {
    738         int ret;
    739 
    740         ret = listen(s, LISTEN_BACKLOG);
    741         if (ret < 0) {
    742             _fh_close(f);
    743             return -1;
    744         }
    745     }
    746     snprintf( f->name, sizeof(f->name), "%d(any-server:%s%d)", _fh_to_int(f), type != SOCK_STREAM ? "udp:" : "", port );
    747     D( "socket_inaddr_server: port %d type %s => fd %d\n", port, type != SOCK_STREAM ? "udp" : "tcp", _fh_to_int(f) );
    748     return _fh_to_int(f);
    749 }
    750 
    751 #undef accept
    752 int  adb_socket_accept(int  serverfd, struct sockaddr*  addr, socklen_t  *addrlen)
    753 {
    754     FH   serverfh = _fh_from_int(serverfd);
    755     FH   fh;
    756 
    757     if ( !serverfh || serverfh->clazz != &_fh_socket_class ) {
    758         D( "adb_socket_accept: invalid fd %d\n", serverfd );
    759         return -1;
    760     }
    761 
    762     fh = _fh_alloc( &_fh_socket_class );
    763     if (!fh) {
    764         D( "adb_socket_accept: not enough memory to allocate accepted socket descriptor\n" );
    765         return -1;
    766     }
    767 
    768     fh->fh_socket = accept( serverfh->fh_socket, addr, addrlen );
    769     if (fh->fh_socket == INVALID_SOCKET) {
    770         _fh_close( fh );
    771         D( "adb_socket_accept: accept on fd %d return error %ld\n", serverfd, GetLastError() );
    772         return -1;
    773     }
    774 
    775     snprintf( fh->name, sizeof(fh->name), "%d(accept:%s)", _fh_to_int(fh), serverfh->name );
    776     D( "adb_socket_accept on fd %d returns fd %d\n", serverfd, _fh_to_int(fh) );
    777     return  _fh_to_int(fh);
    778 }
    779 
    780 
    781 void  disable_tcp_nagle(int fd)
    782 {
    783     FH   fh = _fh_from_int(fd);
    784     int  on;
    785 
    786     if ( !fh || fh->clazz != &_fh_socket_class )
    787         return;
    788 
    789     setsockopt( fh->fh_socket, IPPROTO_TCP, TCP_NODELAY, (const char*)&on, sizeof(on) );
    790 }
    791 
    792 /**************************************************************************/
    793 /**************************************************************************/
    794 /*****                                                                *****/
    795 /*****    emulated socketpairs                                       *****/
    796 /*****                                                                *****/
    797 /**************************************************************************/
    798 /**************************************************************************/
    799 
    800 /* we implement socketpairs directly in use space for the following reasons:
    801  *   - it avoids copying data from/to the Nt kernel
    802  *   - it allows us to implement fdevent hooks easily and cheaply, something
    803  *     that is not possible with standard Win32 pipes !!
    804  *
    805  * basically, we use two circular buffers, each one corresponding to a given
    806  * direction.
    807  *
    808  * each buffer is implemented as two regions:
    809  *
    810  *   region A which is (a_start,a_end)
    811  *   region B which is (0, b_end)  with b_end <= a_start
    812  *
    813  * an empty buffer has:  a_start = a_end = b_end = 0
    814  *
    815  * a_start is the pointer where we start reading data
    816  * a_end is the pointer where we start writing data, unless it is BUFFER_SIZE,
    817  * then you start writing at b_end
    818  *
    819  * the buffer is full when  b_end == a_start && a_end == BUFFER_SIZE
    820  *
    821  * there is room when b_end < a_start || a_end < BUFER_SIZE
    822  *
    823  * when reading, a_start is incremented, it a_start meets a_end, then
    824  * we do:  a_start = 0, a_end = b_end, b_end = 0, and keep going on..
    825  */
    826 
    827 #define  BIP_BUFFER_SIZE   4096
    828 
    829 #if 0
    830 #include <stdio.h>
    831 #  define  BIPD(x)      D x
    832 #  define  BIPDUMP   bip_dump_hex
    833 
    834 static void  bip_dump_hex( const unsigned char*  ptr, size_t  len )
    835 {
    836     int  nn, len2 = len;
    837 
    838     if (len2 > 8) len2 = 8;
    839 
    840     for (nn = 0; nn < len2; nn++)
    841         printf("%02x", ptr[nn]);
    842     printf("  ");
    843 
    844     for (nn = 0; nn < len2; nn++) {
    845         int  c = ptr[nn];
    846         if (c < 32 || c > 127)
    847             c = '.';
    848         printf("%c", c);
    849     }
    850     printf("\n");
    851     fflush(stdout);
    852 }
    853 
    854 #else
    855 #  define  BIPD(x)        do {} while (0)
    856 #  define  BIPDUMP(p,l)   BIPD(p)
    857 #endif
    858 
    859 typedef struct BipBufferRec_
    860 {
    861     int                a_start;
    862     int                a_end;
    863     int                b_end;
    864     int                fdin;
    865     int                fdout;
    866     int                closed;
    867     int                can_write;  /* boolean */
    868     HANDLE             evt_write;  /* event signaled when one can write to a buffer  */
    869     int                can_read;   /* boolean */
    870     HANDLE             evt_read;   /* event signaled when one can read from a buffer */
    871     CRITICAL_SECTION  lock;
    872     unsigned char      buff[ BIP_BUFFER_SIZE ];
    873 
    874 } BipBufferRec, *BipBuffer;
    875 
    876 static void
    877 bip_buffer_init( BipBuffer  buffer )
    878 {
    879     D( "bit_buffer_init %p\n", buffer );
    880     buffer->a_start   = 0;
    881     buffer->a_end     = 0;
    882     buffer->b_end     = 0;
    883     buffer->can_write = 1;
    884     buffer->can_read  = 0;
    885     buffer->fdin      = 0;
    886     buffer->fdout     = 0;
    887     buffer->closed    = 0;
    888     buffer->evt_write = CreateEvent( NULL, TRUE, TRUE, NULL );
    889     buffer->evt_read  = CreateEvent( NULL, TRUE, FALSE, NULL );
    890     InitializeCriticalSection( &buffer->lock );
    891 }
    892 
    893 static void
    894 bip_buffer_close( BipBuffer  bip )
    895 {
    896     bip->closed = 1;
    897 
    898     if (!bip->can_read) {
    899         SetEvent( bip->evt_read );
    900     }
    901     if (!bip->can_write) {
    902         SetEvent( bip->evt_write );
    903     }
    904 }
    905 
    906 static void
    907 bip_buffer_done( BipBuffer  bip )
    908 {
    909     BIPD(( "bip_buffer_done: %d->%d\n", bip->fdin, bip->fdout ));
    910     CloseHandle( bip->evt_read );
    911     CloseHandle( bip->evt_write );
    912     DeleteCriticalSection( &bip->lock );
    913 }
    914 
    915 static int
    916 bip_buffer_write( BipBuffer  bip, const void* src, int  len )
    917 {
    918     int  avail, count = 0;
    919 
    920     if (len <= 0)
    921         return 0;
    922 
    923     BIPD(( "bip_buffer_write: enter %d->%d len %d\n", bip->fdin, bip->fdout, len ));
    924     BIPDUMP( src, len );
    925 
    926     EnterCriticalSection( &bip->lock );
    927 
    928     while (!bip->can_write) {
    929         int  ret;
    930         LeaveCriticalSection( &bip->lock );
    931 
    932         if (bip->closed) {
    933             errno = EPIPE;
    934             return -1;
    935         }
    936         /* spinlocking here is probably unfair, but let's live with it */
    937         ret = WaitForSingleObject( bip->evt_write, INFINITE );
    938         if (ret != WAIT_OBJECT_0) {  /* buffer probably closed */
    939             D( "bip_buffer_write: error %d->%d WaitForSingleObject returned %d, error %ld\n", bip->fdin, bip->fdout, ret, GetLastError() );
    940             return 0;
    941         }
    942         if (bip->closed) {
    943             errno = EPIPE;
    944             return -1;
    945         }
    946         EnterCriticalSection( &bip->lock );
    947     }
    948 
    949     BIPD(( "bip_buffer_write: exec %d->%d len %d\n", bip->fdin, bip->fdout, len ));
    950 
    951     avail = BIP_BUFFER_SIZE - bip->a_end;
    952     if (avail > 0)
    953     {
    954         /* we can append to region A */
    955         if (avail > len)
    956             avail = len;
    957 
    958         memcpy( bip->buff + bip->a_end, src, avail );
    959         src   += avail;
    960         count += avail;
    961         len   -= avail;
    962 
    963         bip->a_end += avail;
    964         if (bip->a_end == BIP_BUFFER_SIZE && bip->a_start == 0) {
    965             bip->can_write = 0;
    966             ResetEvent( bip->evt_write );
    967             goto Exit;
    968         }
    969     }
    970 
    971     if (len == 0)
    972         goto Exit;
    973 
    974     avail = bip->a_start - bip->b_end;
    975     assert( avail > 0 );  /* since can_write is TRUE */
    976 
    977     if (avail > len)
    978         avail = len;
    979 
    980     memcpy( bip->buff + bip->b_end, src, avail );
    981     count += avail;
    982     bip->b_end += avail;
    983 
    984     if (bip->b_end == bip->a_start) {
    985         bip->can_write = 0;
    986         ResetEvent( bip->evt_write );
    987     }
    988 
    989 Exit:
    990     assert( count > 0 );
    991 
    992     if ( !bip->can_read ) {
    993         bip->can_read = 1;
    994         SetEvent( bip->evt_read );
    995     }
    996 
    997     BIPD(( "bip_buffer_write: exit %d->%d count %d (as=%d ae=%d be=%d cw=%d cr=%d\n",
    998             bip->fdin, bip->fdout, count, bip->a_start, bip->a_end, bip->b_end, bip->can_write, bip->can_read ));
    999     LeaveCriticalSection( &bip->lock );
   1000 
   1001     return count;
   1002  }
   1003 
   1004 static int
   1005 bip_buffer_read( BipBuffer  bip, void*  dst, int  len )
   1006 {
   1007     int  avail, count = 0;
   1008 
   1009     if (len <= 0)
   1010         return 0;
   1011 
   1012     BIPD(( "bip_buffer_read: enter %d->%d len %d\n", bip->fdin, bip->fdout, len ));
   1013 
   1014     EnterCriticalSection( &bip->lock );
   1015     while ( !bip->can_read )
   1016     {
   1017 #if 0
   1018         LeaveCriticalSection( &bip->lock );
   1019         errno = EAGAIN;
   1020         return -1;
   1021 #else
   1022         int  ret;
   1023         LeaveCriticalSection( &bip->lock );
   1024 
   1025         if (bip->closed) {
   1026             errno = EPIPE;
   1027             return -1;
   1028         }
   1029 
   1030         ret = WaitForSingleObject( bip->evt_read, INFINITE );
   1031         if (ret != WAIT_OBJECT_0) { /* probably closed buffer */
   1032             D( "bip_buffer_read: error %d->%d WaitForSingleObject returned %d, error %ld\n", bip->fdin, bip->fdout, ret, GetLastError());
   1033             return 0;
   1034         }
   1035         if (bip->closed) {
   1036             errno = EPIPE;
   1037             return -1;
   1038         }
   1039         EnterCriticalSection( &bip->lock );
   1040 #endif
   1041     }
   1042 
   1043     BIPD(( "bip_buffer_read: exec %d->%d len %d\n", bip->fdin, bip->fdout, len ));
   1044 
   1045     avail = bip->a_end - bip->a_start;
   1046     assert( avail > 0 );  /* since can_read is TRUE */
   1047 
   1048     if (avail > len)
   1049         avail = len;
   1050 
   1051     memcpy( dst, bip->buff + bip->a_start, avail );
   1052     dst   += avail;
   1053     count += avail;
   1054     len   -= avail;
   1055 
   1056     bip->a_start += avail;
   1057     if (bip->a_start < bip->a_end)
   1058         goto Exit;
   1059 
   1060     bip->a_start = 0;
   1061     bip->a_end   = bip->b_end;
   1062     bip->b_end   = 0;
   1063 
   1064     avail = bip->a_end;
   1065     if (avail > 0) {
   1066         if (avail > len)
   1067             avail = len;
   1068         memcpy( dst, bip->buff, avail );
   1069         count += avail;
   1070         bip->a_start += avail;
   1071 
   1072         if ( bip->a_start < bip->a_end )
   1073             goto Exit;
   1074 
   1075         bip->a_start = bip->a_end = 0;
   1076     }
   1077 
   1078     bip->can_read = 0;
   1079     ResetEvent( bip->evt_read );
   1080 
   1081 Exit:
   1082     assert( count > 0 );
   1083 
   1084     if (!bip->can_write ) {
   1085         bip->can_write = 1;
   1086         SetEvent( bip->evt_write );
   1087     }
   1088 
   1089     BIPDUMP( (const unsigned char*)dst - count, count );
   1090     BIPD(( "bip_buffer_read: exit %d->%d count %d (as=%d ae=%d be=%d cw=%d cr=%d\n",
   1091             bip->fdin, bip->fdout, count, bip->a_start, bip->a_end, bip->b_end, bip->can_write, bip->can_read ));
   1092     LeaveCriticalSection( &bip->lock );
   1093 
   1094     return count;
   1095 }
   1096 
   1097 typedef struct SocketPairRec_
   1098 {
   1099     BipBufferRec  a2b_bip;
   1100     BipBufferRec  b2a_bip;
   1101     FH            a_fd;
   1102     int           used;
   1103 
   1104 } SocketPairRec;
   1105 
   1106 void _fh_socketpair_init( FH  f )
   1107 {
   1108     f->fh_pair = NULL;
   1109 }
   1110 
   1111 static int
   1112 _fh_socketpair_close( FH  f )
   1113 {
   1114     if ( f->fh_pair ) {
   1115         SocketPair  pair = f->fh_pair;
   1116 
   1117         if ( f == pair->a_fd ) {
   1118             pair->a_fd = NULL;
   1119         }
   1120 
   1121         bip_buffer_close( &pair->b2a_bip );
   1122         bip_buffer_close( &pair->a2b_bip );
   1123 
   1124         if ( --pair->used == 0 ) {
   1125             bip_buffer_done( &pair->b2a_bip );
   1126             bip_buffer_done( &pair->a2b_bip );
   1127             free( pair );
   1128         }
   1129         f->fh_pair = NULL;
   1130     }
   1131     return 0;
   1132 }
   1133 
   1134 static int
   1135 _fh_socketpair_lseek( FH  f, int pos, int  origin )
   1136 {
   1137     errno = ESPIPE;
   1138     return -1;
   1139 }
   1140 
   1141 static int
   1142 _fh_socketpair_read( FH  f, void* buf, int  len )
   1143 {
   1144     SocketPair  pair = f->fh_pair;
   1145     BipBuffer   bip;
   1146 
   1147     if (!pair)
   1148         return -1;
   1149 
   1150     if ( f == pair->a_fd )
   1151         bip = &pair->b2a_bip;
   1152     else
   1153         bip = &pair->a2b_bip;
   1154 
   1155     return bip_buffer_read( bip, buf, len );
   1156 }
   1157 
   1158 static int
   1159 _fh_socketpair_write( FH  f, const void*  buf, int  len )
   1160 {
   1161     SocketPair  pair = f->fh_pair;
   1162     BipBuffer   bip;
   1163 
   1164     if (!pair)
   1165         return -1;
   1166 
   1167     if ( f == pair->a_fd )
   1168         bip = &pair->a2b_bip;
   1169     else
   1170         bip = &pair->b2a_bip;
   1171 
   1172     return bip_buffer_write( bip, buf, len );
   1173 }
   1174 
   1175 
   1176 static void  _fh_socketpair_hook( FH  f, int  event, EventHook  hook );  /* forward */
   1177 
   1178 static const FHClassRec  _fh_socketpair_class =
   1179 {
   1180     _fh_socketpair_init,
   1181     _fh_socketpair_close,
   1182     _fh_socketpair_lseek,
   1183     _fh_socketpair_read,
   1184     _fh_socketpair_write,
   1185     _fh_socketpair_hook
   1186 };
   1187 
   1188 
   1189 int  adb_socketpair( int  sv[2] )
   1190 {
   1191     FH          fa, fb;
   1192     SocketPair  pair;
   1193 
   1194     fa = _fh_alloc( &_fh_socketpair_class );
   1195     fb = _fh_alloc( &_fh_socketpair_class );
   1196 
   1197     if (!fa || !fb)
   1198         goto Fail;
   1199 
   1200     pair = malloc( sizeof(*pair) );
   1201     if (pair == NULL) {
   1202         D("adb_socketpair: not enough memory to allocate pipes\n" );
   1203         goto Fail;
   1204     }
   1205 
   1206     bip_buffer_init( &pair->a2b_bip );
   1207     bip_buffer_init( &pair->b2a_bip );
   1208 
   1209     fa->fh_pair = pair;
   1210     fb->fh_pair = pair;
   1211     pair->used  = 2;
   1212     pair->a_fd  = fa;
   1213 
   1214     sv[0] = _fh_to_int(fa);
   1215     sv[1] = _fh_to_int(fb);
   1216 
   1217     pair->a2b_bip.fdin  = sv[0];
   1218     pair->a2b_bip.fdout = sv[1];
   1219     pair->b2a_bip.fdin  = sv[1];
   1220     pair->b2a_bip.fdout = sv[0];
   1221 
   1222     snprintf( fa->name, sizeof(fa->name), "%d(pair:%d)", sv[0], sv[1] );
   1223     snprintf( fb->name, sizeof(fb->name), "%d(pair:%d)", sv[1], sv[0] );
   1224     D( "adb_socketpair: returns (%d, %d)\n", sv[0], sv[1] );
   1225     return 0;
   1226 
   1227 Fail:
   1228     _fh_close(fb);
   1229     _fh_close(fa);
   1230     return -1;
   1231 }
   1232 
   1233 /**************************************************************************/
   1234 /**************************************************************************/
   1235 /*****                                                                *****/
   1236 /*****    fdevents emulation                                          *****/
   1237 /*****                                                                *****/
   1238 /*****   this is a very simple implementation, we rely on the fact    *****/
   1239 /*****   that ADB doesn't use FDE_ERROR.                              *****/
   1240 /*****                                                                *****/
   1241 /**************************************************************************/
   1242 /**************************************************************************/
   1243 
   1244 #define FATAL(x...) fatal(__FUNCTION__, x)
   1245 
   1246 #if DEBUG
   1247 static void dump_fde(fdevent *fde, const char *info)
   1248 {
   1249     fprintf(stderr,"FDE #%03d %c%c%c %s\n", fde->fd,
   1250             fde->state & FDE_READ ? 'R' : ' ',
   1251             fde->state & FDE_WRITE ? 'W' : ' ',
   1252             fde->state & FDE_ERROR ? 'E' : ' ',
   1253             info);
   1254 }
   1255 #else
   1256 #define dump_fde(fde, info) do { } while(0)
   1257 #endif
   1258 
   1259 #define FDE_EVENTMASK  0x00ff
   1260 #define FDE_STATEMASK  0xff00
   1261 
   1262 #define FDE_ACTIVE     0x0100
   1263 #define FDE_PENDING    0x0200
   1264 #define FDE_CREATED    0x0400
   1265 
   1266 static void fdevent_plist_enqueue(fdevent *node);
   1267 static void fdevent_plist_remove(fdevent *node);
   1268 static fdevent *fdevent_plist_dequeue(void);
   1269 
   1270 static fdevent list_pending = {
   1271     .next = &list_pending,
   1272     .prev = &list_pending,
   1273 };
   1274 
   1275 static fdevent **fd_table = 0;
   1276 static int       fd_table_max = 0;
   1277 
   1278 typedef struct EventLooperRec_*  EventLooper;
   1279 
   1280 typedef struct EventHookRec_
   1281 {
   1282     EventHook    next;
   1283     FH           fh;
   1284     HANDLE       h;
   1285     int          wanted;   /* wanted event flags */
   1286     int          ready;    /* ready event flags  */
   1287     void*        aux;
   1288     void        (*prepare)( EventHook  hook );
   1289     int         (*start)  ( EventHook  hook );
   1290     void        (*stop)   ( EventHook  hook );
   1291     int         (*check)  ( EventHook  hook );
   1292     int         (*peek)   ( EventHook  hook );
   1293 } EventHookRec;
   1294 
   1295 static EventHook  _free_hooks;
   1296 
   1297 static EventHook
   1298 event_hook_alloc( FH  fh )
   1299 {
   1300     EventHook  hook = _free_hooks;
   1301     if (hook != NULL)
   1302         _free_hooks = hook->next;
   1303     else {
   1304         hook = malloc( sizeof(*hook) );
   1305         if (hook == NULL)
   1306             fatal( "could not allocate event hook\n" );
   1307     }
   1308     hook->next   = NULL;
   1309     hook->fh     = fh;
   1310     hook->wanted = 0;
   1311     hook->ready  = 0;
   1312     hook->h      = INVALID_HANDLE_VALUE;
   1313     hook->aux    = NULL;
   1314 
   1315     hook->prepare = NULL;
   1316     hook->start   = NULL;
   1317     hook->stop    = NULL;
   1318     hook->check   = NULL;
   1319     hook->peek    = NULL;
   1320 
   1321     return hook;
   1322 }
   1323 
   1324 static void
   1325 event_hook_free( EventHook  hook )
   1326 {
   1327     hook->fh     = NULL;
   1328     hook->wanted = 0;
   1329     hook->ready  = 0;
   1330     hook->next   = _free_hooks;
   1331     _free_hooks  = hook;
   1332 }
   1333 
   1334 
   1335 static void
   1336 event_hook_signal( EventHook  hook )
   1337 {
   1338     FH        f   = hook->fh;
   1339     int       fd  = _fh_to_int(f);
   1340     fdevent*  fde = fd_table[ fd - WIN32_FH_BASE ];
   1341 
   1342     if (fde != NULL && fde->fd == fd) {
   1343         if ((fde->state & FDE_PENDING) == 0) {
   1344             fde->state |= FDE_PENDING;
   1345             fdevent_plist_enqueue( fde );
   1346         }
   1347         fde->events |= hook->wanted;
   1348     }
   1349 }
   1350 
   1351 
   1352 #define  MAX_LOOPER_HANDLES  WIN32_MAX_FHS
   1353 
   1354 typedef struct EventLooperRec_
   1355 {
   1356     EventHook    hooks;
   1357     HANDLE       htab[ MAX_LOOPER_HANDLES ];
   1358     int          htab_count;
   1359 
   1360 } EventLooperRec;
   1361 
   1362 static EventHook*
   1363 event_looper_find_p( EventLooper  looper, FH  fh )
   1364 {
   1365     EventHook  *pnode = &looper->hooks;
   1366     EventHook   node  = *pnode;
   1367     for (;;) {
   1368         if ( node == NULL || node->fh == fh )
   1369             break;
   1370         pnode = &node->next;
   1371         node  = *pnode;
   1372     }
   1373     return  pnode;
   1374 }
   1375 
   1376 static void
   1377 event_looper_hook( EventLooper  looper, int  fd, int  events )
   1378 {
   1379     FH          f = _fh_from_int(fd);
   1380     EventHook  *pnode;
   1381     EventHook   node;
   1382 
   1383     if (f == NULL)  /* invalid arg */ {
   1384         D("event_looper_hook: invalid fd=%d\n", fd);
   1385         return;
   1386     }
   1387 
   1388     pnode = event_looper_find_p( looper, f );
   1389     node  = *pnode;
   1390     if ( node == NULL ) {
   1391         node       = event_hook_alloc( f );
   1392         node->next = *pnode;
   1393         *pnode     = node;
   1394     }
   1395 
   1396     if ( (node->wanted & events) != events ) {
   1397         /* this should update start/stop/check/peek */
   1398         D("event_looper_hook: call hook for %d (new=%x, old=%x)\n",
   1399            fd, node->wanted, events);
   1400         f->clazz->_fh_hook( f, events & ~node->wanted, node );
   1401         node->wanted |= events;
   1402     } else {
   1403         D("event_looper_hook: ignoring events %x for %d wanted=%x)\n",
   1404            events, fd, node->wanted);
   1405     }
   1406 }
   1407 
   1408 static void
   1409 event_looper_unhook( EventLooper  looper, int  fd, int  events )
   1410 {
   1411     FH          fh    = _fh_from_int(fd);
   1412     EventHook  *pnode = event_looper_find_p( looper, fh );
   1413     EventHook   node  = *pnode;
   1414 
   1415     if (node != NULL) {
   1416         int  events2 = events & node->wanted;
   1417         if ( events2 == 0 ) {
   1418             D( "event_looper_unhook: events %x not registered for fd %d\n", events, fd );
   1419             return;
   1420         }
   1421         node->wanted &= ~events2;
   1422         if (!node->wanted) {
   1423             *pnode = node->next;
   1424             event_hook_free( node );
   1425         }
   1426     }
   1427 }
   1428 
   1429 static EventLooperRec  win32_looper;
   1430 
   1431 static void fdevent_init(void)
   1432 {
   1433     win32_looper.htab_count = 0;
   1434     win32_looper.hooks      = NULL;
   1435 }
   1436 
   1437 static void fdevent_connect(fdevent *fde)
   1438 {
   1439     EventLooper  looper = &win32_looper;
   1440     int          events = fde->state & FDE_EVENTMASK;
   1441 
   1442     if (events != 0)
   1443         event_looper_hook( looper, fde->fd, events );
   1444 }
   1445 
   1446 static void fdevent_disconnect(fdevent *fde)
   1447 {
   1448     EventLooper  looper = &win32_looper;
   1449     int          events = fde->state & FDE_EVENTMASK;
   1450 
   1451     if (events != 0)
   1452         event_looper_unhook( looper, fde->fd, events );
   1453 }
   1454 
   1455 static void fdevent_update(fdevent *fde, unsigned events)
   1456 {
   1457     EventLooper  looper  = &win32_looper;
   1458     unsigned     events0 = fde->state & FDE_EVENTMASK;
   1459 
   1460     if (events != events0) {
   1461         int  removes = events0 & ~events;
   1462         int  adds    = events  & ~events0;
   1463         if (removes) {
   1464             D("fdevent_update: remove %x from %d\n", removes, fde->fd);
   1465             event_looper_unhook( looper, fde->fd, removes );
   1466         }
   1467         if (adds) {
   1468             D("fdevent_update: add %x to %d\n", adds, fde->fd);
   1469             event_looper_hook  ( looper, fde->fd, adds );
   1470         }
   1471     }
   1472 }
   1473 
   1474 static void fdevent_process()
   1475 {
   1476     EventLooper  looper = &win32_looper;
   1477     EventHook    hook;
   1478     int          gotone = 0;
   1479 
   1480     /* if we have at least one ready hook, execute it/them */
   1481     for (hook = looper->hooks; hook; hook = hook->next) {
   1482         hook->ready = 0;
   1483         if (hook->prepare) {
   1484             hook->prepare(hook);
   1485             if (hook->ready != 0) {
   1486                 event_hook_signal( hook );
   1487                 gotone = 1;
   1488             }
   1489         }
   1490     }
   1491 
   1492     /* nothing's ready yet, so wait for something to happen */
   1493     if (!gotone)
   1494     {
   1495         looper->htab_count = 0;
   1496 
   1497         for (hook = looper->hooks; hook; hook = hook->next)
   1498         {
   1499             if (hook->start && !hook->start(hook)) {
   1500                 D( "fdevent_process: error when starting a hook\n" );
   1501                 return;
   1502             }
   1503             if (hook->h != INVALID_HANDLE_VALUE) {
   1504                 int  nn;
   1505 
   1506                 for (nn = 0; nn < looper->htab_count; nn++)
   1507                 {
   1508                     if ( looper->htab[nn] == hook->h )
   1509                         goto DontAdd;
   1510                 }
   1511                 looper->htab[ looper->htab_count++ ] = hook->h;
   1512             DontAdd:
   1513                 ;
   1514             }
   1515         }
   1516 
   1517         if (looper->htab_count == 0) {
   1518             D( "fdevent_process: nothing to wait for !!\n" );
   1519             return;
   1520         }
   1521 
   1522         do
   1523         {
   1524             int   wait_ret;
   1525 
   1526             D( "adb_win32: waiting for %d events\n", looper->htab_count );
   1527             if (looper->htab_count > MAXIMUM_WAIT_OBJECTS) {
   1528                 D("handle count %d exceeds MAXIMUM_WAIT_OBJECTS, aborting!\n", looper->htab_count);
   1529                 abort();
   1530             }
   1531             wait_ret = WaitForMultipleObjects( looper->htab_count, looper->htab, FALSE, INFINITE );
   1532             if (wait_ret == (int)WAIT_FAILED) {
   1533                 D( "adb_win32: wait failed, error %ld\n", GetLastError() );
   1534             } else {
   1535                 D( "adb_win32: got one (index %d)\n", wait_ret );
   1536 
   1537                 /* according to Cygwin, some objects like consoles wake up on "inappropriate" events
   1538                  * like mouse movements. we need to filter these with the "check" function
   1539                  */
   1540                 if ((unsigned)wait_ret < (unsigned)looper->htab_count)
   1541                 {
   1542                     for (hook = looper->hooks; hook; hook = hook->next)
   1543                     {
   1544                         if ( looper->htab[wait_ret] == hook->h       &&
   1545                          (!hook->check || hook->check(hook)) )
   1546                         {
   1547                             D( "adb_win32: signaling %s for %x\n", hook->fh->name, hook->ready );
   1548                             event_hook_signal( hook );
   1549                             gotone = 1;
   1550                             break;
   1551                         }
   1552                     }
   1553                 }
   1554             }
   1555         }
   1556         while (!gotone);
   1557 
   1558         for (hook = looper->hooks; hook; hook = hook->next) {
   1559             if (hook->stop)
   1560                 hook->stop( hook );
   1561         }
   1562     }
   1563 
   1564     for (hook = looper->hooks; hook; hook = hook->next) {
   1565         if (hook->peek && hook->peek(hook))
   1566                 event_hook_signal( hook );
   1567     }
   1568 }
   1569 
   1570 
   1571 static void fdevent_register(fdevent *fde)
   1572 {
   1573     int  fd = fde->fd - WIN32_FH_BASE;
   1574 
   1575     if(fd < 0) {
   1576         FATAL("bogus negative fd (%d)\n", fde->fd);
   1577     }
   1578 
   1579     if(fd >= fd_table_max) {
   1580         int oldmax = fd_table_max;
   1581         if(fde->fd > 32000) {
   1582             FATAL("bogus huuuuge fd (%d)\n", fde->fd);
   1583         }
   1584         if(fd_table_max == 0) {
   1585             fdevent_init();
   1586             fd_table_max = 256;
   1587         }
   1588         while(fd_table_max <= fd) {
   1589             fd_table_max *= 2;
   1590         }
   1591         fd_table = realloc(fd_table, sizeof(fdevent*) * fd_table_max);
   1592         if(fd_table == 0) {
   1593             FATAL("could not expand fd_table to %d entries\n", fd_table_max);
   1594         }
   1595         memset(fd_table + oldmax, 0, sizeof(int) * (fd_table_max - oldmax));
   1596     }
   1597 
   1598     fd_table[fd] = fde;
   1599 }
   1600 
   1601 static void fdevent_unregister(fdevent *fde)
   1602 {
   1603     int  fd = fde->fd - WIN32_FH_BASE;
   1604 
   1605     if((fd < 0) || (fd >= fd_table_max)) {
   1606         FATAL("fd out of range (%d)\n", fde->fd);
   1607     }
   1608 
   1609     if(fd_table[fd] != fde) {
   1610         FATAL("fd_table out of sync");
   1611     }
   1612 
   1613     fd_table[fd] = 0;
   1614 
   1615     if(!(fde->state & FDE_DONT_CLOSE)) {
   1616         dump_fde(fde, "close");
   1617         adb_close(fde->fd);
   1618     }
   1619 }
   1620 
   1621 static void fdevent_plist_enqueue(fdevent *node)
   1622 {
   1623     fdevent *list = &list_pending;
   1624 
   1625     node->next = list;
   1626     node->prev = list->prev;
   1627     node->prev->next = node;
   1628     list->prev = node;
   1629 }
   1630 
   1631 static void fdevent_plist_remove(fdevent *node)
   1632 {
   1633     node->prev->next = node->next;
   1634     node->next->prev = node->prev;
   1635     node->next = 0;
   1636     node->prev = 0;
   1637 }
   1638 
   1639 static fdevent *fdevent_plist_dequeue(void)
   1640 {
   1641     fdevent *list = &list_pending;
   1642     fdevent *node = list->next;
   1643 
   1644     if(node == list) return 0;
   1645 
   1646     list->next = node->next;
   1647     list->next->prev = list;
   1648     node->next = 0;
   1649     node->prev = 0;
   1650 
   1651     return node;
   1652 }
   1653 
   1654 fdevent *fdevent_create(int fd, fd_func func, void *arg)
   1655 {
   1656     fdevent *fde = (fdevent*) malloc(sizeof(fdevent));
   1657     if(fde == 0) return 0;
   1658     fdevent_install(fde, fd, func, arg);
   1659     fde->state |= FDE_CREATED;
   1660     return fde;
   1661 }
   1662 
   1663 void fdevent_destroy(fdevent *fde)
   1664 {
   1665     if(fde == 0) return;
   1666     if(!(fde->state & FDE_CREATED)) {
   1667         FATAL("fde %p not created by fdevent_create()\n", fde);
   1668     }
   1669     fdevent_remove(fde);
   1670 }
   1671 
   1672 void fdevent_install(fdevent *fde, int fd, fd_func func, void *arg)
   1673 {
   1674     memset(fde, 0, sizeof(fdevent));
   1675     fde->state = FDE_ACTIVE;
   1676     fde->fd = fd;
   1677     fde->func = func;
   1678     fde->arg = arg;
   1679 
   1680     fdevent_register(fde);
   1681     dump_fde(fde, "connect");
   1682     fdevent_connect(fde);
   1683     fde->state |= FDE_ACTIVE;
   1684 }
   1685 
   1686 void fdevent_remove(fdevent *fde)
   1687 {
   1688     if(fde->state & FDE_PENDING) {
   1689         fdevent_plist_remove(fde);
   1690     }
   1691 
   1692     if(fde->state & FDE_ACTIVE) {
   1693         fdevent_disconnect(fde);
   1694         dump_fde(fde, "disconnect");
   1695         fdevent_unregister(fde);
   1696     }
   1697 
   1698     fde->state = 0;
   1699     fde->events = 0;
   1700 }
   1701 
   1702 
   1703 void fdevent_set(fdevent *fde, unsigned events)
   1704 {
   1705     events &= FDE_EVENTMASK;
   1706 
   1707     if((fde->state & FDE_EVENTMASK) == (int)events) return;
   1708 
   1709     if(fde->state & FDE_ACTIVE) {
   1710         fdevent_update(fde, events);
   1711         dump_fde(fde, "update");
   1712     }
   1713 
   1714     fde->state = (fde->state & FDE_STATEMASK) | events;
   1715 
   1716     if(fde->state & FDE_PENDING) {
   1717             /* if we're pending, make sure
   1718             ** we don't signal an event that
   1719             ** is no longer wanted.
   1720             */
   1721         fde->events &= (~events);
   1722         if(fde->events == 0) {
   1723             fdevent_plist_remove(fde);
   1724             fde->state &= (~FDE_PENDING);
   1725         }
   1726     }
   1727 }
   1728 
   1729 void fdevent_add(fdevent *fde, unsigned events)
   1730 {
   1731     fdevent_set(
   1732         fde, (fde->state & FDE_EVENTMASK) | (events & FDE_EVENTMASK));
   1733 }
   1734 
   1735 void fdevent_del(fdevent *fde, unsigned events)
   1736 {
   1737     fdevent_set(
   1738         fde, (fde->state & FDE_EVENTMASK) & (~(events & FDE_EVENTMASK)));
   1739 }
   1740 
   1741 void fdevent_loop()
   1742 {
   1743     fdevent *fde;
   1744 
   1745     for(;;) {
   1746 #if DEBUG
   1747         fprintf(stderr,"--- ---- waiting for events\n");
   1748 #endif
   1749         fdevent_process();
   1750 
   1751         while((fde = fdevent_plist_dequeue())) {
   1752             unsigned events = fde->events;
   1753             fde->events = 0;
   1754             fde->state &= (~FDE_PENDING);
   1755             dump_fde(fde, "callback");
   1756             fde->func(fde->fd, events, fde->arg);
   1757         }
   1758     }
   1759 }
   1760 
   1761 /**  FILE EVENT HOOKS
   1762  **/
   1763 
   1764 static void  _event_file_prepare( EventHook  hook )
   1765 {
   1766     if (hook->wanted & (FDE_READ|FDE_WRITE)) {
   1767         /* we can always read/write */
   1768         hook->ready |= hook->wanted & (FDE_READ|FDE_WRITE);
   1769     }
   1770 }
   1771 
   1772 static int  _event_file_peek( EventHook  hook )
   1773 {
   1774     return (hook->wanted & (FDE_READ|FDE_WRITE));
   1775 }
   1776 
   1777 static void  _fh_file_hook( FH  f, int  events, EventHook  hook )
   1778 {
   1779     hook->h       = f->fh_handle;
   1780     hook->prepare = _event_file_prepare;
   1781     hook->peek    = _event_file_peek;
   1782 }
   1783 
   1784 /** SOCKET EVENT HOOKS
   1785  **/
   1786 
   1787 static void  _event_socket_verify( EventHook  hook, WSANETWORKEVENTS*  evts )
   1788 {
   1789     if ( evts->lNetworkEvents & (FD_READ|FD_ACCEPT|FD_CLOSE) ) {
   1790         if (hook->wanted & FDE_READ)
   1791             hook->ready |= FDE_READ;
   1792         if ((evts->iErrorCode[FD_READ] != 0) && hook->wanted & FDE_ERROR)
   1793             hook->ready |= FDE_ERROR;
   1794     }
   1795     if ( evts->lNetworkEvents & (FD_WRITE|FD_CONNECT|FD_CLOSE) ) {
   1796         if (hook->wanted & FDE_WRITE)
   1797             hook->ready |= FDE_WRITE;
   1798         if ((evts->iErrorCode[FD_WRITE] != 0) && hook->wanted & FDE_ERROR)
   1799             hook->ready |= FDE_ERROR;
   1800     }
   1801     if ( evts->lNetworkEvents & FD_OOB ) {
   1802         if (hook->wanted & FDE_ERROR)
   1803             hook->ready |= FDE_ERROR;
   1804     }
   1805 }
   1806 
   1807 static void  _event_socket_prepare( EventHook  hook )
   1808 {
   1809     WSANETWORKEVENTS  evts;
   1810 
   1811     /* look if some of the events we want already happened ? */
   1812     if (!WSAEnumNetworkEvents( hook->fh->fh_socket, NULL, &evts ))
   1813         _event_socket_verify( hook, &evts );
   1814 }
   1815 
   1816 static int  _socket_wanted_to_flags( int  wanted )
   1817 {
   1818     int  flags = 0;
   1819     if (wanted & FDE_READ)
   1820         flags |= FD_READ | FD_ACCEPT | FD_CLOSE;
   1821 
   1822     if (wanted & FDE_WRITE)
   1823         flags |= FD_WRITE | FD_CONNECT | FD_CLOSE;
   1824 
   1825     if (wanted & FDE_ERROR)
   1826         flags |= FD_OOB;
   1827 
   1828     return flags;
   1829 }
   1830 
   1831 static int _event_socket_start( EventHook  hook )
   1832 {
   1833     /* create an event which we're going to wait for */
   1834     FH    fh    = hook->fh;
   1835     long  flags = _socket_wanted_to_flags( hook->wanted );
   1836 
   1837     hook->h = fh->event;
   1838     if (hook->h == INVALID_HANDLE_VALUE) {
   1839         D( "_event_socket_start: no event for %s\n", fh->name );
   1840         return 0;
   1841     }
   1842 
   1843     if ( flags != fh->mask ) {
   1844         D( "_event_socket_start: hooking %s for %x (flags %ld)\n", hook->fh->name, hook->wanted, flags );
   1845         if ( WSAEventSelect( fh->fh_socket, hook->h, flags ) ) {
   1846             D( "_event_socket_start: WSAEventSelect() for %s failed, error %d\n", hook->fh->name, WSAGetLastError() );
   1847             CloseHandle( hook->h );
   1848             hook->h = INVALID_HANDLE_VALUE;
   1849             exit(1);
   1850             return 0;
   1851         }
   1852         fh->mask = flags;
   1853     }
   1854     return 1;
   1855 }
   1856 
   1857 static void _event_socket_stop( EventHook  hook )
   1858 {
   1859     hook->h = INVALID_HANDLE_VALUE;
   1860 }
   1861 
   1862 static int  _event_socket_check( EventHook  hook )
   1863 {
   1864     int               result = 0;
   1865     FH                fh = hook->fh;
   1866     WSANETWORKEVENTS  evts;
   1867 
   1868     if (!WSAEnumNetworkEvents( fh->fh_socket, hook->h, &evts ) ) {
   1869         _event_socket_verify( hook, &evts );
   1870         result = (hook->ready != 0);
   1871         if (result) {
   1872             ResetEvent( hook->h );
   1873         }
   1874     }
   1875     D( "_event_socket_check %s returns %d\n", fh->name, result );
   1876     return  result;
   1877 }
   1878 
   1879 static int  _event_socket_peek( EventHook  hook )
   1880 {
   1881     WSANETWORKEVENTS  evts;
   1882     FH                fh = hook->fh;
   1883 
   1884     /* look if some of the events we want already happened ? */
   1885     if (!WSAEnumNetworkEvents( fh->fh_socket, NULL, &evts )) {
   1886         _event_socket_verify( hook, &evts );
   1887         if (hook->ready)
   1888             ResetEvent( hook->h );
   1889     }
   1890 
   1891     return hook->ready != 0;
   1892 }
   1893 
   1894 
   1895 
   1896 static void  _fh_socket_hook( FH  f, int  events, EventHook  hook )
   1897 {
   1898     hook->prepare = _event_socket_prepare;
   1899     hook->start   = _event_socket_start;
   1900     hook->stop    = _event_socket_stop;
   1901     hook->check   = _event_socket_check;
   1902     hook->peek    = _event_socket_peek;
   1903 
   1904     _event_socket_start( hook );
   1905 }
   1906 
   1907 /** SOCKETPAIR EVENT HOOKS
   1908  **/
   1909 
   1910 static void  _event_socketpair_prepare( EventHook  hook )
   1911 {
   1912     FH          fh   = hook->fh;
   1913     SocketPair  pair = fh->fh_pair;
   1914     BipBuffer   rbip = (pair->a_fd == fh) ? &pair->b2a_bip : &pair->a2b_bip;
   1915     BipBuffer   wbip = (pair->a_fd == fh) ? &pair->a2b_bip : &pair->b2a_bip;
   1916 
   1917     if (hook->wanted & FDE_READ && rbip->can_read)
   1918         hook->ready |= FDE_READ;
   1919 
   1920     if (hook->wanted & FDE_WRITE && wbip->can_write)
   1921         hook->ready |= FDE_WRITE;
   1922  }
   1923 
   1924  static int  _event_socketpair_start( EventHook  hook )
   1925  {
   1926     FH          fh   = hook->fh;
   1927     SocketPair  pair = fh->fh_pair;
   1928     BipBuffer   rbip = (pair->a_fd == fh) ? &pair->b2a_bip : &pair->a2b_bip;
   1929     BipBuffer   wbip = (pair->a_fd == fh) ? &pair->a2b_bip : &pair->b2a_bip;
   1930 
   1931     if (hook->wanted == FDE_READ)
   1932         hook->h = rbip->evt_read;
   1933 
   1934     else if (hook->wanted == FDE_WRITE)
   1935         hook->h = wbip->evt_write;
   1936 
   1937     else {
   1938         D("_event_socketpair_start: can't handle FDE_READ+FDE_WRITE\n" );
   1939         return 0;
   1940     }
   1941     D( "_event_socketpair_start: hook %s for %x wanted=%x\n",
   1942        hook->fh->name, _fh_to_int(fh), hook->wanted);
   1943     return 1;
   1944 }
   1945 
   1946 static int  _event_socketpair_peek( EventHook  hook )
   1947 {
   1948     _event_socketpair_prepare( hook );
   1949     return hook->ready != 0;
   1950 }
   1951 
   1952 static void  _fh_socketpair_hook( FH  fh, int  events, EventHook  hook )
   1953 {
   1954     hook->prepare = _event_socketpair_prepare;
   1955     hook->start   = _event_socketpair_start;
   1956     hook->peek    = _event_socketpair_peek;
   1957 }
   1958 
   1959 
   1960 void
   1961 adb_sysdeps_init( void )
   1962 {
   1963 #define  ADB_MUTEX(x)  InitializeCriticalSection( & x );
   1964 #include "mutex_list.h"
   1965     InitializeCriticalSection( &_win32_lock );
   1966 }
   1967 
   1968