123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220 |
- #include "sysdeps.h"
- #include <windows.h>
- #include <winsock2.h>
- #include <stdio.h>
- #include <errno.h>
- #define TRACE_TAG TRACE_SYSDEPS
- #include "adb.h"
- extern void fatal(const char *fmt, ...);
- #define assert(cond) do { if (!(cond)) fatal( "assertion failed '%s' on %s:%ld\n", #cond, __FILE__, __LINE__ ); } while (0)
- /**************************************************************************/
- /**************************************************************************/
- /***** *****/
- /***** replaces libs/cutils/load_file.c *****/
- /***** *****/
- /**************************************************************************/
- /**************************************************************************/
- void *load_file(const char *fn, unsigned *_sz)
- {
- HANDLE file;
- char *data;
- DWORD file_size;
- file = CreateFile( fn,
- GENERIC_READ,
- FILE_SHARE_READ,
- NULL,
- OPEN_EXISTING,
- 0,
- NULL );
- if (file == INVALID_HANDLE_VALUE)
- return NULL;
- file_size = GetFileSize( file, NULL );
- data = NULL;
- if (file_size > 0) {
- data = (char*) malloc( file_size + 1 );
- if (data == NULL) {
- D("load_file: could not allocate %ld bytes\n", file_size );
- file_size = 0;
- } else {
- DWORD out_bytes;
- if ( !ReadFile( file, data, file_size, &out_bytes, NULL ) ||
- out_bytes != file_size )
- {
- D("load_file: could not read %ld bytes from '%s'\n", file_size, fn);
- free(data);
- data = NULL;
- file_size = 0;
- }
- }
- }
- CloseHandle( file );
- *_sz = (unsigned) file_size;
- return data;
- }
- /**************************************************************************/
- /**************************************************************************/
- /***** *****/
- /***** common file descriptor handling *****/
- /***** *****/
- /**************************************************************************/
- /**************************************************************************/
- typedef const struct FHClassRec_* FHClass;
- typedef struct FHRec_* FH;
- typedef struct EventHookRec_* EventHook;
- typedef struct FHClassRec_
- {
- void (*_fh_init) ( FH f );
- int (*_fh_close)( FH f );
- int (*_fh_lseek)( FH f, int pos, int origin );
- int (*_fh_read) ( FH f, void* buf, int len );
- int (*_fh_write)( FH f, const void* buf, int len );
- void (*_fh_hook) ( FH f, int events, EventHook hook );
- } FHClassRec;
- /* used to emulate unix-domain socket pairs */
- typedef struct SocketPairRec_* SocketPair;
- typedef struct FHRec_
- {
- FHClass clazz;
- int used;
- int eof;
- union {
- HANDLE handle;
- SOCKET socket;
- SocketPair pair;
- } u;
- HANDLE event;
- int mask;
- char name[32];
- } FHRec;
- #define fh_handle u.handle
- #define fh_socket u.socket
- #define fh_pair u.pair
- #define WIN32_FH_BASE 100
- #define WIN32_MAX_FHS 128
- static adb_mutex_t _win32_lock;
- static FHRec _win32_fhs[ WIN32_MAX_FHS ];
- static int _win32_fh_count;
- static FH
- _fh_from_int( int fd )
- {
- FH f;
- fd -= WIN32_FH_BASE;
- if (fd < 0 || fd >= _win32_fh_count) {
- D( "_fh_from_int: invalid fd %d\n", fd + WIN32_FH_BASE );
- errno = EBADF;
- return NULL;
- }
- f = &_win32_fhs[fd];
- if (f->used == 0) {
- D( "_fh_from_int: invalid fd %d\n", fd + WIN32_FH_BASE );
- errno = EBADF;
- return NULL;
- }
- return f;
- }
- static int
- _fh_to_int( FH f )
- {
- if (f && f->used && f >= _win32_fhs && f < _win32_fhs + WIN32_MAX_FHS)
- return (int)(f - _win32_fhs) + WIN32_FH_BASE;
- return -1;
- }
- static FH
- _fh_alloc( FHClass clazz )
- {
- int nn;
- FH f = NULL;
- adb_mutex_lock( &_win32_lock );
- if (_win32_fh_count < WIN32_MAX_FHS) {
- f = &_win32_fhs[ _win32_fh_count++ ];
- goto Exit;
- }
- for (nn = 0; nn < WIN32_MAX_FHS; nn++) {
- if ( _win32_fhs[nn].clazz == NULL) {
- f = &_win32_fhs[nn];
- goto Exit;
- }
- }
- D( "_fh_alloc: no more free file descriptors\n" );
- Exit:
- if (f) {
- f->clazz = clazz;
- f->used = 1;
- f->eof = 0;
- clazz->_fh_init(f);
- }
- adb_mutex_unlock( &_win32_lock );
- return f;
- }
- static int
- _fh_close( FH f )
- {
- if ( f->used ) {
- f->clazz->_fh_close( f );
- f->used = 0;
- f->eof = 0;
- f->clazz = NULL;
- }
- return 0;
- }
- /* forward definitions */
- static const FHClassRec _fh_file_class;
- static const FHClassRec _fh_socket_class;
- /**************************************************************************/
- /**************************************************************************/
- /***** *****/
- /***** file-based descriptor handling *****/
- /***** *****/
- /**************************************************************************/
- /**************************************************************************/
- static void
- _fh_file_init( FH f )
- {
- f->fh_handle = INVALID_HANDLE_VALUE;
- }
- static int
- _fh_file_close( FH f )
- {
- CloseHandle( f->fh_handle );
- f->fh_handle = INVALID_HANDLE_VALUE;
- return 0;
- }
- static int
- _fh_file_read( FH f, void* buf, int len )
- {
- DWORD read_bytes;
- if ( !ReadFile( f->fh_handle, buf, (DWORD)len, &read_bytes, NULL ) ) {
- D( "adb_read: could not read %d bytes from %s\n", len, f->name );
- errno = EIO;
- return -1;
- } else if (read_bytes < (DWORD)len) {
- f->eof = 1;
- }
- return (int)read_bytes;
- }
- static int
- _fh_file_write( FH f, const void* buf, int len )
- {
- DWORD wrote_bytes;
- if ( !WriteFile( f->fh_handle, buf, (DWORD)len, &wrote_bytes, NULL ) ) {
- D( "adb_file_write: could not write %d bytes from %s\n", len, f->name );
- errno = EIO;
- return -1;
- } else if (wrote_bytes < (DWORD)len) {
- f->eof = 1;
- }
- return (int)wrote_bytes;
- }
- static int
- _fh_file_lseek( FH f, int pos, int origin )
- {
- DWORD method;
- DWORD result;
- switch (origin)
- {
- case SEEK_SET: method = FILE_BEGIN; break;
- case SEEK_CUR: method = FILE_CURRENT; break;
- case SEEK_END: method = FILE_END; break;
- default:
- errno = EINVAL;
- return -1;
- }
- result = SetFilePointer( f->fh_handle, pos, NULL, method );
- if (result == INVALID_SET_FILE_POINTER) {
- errno = EIO;
- return -1;
- } else {
- f->eof = 0;
- }
- return (int)result;
- }
- static void _fh_file_hook( FH f, int event, EventHook eventhook ); /* forward */
- static const FHClassRec _fh_file_class =
- {
- _fh_file_init,
- _fh_file_close,
- _fh_file_lseek,
- _fh_file_read,
- _fh_file_write,
- _fh_file_hook
- };
- /**************************************************************************/
- /**************************************************************************/
- /***** *****/
- /***** file-based descriptor handling *****/
- /***** *****/
- /**************************************************************************/
- /**************************************************************************/
- int adb_open(const char* path, int options)
- {
- FH f;
- DWORD desiredAccess = 0;
- DWORD shareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
- switch (options) {
- case O_RDONLY:
- desiredAccess = GENERIC_READ;
- break;
- case O_WRONLY:
- desiredAccess = GENERIC_WRITE;
- break;
- case O_RDWR:
- desiredAccess = GENERIC_READ | GENERIC_WRITE;
- break;
- default:
- D("adb_open: invalid options (0x%0x)\n", options);
- errno = EINVAL;
- return -1;
- }
- f = _fh_alloc( &_fh_file_class );
- if ( !f ) {
- errno = ENOMEM;
- return -1;
- }
- f->fh_handle = CreateFile( path, desiredAccess, shareMode, NULL, OPEN_EXISTING,
- 0, NULL );
- if ( f->fh_handle == INVALID_HANDLE_VALUE ) {
- _fh_close(f);
- D( "adb_open: could not open '%s':", path );
- switch (GetLastError()) {
- case ERROR_FILE_NOT_FOUND:
- D( "file not found\n" );
- errno = ENOENT;
- return -1;
- case ERROR_PATH_NOT_FOUND:
- D( "path not found\n" );
- errno = ENOTDIR;
- return -1;
- default:
- D( "unknown error\n" );
- errno = ENOENT;
- return -1;
- }
- }
- snprintf( f->name, sizeof(f->name), "%d(%s)", _fh_to_int(f), path );
- D( "adb_open: '%s' => fd %d\n", path, _fh_to_int(f) );
- return _fh_to_int(f);
- }
- /* ignore mode on Win32 */
- int adb_creat(const char* path, int mode)
- {
- FH f;
- f = _fh_alloc( &_fh_file_class );
- if ( !f ) {
- errno = ENOMEM;
- return -1;
- }
- f->fh_handle = CreateFile( path, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
- NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,
- NULL );
- if ( f->fh_handle == INVALID_HANDLE_VALUE ) {
- _fh_close(f);
- D( "adb_creat: could not open '%s':", path );
- switch (GetLastError()) {
- case ERROR_FILE_NOT_FOUND:
- D( "file not found\n" );
- errno = ENOENT;
- return -1;
- case ERROR_PATH_NOT_FOUND:
- D( "path not found\n" );
- errno = ENOTDIR;
- return -1;
- default:
- D( "unknown error\n" );
- errno = ENOENT;
- return -1;
- }
- }
- snprintf( f->name, sizeof(f->name), "%d(%s)", _fh_to_int(f), path );
- D( "adb_creat: '%s' => fd %d\n", path, _fh_to_int(f) );
- return _fh_to_int(f);
- }
- int adb_read(int fd, void* buf, int len)
- {
- FH f = _fh_from_int(fd);
- if (f == NULL) {
- return -1;
- }
- return f->clazz->_fh_read( f, buf, len );
- }
- int adb_write(int fd, const void* buf, int len)
- {
- FH f = _fh_from_int(fd);
- if (f == NULL) {
- return -1;
- }
- return f->clazz->_fh_write(f, buf, len);
- }
- int adb_lseek(int fd, int pos, int where)
- {
- FH f = _fh_from_int(fd);
- if (!f) {
- return -1;
- }
- return f->clazz->_fh_lseek(f, pos, where);
- }
- int adb_shutdown(int fd)
- {
- FH f = _fh_from_int(fd);
- if (!f) {
- return -1;
- }
- D( "adb_shutdown: %s\n", f->name);
- shutdown( f->fh_socket, SD_BOTH );
- return 0;
- }
- int adb_close(int fd)
- {
- FH f = _fh_from_int(fd);
- if (!f) {
- return -1;
- }
- D( "adb_close: %s\n", f->name);
- _fh_close(f);
- return 0;
- }
- /**************************************************************************/
- /**************************************************************************/
- /***** *****/
- /***** socket-based file descriptors *****/
- /***** *****/
- /**************************************************************************/
- /**************************************************************************/
- static void
- _socket_set_errno( void )
- {
- switch (WSAGetLastError()) {
- case 0: errno = 0; break;
- case WSAEWOULDBLOCK: errno = EAGAIN; break;
- case WSAEINTR: errno = EINTR; break;
- default:
- D( "_socket_set_errno: unhandled value %d\n", WSAGetLastError() );
- errno = EINVAL;
- }
- }
- static void
- _fh_socket_init( FH f )
- {
- f->fh_socket = INVALID_SOCKET;
- f->event = WSACreateEvent();
- f->mask = 0;
- }
- static int
- _fh_socket_close( FH f )
- {
- /* gently tell any peer that we're closing the socket */
- shutdown( f->fh_socket, SD_BOTH );
- closesocket( f->fh_socket );
- f->fh_socket = INVALID_SOCKET;
- CloseHandle( f->event );
- f->mask = 0;
- return 0;
- }
- static int
- _fh_socket_lseek( FH f, int pos, int origin )
- {
- errno = EPIPE;
- return -1;
- }
- static int
- _fh_socket_read( FH f, void* buf, int len )
- {
- int result = recv( f->fh_socket, buf, len, 0 );
- if (result == SOCKET_ERROR) {
- _socket_set_errno();
- result = -1;
- }
- return result;
- }
- static int
- _fh_socket_write( FH f, const void* buf, int len )
- {
- int result = send( f->fh_socket, buf, len, 0 );
- if (result == SOCKET_ERROR) {
- _socket_set_errno();
- result = -1;
- }
- return result;
- }
- static void _fh_socket_hook( FH f, int event, EventHook hook ); /* forward */
- static const FHClassRec _fh_socket_class =
- {
- _fh_socket_init,
- _fh_socket_close,
- _fh_socket_lseek,
- _fh_socket_read,
- _fh_socket_write,
- _fh_socket_hook
- };
- /**************************************************************************/
- /**************************************************************************/
- /***** *****/
- /***** replacement for libs/cutils/socket_xxxx.c *****/
- /***** *****/
- /**************************************************************************/
- /**************************************************************************/
- #include <winsock2.h>
- static int _winsock_init;
- static void
- _cleanup_winsock( void )
- {
- WSACleanup();
- }
- static void
- _init_winsock( void )
- {
- if (!_winsock_init) {
- WSADATA wsaData;
- int rc = WSAStartup( MAKEWORD(2,2), &wsaData);
- if (rc != 0) {
- fatal( "adb: could not initialize Winsock\n" );
- }
- atexit( _cleanup_winsock );
- _winsock_init = 1;
- }
- }
- int socket_loopback_client(int port, int type)
- {
- FH f = _fh_alloc( &_fh_socket_class );
- struct sockaddr_in addr;
- SOCKET s;
- if (!f)
- return -1;
- if (!_winsock_init)
- _init_winsock();
- memset(&addr, 0, sizeof(addr));
- addr.sin_family = AF_INET;
- addr.sin_port = htons(port);
- addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
- s = socket(AF_INET, type, 0);
- if(s == INVALID_SOCKET) {
- D("socket_loopback_client: could not create socket\n" );
- _fh_close(f);
- return -1;
- }
- f->fh_socket = s;
- if(connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
- D("socket_loopback_client: could not connect to %s:%d\n", type != SOCK_STREAM ? "udp" : "tcp", port );
- _fh_close(f);
- return -1;
- }
- snprintf( f->name, sizeof(f->name), "%d(lo-client:%s%d)", _fh_to_int(f), type != SOCK_STREAM ? "udp:" : "", port );
- D( "socket_loopback_client: port %d type %s => fd %d\n", port, type != SOCK_STREAM ? "udp" : "tcp", _fh_to_int(f) );
- return _fh_to_int(f);
- }
- #define LISTEN_BACKLOG 4
- int socket_loopback_server(int port, int type)
- {
- FH f = _fh_alloc( &_fh_socket_class );
- struct sockaddr_in addr;
- SOCKET s;
- int n;
- if (!f) {
- return -1;
- }
- if (!_winsock_init)
- _init_winsock();
- memset(&addr, 0, sizeof(addr));
- addr.sin_family = AF_INET;
- addr.sin_port = htons(port);
- addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
- s = socket(AF_INET, type, 0);
- if(s == INVALID_SOCKET) return -1;
- f->fh_socket = s;
- n = 1;
- setsockopt(s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (const char*)&n, sizeof(n));
- if(bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
- _fh_close(f);
- return -1;
- }
- if (type == SOCK_STREAM) {
- int ret;
- ret = listen(s, LISTEN_BACKLOG);
- if (ret < 0) {
- _fh_close(f);
- return -1;
- }
- }
- snprintf( f->name, sizeof(f->name), "%d(lo-server:%s%d)", _fh_to_int(f), type != SOCK_STREAM ? "udp:" : "", port );
- D( "socket_loopback_server: port %d type %s => fd %d\n", port, type != SOCK_STREAM ? "udp" : "tcp", _fh_to_int(f) );
- return _fh_to_int(f);
- }
- int socket_network_client(const char *host, int port, int type)
- {
- FH f = _fh_alloc( &_fh_socket_class );
- struct hostent *hp;
- struct sockaddr_in addr;
- SOCKET s;
- if (!f)
- return -1;
- if (!_winsock_init)
- _init_winsock();
- hp = gethostbyname(host);
- if(hp == 0) {
- _fh_close(f);
- return -1;
- }
- memset(&addr, 0, sizeof(addr));
- addr.sin_family = hp->h_addrtype;
- addr.sin_port = htons(port);
- memcpy(&addr.sin_addr, hp->h_addr, hp->h_length);
- s = socket(hp->h_addrtype, type, 0);
- if(s == INVALID_SOCKET) {
- _fh_close(f);
- return -1;
- }
- f->fh_socket = s;
- if(connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
- _fh_close(f);
- return -1;
- }
- snprintf( f->name, sizeof(f->name), "%d(net-client:%s%d)", _fh_to_int(f), type != SOCK_STREAM ? "udp:" : "", port );
- D( "socket_network_client: host '%s' port %d type %s => fd %d\n", host, port, type != SOCK_STREAM ? "udp" : "tcp", _fh_to_int(f) );
- return _fh_to_int(f);
- }
- int socket_inaddr_any_server(int port, int type)
- {
- FH f = _fh_alloc( &_fh_socket_class );
- struct sockaddr_in addr;
- SOCKET s;
- int n;
- if (!f)
- return -1;
- if (!_winsock_init)
- _init_winsock();
- memset(&addr, 0, sizeof(addr));
- addr.sin_family = AF_INET;
- addr.sin_port = htons(port);
- addr.sin_addr.s_addr = htonl(INADDR_ANY);
- s = socket(AF_INET, type, 0);
- if(s == INVALID_SOCKET) {
- _fh_close(f);
- return -1;
- }
- f->fh_socket = s;
- n = 1;
- setsockopt(s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (const char*)&n, sizeof(n));
- if(bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
- _fh_close(f);
- return -1;
- }
- if (type == SOCK_STREAM) {
- int ret;
- ret = listen(s, LISTEN_BACKLOG);
- if (ret < 0) {
- _fh_close(f);
- return -1;
- }
- }
- snprintf( f->name, sizeof(f->name), "%d(any-server:%s%d)", _fh_to_int(f), type != SOCK_STREAM ? "udp:" : "", port );
- D( "socket_inaddr_server: port %d type %s => fd %d\n", port, type != SOCK_STREAM ? "udp" : "tcp", _fh_to_int(f) );
- return _fh_to_int(f);
- }
- #undef accept
- int adb_socket_accept(int serverfd, struct sockaddr* addr, socklen_t *addrlen)
- {
- FH serverfh = _fh_from_int(serverfd);
- FH fh;
- if ( !serverfh || serverfh->clazz != &_fh_socket_class ) {
- D( "adb_socket_accept: invalid fd %d\n", serverfd );
- return -1;
- }
- fh = _fh_alloc( &_fh_socket_class );
- if (!fh) {
- D( "adb_socket_accept: not enough memory to allocate accepted socket descriptor\n" );
- return -1;
- }
- fh->fh_socket = accept( serverfh->fh_socket, addr, addrlen );
- if (fh->fh_socket == INVALID_SOCKET) {
- _fh_close( fh );
- D( "adb_socket_accept: accept on fd %d return error %ld\n", serverfd, GetLastError() );
- return -1;
- }
- snprintf( fh->name, sizeof(fh->name), "%d(accept:%s)", _fh_to_int(fh), serverfh->name );
- D( "adb_socket_accept on fd %d returns fd %d\n", serverfd, _fh_to_int(fh) );
- return _fh_to_int(fh);
- }
- void disable_tcp_nagle(int fd)
- {
- FH fh = _fh_from_int(fd);
- int on;
- if ( !fh || fh->clazz != &_fh_socket_class )
- return;
- setsockopt( fh->fh_socket, IPPROTO_TCP, TCP_NODELAY, (const char*)&on, sizeof(on) );
- }
- /**************************************************************************/
- /**************************************************************************/
- /***** *****/
- /***** emulated socketpairs *****/
- /***** *****/
- /**************************************************************************/
- /**************************************************************************/
- /* we implement socketpairs directly in use space for the following reasons:
- * - it avoids copying data from/to the Nt kernel
- * - it allows us to implement fdevent hooks easily and cheaply, something
- * that is not possible with standard Win32 pipes !!
- *
- * basically, we use two circular buffers, each one corresponding to a given
- * direction.
- *
- * each buffer is implemented as two regions:
- *
- * region A which is (a_start,a_end)
- * region B which is (0, b_end) with b_end <= a_start
- *
- * an empty buffer has: a_start = a_end = b_end = 0
- *
- * a_start is the pointer where we start reading data
- * a_end is the pointer where we start writing data, unless it is BUFFER_SIZE,
- * then you start writing at b_end
- *
- * the buffer is full when b_end == a_start && a_end == BUFFER_SIZE
- *
- * there is room when b_end < a_start || a_end < BUFER_SIZE
- *
- * when reading, a_start is incremented, it a_start meets a_end, then
- * we do: a_start = 0, a_end = b_end, b_end = 0, and keep going on..
- */
- #define BIP_BUFFER_SIZE 4096
- #if 0
- #include <stdio.h>
- # define BIPD(x) D x
- # define BIPDUMP bip_dump_hex
- static void bip_dump_hex( const unsigned char* ptr, size_t len )
- {
- int nn, len2 = len;
- if (len2 > 8) len2 = 8;
- for (nn = 0; nn < len2; nn++)
- printf("%02x", ptr[nn]);
- printf(" ");
- for (nn = 0; nn < len2; nn++) {
- int c = ptr[nn];
- if (c < 32 || c > 127)
- c = '.';
- printf("%c", c);
- }
- printf("\n");
- fflush(stdout);
- }
- #else
- # define BIPD(x) do {} while (0)
- # define BIPDUMP(p,l) BIPD(p)
- #endif
- typedef struct BipBufferRec_
- {
- int a_start;
- int a_end;
- int b_end;
- int fdin;
- int fdout;
- int closed;
- int can_write; /* boolean */
- HANDLE evt_write; /* event signaled when one can write to a buffer */
- int can_read; /* boolean */
- HANDLE evt_read; /* event signaled when one can read from a buffer */
- CRITICAL_SECTION lock;
- unsigned char buff[ BIP_BUFFER_SIZE ];
- } BipBufferRec, *BipBuffer;
- static void
- bip_buffer_init( BipBuffer buffer )
- {
- D( "bit_buffer_init %p\n", buffer );
- buffer->a_start = 0;
- buffer->a_end = 0;
- buffer->b_end = 0;
- buffer->can_write = 1;
- buffer->can_read = 0;
- buffer->fdin = 0;
- buffer->fdout = 0;
- buffer->closed = 0;
- buffer->evt_write = CreateEvent( NULL, TRUE, TRUE, NULL );
- buffer->evt_read = CreateEvent( NULL, TRUE, FALSE, NULL );
- InitializeCriticalSection( &buffer->lock );
- }
- static void
- bip_buffer_close( BipBuffer bip )
- {
- bip->closed = 1;
- if (!bip->can_read) {
- SetEvent( bip->evt_read );
- }
- if (!bip->can_write) {
- SetEvent( bip->evt_write );
- }
- }
- static void
- bip_buffer_done( BipBuffer bip )
- {
- BIPD(( "bip_buffer_done: %d->%d\n", bip->fdin, bip->fdout ));
- CloseHandle( bip->evt_read );
- CloseHandle( bip->evt_write );
- DeleteCriticalSection( &bip->lock );
- }
- static int
- bip_buffer_write( BipBuffer bip, const void* src, int len )
- {
- int avail, count = 0;
- if (len <= 0)
- return 0;
- BIPD(( "bip_buffer_write: enter %d->%d len %d\n", bip->fdin, bip->fdout, len ));
- BIPDUMP( src, len );
- EnterCriticalSection( &bip->lock );
- while (!bip->can_write) {
- int ret;
- LeaveCriticalSection( &bip->lock );
- if (bip->closed) {
- errno = EPIPE;
- return -1;
- }
- /* spinlocking here is probably unfair, but let's live with it */
- ret = WaitForSingleObject( bip->evt_write, INFINITE );
- if (ret != WAIT_OBJECT_0) { /* buffer probably closed */
- D( "bip_buffer_write: error %d->%d WaitForSingleObject returned %d, error %ld\n", bip->fdin, bip->fdout, ret, GetLastError() );
- return 0;
- }
- if (bip->closed) {
- errno = EPIPE;
- return -1;
- }
- EnterCriticalSection( &bip->lock );
- }
- BIPD(( "bip_buffer_write: exec %d->%d len %d\n", bip->fdin, bip->fdout, len ));
- avail = BIP_BUFFER_SIZE - bip->a_end;
- if (avail > 0)
- {
- /* we can append to region A */
- if (avail > len)
- avail = len;
- memcpy( bip->buff + bip->a_end, src, avail );
- src += avail;
- count += avail;
- len -= avail;
- bip->a_end += avail;
- if (bip->a_end == BIP_BUFFER_SIZE && bip->a_start == 0) {
- bip->can_write = 0;
- ResetEvent( bip->evt_write );
- goto Exit;
- }
- }
- if (len == 0)
- goto Exit;
- avail = bip->a_start - bip->b_end;
- assert( avail > 0 ); /* since can_write is TRUE */
- if (avail > len)
- avail = len;
- memcpy( bip->buff + bip->b_end, src, avail );
- count += avail;
- bip->b_end += avail;
- if (bip->b_end == bip->a_start) {
- bip->can_write = 0;
- ResetEvent( bip->evt_write );
- }
- Exit:
- assert( count > 0 );
- if ( !bip->can_read ) {
- bip->can_read = 1;
- SetEvent( bip->evt_read );
- }
- BIPD(( "bip_buffer_write: exit %d->%d count %d (as=%d ae=%d be=%d cw=%d cr=%d\n",
- bip->fdin, bip->fdout, count, bip->a_start, bip->a_end, bip->b_end, bip->can_write, bip->can_read ));
- LeaveCriticalSection( &bip->lock );
- return count;
- }
- static int
- bip_buffer_read( BipBuffer bip, void* dst, int len )
- {
- int avail, count = 0;
- if (len <= 0)
- return 0;
- BIPD(( "bip_buffer_read: enter %d->%d len %d\n", bip->fdin, bip->fdout, len ));
- EnterCriticalSection( &bip->lock );
- while ( !bip->can_read )
- {
- #if 0
- LeaveCriticalSection( &bip->lock );
- errno = EAGAIN;
- return -1;
- #else
- int ret;
- LeaveCriticalSection( &bip->lock );
- if (bip->closed) {
- errno = EPIPE;
- return -1;
- }
- ret = WaitForSingleObject( bip->evt_read, INFINITE );
- if (ret != WAIT_OBJECT_0) { /* probably closed buffer */
- D( "bip_buffer_read: error %d->%d WaitForSingleObject returned %d, error %ld\n", bip->fdin, bip->fdout, ret, GetLastError());
- return 0;
- }
- if (bip->closed) {
- errno = EPIPE;
- return -1;
- }
- EnterCriticalSection( &bip->lock );
- #endif
- }
- BIPD(( "bip_buffer_read: exec %d->%d len %d\n", bip->fdin, bip->fdout, len ));
- avail = bip->a_end - bip->a_start;
- assert( avail > 0 ); /* since can_read is TRUE */
- if (avail > len)
- avail = len;
- memcpy( dst, bip->buff + bip->a_start, avail );
- dst += avail;
- count += avail;
- len -= avail;
- bip->a_start += avail;
- if (bip->a_start < bip->a_end)
- goto Exit;
- bip->a_start = 0;
- bip->a_end = bip->b_end;
- bip->b_end = 0;
- avail = bip->a_end;
- if (avail > 0) {
- if (avail > len)
- avail = len;
- memcpy( dst, bip->buff, avail );
- count += avail;
- bip->a_start += avail;
- if ( bip->a_start < bip->a_end )
- goto Exit;
- bip->a_start = bip->a_end = 0;
- }
- bip->can_read = 0;
- ResetEvent( bip->evt_read );
- Exit:
- assert( count > 0 );
- if (!bip->can_write ) {
- bip->can_write = 1;
- SetEvent( bip->evt_write );
- }
- BIPDUMP( (const unsigned char*)dst - count, count );
- BIPD(( "bip_buffer_read: exit %d->%d count %d (as=%d ae=%d be=%d cw=%d cr=%d\n",
- bip->fdin, bip->fdout, count, bip->a_start, bip->a_end, bip->b_end, bip->can_write, bip->can_read ));
- LeaveCriticalSection( &bip->lock );
- return count;
- }
- typedef struct SocketPairRec_
- {
- BipBufferRec a2b_bip;
- BipBufferRec b2a_bip;
- FH a_fd;
- int used;
- } SocketPairRec;
- void _fh_socketpair_init( FH f )
- {
- f->fh_pair = NULL;
- }
- static int
- _fh_socketpair_close( FH f )
- {
- if ( f->fh_pair ) {
- SocketPair pair = f->fh_pair;
- if ( f == pair->a_fd ) {
- pair->a_fd = NULL;
- }
- bip_buffer_close( &pair->b2a_bip );
- bip_buffer_close( &pair->a2b_bip );
- if ( --pair->used == 0 ) {
- bip_buffer_done( &pair->b2a_bip );
- bip_buffer_done( &pair->a2b_bip );
- free( pair );
- }
- f->fh_pair = NULL;
- }
- return 0;
- }
- static int
- _fh_socketpair_lseek( FH f, int pos, int origin )
- {
- errno = ESPIPE;
- return -1;
- }
- static int
- _fh_socketpair_read( FH f, void* buf, int len )
- {
- SocketPair pair = f->fh_pair;
- BipBuffer bip;
- if (!pair)
- return -1;
- if ( f == pair->a_fd )
- bip = &pair->b2a_bip;
- else
- bip = &pair->a2b_bip;
- return bip_buffer_read( bip, buf, len );
- }
- static int
- _fh_socketpair_write( FH f, const void* buf, int len )
- {
- SocketPair pair = f->fh_pair;
- BipBuffer bip;
- if (!pair)
- return -1;
- if ( f == pair->a_fd )
- bip = &pair->a2b_bip;
- else
- bip = &pair->b2a_bip;
- return bip_buffer_write( bip, buf, len );
- }
- static void _fh_socketpair_hook( FH f, int event, EventHook hook ); /* forward */
- static const FHClassRec _fh_socketpair_class =
- {
- _fh_socketpair_init,
- _fh_socketpair_close,
- _fh_socketpair_lseek,
- _fh_socketpair_read,
- _fh_socketpair_write,
- _fh_socketpair_hook
- };
- int adb_socketpair( int sv[2] )
- {
- FH fa, fb;
- SocketPair pair;
- fa = _fh_alloc( &_fh_socketpair_class );
- fb = _fh_alloc( &_fh_socketpair_class );
- if (!fa || !fb)
- goto Fail;
- pair = malloc( sizeof(*pair) );
- if (pair == NULL) {
- D("adb_socketpair: not enough memory to allocate pipes\n" );
- goto Fail;
- }
- bip_buffer_init( &pair->a2b_bip );
- bip_buffer_init( &pair->b2a_bip );
- fa->fh_pair = pair;
- fb->fh_pair = pair;
- pair->used = 2;
- pair->a_fd = fa;
- sv[0] = _fh_to_int(fa);
- sv[1] = _fh_to_int(fb);
- pair->a2b_bip.fdin = sv[0];
- pair->a2b_bip.fdout = sv[1];
- pair->b2a_bip.fdin = sv[1];
- pair->b2a_bip.fdout = sv[0];
- snprintf( fa->name, sizeof(fa->name), "%d(pair:%d)", sv[0], sv[1] );
- snprintf( fb->name, sizeof(fb->name), "%d(pair:%d)", sv[1], sv[0] );
- D( "adb_socketpair: returns (%d, %d)\n", sv[0], sv[1] );
- return 0;
- Fail:
- _fh_close(fb);
- _fh_close(fa);
- return -1;
- }
- /**************************************************************************/
- /**************************************************************************/
- /***** *****/
- /***** fdevents emulation *****/
- /***** *****/
- /***** this is a very simple implementation, we rely on the fact *****/
- /***** that ADB doesn't use FDE_ERROR. *****/
- /***** *****/
- /**************************************************************************/
- /**************************************************************************/
- #define FATAL(x...) fatal(__FUNCTION__, x)
- #if DEBUG
- static void dump_fde(fdevent *fde, const char *info)
- {
- fprintf(stderr,"FDE #%03d %c%c%c %s\n", fde->fd,
- fde->state & FDE_READ ? 'R' : ' ',
- fde->state & FDE_WRITE ? 'W' : ' ',
- fde->state & FDE_ERROR ? 'E' : ' ',
- info);
- }
- #else
- #define dump_fde(fde, info) do { } while(0)
- #endif
- #define FDE_EVENTMASK 0x00ff
- #define FDE_STATEMASK 0xff00
- #define FDE_ACTIVE 0x0100
- #define FDE_PENDING 0x0200
- #define FDE_CREATED 0x0400
- static void fdevent_plist_enqueue(fdevent *node);
- static void fdevent_plist_remove(fdevent *node);
- static fdevent *fdevent_plist_dequeue(void);
- static fdevent list_pending = {
- .next = &list_pending,
- .prev = &list_pending,
- };
- static fdevent **fd_table = 0;
- static int fd_table_max = 0;
- typedef struct EventLooperRec_* EventLooper;
- typedef struct EventHookRec_
- {
- EventHook next;
- FH fh;
- HANDLE h;
- int wanted; /* wanted event flags */
- int ready; /* ready event flags */
- void* aux;
- void (*prepare)( EventHook hook );
- int (*start) ( EventHook hook );
- void (*stop) ( EventHook hook );
- int (*check) ( EventHook hook );
- int (*peek) ( EventHook hook );
- } EventHookRec;
- static EventHook _free_hooks;
- static EventHook
- event_hook_alloc( FH fh )
- {
- EventHook hook = _free_hooks;
- if (hook != NULL)
- _free_hooks = hook->next;
- else {
- hook = malloc( sizeof(*hook) );
- if (hook == NULL)
- fatal( "could not allocate event hook\n" );
- }
- hook->next = NULL;
- hook->fh = fh;
- hook->wanted = 0;
- hook->ready = 0;
- hook->h = INVALID_HANDLE_VALUE;
- hook->aux = NULL;
- hook->prepare = NULL;
- hook->start = NULL;
- hook->stop = NULL;
- hook->check = NULL;
- hook->peek = NULL;
- return hook;
- }
- static void
- event_hook_free( EventHook hook )
- {
- hook->fh = NULL;
- hook->wanted = 0;
- hook->ready = 0;
- hook->next = _free_hooks;
- _free_hooks = hook;
- }
- static void
- event_hook_signal( EventHook hook )
- {
- FH f = hook->fh;
- int fd = _fh_to_int(f);
- fdevent* fde = fd_table[ fd - WIN32_FH_BASE ];
- if (fde != NULL && fde->fd == fd) {
- if ((fde->state & FDE_PENDING) == 0) {
- fde->state |= FDE_PENDING;
- fdevent_plist_enqueue( fde );
- }
- fde->events |= hook->wanted;
- }
- }
- #define MAX_LOOPER_HANDLES WIN32_MAX_FHS
- typedef struct EventLooperRec_
- {
- EventHook hooks;
- HANDLE htab[ MAX_LOOPER_HANDLES ];
- int htab_count;
- } EventLooperRec;
- static EventHook*
- event_looper_find_p( EventLooper looper, FH fh )
- {
- EventHook *pnode = &looper->hooks;
- EventHook node = *pnode;
- for (;;) {
- if ( node == NULL || node->fh == fh )
- break;
- pnode = &node->next;
- node = *pnode;
- }
- return pnode;
- }
- static void
- event_looper_hook( EventLooper looper, int fd, int events )
- {
- FH f = _fh_from_int(fd);
- EventHook *pnode;
- EventHook node;
- if (f == NULL) /* invalid arg */ {
- D("event_looper_hook: invalid fd=%d\n", fd);
- return;
- }
- pnode = event_looper_find_p( looper, f );
- node = *pnode;
- if ( node == NULL ) {
- node = event_hook_alloc( f );
- node->next = *pnode;
- *pnode = node;
- }
- if ( (node->wanted & events) != events ) {
- /* this should update start/stop/check/peek */
- D("event_looper_hook: call hook for %d (new=%x, old=%x)\n",
- fd, node->wanted, events);
- f->clazz->_fh_hook( f, events & ~node->wanted, node );
- node->wanted |= events;
- } else {
- D("event_looper_hook: ignoring events %x for %d wanted=%x)\n",
- events, fd, node->wanted);
- }
- }
- static void
- event_looper_unhook( EventLooper looper, int fd, int events )
- {
- FH fh = _fh_from_int(fd);
- EventHook *pnode = event_looper_find_p( looper, fh );
- EventHook node = *pnode;
- if (node != NULL) {
- int events2 = events & node->wanted;
- if ( events2 == 0 ) {
- D( "event_looper_unhook: events %x not registered for fd %d\n", events, fd );
- return;
- }
- node->wanted &= ~events2;
- if (!node->wanted) {
- *pnode = node->next;
- event_hook_free( node );
- }
- }
- }
- /*
- * A fixer for WaitForMultipleObjects on condition that there are more than 64
- * handles to wait on.
- *
- * In cetain cases DDMS may establish more than 64 connections with ADB. For
- * instance, this may happen if there are more than 64 processes running on a
- * device, or there are multiple devices connected (including the emulator) with
- * the combined number of running processes greater than 64. In this case using
- * WaitForMultipleObjects to wait on connection events simply wouldn't cut,
- * because of the API limitations (64 handles max). So, we need to provide a way
- * to scale WaitForMultipleObjects to accept an arbitrary number of handles. The
- * easiest (and "Microsoft recommended") way to do that would be dividing the
- * handle array into chunks with the chunk size less than 64, and fire up as many
- * waiting threads as there are chunks. Then each thread would wait on a chunk of
- * handles, and will report back to the caller which handle has been set.
- * Here is the implementation of that algorithm.
- */
- /* Number of handles to wait on in each wating thread. */
- #define WAIT_ALL_CHUNK_SIZE 63
- /* Descriptor for a wating thread */
- typedef struct WaitForAllParam {
- /* A handle to an event to signal when waiting is over. This handle is shared
- * accross all the waiting threads, so each waiting thread knows when any
- * other thread has exited, so it can exit too. */
- HANDLE main_event;
- /* Upon exit from a waiting thread contains the index of the handle that has
- * been signaled. The index is an absolute index of the signaled handle in
- * the original array. This pointer is shared accross all the waiting threads
- * and it's not guaranteed (due to a race condition) that when all the
- * waiting threads exit, the value contained here would indicate the first
- * handle that was signaled. This is fine, because the caller cares only
- * about any handle being signaled. It doesn't care about the order, nor
- * about the whole list of handles that were signaled. */
- LONG volatile *signaled_index;
- /* Array of handles to wait on in a waiting thread. */
- HANDLE* handles;
- /* Number of handles in 'handles' array to wait on. */
- int handles_count;
- /* Index inside the main array of the first handle in the 'handles' array. */
- int first_handle_index;
- /* Waiting thread handle. */
- HANDLE thread;
- } WaitForAllParam;
- /* Waiting thread routine. */
- static unsigned __stdcall
- _in_waiter_thread(void* arg)
- {
- HANDLE wait_on[WAIT_ALL_CHUNK_SIZE + 1];
- int res;
- WaitForAllParam* const param = (WaitForAllParam*)arg;
- /* We have to wait on the main_event in order to be notified when any of the
- * sibling threads is exiting. */
- wait_on[0] = param->main_event;
- /* The rest of the handles go behind the main event handle. */
- memcpy(wait_on + 1, param->handles, param->handles_count * sizeof(HANDLE));
- res = WaitForMultipleObjects(param->handles_count + 1, wait_on, FALSE, INFINITE);
- if (res > 0 && res < (param->handles_count + 1)) {
- /* One of the original handles got signaled. Save its absolute index into
- * the output variable. */
- InterlockedCompareExchange(param->signaled_index,
- res - 1L + param->first_handle_index, -1L);
- }
- /* Notify the caller (and the siblings) that the wait is over. */
- SetEvent(param->main_event);
- _endthreadex(0);
- return 0;
- }
- /* WaitForMultipeObjects fixer routine.
- * Param:
- * handles Array of handles to wait on.
- * handles_count Number of handles in the array.
- * Return:
- * (>= 0 && < handles_count) - Index of the signaled handle in the array, or
- * WAIT_FAILED on an error.
- */
- static int
- _wait_for_all(HANDLE* handles, int handles_count)
- {
- WaitForAllParam* threads;
- HANDLE main_event;
- int chunks, chunk, remains;
- /* This variable is going to be accessed by several threads at the same time,
- * this is bound to fail randomly when the core is run on multi-core machines.
- * To solve this, we need to do the following (1 _and_ 2):
- * 1. Use the "volatile" qualifier to ensure the compiler doesn't optimize
- * out the reads/writes in this function unexpectedly.
- * 2. Ensure correct memory ordering. The "simple" way to do that is to wrap
- * all accesses inside a critical section. But we can also use
- * InterlockedCompareExchange() which always provide a full memory barrier
- * on Win32.
- */
- volatile LONG sig_index = -1;
- /* Calculate number of chunks, and allocate thread param array. */
- chunks = handles_count / WAIT_ALL_CHUNK_SIZE;
- remains = handles_count % WAIT_ALL_CHUNK_SIZE;
- threads = (WaitForAllParam*)malloc((chunks + (remains ? 1 : 0)) *
- sizeof(WaitForAllParam));
- if (threads == NULL) {
- D("Unable to allocate thread array for %d handles.", handles_count);
- return (int)WAIT_FAILED;
- }
- /* Create main event to wait on for all waiting threads. This is a "manualy
- * reset" event that will remain set once it was set. */
- main_event = CreateEvent(NULL, TRUE, FALSE, NULL);
- if (main_event == NULL) {
- D("Unable to create main event. Error: %d", GetLastError());
- free(threads);
- return (int)WAIT_FAILED;
- }
- /*
- * Initialize waiting thread parameters.
- */
- for (chunk = 0; chunk < chunks; chunk++) {
- threads[chunk].main_event = main_event;
- threads[chunk].signaled_index = &sig_index;
- threads[chunk].first_handle_index = WAIT_ALL_CHUNK_SIZE * chunk;
- threads[chunk].handles = handles + threads[chunk].first_handle_index;
- threads[chunk].handles_count = WAIT_ALL_CHUNK_SIZE;
- }
- if (remains) {
- threads[chunk].main_event = main_event;
- threads[chunk].signaled_index = &sig_index;
- threads[chunk].first_handle_index = WAIT_ALL_CHUNK_SIZE * chunk;
- threads[chunk].handles = handles + threads[chunk].first_handle_index;
- threads[chunk].handles_count = remains;
- chunks++;
- }
- /* Start the waiting threads. */
- for (chunk = 0; chunk < chunks; chunk++) {
- /* Note that using adb_thread_create is not appropriate here, since we
- * need a handle to wait on for thread termination. */
- threads[chunk].thread = (HANDLE)_beginthreadex(NULL, 0, _in_waiter_thread,
- &threads[chunk], 0, NULL);
- if (threads[chunk].thread == NULL) {
- /* Unable to create a waiter thread. Collapse. */
- D("Unable to create a waiting thread %d of %d. errno=%d",
- chunk, chunks, errno);
- chunks = chunk;
- SetEvent(main_event);
- break;
- }
- }
- /* Wait on any of the threads to get signaled. */
- WaitForSingleObject(main_event, INFINITE);
- /* Wait on all the waiting threads to exit. */
- for (chunk = 0; chunk < chunks; chunk++) {
- WaitForSingleObject(threads[chunk].thread, INFINITE);
- CloseHandle(threads[chunk].thread);
- }
- CloseHandle(main_event);
- free(threads);
- const int ret = (int)InterlockedCompareExchange(&sig_index, -1, -1);
- return (ret >= 0) ? ret : (int)WAIT_FAILED;
- }
- static EventLooperRec win32_looper;
- static void fdevent_init(void)
- {
- win32_looper.htab_count = 0;
- win32_looper.hooks = NULL;
- }
- static void fdevent_connect(fdevent *fde)
- {
- EventLooper looper = &win32_looper;
- int events = fde->state & FDE_EVENTMASK;
- if (events != 0)
- event_looper_hook( looper, fde->fd, events );
- }
- static void fdevent_disconnect(fdevent *fde)
- {
- EventLooper looper = &win32_looper;
- int events = fde->state & FDE_EVENTMASK;
- if (events != 0)
- event_looper_unhook( looper, fde->fd, events );
- }
- static void fdevent_update(fdevent *fde, unsigned events)
- {
- EventLooper looper = &win32_looper;
- unsigned events0 = fde->state & FDE_EVENTMASK;
- if (events != events0) {
- int removes = events0 & ~events;
- int adds = events & ~events0;
- if (removes) {
- D("fdevent_update: remove %x from %d\n", removes, fde->fd);
- event_looper_unhook( looper, fde->fd, removes );
- }
- if (adds) {
- D("fdevent_update: add %x to %d\n", adds, fde->fd);
- event_looper_hook ( looper, fde->fd, adds );
- }
- }
- }
- static void fdevent_process()
- {
- EventLooper looper = &win32_looper;
- EventHook hook;
- int gotone = 0;
- /* if we have at least one ready hook, execute it/them */
- for (hook = looper->hooks; hook; hook = hook->next) {
- hook->ready = 0;
- if (hook->prepare) {
- hook->prepare(hook);
- if (hook->ready != 0) {
- event_hook_signal( hook );
- gotone = 1;
- }
- }
- }
- /* nothing's ready yet, so wait for something to happen */
- if (!gotone)
- {
- looper->htab_count = 0;
- for (hook = looper->hooks; hook; hook = hook->next)
- {
- if (hook->start && !hook->start(hook)) {
- D( "fdevent_process: error when starting a hook\n" );
- return;
- }
- if (hook->h != INVALID_HANDLE_VALUE) {
- int nn;
- for (nn = 0; nn < looper->htab_count; nn++)
- {
- if ( looper->htab[nn] == hook->h )
- goto DontAdd;
- }
- looper->htab[ looper->htab_count++ ] = hook->h;
- DontAdd:
- ;
- }
- }
- if (looper->htab_count == 0) {
- D( "fdevent_process: nothing to wait for !!\n" );
- return;
- }
- do
- {
- int wait_ret;
- D( "adb_win32: waiting for %d events\n", looper->htab_count );
- if (looper->htab_count > MAXIMUM_WAIT_OBJECTS) {
- D("handle count %d exceeds MAXIMUM_WAIT_OBJECTS.\n", looper->htab_count);
- wait_ret = _wait_for_all(looper->htab, looper->htab_count);
- } else {
- wait_ret = WaitForMultipleObjects( looper->htab_count, looper->htab, FALSE, INFINITE );
- }
- if (wait_ret == (int)WAIT_FAILED) {
- D( "adb_win32: wait failed, error %ld\n", GetLastError() );
- } else {
- D( "adb_win32: got one (index %d)\n", wait_ret );
- /* according to Cygwin, some objects like consoles wake up on "inappropriate" events
- * like mouse movements. we need to filter these with the "check" function
- */
- if ((unsigned)wait_ret < (unsigned)looper->htab_count)
- {
- for (hook = looper->hooks; hook; hook = hook->next)
- {
- if ( looper->htab[wait_ret] == hook->h &&
- (!hook->check || hook->check(hook)) )
- {
- D( "adb_win32: signaling %s for %x\n", hook->fh->name, hook->ready );
- event_hook_signal( hook );
- gotone = 1;
- break;
- }
- }
- }
- }
- }
- while (!gotone);
- for (hook = looper->hooks; hook; hook = hook->next) {
- if (hook->stop)
- hook->stop( hook );
- }
- }
- for (hook = looper->hooks; hook; hook = hook->next) {
- if (hook->peek && hook->peek(hook))
- event_hook_signal( hook );
- }
- }
- static void fdevent_register(fdevent *fde)
- {
- int fd = fde->fd - WIN32_FH_BASE;
- if(fd < 0) {
- FATAL("bogus negative fd (%d)\n", fde->fd);
- }
- if(fd >= fd_table_max) {
- int oldmax = fd_table_max;
- if(fde->fd > 32000) {
- FATAL("bogus huuuuge fd (%d)\n", fde->fd);
- }
- if(fd_table_max == 0) {
- fdevent_init();
- fd_table_max = 256;
- }
- while(fd_table_max <= fd) {
- fd_table_max *= 2;
- }
- fd_table = realloc(fd_table, sizeof(fdevent*) * fd_table_max);
- if(fd_table == 0) {
- FATAL("could not expand fd_table to %d entries\n", fd_table_max);
- }
- memset(fd_table + oldmax, 0, sizeof(int) * (fd_table_max - oldmax));
- }
- fd_table[fd] = fde;
- }
- static void fdevent_unregister(fdevent *fde)
- {
- int fd = fde->fd - WIN32_FH_BASE;
- if((fd < 0) || (fd >= fd_table_max)) {
- FATAL("fd out of range (%d)\n", fde->fd);
- }
- if(fd_table[fd] != fde) {
- FATAL("fd_table out of sync");
- }
- fd_table[fd] = 0;
- if(!(fde->state & FDE_DONT_CLOSE)) {
- dump_fde(fde, "close");
- adb_close(fde->fd);
- }
- }
- static void fdevent_plist_enqueue(fdevent *node)
- {
- fdevent *list = &list_pending;
- node->next = list;
- node->prev = list->prev;
- node->prev->next = node;
- list->prev = node;
- }
- static void fdevent_plist_remove(fdevent *node)
- {
- node->prev->next = node->next;
- node->next->prev = node->prev;
- node->next = 0;
- node->prev = 0;
- }
- static fdevent *fdevent_plist_dequeue(void)
- {
- fdevent *list = &list_pending;
- fdevent *node = list->next;
- if(node == list) return 0;
- list->next = node->next;
- list->next->prev = list;
- node->next = 0;
- node->prev = 0;
- return node;
- }
- fdevent *fdevent_create(int fd, fd_func func, void *arg)
- {
- fdevent *fde = (fdevent*) malloc(sizeof(fdevent));
- if(fde == 0) return 0;
- fdevent_install(fde, fd, func, arg);
- fde->state |= FDE_CREATED;
- return fde;
- }
- void fdevent_destroy(fdevent *fde)
- {
- if(fde == 0) return;
- if(!(fde->state & FDE_CREATED)) {
- FATAL("fde %p not created by fdevent_create()\n", fde);
- }
- fdevent_remove(fde);
- }
- void fdevent_install(fdevent *fde, int fd, fd_func func, void *arg)
- {
- memset(fde, 0, sizeof(fdevent));
- fde->state = FDE_ACTIVE;
- fde->fd = fd;
- fde->func = func;
- fde->arg = arg;
- fdevent_register(fde);
- dump_fde(fde, "connect");
- fdevent_connect(fde);
- fde->state |= FDE_ACTIVE;
- }
- void fdevent_remove(fdevent *fde)
- {
- if(fde->state & FDE_PENDING) {
- fdevent_plist_remove(fde);
- }
- if(fde->state & FDE_ACTIVE) {
- fdevent_disconnect(fde);
- dump_fde(fde, "disconnect");
- fdevent_unregister(fde);
- }
- fde->state = 0;
- fde->events = 0;
- }
- void fdevent_set(fdevent *fde, unsigned events)
- {
- events &= FDE_EVENTMASK;
- if((fde->state & FDE_EVENTMASK) == (int)events) return;
- if(fde->state & FDE_ACTIVE) {
- fdevent_update(fde, events);
- dump_fde(fde, "update");
- }
- fde->state = (fde->state & FDE_STATEMASK) | events;
- if(fde->state & FDE_PENDING) {
- /* if we're pending, make sure
- ** we don't signal an event that
- ** is no longer wanted.
- */
- fde->events &= (~events);
- if(fde->events == 0) {
- fdevent_plist_remove(fde);
- fde->state &= (~FDE_PENDING);
- }
- }
- }
- void fdevent_add(fdevent *fde, unsigned events)
- {
- fdevent_set(
- fde, (fde->state & FDE_EVENTMASK) | (events & FDE_EVENTMASK));
- }
- void fdevent_del(fdevent *fde, unsigned events)
- {
- fdevent_set(
- fde, (fde->state & FDE_EVENTMASK) & (~(events & FDE_EVENTMASK)));
- }
- void fdevent_loop()
- {
- fdevent *fde;
- for(;;) {
- #if DEBUG
- fprintf(stderr,"--- ---- waiting for events\n");
- #endif
- fdevent_process();
- while((fde = fdevent_plist_dequeue())) {
- unsigned events = fde->events;
- fde->events = 0;
- fde->state &= (~FDE_PENDING);
- dump_fde(fde, "callback");
- fde->func(fde->fd, events, fde->arg);
- }
- }
- }
- /** FILE EVENT HOOKS
- **/
- static void _event_file_prepare( EventHook hook )
- {
- if (hook->wanted & (FDE_READ|FDE_WRITE)) {
- /* we can always read/write */
- hook->ready |= hook->wanted & (FDE_READ|FDE_WRITE);
- }
- }
- static int _event_file_peek( EventHook hook )
- {
- return (hook->wanted & (FDE_READ|FDE_WRITE));
- }
- static void _fh_file_hook( FH f, int events, EventHook hook )
- {
- hook->h = f->fh_handle;
- hook->prepare = _event_file_prepare;
- hook->peek = _event_file_peek;
- }
- /** SOCKET EVENT HOOKS
- **/
- static void _event_socket_verify( EventHook hook, WSANETWORKEVENTS* evts )
- {
- if ( evts->lNetworkEvents & (FD_READ|FD_ACCEPT|FD_CLOSE) ) {
- if (hook->wanted & FDE_READ)
- hook->ready |= FDE_READ;
- if ((evts->iErrorCode[FD_READ] != 0) && hook->wanted & FDE_ERROR)
- hook->ready |= FDE_ERROR;
- }
- if ( evts->lNetworkEvents & (FD_WRITE|FD_CONNECT|FD_CLOSE) ) {
- if (hook->wanted & FDE_WRITE)
- hook->ready |= FDE_WRITE;
- if ((evts->iErrorCode[FD_WRITE] != 0) && hook->wanted & FDE_ERROR)
- hook->ready |= FDE_ERROR;
- }
- if ( evts->lNetworkEvents & FD_OOB ) {
- if (hook->wanted & FDE_ERROR)
- hook->ready |= FDE_ERROR;
- }
- }
- static void _event_socket_prepare( EventHook hook )
- {
- WSANETWORKEVENTS evts;
- /* look if some of the events we want already happened ? */
- if (!WSAEnumNetworkEvents( hook->fh->fh_socket, NULL, &evts ))
- _event_socket_verify( hook, &evts );
- }
- static int _socket_wanted_to_flags( int wanted )
- {
- int flags = 0;
- if (wanted & FDE_READ)
- flags |= FD_READ | FD_ACCEPT | FD_CLOSE;
- if (wanted & FDE_WRITE)
- flags |= FD_WRITE | FD_CONNECT | FD_CLOSE;
- if (wanted & FDE_ERROR)
- flags |= FD_OOB;
- return flags;
- }
- static int _event_socket_start( EventHook hook )
- {
- /* create an event which we're going to wait for */
- FH fh = hook->fh;
- long flags = _socket_wanted_to_flags( hook->wanted );
- hook->h = fh->event;
- if (hook->h == INVALID_HANDLE_VALUE) {
- D( "_event_socket_start: no event for %s\n", fh->name );
- return 0;
- }
- if ( flags != fh->mask ) {
- D( "_event_socket_start: hooking %s for %x (flags %ld)\n", hook->fh->name, hook->wanted, flags );
- if ( WSAEventSelect( fh->fh_socket, hook->h, flags ) ) {
- D( "_event_socket_start: WSAEventSelect() for %s failed, error %d\n", hook->fh->name, WSAGetLastError() );
- CloseHandle( hook->h );
- hook->h = INVALID_HANDLE_VALUE;
- exit(1);
- return 0;
- }
- fh->mask = flags;
- }
- return 1;
- }
- static void _event_socket_stop( EventHook hook )
- {
- hook->h = INVALID_HANDLE_VALUE;
- }
- static int _event_socket_check( EventHook hook )
- {
- int result = 0;
- FH fh = hook->fh;
- WSANETWORKEVENTS evts;
- if (!WSAEnumNetworkEvents( fh->fh_socket, hook->h, &evts ) ) {
- _event_socket_verify( hook, &evts );
- result = (hook->ready != 0);
- if (result) {
- ResetEvent( hook->h );
- }
- }
- D( "_event_socket_check %s returns %d\n", fh->name, result );
- return result;
- }
- static int _event_socket_peek( EventHook hook )
- {
- WSANETWORKEVENTS evts;
- FH fh = hook->fh;
- /* look if some of the events we want already happened ? */
- if (!WSAEnumNetworkEvents( fh->fh_socket, NULL, &evts )) {
- _event_socket_verify( hook, &evts );
- if (hook->ready)
- ResetEvent( hook->h );
- }
- return hook->ready != 0;
- }
- static void _fh_socket_hook( FH f, int events, EventHook hook )
- {
- hook->prepare = _event_socket_prepare;
- hook->start = _event_socket_start;
- hook->stop = _event_socket_stop;
- hook->check = _event_socket_check;
- hook->peek = _event_socket_peek;
- _event_socket_start( hook );
- }
- /** SOCKETPAIR EVENT HOOKS
- **/
- static void _event_socketpair_prepare( EventHook hook )
- {
- FH fh = hook->fh;
- SocketPair pair = fh->fh_pair;
- BipBuffer rbip = (pair->a_fd == fh) ? &pair->b2a_bip : &pair->a2b_bip;
- BipBuffer wbip = (pair->a_fd == fh) ? &pair->a2b_bip : &pair->b2a_bip;
- if (hook->wanted & FDE_READ && rbip->can_read)
- hook->ready |= FDE_READ;
- if (hook->wanted & FDE_WRITE && wbip->can_write)
- hook->ready |= FDE_WRITE;
- }
- static int _event_socketpair_start( EventHook hook )
- {
- FH fh = hook->fh;
- SocketPair pair = fh->fh_pair;
- BipBuffer rbip = (pair->a_fd == fh) ? &pair->b2a_bip : &pair->a2b_bip;
- BipBuffer wbip = (pair->a_fd == fh) ? &pair->a2b_bip : &pair->b2a_bip;
- if (hook->wanted == FDE_READ)
- hook->h = rbip->evt_read;
- else if (hook->wanted == FDE_WRITE)
- hook->h = wbip->evt_write;
- else {
- D("_event_socketpair_start: can't handle FDE_READ+FDE_WRITE\n" );
- return 0;
- }
- D( "_event_socketpair_start: hook %s for %x wanted=%x\n",
- hook->fh->name, _fh_to_int(fh), hook->wanted);
- return 1;
- }
- static int _event_socketpair_peek( EventHook hook )
- {
- _event_socketpair_prepare( hook );
- return hook->ready != 0;
- }
- static void _fh_socketpair_hook( FH fh, int events, EventHook hook )
- {
- hook->prepare = _event_socketpair_prepare;
- hook->start = _event_socketpair_start;
- hook->peek = _event_socketpair_peek;
- }
- void
- adb_sysdeps_init( void )
- {
- #define ADB_MUTEX(x) InitializeCriticalSection( & x );
- #include "mutex_list.h"
- InitializeCriticalSection( &_win32_lock );
- }
- /* Windows doesn't have strtok_r. Use the one from bionic. */
- /*
- * Copyright (c) 1988 Regents of the University of California.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the University nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
- char *
- adb_strtok_r(char *s, const char *delim, char **last)
- {
- char *spanp;
- int c, sc;
- char *tok;
- if (s == NULL && (s = *last) == NULL)
- return (NULL);
- /*
- * Skip (span) leading delimiters (s += strspn(s, delim), sort of).
- */
- cont:
- c = *s++;
- for (spanp = (char *)delim; (sc = *spanp++) != 0;) {
- if (c == sc)
- goto cont;
- }
- if (c == 0) { /* no non-delimiter characters */
- *last = NULL;
- return (NULL);
- }
- tok = s - 1;
- /*
- * Scan token (scan for delimiters: s += strcspn(s, delim), sort of).
- * Note that delim must have one NUL; we stop if we see that, too.
- */
- for (;;) {
- c = *s++;
- spanp = (char *)delim;
- do {
- if ((sc = *spanp++) == c) {
- if (c == 0)
- s = NULL;
- else
- s[-1] = 0;
- *last = s;
- return (tok);
- }
- } while (sc != 0);
- }
- /* NOTREACHED */
- }
|