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#include <errno.h> 28 29#include <string> 30#include <vector> 31 32// Include this before open/close/unlink are defined as macros below. 33#include <android-base/errors.h> 34#include <android-base/unique_fd.h> 35#include <android-base/utf8.h> 36 37#include "sysdeps/errno.h" 38#include "sysdeps/stat.h" 39 40/* 41 * TEMP_FAILURE_RETRY is defined by some, but not all, versions of 42 * <unistd.h>. (Alas, it is not as standard as we'd hoped!) So, if it's 43 * not already defined, then define it here. 44 */ 45#ifndef TEMP_FAILURE_RETRY 46/* Used to retry syscalls that can return EINTR. */ 47#define TEMP_FAILURE_RETRY(exp) ({ \ 48 typeof (exp) _rc; \ 49 do { \ 50 _rc = (exp); \ 51 } while (_rc == -1 && errno == EINTR); \ 52 _rc; }) 53#endif 54 55// Some printf-like functions are implemented in terms of 56// android::base::StringAppendV, so they should use the same attribute for 57// compile-time format string checking. On Windows, if the mingw version of 58// vsnprintf is used in StringAppendV, use `gnu_printf' which allows z in %zd 59// and PRIu64 (and related) to be recognized by the compile-time checking. 60#define ADB_FORMAT_ARCHETYPE __printf__ 61#ifdef __USE_MINGW_ANSI_STDIO 62#if __USE_MINGW_ANSI_STDIO 63#undef ADB_FORMAT_ARCHETYPE 64#define ADB_FORMAT_ARCHETYPE gnu_printf 65#endif 66#endif 67 68#ifdef _WIN32 69 70// Clang-only nullability specifiers 71#define _Nonnull 72#define _Nullable 73 74#include <ctype.h> 75#include <direct.h> 76#include <dirent.h> 77#include <errno.h> 78#include <fcntl.h> 79#include <io.h> 80#include <process.h> 81#include <sys/stat.h> 82#include <utime.h> 83#include <winsock2.h> 84#include <windows.h> 85#include <ws2tcpip.h> 86 87#include <memory> // unique_ptr 88#include <string> 89 90#include "fdevent.h" 91 92#define OS_PATH_SEPARATORS "\\/" 93#define OS_PATH_SEPARATOR '\\' 94#define OS_PATH_SEPARATOR_STR "\\" 95#define ENV_PATH_SEPARATOR_STR ";" 96 97static __inline__ bool adb_is_separator(char c) { 98 return c == '\\' || c == '/'; 99} 100 101typedef void (*adb_thread_func_t)(void* arg); 102typedef HANDLE adb_thread_t; 103 104struct adb_winthread_args { 105 adb_thread_func_t func; 106 void* arg; 107}; 108 109static unsigned __stdcall adb_winthread_wrapper(void* heap_args) { 110 // Move the arguments from the heap onto the thread's stack. 111 adb_winthread_args thread_args = *static_cast<adb_winthread_args*>(heap_args); 112 delete static_cast<adb_winthread_args*>(heap_args); 113 thread_args.func(thread_args.arg); 114 return 0; 115} 116 117static __inline__ bool adb_thread_create(adb_thread_func_t func, void* arg, 118 adb_thread_t* thread = nullptr) { 119 adb_winthread_args* args = new adb_winthread_args{.func = func, .arg = arg}; 120 uintptr_t handle = _beginthreadex(nullptr, 0, adb_winthread_wrapper, args, 0, nullptr); 121 if (handle != static_cast<uintptr_t>(0)) { 122 if (thread) { 123 *thread = reinterpret_cast<HANDLE>(handle); 124 } else { 125 CloseHandle(thread); 126 } 127 return true; 128 } 129 return false; 130} 131 132static __inline__ bool adb_thread_join(adb_thread_t thread) { 133 switch (WaitForSingleObject(thread, INFINITE)) { 134 case WAIT_OBJECT_0: 135 CloseHandle(thread); 136 return true; 137 138 case WAIT_FAILED: 139 fprintf(stderr, "adb_thread_join failed: %s\n", 140 android::base::SystemErrorCodeToString(GetLastError()).c_str()); 141 break; 142 143 default: 144 abort(); 145 } 146 147 return false; 148} 149 150static __inline__ bool adb_thread_detach(adb_thread_t thread) { 151 CloseHandle(thread); 152 return true; 153} 154 155static __inline__ void __attribute__((noreturn)) adb_thread_exit() { 156 _endthreadex(0); 157} 158 159static __inline__ int adb_thread_setname(const std::string& name) { 160 // TODO: See https://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx for how to set 161 // the thread name in Windows. Unfortunately, it only works during debugging, but 162 // our build process doesn't generate PDB files needed for debugging. 163 return 0; 164} 165 166static __inline__ adb_thread_t adb_thread_self() { 167 return GetCurrentThread(); 168} 169 170static __inline__ bool adb_thread_equal(adb_thread_t lhs, adb_thread_t rhs) { 171 return GetThreadId(lhs) == GetThreadId(rhs); 172} 173 174static __inline__ unsigned long adb_thread_id() 175{ 176 return GetCurrentThreadId(); 177} 178 179static __inline__ void close_on_exec(int fd) 180{ 181 /* nothing really */ 182} 183 184extern int adb_unlink(const char* path); 185#undef unlink 186#define unlink ___xxx_unlink 187 188extern int adb_mkdir(const std::string& path, int mode); 189#undef mkdir 190#define mkdir ___xxx_mkdir 191 192// See the comments for the !defined(_WIN32) versions of adb_*(). 193extern int adb_open(const char* path, int options); 194extern int adb_creat(const char* path, int mode); 195extern int adb_read(int fd, void* buf, int len); 196extern int adb_write(int fd, const void* buf, int len); 197extern int adb_lseek(int fd, int pos, int where); 198extern int adb_shutdown(int fd); 199extern int adb_close(int fd); 200extern int adb_register_socket(SOCKET s); 201 202// See the comments for the !defined(_WIN32) version of unix_close(). 203static __inline__ int unix_close(int fd) 204{ 205 return close(fd); 206} 207#undef close 208#define close ____xxx_close 209 210// Like unix_read(), but may return EINTR. 211extern int unix_read_interruptible(int fd, void* buf, size_t len); 212 213// See the comments for the !defined(_WIN32) version of unix_read(). 214static __inline__ int unix_read(int fd, void* buf, size_t len) { 215 return TEMP_FAILURE_RETRY(unix_read_interruptible(fd, buf, len)); 216} 217 218#undef read 219#define read ___xxx_read 220 221// See the comments for the !defined(_WIN32) version of unix_write(). 222static __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 229// See the comments for the !defined(_WIN32) version of adb_open_mode(). 230static __inline__ int adb_open_mode(const char* path, int options, int mode) 231{ 232 return adb_open(path, options); 233} 234 235// See the comments for the !defined(_WIN32) version of unix_open(). 236extern int unix_open(const char* path, int options, ...); 237#define open ___xxx_unix_open 238 239// 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 250 251int 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); 254 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 263int network_connect(const std::string& host, int port, int type, int timeout, 264 std::string* error); 265 266extern int adb_socket_accept(int serverfd, struct sockaddr* addr, socklen_t *addrlen); 267 268#undef accept 269#define accept ___xxx_accept 270 271int adb_getsockname(int fd, struct sockaddr* sockaddr, socklen_t* optlen); 272#undef getsockname 273#define getsockname(...) ___xxx_getsockname(__VA__ARGS__) 274 275// Returns the local port number of a bound socket, or -1 on failure. 276int adb_socket_get_local_port(int fd); 277 278extern 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 283extern int adb_socketpair( int sv[2] ); 284 285struct 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 293static __inline__ int adb_is_absolute_host_path(const char* path) { 294 return isalpha(path[0]) && path[1] == ':' && path[2] == '\\'; 295} 296 297// 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))); 307extern int adb_vprintf(const char *format, va_list ap) 308 __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 1, 0))); 309extern 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); 316extern int adb_putchar(int ch); 317extern int adb_puts(const char* buf); 318extern 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 333// 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} 339 340#define utime adb_utime 341#define chmod adb_chmod 342 343#define vfprintf adb_vfprintf 344#define vprintf adb_vprintf 345#define fprintf adb_fprintf 346#define printf adb_printf 347#define fputs adb_fputs 348#define fputc adb_fputc 349// 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 354#define fwrite adb_fwrite 355 356#define fopen adb_fopen 357#define freopen freopen_utf8_not_yet_implemented 358 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 366// Helper class to convert UTF-16 argv from wmain() to UTF-8 args that can be 367// passed to main(). 368class NarrowArgs { 369public: 370 NarrowArgs(int argc, wchar_t** argv); 371 ~NarrowArgs(); 372 373 inline char** data() { 374 return narrow_args; 375 } 376 377private: 378 char** narrow_args; 379}; 380 381// Windows HANDLE values only use 32-bits of the type, even on 64-bit machines, 382// so they can fit in an int. To convert back, we just need to sign-extend. 383// https://msdn.microsoft.com/en-us/library/windows/desktop/aa384203%28v=vs.85%29.aspx 384// Note that this does not make a HANDLE value work with APIs like open(), nor 385// does this make a value from open() passable to APIs taking a HANDLE. This 386// just lets you take a HANDLE, pass it around as an int, and then use it again 387// as a HANDLE. 388inline int cast_handle_to_int(const HANDLE h) { 389 // truncate 390 return static_cast<int>(reinterpret_cast<INT_PTR>(h)); 391} 392 393inline HANDLE cast_int_to_handle(const int fd) { 394 // sign-extend 395 return reinterpret_cast<HANDLE>(static_cast<INT_PTR>(fd)); 396} 397 398// Deleter for unique_handle. Adapted from many sources, including: 399// http://stackoverflow.com/questions/14841396/stdunique-ptr-deleters-and-the-win32-api 400// https://visualstudiomagazine.com/articles/2013/09/01/get-a-handle-on-the-windows-api.aspx 401class handle_deleter { 402public: 403 typedef HANDLE pointer; 404 405 void operator()(HANDLE h); 406}; 407 408// Like std::unique_ptr, but for Windows HANDLE objects that should be 409// CloseHandle()'d. Operator bool() only checks if the handle != nullptr, 410// but does not check if the handle != INVALID_HANDLE_VALUE. 411typedef std::unique_ptr<HANDLE, handle_deleter> unique_handle; 412 413namespace internal { 414 415size_t ParseCompleteUTF8(const char* first, const char* last, std::vector<char>* remaining_bytes); 416 417} 418 419#else /* !_WIN32 a.k.a. Unix */ 420 421#include <cutils/sockets.h> 422#include <cutils/threads.h> 423#include <fcntl.h> 424#include <poll.h> 425#include <signal.h> 426#include <sys/stat.h> 427#include <sys/wait.h> 428 429#include <pthread.h> 430#include <unistd.h> 431#include <fcntl.h> 432#include <stdarg.h> 433#include <netdb.h> 434#include <netinet/in.h> 435#include <netinet/tcp.h> 436#include <string.h> 437#include <unistd.h> 438 439#include <string> 440 441#define OS_PATH_SEPARATORS "/" 442#define OS_PATH_SEPARATOR '/' 443#define OS_PATH_SEPARATOR_STR "/" 444#define ENV_PATH_SEPARATOR_STR ":" 445 446static __inline__ bool adb_is_separator(char c) { 447 return c == '/'; 448} 449 450static __inline__ void close_on_exec(int fd) 451{ 452 fcntl( fd, F_SETFD, FD_CLOEXEC ); 453} 454 455// Open a file and return a file descriptor that may be used with unix_read(), 456// unix_write(), unix_close(), but not adb_read(), adb_write(), adb_close(). 457// 458// On Unix, this is based on open(), so the file descriptor is a real OS file 459// descriptor, but the Windows implementation (in sysdeps_win32.cpp) returns a 460// file descriptor that can only be used with C Runtime APIs (which are wrapped 461// by unix_read(), unix_write(), unix_close()). Also, the C Runtime has 462// configurable CR/LF translation which defaults to text mode, but is settable 463// with _setmode(). 464static __inline__ int unix_open(const char* path, int options,...) 465{ 466 if ((options & O_CREAT) == 0) 467 { 468 return TEMP_FAILURE_RETRY( open(path, options) ); 469 } 470 else 471 { 472 int mode; 473 va_list args; 474 va_start( args, options ); 475 mode = va_arg( args, int ); 476 va_end( args ); 477 return TEMP_FAILURE_RETRY( open( path, options, mode ) ); 478 } 479} 480 481// Similar to the two-argument adb_open(), but takes a mode parameter for file 482// creation. See adb_open() for more info. 483static __inline__ int adb_open_mode( const char* pathname, int options, int mode ) 484{ 485 return TEMP_FAILURE_RETRY( open( pathname, options, mode ) ); 486} 487 488 489// Open a file and return a file descriptor that may be used with adb_read(), 490// adb_write(), adb_close(), but not unix_read(), unix_write(), unix_close(). 491// 492// On Unix, this is based on open(), but the Windows implementation (in 493// sysdeps_win32.cpp) uses Windows native file I/O and bypasses the C Runtime 494// and its CR/LF translation. The returned file descriptor should be used with 495// adb_read(), adb_write(), adb_close(), etc. 496static __inline__ int adb_open( const char* pathname, int options ) 497{ 498 int fd = TEMP_FAILURE_RETRY( open( pathname, options ) ); 499 if (fd < 0) 500 return -1; 501 close_on_exec( fd ); 502 return fd; 503} 504#undef open 505#define open ___xxx_open 506 507static __inline__ int adb_shutdown(int fd) 508{ 509 return shutdown(fd, SHUT_RDWR); 510} 511static __inline__ int adb_shutdown(int fd, int direction) 512{ 513 return shutdown(fd, direction); 514} 515#undef shutdown 516#define shutdown ____xxx_shutdown 517 518// Closes a file descriptor that came from adb_open() or adb_open_mode(), but 519// not designed to take a file descriptor from unix_open(). See the comments 520// for adb_open() for more info. 521__inline__ int adb_close(int fd) { 522 return close(fd); 523} 524#undef close 525#define close ____xxx_close 526 527// On Windows, ADB has an indirection layer for file descriptors. If we get a 528// Win32 SOCKET object from an external library, we have to map it in to that 529// indirection layer, which this does. 530__inline__ int adb_register_socket(int s) { 531 return s; 532} 533 534static __inline__ int adb_read(int fd, void* buf, size_t len) 535{ 536 return TEMP_FAILURE_RETRY( read( fd, buf, len ) ); 537} 538 539// Like unix_read(), but does not handle EINTR. 540static __inline__ int unix_read_interruptible(int fd, void* buf, size_t len) { 541 return read(fd, buf, len); 542} 543 544#undef read 545#define read ___xxx_read 546 547static __inline__ int adb_write(int fd, const void* buf, size_t len) 548{ 549 return TEMP_FAILURE_RETRY( write( fd, buf, len ) ); 550} 551#undef write 552#define write ___xxx_write 553 554static __inline__ int adb_lseek(int fd, int pos, int where) 555{ 556 return lseek(fd, pos, where); 557} 558#undef lseek 559#define lseek ___xxx_lseek 560 561static __inline__ int adb_unlink(const char* path) 562{ 563 return unlink(path); 564} 565#undef unlink 566#define unlink ___xxx_unlink 567 568static __inline__ int adb_creat(const char* path, int mode) 569{ 570 int fd = TEMP_FAILURE_RETRY( creat( path, mode ) ); 571 572 if ( fd < 0 ) 573 return -1; 574 575 close_on_exec(fd); 576 return fd; 577} 578#undef creat 579#define creat ___xxx_creat 580 581static __inline__ int unix_isatty(int fd) { 582 return isatty(fd); 583} 584#define isatty ___xxx_isatty 585 586// Helper for network_* functions. 587inline int _fd_set_error_str(int fd, std::string* error) { 588 if (fd == -1) { 589 *error = strerror(errno); 590 } 591 return fd; 592} 593 594inline int network_loopback_client(int port, int type, std::string* error) { 595 return _fd_set_error_str(socket_network_client("localhost", port, type), error); 596} 597 598inline int network_loopback_server(int port, int type, std::string* error) { 599 int fd = socket_loopback_server(port, type); 600 if (fd < 0 && errno == EAFNOSUPPORT) 601 return _fd_set_error_str(socket_loopback_server6(port, type), error); 602 return _fd_set_error_str(fd, error); 603} 604 605inline int network_inaddr_any_server(int port, int type, std::string* error) { 606 return _fd_set_error_str(socket_inaddr_any_server(port, type), error); 607} 608 609inline int network_local_client(const char* name, int namespace_id, int type, std::string* error) { 610 return _fd_set_error_str(socket_local_client(name, namespace_id, type), error); 611} 612 613inline int network_local_server(const char* name, int namespace_id, int type, std::string* error) { 614 return _fd_set_error_str(socket_local_server(name, namespace_id, type), error); 615} 616 617inline int network_connect(const std::string& host, int port, int type, 618 int timeout, std::string* error) { 619 int getaddrinfo_error = 0; 620 int fd = socket_network_client_timeout(host.c_str(), port, type, timeout, 621 &getaddrinfo_error); 622 if (fd != -1) { 623 return fd; 624 } 625 if (getaddrinfo_error != 0) { 626 *error = gai_strerror(getaddrinfo_error); 627 } else { 628 *error = strerror(errno); 629 } 630 return -1; 631} 632 633static __inline__ int adb_socket_accept(int serverfd, struct sockaddr* addr, socklen_t *addrlen) 634{ 635 int fd; 636 637 fd = TEMP_FAILURE_RETRY( accept( serverfd, addr, addrlen ) ); 638 if (fd >= 0) 639 close_on_exec(fd); 640 641 return fd; 642} 643 644#undef accept 645#define accept ___xxx_accept 646 647inline int adb_socket_get_local_port(int fd) { 648 return socket_get_local_port(fd); 649} 650 651// Operate on a file descriptor returned from unix_open() or a well-known file 652// descriptor such as STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO. 653// 654// On Unix, unix_read(), unix_write(), unix_close() map to adb_read(), 655// adb_write(), adb_close() (which all map to Unix system calls), but the 656// Windows implementations (in the ifdef above and in sysdeps_win32.cpp) call 657// into the C Runtime and its configurable CR/LF translation (which is settable 658// via _setmode()). 659#define unix_read adb_read 660#define unix_write adb_write 661#define unix_close adb_close 662 663// Win32 is limited to DWORDs for thread return values; limit the POSIX systems to this as well to 664// ensure compatibility. 665typedef void (*adb_thread_func_t)(void* arg); 666typedef pthread_t adb_thread_t; 667 668struct adb_pthread_args { 669 adb_thread_func_t func; 670 void* arg; 671}; 672 673static void* adb_pthread_wrapper(void* heap_args) { 674 // Move the arguments from the heap onto the thread's stack. 675 adb_pthread_args thread_args = *reinterpret_cast<adb_pthread_args*>(heap_args); 676 delete static_cast<adb_pthread_args*>(heap_args); 677 thread_args.func(thread_args.arg); 678 return nullptr; 679} 680 681static __inline__ bool adb_thread_create(adb_thread_func_t start, void* arg, 682 adb_thread_t* thread = nullptr) { 683 pthread_t temp; 684 pthread_attr_t attr; 685 pthread_attr_init(&attr); 686 pthread_attr_setdetachstate(&attr, thread ? PTHREAD_CREATE_JOINABLE : PTHREAD_CREATE_DETACHED); 687 auto* pthread_args = new adb_pthread_args{.func = start, .arg = arg}; 688 errno = pthread_create(&temp, &attr, adb_pthread_wrapper, pthread_args); 689 if (errno == 0) { 690 if (thread) { 691 *thread = temp; 692 } 693 return true; 694 } 695 return false; 696} 697 698static __inline__ bool adb_thread_join(adb_thread_t thread) { 699 errno = pthread_join(thread, nullptr); 700 return errno == 0; 701} 702 703static __inline__ bool adb_thread_detach(adb_thread_t thread) { 704 errno = pthread_detach(thread); 705 return errno == 0; 706} 707 708static __inline__ void __attribute__((noreturn)) adb_thread_exit() { 709 pthread_exit(nullptr); 710} 711 712static __inline__ int adb_thread_setname(const std::string& name) { 713#ifdef __APPLE__ 714 return pthread_setname_np(name.c_str()); 715#else 716 const char *s = name.c_str(); 717 718 // pthread_setname_np fails rather than truncating long strings. 719 const int max_task_comm_len = 16; // including the null terminator 720 if (name.length() > (max_task_comm_len - 1)) { 721 char buf[max_task_comm_len]; 722 strncpy(buf, name.c_str(), sizeof(buf) - 1); 723 buf[sizeof(buf) - 1] = '\0'; 724 s = buf; 725 } 726 727 return pthread_setname_np(pthread_self(), s) ; 728#endif 729} 730 731static __inline__ int adb_setsockopt( int fd, int level, int optname, const void* optval, socklen_t optlen ) 732{ 733 return setsockopt( fd, level, optname, optval, optlen ); 734} 735 736#undef setsockopt 737#define setsockopt ___xxx_setsockopt 738 739static __inline__ int unix_socketpair( int d, int type, int protocol, int sv[2] ) 740{ 741 return socketpair( d, type, protocol, sv ); 742} 743 744static __inline__ int adb_socketpair( int sv[2] ) 745{ 746 int rc; 747 748 rc = unix_socketpair( AF_UNIX, SOCK_STREAM, 0, sv ); 749 if (rc < 0) 750 return -1; 751 752 close_on_exec( sv[0] ); 753 close_on_exec( sv[1] ); 754 return 0; 755} 756 757#undef socketpair 758#define socketpair ___xxx_socketpair 759 760typedef struct pollfd adb_pollfd; 761static __inline__ int adb_poll(adb_pollfd* fds, size_t nfds, int timeout) { 762 return TEMP_FAILURE_RETRY(poll(fds, nfds, timeout)); 763} 764 765#define poll ___xxx_poll 766 767static __inline__ int adb_mkdir(const std::string& path, int mode) 768{ 769 return mkdir(path.c_str(), mode); 770} 771 772#undef mkdir 773#define mkdir ___xxx_mkdir 774 775static __inline__ int adb_is_absolute_host_path(const char* path) { 776 return path[0] == '/'; 777} 778 779static __inline__ unsigned long adb_thread_id() 780{ 781 return (unsigned long)gettid(); 782} 783 784#endif /* !_WIN32 */ 785 786static inline void disable_tcp_nagle(int fd) { 787 int off = 1; 788 adb_setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &off, sizeof(off)); 789} 790 791// Sets TCP socket |fd| to send a keepalive TCP message every |interval_sec| seconds. Set 792// |interval_sec| to 0 to disable keepalives. If keepalives are enabled, the connection will be 793// configured to drop after 10 missed keepalives. Returns true on success. 794bool set_tcp_keepalive(int fd, int interval_sec); 795 796#if defined(_WIN32) 797// Win32 defines ERROR, which we don't need, but which conflicts with google3 logging. 798#undef ERROR 799#endif 800 801#endif /* _ADB_SYSDEPS_H */ 802