1 /* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 /* this file contains system-dependent definitions used by ADB 18 * they're related to threads, sockets and file descriptors 19 */ 20 #ifndef _ADB_SYSDEPS_H 21 #define _ADB_SYSDEPS_H 22 23 #ifdef __CYGWIN__ 24 # undef _WIN32 25 #endif 26 27 #ifdef _WIN32 28 29 #include <windows.h> 30 #include <winsock2.h> 31 #include <ws2tcpip.h> 32 #include <process.h> 33 #include <fcntl.h> 34 #include <io.h> 35 #include <sys/stat.h> 36 #include <errno.h> 37 #include <ctype.h> 38 39 #define OS_PATH_SEPARATOR '\\' 40 #define OS_PATH_SEPARATOR_STR "\\" 41 #define ENV_PATH_SEPARATOR_STR ";" 42 43 typedef CRITICAL_SECTION adb_mutex_t; 44 45 #define ADB_MUTEX_DEFINE(x) adb_mutex_t x 46 47 /* declare all mutexes */ 48 /* For win32, adb_sysdeps_init() will do the mutex runtime initialization. */ 49 #define ADB_MUTEX(x) extern adb_mutex_t x; 50 #include "mutex_list.h" 51 52 extern void adb_sysdeps_init(void); 53 54 static __inline__ void adb_mutex_lock( adb_mutex_t* lock ) 55 { 56 EnterCriticalSection( lock ); 57 } 58 59 static __inline__ void adb_mutex_unlock( adb_mutex_t* lock ) 60 { 61 LeaveCriticalSection( lock ); 62 } 63 64 typedef struct { unsigned tid; } adb_thread_t; 65 66 typedef void* (*adb_thread_func_t)(void* arg); 67 68 typedef void (*win_thread_func_t)(void* arg); 69 70 static __inline__ int adb_thread_create( adb_thread_t *thread, adb_thread_func_t func, void* arg) 71 { 72 thread->tid = _beginthread( (win_thread_func_t)func, 0, arg ); 73 if (thread->tid == (unsigned)-1L) { 74 return -1; 75 } 76 return 0; 77 } 78 79 static __inline__ void close_on_exec(int fd) 80 { 81 /* nothing really */ 82 } 83 84 extern void disable_tcp_nagle(int fd); 85 86 #define lstat stat /* no symlinks on Win32 */ 87 88 #define S_ISLNK(m) 0 /* no symlinks on Win32 */ 89 90 static __inline__ int adb_unlink(const char* path) 91 { 92 int rc = unlink(path); 93 94 if (rc == -1 && errno == EACCES) { 95 /* unlink returns EACCES when the file is read-only, so we first */ 96 /* try to make it writable, then unlink again... */ 97 rc = chmod(path, _S_IREAD|_S_IWRITE ); 98 if (rc == 0) 99 rc = unlink(path); 100 } 101 return rc; 102 } 103 #undef unlink 104 #define unlink ___xxx_unlink 105 106 static __inline__ int adb_mkdir(const char* path, int mode) 107 { 108 return _mkdir(path); 109 } 110 #undef mkdir 111 #define mkdir ___xxx_mkdir 112 113 extern int adb_open(const char* path, int options); 114 extern int adb_creat(const char* path, int mode); 115 extern int adb_read(int fd, void* buf, int len); 116 extern int adb_write(int fd, const void* buf, int len); 117 extern int adb_lseek(int fd, int pos, int where); 118 extern int adb_shutdown(int fd); 119 extern int adb_close(int fd); 120 121 static __inline__ int unix_close(int fd) 122 { 123 return close(fd); 124 } 125 #undef close 126 #define close ____xxx_close 127 128 static __inline__ int unix_read(int fd, void* buf, size_t len) 129 { 130 return read(fd, buf, len); 131 } 132 #undef read 133 #define read ___xxx_read 134 135 static __inline__ int unix_write(int fd, const void* buf, size_t len) 136 { 137 return write(fd, buf, len); 138 } 139 #undef write 140 #define write ___xxx_write 141 142 static __inline__ int adb_open_mode(const char* path, int options, int mode) 143 { 144 return adb_open(path, options); 145 } 146 147 static __inline__ int unix_open(const char* path, int options,...) 148 { 149 if ((options & O_CREAT) == 0) 150 { 151 return open(path, options); 152 } 153 else 154 { 155 int mode; 156 va_list args; 157 va_start( args, options ); 158 mode = va_arg( args, int ); 159 va_end( args ); 160 return open(path, options, mode); 161 } 162 } 163 #define open ___xxx_unix_open 164 165 166 /* normally provided by <cutils/misc.h> */ 167 extern void* load_file(const char* pathname, unsigned* psize); 168 169 /* normally provided by <cutils/sockets.h> */ 170 extern int socket_loopback_client(int port, int type); 171 extern int socket_network_client(const char *host, int port, int type); 172 extern int socket_loopback_server(int port, int type); 173 extern int socket_inaddr_any_server(int port, int type); 174 175 /* normally provided by "fdevent.h" */ 176 177 #define FDE_READ 0x0001 178 #define FDE_WRITE 0x0002 179 #define FDE_ERROR 0x0004 180 #define FDE_DONT_CLOSE 0x0080 181 182 typedef struct fdevent fdevent; 183 184 typedef void (*fd_func)(int fd, unsigned events, void *userdata); 185 186 fdevent *fdevent_create(int fd, fd_func func, void *arg); 187 void fdevent_destroy(fdevent *fde); 188 void fdevent_install(fdevent *fde, int fd, fd_func func, void *arg); 189 void fdevent_remove(fdevent *item); 190 void fdevent_set(fdevent *fde, unsigned events); 191 void fdevent_add(fdevent *fde, unsigned events); 192 void fdevent_del(fdevent *fde, unsigned events); 193 void fdevent_loop(); 194 195 struct fdevent { 196 fdevent *next; 197 fdevent *prev; 198 199 int fd; 200 int force_eof; 201 202 unsigned short state; 203 unsigned short events; 204 205 fd_func func; 206 void *arg; 207 }; 208 209 static __inline__ void adb_sleep_ms( int mseconds ) 210 { 211 Sleep( mseconds ); 212 } 213 214 extern int adb_socket_accept(int serverfd, struct sockaddr* addr, socklen_t *addrlen); 215 216 #undef accept 217 #define accept ___xxx_accept 218 219 static __inline__ int adb_socket_setbufsize( int fd, int bufsize ) 220 { 221 int opt = bufsize; 222 return setsockopt(fd, SOL_SOCKET, SO_RCVBUF, (const char*)&opt, sizeof(opt)); 223 } 224 225 extern int adb_socketpair( int sv[2] ); 226 227 static __inline__ char* adb_dirstart( const char* path ) 228 { 229 char* p = strchr(path, '/'); 230 char* p2 = strchr(path, '\\'); 231 232 if ( !p ) 233 p = p2; 234 else if ( p2 && p2 > p ) 235 p = p2; 236 237 return p; 238 } 239 240 static __inline__ char* adb_dirstop( const char* path ) 241 { 242 char* p = strrchr(path, '/'); 243 char* p2 = strrchr(path, '\\'); 244 245 if ( !p ) 246 p = p2; 247 else if ( p2 && p2 > p ) 248 p = p2; 249 250 return p; 251 } 252 253 static __inline__ int adb_is_absolute_host_path( const char* path ) 254 { 255 return isalpha(path[0]) && path[1] == ':' && path[2] == '\\'; 256 } 257 258 extern char* adb_strtok_r(char *str, const char *delim, char **saveptr); 259 260 #else /* !_WIN32 a.k.a. Unix */ 261 262 #include "fdevent.h" 263 #include <cutils/sockets.h> 264 #include <cutils/properties.h> 265 #include <cutils/misc.h> 266 #include <signal.h> 267 #include <sys/wait.h> 268 #include <sys/stat.h> 269 #include <fcntl.h> 270 271 #include <pthread.h> 272 #include <unistd.h> 273 #include <fcntl.h> 274 #include <stdarg.h> 275 #include <netinet/in.h> 276 #include <netinet/tcp.h> 277 #include <string.h> 278 #include <unistd.h> 279 280 /* 281 * TEMP_FAILURE_RETRY is defined by some, but not all, versions of 282 * <unistd.h>. (Alas, it is not as standard as we'd hoped!) So, if it's 283 * not already defined, then define it here. 284 */ 285 #ifndef TEMP_FAILURE_RETRY 286 /* Used to retry syscalls that can return EINTR. */ 287 #define TEMP_FAILURE_RETRY(exp) ({ \ 288 typeof (exp) _rc; \ 289 do { \ 290 _rc = (exp); \ 291 } while (_rc == -1 && errno == EINTR); \ 292 _rc; }) 293 #endif 294 295 #define OS_PATH_SEPARATOR '/' 296 #define OS_PATH_SEPARATOR_STR "/" 297 #define ENV_PATH_SEPARATOR_STR ":" 298 299 typedef pthread_mutex_t adb_mutex_t; 300 301 #define ADB_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER 302 #define adb_mutex_init pthread_mutex_init 303 #define adb_mutex_lock pthread_mutex_lock 304 #define adb_mutex_unlock pthread_mutex_unlock 305 #define adb_mutex_destroy pthread_mutex_destroy 306 307 #define ADB_MUTEX_DEFINE(m) adb_mutex_t m = PTHREAD_MUTEX_INITIALIZER 308 309 #define adb_cond_t pthread_cond_t 310 #define adb_cond_init pthread_cond_init 311 #define adb_cond_wait pthread_cond_wait 312 #define adb_cond_broadcast pthread_cond_broadcast 313 #define adb_cond_signal pthread_cond_signal 314 #define adb_cond_destroy pthread_cond_destroy 315 316 /* declare all mutexes */ 317 #define ADB_MUTEX(x) extern adb_mutex_t x; 318 #include "mutex_list.h" 319 320 static __inline__ void close_on_exec(int fd) 321 { 322 fcntl( fd, F_SETFD, FD_CLOEXEC ); 323 } 324 325 static __inline__ int unix_open(const char* path, int options,...) 326 { 327 if ((options & O_CREAT) == 0) 328 { 329 return TEMP_FAILURE_RETRY( open(path, options) ); 330 } 331 else 332 { 333 int mode; 334 va_list args; 335 va_start( args, options ); 336 mode = va_arg( args, int ); 337 va_end( args ); 338 return TEMP_FAILURE_RETRY( open( path, options, mode ) ); 339 } 340 } 341 342 static __inline__ int adb_open_mode( const char* pathname, int options, int mode ) 343 { 344 return TEMP_FAILURE_RETRY( open( pathname, options, mode ) ); 345 } 346 347 348 static __inline__ int adb_open( const char* pathname, int options ) 349 { 350 int fd = TEMP_FAILURE_RETRY( open( pathname, options ) ); 351 if (fd < 0) 352 return -1; 353 close_on_exec( fd ); 354 return fd; 355 } 356 #undef open 357 #define open ___xxx_open 358 359 static __inline__ int adb_shutdown(int fd) 360 { 361 return shutdown(fd, SHUT_RDWR); 362 } 363 #undef shutdown 364 #define shutdown ____xxx_shutdown 365 366 static __inline__ int adb_close(int fd) 367 { 368 return close(fd); 369 } 370 #undef close 371 #define close ____xxx_close 372 373 374 static __inline__ int adb_read(int fd, void* buf, size_t len) 375 { 376 return TEMP_FAILURE_RETRY( read( fd, buf, len ) ); 377 } 378 379 #undef read 380 #define read ___xxx_read 381 382 static __inline__ int adb_write(int fd, const void* buf, size_t len) 383 { 384 return TEMP_FAILURE_RETRY( write( fd, buf, len ) ); 385 } 386 #undef write 387 #define write ___xxx_write 388 389 static __inline__ int adb_lseek(int fd, int pos, int where) 390 { 391 return lseek(fd, pos, where); 392 } 393 #undef lseek 394 #define lseek ___xxx_lseek 395 396 static __inline__ int adb_unlink(const char* path) 397 { 398 return unlink(path); 399 } 400 #undef unlink 401 #define unlink ___xxx_unlink 402 403 static __inline__ int adb_creat(const char* path, int mode) 404 { 405 int fd = TEMP_FAILURE_RETRY( creat( path, mode ) ); 406 407 if ( fd < 0 ) 408 return -1; 409 410 close_on_exec(fd); 411 return fd; 412 } 413 #undef creat 414 #define creat ___xxx_creat 415 416 static __inline__ int adb_socket_accept(int serverfd, struct sockaddr* addr, socklen_t *addrlen) 417 { 418 int fd; 419 420 fd = TEMP_FAILURE_RETRY( accept( serverfd, addr, addrlen ) ); 421 if (fd >= 0) 422 close_on_exec(fd); 423 424 return fd; 425 } 426 427 #undef accept 428 #define accept ___xxx_accept 429 430 #define unix_read adb_read 431 #define unix_write adb_write 432 #define unix_close adb_close 433 434 typedef pthread_t adb_thread_t; 435 436 typedef void* (*adb_thread_func_t)( void* arg ); 437 438 static __inline__ int adb_thread_create( adb_thread_t *pthread, adb_thread_func_t start, void* arg ) 439 { 440 pthread_attr_t attr; 441 442 pthread_attr_init (&attr); 443 pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED); 444 445 return pthread_create( pthread, &attr, start, arg ); 446 } 447 448 static __inline__ int adb_socket_setbufsize( int fd, int bufsize ) 449 { 450 int opt = bufsize; 451 return setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt)); 452 } 453 454 static __inline__ void disable_tcp_nagle(int fd) 455 { 456 int on = 1; 457 setsockopt( fd, IPPROTO_TCP, TCP_NODELAY, (void*)&on, sizeof(on) ); 458 } 459 460 461 static __inline__ int unix_socketpair( int d, int type, int protocol, int sv[2] ) 462 { 463 return socketpair( d, type, protocol, sv ); 464 } 465 466 static __inline__ int adb_socketpair( int sv[2] ) 467 { 468 int rc; 469 470 rc = unix_socketpair( AF_UNIX, SOCK_STREAM, 0, sv ); 471 if (rc < 0) 472 return -1; 473 474 close_on_exec( sv[0] ); 475 close_on_exec( sv[1] ); 476 return 0; 477 } 478 479 #undef socketpair 480 #define socketpair ___xxx_socketpair 481 482 static __inline__ void adb_sleep_ms( int mseconds ) 483 { 484 usleep( mseconds*1000 ); 485 } 486 487 static __inline__ int adb_mkdir(const char* path, int mode) 488 { 489 return mkdir(path, mode); 490 } 491 #undef mkdir 492 #define mkdir ___xxx_mkdir 493 494 static __inline__ void adb_sysdeps_init(void) 495 { 496 } 497 498 static __inline__ char* adb_dirstart(const char* path) 499 { 500 return strchr(path, '/'); 501 } 502 503 static __inline__ char* adb_dirstop(const char* path) 504 { 505 return strrchr(path, '/'); 506 } 507 508 static __inline__ int adb_is_absolute_host_path( const char* path ) 509 { 510 return path[0] == '/'; 511 } 512 513 static __inline__ char* adb_strtok_r(char *str, const char *delim, char **saveptr) 514 { 515 return strtok_r(str, delim, saveptr); 516 } 517 #undef strtok_r 518 #define strtok_r ___xxx_strtok_r 519 520 #endif /* !_WIN32 */ 521 522 #endif /* _ADB_SYSDEPS_H */ 523
