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