blob: 0489d09a21ac4dfdc103d90a51c9610f6ee47d0d [file] [log] [blame]
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001/*
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
Elliott Hughes381cfa92015-07-23 17:12:58 -070027#include <errno.h>
28
Spencer Low5200c662015-07-30 23:07:55 -070029#include <string>
Spencer Lowa30b79a2015-11-15 16:29:36 -080030#include <vector>
Spencer Low5200c662015-07-30 23:07:55 -070031
Josh Gao13ea01d2016-05-13 14:52:06 -070032// Include this before open/close/unlink are defined as macros below.
Josh Gao3b3e10d2016-02-09 14:59:09 -080033#include <android-base/errors.h>
Josh Gao13ea01d2016-05-13 14:52:06 -070034#include <android-base/unique_fd.h>
Elliott Hughes4f713192015-12-04 22:00:26 -080035#include <android-base/utf8.h>
Spencer Lowd21dc822015-11-12 15:20:15 -080036
Josh Gaof551ea02016-07-28 18:09:48 -070037#include "sysdeps/stat.h"
38
Dan Albertcc731cc2015-02-24 21:26:58 -080039/*
40 * TEMP_FAILURE_RETRY is defined by some, but not all, versions of
41 * <unistd.h>. (Alas, it is not as standard as we'd hoped!) So, if it's
42 * not already defined, then define it here.
43 */
44#ifndef TEMP_FAILURE_RETRY
45/* Used to retry syscalls that can return EINTR. */
46#define TEMP_FAILURE_RETRY(exp) ({ \
47 typeof (exp) _rc; \
48 do { \
49 _rc = (exp); \
50 } while (_rc == -1 && errno == EINTR); \
51 _rc; })
52#endif
53
Spencer Lowcf4ff642015-05-11 01:08:48 -070054// Some printf-like functions are implemented in terms of
55// android::base::StringAppendV, so they should use the same attribute for
56// compile-time format string checking. On Windows, if the mingw version of
57// vsnprintf is used in StringAppendV, use `gnu_printf' which allows z in %zd
58// and PRIu64 (and related) to be recognized by the compile-time checking.
59#define ADB_FORMAT_ARCHETYPE __printf__
60#ifdef __USE_MINGW_ANSI_STDIO
61#if __USE_MINGW_ANSI_STDIO
62#undef ADB_FORMAT_ARCHETYPE
63#define ADB_FORMAT_ARCHETYPE gnu_printf
64#endif
65#endif
66
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080067#ifdef _WIN32
68
Josh Gaoa166e712016-01-29 12:08:34 -080069// Clang-only nullability specifiers
70#define _Nonnull
71#define _Nullable
72
Dan Albert630b9af2014-11-24 23:34:35 -080073#include <ctype.h>
74#include <direct.h>
Spencer Lowcf4ff642015-05-11 01:08:48 -070075#include <dirent.h>
Dan Albert630b9af2014-11-24 23:34:35 -080076#include <errno.h>
77#include <fcntl.h>
78#include <io.h>
79#include <process.h>
80#include <sys/stat.h>
Spencer Lowcf4ff642015-05-11 01:08:48 -070081#include <utime.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080082#include <winsock2.h>
Stephen Hines2f431a82014-10-01 17:37:06 -070083#include <windows.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080084#include <ws2tcpip.h>
Dan Albert630b9af2014-11-24 23:34:35 -080085
Spencer Low2122c7a2015-08-26 18:46:09 -070086#include <memory> // unique_ptr
Spencer Lowd21dc822015-11-12 15:20:15 -080087#include <string>
Alex Vallée47d67c92015-05-06 16:26:00 -040088
Dan Albert630b9af2014-11-24 23:34:35 -080089#include "fdevent.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080090
Elliott Hughes5c742702015-07-30 17:42:01 -070091#define OS_PATH_SEPARATORS "\\/"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080092#define OS_PATH_SEPARATOR '\\'
93#define OS_PATH_SEPARATOR_STR "\\"
Benoit Gobyd5fcafa2012-04-12 12:23:49 -070094#define ENV_PATH_SEPARATOR_STR ";"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080095
Josh Gao07db1192015-11-07 15:38:19 -080096static __inline__ bool adb_is_separator(char c) {
97 return c == '\\' || c == '/';
98}
99
Josh Gaob5fea142016-02-12 14:31:15 -0800100typedef void (*adb_thread_func_t)(void* arg);
Josh Gao3b3e10d2016-02-09 14:59:09 -0800101typedef HANDLE adb_thread_t;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800102
Josh Gaob5fea142016-02-12 14:31:15 -0800103struct adb_winthread_args {
Josh Gao3b3e10d2016-02-09 14:59:09 -0800104 adb_thread_func_t func;
105 void* arg;
106};
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800107
Josh Gaob5fea142016-02-12 14:31:15 -0800108static unsigned __stdcall adb_winthread_wrapper(void* heap_args) {
109 // Move the arguments from the heap onto the thread's stack.
110 adb_winthread_args thread_args = *static_cast<adb_winthread_args*>(heap_args);
111 delete static_cast<adb_winthread_args*>(heap_args);
112 thread_args.func(thread_args.arg);
113 return 0;
Josh Gao3b3e10d2016-02-09 14:59:09 -0800114}
115
116static __inline__ bool adb_thread_create(adb_thread_func_t func, void* arg,
117 adb_thread_t* thread = nullptr) {
Josh Gaob5fea142016-02-12 14:31:15 -0800118 adb_winthread_args* args = new adb_winthread_args{.func = func, .arg = arg};
119 uintptr_t handle = _beginthreadex(nullptr, 0, adb_winthread_wrapper, args, 0, nullptr);
Josh Gao3b3e10d2016-02-09 14:59:09 -0800120 if (handle != static_cast<uintptr_t>(0)) {
121 if (thread) {
122 *thread = reinterpret_cast<HANDLE>(handle);
123 } else {
124 CloseHandle(thread);
125 }
126 return true;
127 }
128 return false;
129}
130
131static __inline__ bool adb_thread_join(adb_thread_t thread) {
132 switch (WaitForSingleObject(thread, INFINITE)) {
133 case WAIT_OBJECT_0:
134 CloseHandle(thread);
135 return true;
136
137 case WAIT_FAILED:
138 fprintf(stderr, "adb_thread_join failed: %s\n",
139 android::base::SystemErrorCodeToString(GetLastError()).c_str());
140 break;
141
142 default:
143 abort();
144 }
145
146 return false;
147}
148
149static __inline__ bool adb_thread_detach(adb_thread_t thread) {
150 CloseHandle(thread);
151 return true;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800152}
153
Josh Gaob5fea142016-02-12 14:31:15 -0800154static __inline__ void __attribute__((noreturn)) adb_thread_exit() {
Josh Gaod7b37492016-02-12 15:45:04 -0800155 _endthreadex(0);
Josh Gaob5fea142016-02-12 14:31:15 -0800156}
157
Siva Velusamy49ee7cf2015-08-28 16:37:29 -0700158static __inline__ int adb_thread_setname(const std::string& name) {
159 // TODO: See https://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx for how to set
160 // the thread name in Windows. Unfortunately, it only works during debugging, but
161 // our build process doesn't generate PDB files needed for debugging.
162 return 0;
163}
164
Josh Gao3777d2e2016-02-16 17:34:53 -0800165static __inline__ adb_thread_t adb_thread_self() {
166 return GetCurrentThread();
167}
168
169static __inline__ bool adb_thread_equal(adb_thread_t lhs, adb_thread_t rhs) {
170 return GetThreadId(lhs) == GetThreadId(rhs);
171}
172
leozwangcbf02672014-08-15 09:51:27 -0700173static __inline__ unsigned long adb_thread_id()
174{
175 return GetCurrentThreadId();
176}
177
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800178static __inline__ void close_on_exec(int fd)
179{
David 'Digit' Turnerf6330a22009-05-18 17:36:28 +0200180 /* nothing really */
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800181}
182
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800183#define S_ISLNK(m) 0 /* no symlinks on Win32 */
184
Spencer Lowcf4ff642015-05-11 01:08:48 -0700185extern int adb_unlink(const char* path);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800186#undef unlink
187#define unlink ___xxx_unlink
188
Spencer Lowcf4ff642015-05-11 01:08:48 -0700189extern int adb_mkdir(const std::string& path, int mode);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800190#undef mkdir
191#define mkdir ___xxx_mkdir
192
Spencer Low6ac5d7d2015-05-22 20:09:06 -0700193// See the comments for the !defined(_WIN32) versions of adb_*().
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800194extern int adb_open(const char* path, int options);
195extern int adb_creat(const char* path, int mode);
196extern int adb_read(int fd, void* buf, int len);
197extern int adb_write(int fd, const void* buf, int len);
198extern int adb_lseek(int fd, int pos, int where);
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400199extern int adb_shutdown(int fd);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800200extern int adb_close(int fd);
201
Spencer Low6ac5d7d2015-05-22 20:09:06 -0700202// See the comments for the !defined(_WIN32) version of unix_close().
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800203static __inline__ int unix_close(int fd)
204{
205 return close(fd);
206}
207#undef close
208#define close ____xxx_close
209
Spencer Low2e02dc62015-11-07 17:34:39 -0800210// Like unix_read(), but may return EINTR.
211extern int unix_read_interruptible(int fd, void* buf, size_t len);
212
Spencer Low6ac5d7d2015-05-22 20:09:06 -0700213// See the comments for the !defined(_WIN32) version of unix_read().
Spencer Low2e02dc62015-11-07 17:34:39 -0800214static __inline__ int unix_read(int fd, void* buf, size_t len) {
215 return TEMP_FAILURE_RETRY(unix_read_interruptible(fd, buf, len));
216}
Spencer Low50184062015-03-01 15:06:21 -0800217
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800218#undef read
219#define read ___xxx_read
220
Spencer Low6ac5d7d2015-05-22 20:09:06 -0700221// See the comments for the !defined(_WIN32) version of unix_write().
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800222static __inline__ int unix_write(int fd, const void* buf, size_t len)
223{
224 return write(fd, buf, len);
225}
226#undef write
227#define write ___xxx_write
228
Spencer Low6ac5d7d2015-05-22 20:09:06 -0700229// See the comments for the !defined(_WIN32) version of adb_open_mode().
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800230static __inline__ int adb_open_mode(const char* path, int options, int mode)
231{
David 'Digit' Turnerf6330a22009-05-18 17:36:28 +0200232 return adb_open(path, options);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800233}
234
Spencer Low6ac5d7d2015-05-22 20:09:06 -0700235// See the comments for the !defined(_WIN32) version of unix_open().
Spencer Lowcf4ff642015-05-11 01:08:48 -0700236extern int unix_open(const char* path, int options, ...);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800237#define open ___xxx_unix_open
238
David Pursellc5b8ad82015-10-28 14:29:51 -0700239// Checks if |fd| corresponds to a console.
240// Standard Windows isatty() returns 1 for both console FDs and character
241// devices like NUL. unix_isatty() performs some extra checking to only match
242// console FDs.
243// |fd| must be a real file descriptor, meaning STDxx_FILENO or unix_open() FDs
244// will work but adb_open() FDs will not. Additionally the OS handle associated
245// with |fd| must have GENERIC_READ access (which console FDs have by default).
246// Returns 1 if |fd| is a console FD, 0 otherwise. The value of errno after
247// calling this function is unreliable and should not be used.
248int unix_isatty(int fd);
249#define isatty ___xxx_isatty
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800250
Spencer Low5200c662015-07-30 23:07:55 -0700251int network_loopback_client(int port, int type, std::string* error);
252int network_loopback_server(int port, int type, std::string* error);
253int network_inaddr_any_server(int port, int type, std::string* error);
Josh Gaocfb21412016-08-24 18:38:44 -0700254
255inline int network_local_client(const char* name, int namespace_id, int type, std::string* error) {
256 abort();
257}
258
259inline int network_local_server(const char* name, int namespace_id, int type, std::string* error) {
260 abort();
261}
262
Spencer Low5200c662015-07-30 23:07:55 -0700263int network_connect(const std::string& host, int port, int type, int timeout,
264 std::string* error);
265
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800266extern int adb_socket_accept(int serverfd, struct sockaddr* addr, socklen_t *addrlen);
267
268#undef accept
269#define accept ___xxx_accept
270
Josh Gao59901912016-08-23 15:28:43 -0700271int adb_getsockname(int fd, struct sockaddr* sockaddr, socklen_t* optlen);
272#undef getsockname
273#define getsockname(...) ___xxx_getsockname(__VA__ARGS__)
274
David Purselleaae97e2016-04-07 11:25:48 -0700275// Returns the local port number of a bound socket, or -1 on failure.
276int adb_socket_get_local_port(int fd);
277
Spencer Lowf055c192015-01-25 14:40:16 -0800278extern int adb_setsockopt(int fd, int level, int optname, const void* optval, socklen_t optlen);
279
280#undef setsockopt
281#define setsockopt ___xxx_setsockopt
282
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800283extern int adb_socketpair( int sv[2] );
284
Josh Gao3777d2e2016-02-16 17:34:53 -0800285struct adb_pollfd {
286 int fd;
287 short events;
288 short revents;
289};
290extern int adb_poll(adb_pollfd* fds, size_t nfds, int timeout);
291#define poll ___xxx_poll
292
Elliott Hughes5c742702015-07-30 17:42:01 -0700293static __inline__ int adb_is_absolute_host_path(const char* path) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800294 return isalpha(path[0]) && path[1] == ':' && path[2] == '\\';
295}
296
Spencer Lowcf4ff642015-05-11 01:08:48 -0700297// UTF-8 versions of POSIX APIs.
298extern DIR* adb_opendir(const char* dirname);
299extern struct dirent* adb_readdir(DIR* dir);
300extern int adb_closedir(DIR* dir);
301
302extern int adb_utime(const char *, struct utimbuf *);
303extern int adb_chmod(const char *, int);
304
305extern int adb_vfprintf(FILE *stream, const char *format, va_list ap)
306 __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 2, 0)));
Spencer Lowa30b79a2015-11-15 16:29:36 -0800307extern int adb_vprintf(const char *format, va_list ap)
308 __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 1, 0)));
Spencer Lowcf4ff642015-05-11 01:08:48 -0700309extern int adb_fprintf(FILE *stream, const char *format, ...)
310 __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 2, 3)));
311extern int adb_printf(const char *format, ...)
312 __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 1, 2)));
313
314extern int adb_fputs(const char* buf, FILE* stream);
315extern int adb_fputc(int ch, FILE* stream);
Spencer Lowa30b79a2015-11-15 16:29:36 -0800316extern int adb_putchar(int ch);
317extern int adb_puts(const char* buf);
Spencer Lowcf4ff642015-05-11 01:08:48 -0700318extern size_t adb_fwrite(const void* ptr, size_t size, size_t nmemb,
319 FILE* stream);
320
321extern FILE* adb_fopen(const char* f, const char* m);
322
323extern char* adb_getenv(const char* name);
324
325extern char* adb_getcwd(char* buf, int size);
326
327// Remap calls to POSIX APIs to our UTF-8 versions.
328#define opendir adb_opendir
329#define readdir adb_readdir
330#define closedir adb_closedir
331#define rewinddir rewinddir_utf8_not_yet_implemented
332#define telldir telldir_utf8_not_yet_implemented
Spencer Low363af562015-11-07 18:51:54 -0800333// Some compiler's C++ headers have members named seekdir, so we can't do the
334// macro technique and instead cause a link error if seekdir is called.
335inline void seekdir(DIR*, long) {
336 extern int seekdir_utf8_not_yet_implemented;
337 seekdir_utf8_not_yet_implemented = 1;
338}
Spencer Lowcf4ff642015-05-11 01:08:48 -0700339
340#define utime adb_utime
341#define chmod adb_chmod
342
343#define vfprintf adb_vfprintf
Spencer Lowa30b79a2015-11-15 16:29:36 -0800344#define vprintf adb_vprintf
Spencer Lowcf4ff642015-05-11 01:08:48 -0700345#define fprintf adb_fprintf
346#define printf adb_printf
347#define fputs adb_fputs
348#define fputc adb_fputc
Spencer Lowa30b79a2015-11-15 16:29:36 -0800349// putc may be a macro, so if so, undefine it, so that we can redefine it.
350#undef putc
351#define putc(c, s) adb_fputc(c, s)
352#define putchar adb_putchar
353#define puts adb_puts
Spencer Lowcf4ff642015-05-11 01:08:48 -0700354#define fwrite adb_fwrite
355
356#define fopen adb_fopen
Spencer Lowa30b79a2015-11-15 16:29:36 -0800357#define freopen freopen_utf8_not_yet_implemented
Spencer Lowcf4ff642015-05-11 01:08:48 -0700358
359#define getenv adb_getenv
360#define putenv putenv_utf8_not_yet_implemented
361#define setenv setenv_utf8_not_yet_implemented
362#define unsetenv unsetenv_utf8_not_yet_implemented
363
364#define getcwd adb_getcwd
365
Spencer Low0a796002015-10-18 16:45:09 -0700366char* adb_strerror(int err);
367#define strerror adb_strerror
368
Spencer Lowcf4ff642015-05-11 01:08:48 -0700369// Helper class to convert UTF-16 argv from wmain() to UTF-8 args that can be
370// passed to main().
371class NarrowArgs {
372public:
373 NarrowArgs(int argc, wchar_t** argv);
374 ~NarrowArgs();
375
376 inline char** data() {
377 return narrow_args;
378 }
379
380private:
381 char** narrow_args;
382};
383
Spencer Low5c398d22015-08-08 15:07:07 -0700384// Windows HANDLE values only use 32-bits of the type, even on 64-bit machines,
385// so they can fit in an int. To convert back, we just need to sign-extend.
386// https://msdn.microsoft.com/en-us/library/windows/desktop/aa384203%28v=vs.85%29.aspx
387// Note that this does not make a HANDLE value work with APIs like open(), nor
388// does this make a value from open() passable to APIs taking a HANDLE. This
389// just lets you take a HANDLE, pass it around as an int, and then use it again
390// as a HANDLE.
391inline int cast_handle_to_int(const HANDLE h) {
392 // truncate
393 return static_cast<int>(reinterpret_cast<INT_PTR>(h));
394}
395
396inline HANDLE cast_int_to_handle(const int fd) {
397 // sign-extend
398 return reinterpret_cast<HANDLE>(static_cast<INT_PTR>(fd));
399}
400
Spencer Low2122c7a2015-08-26 18:46:09 -0700401// Deleter for unique_handle. Adapted from many sources, including:
402// http://stackoverflow.com/questions/14841396/stdunique-ptr-deleters-and-the-win32-api
403// https://visualstudiomagazine.com/articles/2013/09/01/get-a-handle-on-the-windows-api.aspx
404class handle_deleter {
405public:
406 typedef HANDLE pointer;
407
408 void operator()(HANDLE h);
409};
410
411// Like std::unique_ptr, but for Windows HANDLE objects that should be
412// CloseHandle()'d. Operator bool() only checks if the handle != nullptr,
413// but does not check if the handle != INVALID_HANDLE_VALUE.
414typedef std::unique_ptr<HANDLE, handle_deleter> unique_handle;
415
Spencer Lowa30b79a2015-11-15 16:29:36 -0800416namespace internal {
417
418size_t ParseCompleteUTF8(const char* first, const char* last, std::vector<char>* remaining_bytes);
419
420}
421
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800422#else /* !_WIN32 a.k.a. Unix */
423
Spencer Low5200c662015-07-30 23:07:55 -0700424#include <cutils/sockets.h>
Spencer Low8d8126a2015-07-21 02:06:26 -0700425#include <cutils/threads.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800426#include <fcntl.h>
Josh Gao3777d2e2016-02-16 17:34:53 -0800427#include <poll.h>
428#include <signal.h>
429#include <sys/stat.h>
430#include <sys/wait.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800431
432#include <pthread.h>
433#include <unistd.h>
434#include <fcntl.h>
435#include <stdarg.h>
Spencer Low5200c662015-07-30 23:07:55 -0700436#include <netdb.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800437#include <netinet/in.h>
438#include <netinet/tcp.h>
439#include <string.h>
Kenny Root73167412012-10-12 15:26:45 -0700440#include <unistd.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800441
Alex Vallée47d67c92015-05-06 16:26:00 -0400442#include <string>
443
Elliott Hughes5c742702015-07-30 17:42:01 -0700444#define OS_PATH_SEPARATORS "/"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800445#define OS_PATH_SEPARATOR '/'
446#define OS_PATH_SEPARATOR_STR "/"
Benoit Gobyd5fcafa2012-04-12 12:23:49 -0700447#define ENV_PATH_SEPARATOR_STR ":"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800448
Josh Gao07db1192015-11-07 15:38:19 -0800449static __inline__ bool adb_is_separator(char c) {
450 return c == '/';
451}
452
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800453static __inline__ void close_on_exec(int fd)
454{
David 'Digit' Turnerf6330a22009-05-18 17:36:28 +0200455 fcntl( fd, F_SETFD, FD_CLOEXEC );
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800456}
457
Spencer Low6ac5d7d2015-05-22 20:09:06 -0700458// Open a file and return a file descriptor that may be used with unix_read(),
459// unix_write(), unix_close(), but not adb_read(), adb_write(), adb_close().
460//
461// On Unix, this is based on open(), so the file descriptor is a real OS file
462// descriptor, but the Windows implementation (in sysdeps_win32.cpp) returns a
463// file descriptor that can only be used with C Runtime APIs (which are wrapped
464// by unix_read(), unix_write(), unix_close()). Also, the C Runtime has
465// configurable CR/LF translation which defaults to text mode, but is settable
466// with _setmode().
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800467static __inline__ int unix_open(const char* path, int options,...)
468{
469 if ((options & O_CREAT) == 0)
470 {
Kenny Root73167412012-10-12 15:26:45 -0700471 return TEMP_FAILURE_RETRY( open(path, options) );
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800472 }
473 else
474 {
475 int mode;
476 va_list args;
477 va_start( args, options );
478 mode = va_arg( args, int );
479 va_end( args );
Kenny Root73167412012-10-12 15:26:45 -0700480 return TEMP_FAILURE_RETRY( open( path, options, mode ) );
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800481 }
482}
483
Spencer Low6ac5d7d2015-05-22 20:09:06 -0700484// Similar to the two-argument adb_open(), but takes a mode parameter for file
485// creation. See adb_open() for more info.
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800486static __inline__ int adb_open_mode( const char* pathname, int options, int mode )
487{
Kenny Root73167412012-10-12 15:26:45 -0700488 return TEMP_FAILURE_RETRY( open( pathname, options, mode ) );
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800489}
490
491
Spencer Low6ac5d7d2015-05-22 20:09:06 -0700492// Open a file and return a file descriptor that may be used with adb_read(),
493// adb_write(), adb_close(), but not unix_read(), unix_write(), unix_close().
494//
495// On Unix, this is based on open(), but the Windows implementation (in
496// sysdeps_win32.cpp) uses Windows native file I/O and bypasses the C Runtime
497// and its CR/LF translation. The returned file descriptor should be used with
498// adb_read(), adb_write(), adb_close(), etc.
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800499static __inline__ int adb_open( const char* pathname, int options )
500{
Kenny Root73167412012-10-12 15:26:45 -0700501 int fd = TEMP_FAILURE_RETRY( open( pathname, options ) );
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800502 if (fd < 0)
503 return -1;
504 close_on_exec( fd );
505 return fd;
506}
507#undef open
508#define open ___xxx_open
509
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400510static __inline__ int adb_shutdown(int fd)
511{
512 return shutdown(fd, SHUT_RDWR);
513}
David Pursell1ed57f02015-10-06 15:30:03 -0700514static __inline__ int adb_shutdown(int fd, int direction)
515{
516 return shutdown(fd, direction);
517}
Mike Lockwood8cf0d592009-10-11 23:04:18 -0400518#undef shutdown
519#define shutdown ____xxx_shutdown
520
Spencer Low6ac5d7d2015-05-22 20:09:06 -0700521// Closes a file descriptor that came from adb_open() or adb_open_mode(), but
522// not designed to take a file descriptor from unix_open(). See the comments
523// for adb_open() for more info.
Josh Gaof0d3b4f2016-03-04 15:15:56 -0800524__inline__ int adb_close(int fd) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800525 return close(fd);
526}
527#undef close
528#define close ____xxx_close
529
530
531static __inline__ int adb_read(int fd, void* buf, size_t len)
532{
Kenny Root73167412012-10-12 15:26:45 -0700533 return TEMP_FAILURE_RETRY( read( fd, buf, len ) );
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800534}
535
Spencer Low2e02dc62015-11-07 17:34:39 -0800536// Like unix_read(), but does not handle EINTR.
537static __inline__ int unix_read_interruptible(int fd, void* buf, size_t len) {
538 return read(fd, buf, len);
539}
540
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800541#undef read
542#define read ___xxx_read
543
544static __inline__ int adb_write(int fd, const void* buf, size_t len)
545{
Kenny Root73167412012-10-12 15:26:45 -0700546 return TEMP_FAILURE_RETRY( write( fd, buf, len ) );
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800547}
548#undef write
549#define write ___xxx_write
550
551static __inline__ int adb_lseek(int fd, int pos, int where)
552{
553 return lseek(fd, pos, where);
554}
555#undef lseek
556#define lseek ___xxx_lseek
557
558static __inline__ int adb_unlink(const char* path)
559{
560 return unlink(path);
561}
562#undef unlink
563#define unlink ___xxx_unlink
564
565static __inline__ int adb_creat(const char* path, int mode)
566{
Kenny Root73167412012-10-12 15:26:45 -0700567 int fd = TEMP_FAILURE_RETRY( creat( path, mode ) );
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800568
David 'Digit' Turnerf6330a22009-05-18 17:36:28 +0200569 if ( fd < 0 )
570 return -1;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800571
572 close_on_exec(fd);
David 'Digit' Turnerf6330a22009-05-18 17:36:28 +0200573 return fd;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800574}
575#undef creat
576#define creat ___xxx_creat
577
David Pursellc5b8ad82015-10-28 14:29:51 -0700578static __inline__ int unix_isatty(int fd) {
579 return isatty(fd);
580}
581#define isatty ___xxx_isatty
582
Spencer Low5200c662015-07-30 23:07:55 -0700583// Helper for network_* functions.
584inline int _fd_set_error_str(int fd, std::string* error) {
585 if (fd == -1) {
586 *error = strerror(errno);
587 }
588 return fd;
589}
590
591inline int network_loopback_client(int port, int type, std::string* error) {
Elliott Hughes139b3722016-10-11 13:45:03 -0700592 return _fd_set_error_str(socket_network_client("localhost", port, type), error);
Spencer Low5200c662015-07-30 23:07:55 -0700593}
594
595inline int network_loopback_server(int port, int type, std::string* error) {
Tao Wu7b700762016-09-19 16:50:10 -0700596 int fd = socket_loopback_server(port, type);
597 if (fd < 0 && errno == EAFNOSUPPORT)
598 return _fd_set_error_str(socket_loopback_server6(port, type), error);
599 return _fd_set_error_str(fd, error);
Spencer Low5200c662015-07-30 23:07:55 -0700600}
601
602inline int network_inaddr_any_server(int port, int type, std::string* error) {
603 return _fd_set_error_str(socket_inaddr_any_server(port, type), error);
604}
605
Josh Gaocfb21412016-08-24 18:38:44 -0700606inline int network_local_client(const char* name, int namespace_id, int type, std::string* error) {
607 return _fd_set_error_str(socket_local_client(name, namespace_id, type), error);
608}
609
610inline int network_local_server(const char* name, int namespace_id, int type, std::string* error) {
611 return _fd_set_error_str(socket_local_server(name, namespace_id, type), error);
Spencer Low5200c662015-07-30 23:07:55 -0700612}
613
614inline int network_connect(const std::string& host, int port, int type,
615 int timeout, std::string* error) {
616 int getaddrinfo_error = 0;
617 int fd = socket_network_client_timeout(host.c_str(), port, type, timeout,
618 &getaddrinfo_error);
619 if (fd != -1) {
620 return fd;
621 }
622 if (getaddrinfo_error != 0) {
623 *error = gai_strerror(getaddrinfo_error);
624 } else {
625 *error = strerror(errno);
626 }
627 return -1;
628}
629
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800630static __inline__ int adb_socket_accept(int serverfd, struct sockaddr* addr, socklen_t *addrlen)
631{
Benoit Goby95ef8282011-02-01 18:57:41 -0800632 int fd;
633
Kenny Root73167412012-10-12 15:26:45 -0700634 fd = TEMP_FAILURE_RETRY( accept( serverfd, addr, addrlen ) );
Benoit Goby95ef8282011-02-01 18:57:41 -0800635 if (fd >= 0)
636 close_on_exec(fd);
637
638 return fd;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800639}
640
641#undef accept
642#define accept ___xxx_accept
643
David Purselleaae97e2016-04-07 11:25:48 -0700644inline int adb_socket_get_local_port(int fd) {
645 return socket_get_local_port(fd);
646}
647
Spencer Low6ac5d7d2015-05-22 20:09:06 -0700648// Operate on a file descriptor returned from unix_open() or a well-known file
649// descriptor such as STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO.
650//
651// On Unix, unix_read(), unix_write(), unix_close() map to adb_read(),
652// adb_write(), adb_close() (which all map to Unix system calls), but the
653// Windows implementations (in the ifdef above and in sysdeps_win32.cpp) call
654// into the C Runtime and its configurable CR/LF translation (which is settable
655// via _setmode()).
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800656#define unix_read adb_read
657#define unix_write adb_write
658#define unix_close adb_close
659
Josh Gaob5fea142016-02-12 14:31:15 -0800660// Win32 is limited to DWORDs for thread return values; limit the POSIX systems to this as well to
661// ensure compatibility.
662typedef void (*adb_thread_func_t)(void* arg);
Josh Gao3b3e10d2016-02-09 14:59:09 -0800663typedef pthread_t adb_thread_t;
664
Josh Gaob5fea142016-02-12 14:31:15 -0800665struct adb_pthread_args {
666 adb_thread_func_t func;
667 void* arg;
668};
669
670static void* adb_pthread_wrapper(void* heap_args) {
671 // Move the arguments from the heap onto the thread's stack.
672 adb_pthread_args thread_args = *reinterpret_cast<adb_pthread_args*>(heap_args);
673 delete static_cast<adb_pthread_args*>(heap_args);
674 thread_args.func(thread_args.arg);
675 return nullptr;
676}
677
Josh Gao3b3e10d2016-02-09 14:59:09 -0800678static __inline__ bool adb_thread_create(adb_thread_func_t start, void* arg,
679 adb_thread_t* thread = nullptr) {
680 pthread_t temp;
Elliott Hughes9b0f3542015-05-05 13:41:21 -0700681 pthread_attr_t attr;
682 pthread_attr_init(&attr);
Josh Gao3b3e10d2016-02-09 14:59:09 -0800683 pthread_attr_setdetachstate(&attr, thread ? PTHREAD_CREATE_JOINABLE : PTHREAD_CREATE_DETACHED);
Josh Gaob5fea142016-02-12 14:31:15 -0800684 auto* pthread_args = new adb_pthread_args{.func = start, .arg = arg};
685 errno = pthread_create(&temp, &attr, adb_pthread_wrapper, pthread_args);
Josh Gao3b3e10d2016-02-09 14:59:09 -0800686 if (errno == 0) {
687 if (thread) {
688 *thread = temp;
689 }
690 return true;
691 }
692 return false;
693}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800694
Josh Gao3b3e10d2016-02-09 14:59:09 -0800695static __inline__ bool adb_thread_join(adb_thread_t thread) {
696 errno = pthread_join(thread, nullptr);
697 return errno == 0;
698}
699
700static __inline__ bool adb_thread_detach(adb_thread_t thread) {
701 errno = pthread_detach(thread);
702 return errno == 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800703}
704
Josh Gaob5fea142016-02-12 14:31:15 -0800705static __inline__ void __attribute__((noreturn)) adb_thread_exit() {
706 pthread_exit(nullptr);
707}
708
Siva Velusamy49ee7cf2015-08-28 16:37:29 -0700709static __inline__ int adb_thread_setname(const std::string& name) {
710#ifdef __APPLE__
711 return pthread_setname_np(name.c_str());
712#else
713 const char *s = name.c_str();
714
715 // pthread_setname_np fails rather than truncating long strings.
716 const int max_task_comm_len = 16; // including the null terminator
717 if (name.length() > (max_task_comm_len - 1)) {
718 char buf[max_task_comm_len];
719 strncpy(buf, name.c_str(), sizeof(buf) - 1);
720 buf[sizeof(buf) - 1] = '\0';
721 s = buf;
722 }
723
724 return pthread_setname_np(pthread_self(), s) ;
725#endif
726}
727
Spencer Lowf055c192015-01-25 14:40:16 -0800728static __inline__ int adb_setsockopt( int fd, int level, int optname, const void* optval, socklen_t optlen )
729{
730 return setsockopt( fd, level, optname, optval, optlen );
731}
732
733#undef setsockopt
734#define setsockopt ___xxx_setsockopt
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800735
736static __inline__ int unix_socketpair( int d, int type, int protocol, int sv[2] )
737{
738 return socketpair( d, type, protocol, sv );
739}
740
741static __inline__ int adb_socketpair( int sv[2] )
742{
743 int rc;
744
745 rc = unix_socketpair( AF_UNIX, SOCK_STREAM, 0, sv );
746 if (rc < 0)
747 return -1;
748
749 close_on_exec( sv[0] );
750 close_on_exec( sv[1] );
751 return 0;
752}
753
754#undef socketpair
755#define socketpair ___xxx_socketpair
756
Josh Gao3777d2e2016-02-16 17:34:53 -0800757typedef struct pollfd adb_pollfd;
758static __inline__ int adb_poll(adb_pollfd* fds, size_t nfds, int timeout) {
759 return TEMP_FAILURE_RETRY(poll(fds, nfds, timeout));
760}
761
762#define poll ___xxx_poll
763
Alex Vallée47d67c92015-05-06 16:26:00 -0400764static __inline__ int adb_mkdir(const std::string& path, int mode)
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800765{
Alex Vallée47d67c92015-05-06 16:26:00 -0400766 return mkdir(path.c_str(), mode);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800767}
Alex Vallée47d67c92015-05-06 16:26:00 -0400768
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800769#undef mkdir
770#define mkdir ___xxx_mkdir
771
Alex Vallée47d67c92015-05-06 16:26:00 -0400772static __inline__ int adb_is_absolute_host_path(const char* path) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800773 return path[0] == '/';
774}
775
leozwangcbf02672014-08-15 09:51:27 -0700776static __inline__ unsigned long adb_thread_id()
777{
Spencer Low8d8126a2015-07-21 02:06:26 -0700778 return (unsigned long)gettid();
leozwangcbf02672014-08-15 09:51:27 -0700779}
780
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800781#endif /* !_WIN32 */
782
Elliott Hughescc65c3b2015-11-20 22:01:06 -0800783static inline void disable_tcp_nagle(int fd) {
784 int off = 1;
785 adb_setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &off, sizeof(off));
786}
787
David Pursellbfd95032016-02-22 14:27:23 -0800788// Sets TCP socket |fd| to send a keepalive TCP message every |interval_sec| seconds. Set
789// |interval_sec| to 0 to disable keepalives. If keepalives are enabled, the connection will be
790// configured to drop after 10 missed keepalives. Returns true on success.
791bool set_tcp_keepalive(int fd, int interval_sec);
792
Elliott Hughes0aeb5052016-06-29 17:42:01 -0700793#if defined(_WIN32)
794// Win32 defines ERROR, which we don't need, but which conflicts with google3 logging.
795#undef ERROR
796#endif
797
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800798#endif /* _ADB_SYSDEPS_H */