/* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* this file contains system-dependent definitions used by ADB * they're related to threads, sockets and file descriptors */ #ifndef _ADB_SYSDEPS_H #define _ADB_SYSDEPS_H #ifdef __CYGWIN__ # undef _WIN32 #endif #ifdef _WIN32 #include #include #include #include #include #include #include #include #include #define OS_PATH_SEPARATOR '\\' #define OS_PATH_SEPARATOR_STR "\\" #define ENV_PATH_SEPARATOR_STR ";" typedef CRITICAL_SECTION adb_mutex_t; #define ADB_MUTEX_DEFINE(x) adb_mutex_t x /* declare all mutexes */ /* For win32, adb_sysdeps_init() will do the mutex runtime initialization. */ #define ADB_MUTEX(x) extern adb_mutex_t x; #include "mutex_list.h" extern void adb_sysdeps_init(void); static __inline__ void adb_mutex_lock( adb_mutex_t* lock ) { EnterCriticalSection( lock ); } static __inline__ void adb_mutex_unlock( adb_mutex_t* lock ) { LeaveCriticalSection( lock ); } typedef struct { unsigned tid; } adb_thread_t; typedef void* (*adb_thread_func_t)(void* arg); typedef void (*win_thread_func_t)(void* arg); static __inline__ int adb_thread_create( adb_thread_t *thread, adb_thread_func_t func, void* arg) { thread->tid = _beginthread( (win_thread_func_t)func, 0, arg ); if (thread->tid == (unsigned)-1L) { return -1; } return 0; } static __inline__ void close_on_exec(int fd) { /* nothing really */ } extern void disable_tcp_nagle(int fd); #define lstat stat /* no symlinks on Win32 */ #define S_ISLNK(m) 0 /* no symlinks on Win32 */ static __inline__ int adb_unlink(const char* path) { int rc = unlink(path); if (rc == -1 && errno == EACCES) { /* unlink returns EACCES when the file is read-only, so we first */ /* try to make it writable, then unlink again... */ rc = chmod(path, _S_IREAD|_S_IWRITE ); if (rc == 0) rc = unlink(path); } return rc; } #undef unlink #define unlink ___xxx_unlink static __inline__ int adb_mkdir(const char* path, int mode) { return _mkdir(path); } #undef mkdir #define mkdir ___xxx_mkdir extern int adb_open(const char* path, int options); extern int adb_creat(const char* path, int mode); extern int adb_read(int fd, void* buf, int len); extern int adb_write(int fd, const void* buf, int len); extern int adb_lseek(int fd, int pos, int where); extern int adb_shutdown(int fd); extern int adb_close(int fd); static __inline__ int unix_close(int fd) { return close(fd); } #undef close #define close ____xxx_close static __inline__ int unix_read(int fd, void* buf, size_t len) { return read(fd, buf, len); } #undef read #define read ___xxx_read static __inline__ int unix_write(int fd, const void* buf, size_t len) { return write(fd, buf, len); } #undef write #define write ___xxx_write static __inline__ int adb_open_mode(const char* path, int options, int mode) { return adb_open(path, options); } static __inline__ int unix_open(const char* path, int options,...) { if ((options & O_CREAT) == 0) { return open(path, options); } else { int mode; va_list args; va_start( args, options ); mode = va_arg( args, int ); va_end( args ); return open(path, options, mode); } } #define open ___xxx_unix_open /* normally provided by */ extern void* load_file(const char* pathname, unsigned* psize); /* normally provided by */ extern int socket_loopback_client(int port, int type); extern int socket_network_client(const char *host, int port, int type); extern int socket_loopback_server(int port, int type); extern int socket_inaddr_any_server(int port, int type); /* normally provided by "fdevent.h" */ #define FDE_READ 0x0001 #define FDE_WRITE 0x0002 #define FDE_ERROR 0x0004 #define FDE_DONT_CLOSE 0x0080 typedef struct fdevent fdevent; typedef void (*fd_func)(int fd, unsigned events, void *userdata); fdevent *fdevent_create(int fd, fd_func func, void *arg); void fdevent_destroy(fdevent *fde); void fdevent_install(fdevent *fde, int fd, fd_func func, void *arg); void fdevent_remove(fdevent *item); void fdevent_set(fdevent *fde, unsigned events); void fdevent_add(fdevent *fde, unsigned events); void fdevent_del(fdevent *fde, unsigned events); void fdevent_loop(); struct fdevent { fdevent *next; fdevent *prev; int fd; int force_eof; unsigned short state; unsigned short events; fd_func func; void *arg; }; static __inline__ void adb_sleep_ms( int mseconds ) { Sleep( mseconds ); } extern int adb_socket_accept(int serverfd, struct sockaddr* addr, socklen_t *addrlen); #undef accept #define accept ___xxx_accept static __inline__ int adb_socket_setbufsize( int fd, int bufsize ) { int opt = bufsize; return setsockopt(fd, SOL_SOCKET, SO_RCVBUF, (const char*)&opt, sizeof(opt)); } extern int adb_socketpair( int sv[2] ); static __inline__ char* adb_dirstart( const char* path ) { char* p = strchr(path, '/'); char* p2 = strchr(path, '\\'); if ( !p ) p = p2; else if ( p2 && p2 > p ) p = p2; return p; } static __inline__ char* adb_dirstop( const char* path ) { char* p = strrchr(path, '/'); char* p2 = strrchr(path, '\\'); if ( !p ) p = p2; else if ( p2 && p2 > p ) p = p2; return p; } static __inline__ int adb_is_absolute_host_path( const char* path ) { return isalpha(path[0]) && path[1] == ':' && path[2] == '\\'; } extern char* adb_strtok_r(char *str, const char *delim, char **saveptr); #else /* !_WIN32 a.k.a. Unix */ #include "fdevent.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define OS_PATH_SEPARATOR '/' #define OS_PATH_SEPARATOR_STR "/" #define ENV_PATH_SEPARATOR_STR ":" typedef pthread_mutex_t adb_mutex_t; #define ADB_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER #define adb_mutex_init pthread_mutex_init #define adb_mutex_lock pthread_mutex_lock #define adb_mutex_unlock pthread_mutex_unlock #define adb_mutex_destroy pthread_mutex_destroy #define ADB_MUTEX_DEFINE(m) adb_mutex_t m = PTHREAD_MUTEX_INITIALIZER #define adb_cond_t pthread_cond_t #define adb_cond_init pthread_cond_init #define adb_cond_wait pthread_cond_wait #define adb_cond_broadcast pthread_cond_broadcast #define adb_cond_signal pthread_cond_signal #define adb_cond_destroy pthread_cond_destroy /* declare all mutexes */ #define ADB_MUTEX(x) extern adb_mutex_t x; #include "mutex_list.h" static __inline__ void close_on_exec(int fd) { fcntl( fd, F_SETFD, FD_CLOEXEC ); } static __inline__ int unix_open(const char* path, int options,...) { if ((options & O_CREAT) == 0) { return open(path, options); } else { int mode; va_list args; va_start( args, options ); mode = va_arg( args, int ); va_end( args ); return open(path, options, mode); } } static __inline__ int adb_open_mode( const char* pathname, int options, int mode ) { return open( pathname, options, mode ); } static __inline__ int adb_open( const char* pathname, int options ) { int fd = open( pathname, options ); if (fd < 0) return -1; close_on_exec( fd ); return fd; } #undef open #define open ___xxx_open static __inline__ int adb_shutdown(int fd) { return shutdown(fd, SHUT_RDWR); } #undef shutdown #define shutdown ____xxx_shutdown static __inline__ int adb_close(int fd) { return close(fd); } #undef close #define close ____xxx_close static __inline__ int adb_read(int fd, void* buf, size_t len) { return read(fd, buf, len); } #undef read #define read ___xxx_read static __inline__ int adb_write(int fd, const void* buf, size_t len) { return write(fd, buf, len); } #undef write #define write ___xxx_write static __inline__ int adb_lseek(int fd, int pos, int where) { return lseek(fd, pos, where); } #undef lseek #define lseek ___xxx_lseek static __inline__ int adb_unlink(const char* path) { return unlink(path); } #undef unlink #define unlink ___xxx_unlink static __inline__ int adb_creat(const char* path, int mode) { int fd = creat(path, mode); if ( fd < 0 ) return -1; close_on_exec(fd); return fd; } #undef creat #define creat ___xxx_creat static __inline__ int adb_socket_accept(int serverfd, struct sockaddr* addr, socklen_t *addrlen) { int fd; fd = accept(serverfd, addr, addrlen); if (fd >= 0) close_on_exec(fd); return fd; } #undef accept #define accept ___xxx_accept #define unix_read adb_read #define unix_write adb_write #define unix_close adb_close typedef pthread_t adb_thread_t; typedef void* (*adb_thread_func_t)( void* arg ); static __inline__ int adb_thread_create( adb_thread_t *pthread, adb_thread_func_t start, void* arg ) { pthread_attr_t attr; pthread_attr_init (&attr); pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED); return pthread_create( pthread, &attr, start, arg ); } static __inline__ int adb_socket_setbufsize( int fd, int bufsize ) { int opt = bufsize; return setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt)); } static __inline__ void disable_tcp_nagle(int fd) { int on = 1; setsockopt( fd, IPPROTO_TCP, TCP_NODELAY, (void*)&on, sizeof(on) ); } static __inline__ int unix_socketpair( int d, int type, int protocol, int sv[2] ) { return socketpair( d, type, protocol, sv ); } static __inline__ int adb_socketpair( int sv[2] ) { int rc; rc = unix_socketpair( AF_UNIX, SOCK_STREAM, 0, sv ); if (rc < 0) return -1; close_on_exec( sv[0] ); close_on_exec( sv[1] ); return 0; } #undef socketpair #define socketpair ___xxx_socketpair static __inline__ void adb_sleep_ms( int mseconds ) { usleep( mseconds*1000 ); } static __inline__ int adb_mkdir(const char* path, int mode) { return mkdir(path, mode); } #undef mkdir #define mkdir ___xxx_mkdir static __inline__ void adb_sysdeps_init(void) { } static __inline__ char* adb_dirstart(const char* path) { return strchr(path, '/'); } static __inline__ char* adb_dirstop(const char* path) { return strrchr(path, '/'); } static __inline__ int adb_is_absolute_host_path( const char* path ) { return path[0] == '/'; } static __inline__ char* adb_strtok_r(char *str, const char *delim, char **saveptr) { return strtok_r(str, delim, saveptr); } #undef strtok_r #define strtok_r ___xxx_strtok_r #endif /* !_WIN32 */ #endif /* _ADB_SYSDEPS_H */