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
adb_mutex_lock(adb_mutex_t * lock)54 static __inline__ void adb_mutex_lock( adb_mutex_t* lock )
55 {
56 EnterCriticalSection( lock );
57 }
58
adb_mutex_unlock(adb_mutex_t * lock)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
adb_thread_create(adb_thread_t * thread,adb_thread_func_t func,void * arg)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
close_on_exec(int fd)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
adb_unlink(const char * path)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
adb_mkdir(const char * path,int mode)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
unix_close(int fd)121 static __inline__ int unix_close(int fd)
122 {
123 return close(fd);
124 }
125 #undef close
126 #define close ____xxx_close
127
unix_read(int fd,void * buf,size_t len)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
unix_write(int fd,const void * buf,size_t len)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
adb_open_mode(const char * path,int options,int mode)142 static __inline__ int adb_open_mode(const char* path, int options, int mode)
143 {
144 return adb_open(path, options);
145 }
146
unix_open(const char * path,int options,...)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
adb_sleep_ms(int mseconds)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
adb_socket_setbufsize(int fd,int bufsize)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
adb_dirstart(const char * path)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
adb_dirstop(const char * path)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
adb_is_absolute_host_path(const char * path)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
close_on_exec(int fd)320 static __inline__ void close_on_exec(int fd)
321 {
322 fcntl( fd, F_SETFD, FD_CLOEXEC );
323 }
324
unix_open(const char * path,int options,...)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
adb_open_mode(const char * pathname,int options,int mode)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
adb_open(const char * pathname,int options)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
adb_shutdown(int fd)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
adb_close(int fd)366 static __inline__ int adb_close(int fd)
367 {
368 return close(fd);
369 }
370 #undef close
371 #define close ____xxx_close
372
373
adb_read(int fd,void * buf,size_t len)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
adb_write(int fd,const void * buf,size_t len)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
adb_lseek(int fd,int pos,int where)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
adb_unlink(const char * path)396 static __inline__ int adb_unlink(const char* path)
397 {
398 return unlink(path);
399 }
400 #undef unlink
401 #define unlink ___xxx_unlink
402
adb_creat(const char * path,int mode)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
adb_socket_accept(int serverfd,struct sockaddr * addr,socklen_t * addrlen)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
adb_thread_create(adb_thread_t * pthread,adb_thread_func_t start,void * arg)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
adb_socket_setbufsize(int fd,int bufsize)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
disable_tcp_nagle(int fd)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
unix_socketpair(int d,int type,int protocol,int sv[2])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
adb_socketpair(int sv[2])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
adb_sleep_ms(int mseconds)482 static __inline__ void adb_sleep_ms( int mseconds )
483 {
484 usleep( mseconds*1000 );
485 }
486
adb_mkdir(const char * path,int mode)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
adb_sysdeps_init(void)494 static __inline__ void adb_sysdeps_init(void)
495 {
496 }
497
adb_dirstart(const char * path)498 static __inline__ char* adb_dirstart(const char* path)
499 {
500 return strchr(path, '/');
501 }
502
adb_dirstop(const char * path)503 static __inline__ char* adb_dirstop(const char* path)
504 {
505 return strrchr(path, '/');
506 }
507
adb_is_absolute_host_path(const char * path)508 static __inline__ int adb_is_absolute_host_path( const char* path )
509 {
510 return path[0] == '/';
511 }
512
adb_strtok_r(char * str,const char * delim,char ** saveptr)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