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/macros.h> 35 #include <android-base/unique_fd.h> 36 #include <android-base/utf8.h> 37 38 #include "sysdeps/errno.h" 39 #include "sysdeps/network.h" 40 #include "sysdeps/stat.h" 41 42 // Some printf-like functions are implemented in terms of 43 // android::base::StringAppendV, so they should use the same attribute for 44 // compile-time format string checking. On Windows, if the mingw version of 45 // vsnprintf is used in StringAppendV, use `gnu_printf' which allows z in %zd 46 // and PRIu64 (and related) to be recognized by the compile-time checking. 47 #define ADB_FORMAT_ARCHETYPE __printf__ 48 #ifdef __USE_MINGW_ANSI_STDIO 49 #if __USE_MINGW_ANSI_STDIO 50 #undef ADB_FORMAT_ARCHETYPE 51 #define ADB_FORMAT_ARCHETYPE gnu_printf 52 #endif 53 #endif 54 55 #ifdef _WIN32 56 57 // Clang-only nullability specifiers 58 #define _Nonnull 59 #define _Nullable 60 61 #include <ctype.h> 62 #include <direct.h> 63 #include <dirent.h> 64 #include <errno.h> 65 #include <fcntl.h> 66 #include <io.h> 67 #include <process.h> 68 #include <sys/stat.h> 69 #include <utime.h> 70 #include <winsock2.h> 71 #include <windows.h> 72 #include <ws2tcpip.h> 73 74 #include <memory> // unique_ptr 75 #include <string> 76 77 #include "fdevent.h" 78 79 #define OS_PATH_SEPARATORS "\\/" 80 #define OS_PATH_SEPARATOR '\\' 81 #define OS_PATH_SEPARATOR_STR "\\" 82 #define ENV_PATH_SEPARATOR_STR ";" 83 84 static __inline__ bool adb_is_separator(char c) { 85 return c == '\\' || c == '/'; 86 } 87 88 static __inline__ int adb_thread_setname(const std::string& name) { 89 // TODO: See https://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx for how to set 90 // the thread name in Windows. Unfortunately, it only works during debugging, but 91 // our build process doesn't generate PDB files needed for debugging. 92 return 0; 93 } 94 95 static __inline__ unsigned long adb_thread_id() 96 { 97 return GetCurrentThreadId(); 98 } 99 100 static __inline__ void close_on_exec(int fd) 101 { 102 /* nothing really */ 103 } 104 105 extern int adb_unlink(const char* path); 106 #undef unlink 107 #define unlink ___xxx_unlink 108 109 extern int adb_mkdir(const std::string& path, int mode); 110 #undef mkdir 111 #define mkdir ___xxx_mkdir 112 113 // See the comments for the !defined(_WIN32) versions of adb_*(). 114 extern int adb_open(const char* path, int options); 115 extern int adb_creat(const char* path, int mode); 116 extern int adb_read(int fd, void* buf, int len); 117 extern int adb_write(int fd, const void* buf, int len); 118 extern int adb_lseek(int fd, int pos, int where); 119 extern int adb_shutdown(int fd, int direction = SHUT_RDWR); 120 extern int adb_close(int fd); 121 extern int adb_register_socket(SOCKET s); 122 123 // See the comments for the !defined(_WIN32) version of unix_close(). 124 static __inline__ int unix_close(int fd) 125 { 126 return close(fd); 127 } 128 #undef close 129 #define close ____xxx_close 130 131 // Like unix_read(), but may return EINTR. 132 extern int unix_read_interruptible(int fd, void* buf, size_t len); 133 134 // See the comments for the !defined(_WIN32) version of unix_read(). 135 static __inline__ int unix_read(int fd, void* buf, size_t len) { 136 return TEMP_FAILURE_RETRY(unix_read_interruptible(fd, buf, len)); 137 } 138 139 #undef read 140 #define read ___xxx_read 141 142 // See the comments for the !defined(_WIN32) version of unix_write(). 143 static __inline__ int unix_write(int fd, const void* buf, size_t len) 144 { 145 return write(fd, buf, len); 146 } 147 #undef write 148 #define write ___xxx_write 149 150 // See the comments for the !defined(_WIN32) version of adb_open_mode(). 151 static __inline__ int adb_open_mode(const char* path, int options, int mode) 152 { 153 return adb_open(path, options); 154 } 155 156 // See the comments for the !defined(_WIN32) version of unix_open(). 157 extern int unix_open(const char* path, int options, ...); 158 #define open ___xxx_unix_open 159 160 // Checks if |fd| corresponds to a console. 161 // Standard Windows isatty() returns 1 for both console FDs and character 162 // devices like NUL. unix_isatty() performs some extra checking to only match 163 // console FDs. 164 // |fd| must be a real file descriptor, meaning STDxx_FILENO or unix_open() FDs 165 // will work but adb_open() FDs will not. Additionally the OS handle associated 166 // with |fd| must have GENERIC_READ access (which console FDs have by default). 167 // Returns 1 if |fd| is a console FD, 0 otherwise. The value of errno after 168 // calling this function is unreliable and should not be used. 169 int unix_isatty(int fd); 170 #define isatty ___xxx_isatty 171 172 int network_inaddr_any_server(int port, int type, std::string* error); 173 174 inline int network_local_client(const char* name, int namespace_id, int type, std::string* error) { 175 abort(); 176 } 177 178 inline int network_local_server(const char* name, int namespace_id, int type, std::string* error) { 179 abort(); 180 } 181 182 int network_connect(const std::string& host, int port, int type, int timeout, 183 std::string* error); 184 185 extern int adb_socket_accept(int serverfd, struct sockaddr* addr, socklen_t *addrlen); 186 187 #undef accept 188 #define accept ___xxx_accept 189 190 // Returns the local port number of a bound socket, or -1 on failure. 191 int adb_socket_get_local_port(int fd); 192 193 extern int adb_setsockopt(int fd, int level, int optname, const void* optval, socklen_t optlen); 194 195 #undef setsockopt 196 #define setsockopt ___xxx_setsockopt 197 198 extern int adb_socketpair( int sv[2] ); 199 200 struct adb_pollfd { 201 int fd; 202 short events; 203 short revents; 204 }; 205 extern int adb_poll(adb_pollfd* fds, size_t nfds, int timeout); 206 #define poll ___xxx_poll 207 208 static __inline__ int adb_is_absolute_host_path(const char* path) { 209 return isalpha(path[0]) && path[1] == ':' && path[2] == '\\'; 210 } 211 212 // UTF-8 versions of POSIX APIs. 213 extern DIR* adb_opendir(const char* dirname); 214 extern struct dirent* adb_readdir(DIR* dir); 215 extern int adb_closedir(DIR* dir); 216 217 extern int adb_utime(const char *, struct utimbuf *); 218 extern int adb_chmod(const char *, int); 219 220 extern int adb_vfprintf(FILE *stream, const char *format, va_list ap) 221 __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 2, 0))); 222 extern int adb_vprintf(const char *format, va_list ap) 223 __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 1, 0))); 224 extern int adb_fprintf(FILE *stream, const char *format, ...) 225 __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 2, 3))); 226 extern int adb_printf(const char *format, ...) 227 __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 1, 2))); 228 229 extern int adb_fputs(const char* buf, FILE* stream); 230 extern int adb_fputc(int ch, FILE* stream); 231 extern int adb_putchar(int ch); 232 extern int adb_puts(const char* buf); 233 extern size_t adb_fwrite(const void* ptr, size_t size, size_t nmemb, 234 FILE* stream); 235 236 extern FILE* adb_fopen(const char* f, const char* m); 237 238 extern char* adb_getenv(const char* name); 239 240 extern char* adb_getcwd(char* buf, int size); 241 242 // Remap calls to POSIX APIs to our UTF-8 versions. 243 #define opendir adb_opendir 244 #define readdir adb_readdir 245 #define closedir adb_closedir 246 #define rewinddir rewinddir_utf8_not_yet_implemented 247 #define telldir telldir_utf8_not_yet_implemented 248 // Some compiler's C++ headers have members named seekdir, so we can't do the 249 // macro technique and instead cause a link error if seekdir is called. 250 inline void seekdir(DIR*, long) { 251 extern int seekdir_utf8_not_yet_implemented; 252 seekdir_utf8_not_yet_implemented = 1; 253 } 254 255 #define utime adb_utime 256 #define chmod adb_chmod 257 258 #define vfprintf adb_vfprintf 259 #define vprintf adb_vprintf 260 #define fprintf adb_fprintf 261 #define printf adb_printf 262 #define fputs adb_fputs 263 #define fputc adb_fputc 264 // putc may be a macro, so if so, undefine it, so that we can redefine it. 265 #undef putc 266 #define putc(c, s) adb_fputc(c, s) 267 #define putchar adb_putchar 268 #define puts adb_puts 269 #define fwrite adb_fwrite 270 271 #define fopen adb_fopen 272 #define freopen freopen_utf8_not_yet_implemented 273 274 #define getenv adb_getenv 275 #define putenv putenv_utf8_not_yet_implemented 276 #define setenv setenv_utf8_not_yet_implemented 277 #define unsetenv unsetenv_utf8_not_yet_implemented 278 279 #define getcwd adb_getcwd 280 281 // Helper class to convert UTF-16 argv from wmain() to UTF-8 args that can be 282 // passed to main(). 283 class NarrowArgs { 284 public: 285 NarrowArgs(int argc, wchar_t** argv); 286 ~NarrowArgs(); 287 288 inline char** data() { 289 return narrow_args; 290 } 291 292 private: 293 char** narrow_args; 294 }; 295 296 // Windows HANDLE values only use 32-bits of the type, even on 64-bit machines, 297 // so they can fit in an int. To convert back, we just need to sign-extend. 298 // https://msdn.microsoft.com/en-us/library/windows/desktop/aa384203%28v=vs.85%29.aspx 299 // Note that this does not make a HANDLE value work with APIs like open(), nor 300 // does this make a value from open() passable to APIs taking a HANDLE. This 301 // just lets you take a HANDLE, pass it around as an int, and then use it again 302 // as a HANDLE. 303 inline int cast_handle_to_int(const HANDLE h) { 304 // truncate 305 return static_cast<int>(reinterpret_cast<INT_PTR>(h)); 306 } 307 308 inline HANDLE cast_int_to_handle(const int fd) { 309 // sign-extend 310 return reinterpret_cast<HANDLE>(static_cast<INT_PTR>(fd)); 311 } 312 313 // Deleter for unique_handle. Adapted from many sources, including: 314 // http://stackoverflow.com/questions/14841396/stdunique-ptr-deleters-and-the-win32-api 315 // https://visualstudiomagazine.com/articles/2013/09/01/get-a-handle-on-the-windows-api.aspx 316 class handle_deleter { 317 public: 318 typedef HANDLE pointer; 319 320 void operator()(HANDLE h); 321 }; 322 323 // Like std::unique_ptr, but for Windows HANDLE objects that should be 324 // CloseHandle()'d. Operator bool() only checks if the handle != nullptr, 325 // but does not check if the handle != INVALID_HANDLE_VALUE. 326 typedef std::unique_ptr<HANDLE, handle_deleter> unique_handle; 327 328 namespace internal { 329 330 size_t ParseCompleteUTF8(const char* first, const char* last, std::vector<char>* remaining_bytes); 331 332 } 333 334 #else /* !_WIN32 a.k.a. Unix */ 335 336 #include <cutils/sockets.h> 337 #include <cutils/threads.h> 338 #include <fcntl.h> 339 #include <poll.h> 340 #include <signal.h> 341 #include <sys/stat.h> 342 #include <sys/wait.h> 343 344 #include <pthread.h> 345 #include <unistd.h> 346 #include <fcntl.h> 347 #include <stdarg.h> 348 #include <netdb.h> 349 #include <netinet/in.h> 350 #include <netinet/tcp.h> 351 #include <string.h> 352 #include <unistd.h> 353 354 #include <string> 355 356 #define OS_PATH_SEPARATORS "/" 357 #define OS_PATH_SEPARATOR '/' 358 #define OS_PATH_SEPARATOR_STR "/" 359 #define ENV_PATH_SEPARATOR_STR ":" 360 361 static __inline__ bool adb_is_separator(char c) { 362 return c == '/'; 363 } 364 365 static __inline__ void close_on_exec(int fd) 366 { 367 fcntl( fd, F_SETFD, FD_CLOEXEC ); 368 } 369 370 // Open a file and return a file descriptor that may be used with unix_read(), 371 // unix_write(), unix_close(), but not adb_read(), adb_write(), adb_close(). 372 // 373 // On Unix, this is based on open(), so the file descriptor is a real OS file 374 // descriptor, but the Windows implementation (in sysdeps_win32.cpp) returns a 375 // file descriptor that can only be used with C Runtime APIs (which are wrapped 376 // by unix_read(), unix_write(), unix_close()). Also, the C Runtime has 377 // configurable CR/LF translation which defaults to text mode, but is settable 378 // with _setmode(). 379 static __inline__ int unix_open(const char* path, int options,...) 380 { 381 if ((options & O_CREAT) == 0) 382 { 383 return TEMP_FAILURE_RETRY( open(path, options) ); 384 } 385 else 386 { 387 int mode; 388 va_list args; 389 va_start( args, options ); 390 mode = va_arg( args, int ); 391 va_end( args ); 392 return TEMP_FAILURE_RETRY( open( path, options, mode ) ); 393 } 394 } 395 396 // Similar to the two-argument adb_open(), but takes a mode parameter for file 397 // creation. See adb_open() for more info. 398 static __inline__ int adb_open_mode( const char* pathname, int options, int mode ) 399 { 400 return TEMP_FAILURE_RETRY( open( pathname, options, mode ) ); 401 } 402 403 404 // Open a file and return a file descriptor that may be used with adb_read(), 405 // adb_write(), adb_close(), but not unix_read(), unix_write(), unix_close(). 406 // 407 // On Unix, this is based on open(), but the Windows implementation (in 408 // sysdeps_win32.cpp) uses Windows native file I/O and bypasses the C Runtime 409 // and its CR/LF translation. The returned file descriptor should be used with 410 // adb_read(), adb_write(), adb_close(), etc. 411 static __inline__ int adb_open( const char* pathname, int options ) 412 { 413 int fd = TEMP_FAILURE_RETRY( open( pathname, options ) ); 414 if (fd < 0) 415 return -1; 416 close_on_exec( fd ); 417 return fd; 418 } 419 #undef open 420 #define open ___xxx_open 421 422 static __inline__ int adb_shutdown(int fd, int direction = SHUT_RDWR) { 423 return shutdown(fd, direction); 424 } 425 426 #undef shutdown 427 #define shutdown ____xxx_shutdown 428 429 // Closes a file descriptor that came from adb_open() or adb_open_mode(), but 430 // not designed to take a file descriptor from unix_open(). See the comments 431 // for adb_open() for more info. 432 __inline__ int adb_close(int fd) { 433 return close(fd); 434 } 435 #undef close 436 #define close ____xxx_close 437 438 // On Windows, ADB has an indirection layer for file descriptors. If we get a 439 // Win32 SOCKET object from an external library, we have to map it in to that 440 // indirection layer, which this does. 441 __inline__ int adb_register_socket(int s) { 442 return s; 443 } 444 445 static __inline__ int adb_read(int fd, void* buf, size_t len) 446 { 447 return TEMP_FAILURE_RETRY( read( fd, buf, len ) ); 448 } 449 450 // Like unix_read(), but does not handle EINTR. 451 static __inline__ int unix_read_interruptible(int fd, void* buf, size_t len) { 452 return read(fd, buf, len); 453 } 454 455 #undef read 456 #define read ___xxx_read 457 458 static __inline__ int adb_write(int fd, const void* buf, size_t len) 459 { 460 return TEMP_FAILURE_RETRY( write( fd, buf, len ) ); 461 } 462 #undef write 463 #define write ___xxx_write 464 465 static __inline__ int adb_lseek(int fd, int pos, int where) 466 { 467 return lseek(fd, pos, where); 468 } 469 #undef lseek 470 #define lseek ___xxx_lseek 471 472 static __inline__ int adb_unlink(const char* path) 473 { 474 return unlink(path); 475 } 476 #undef unlink 477 #define unlink ___xxx_unlink 478 479 static __inline__ int adb_creat(const char* path, int mode) 480 { 481 int fd = TEMP_FAILURE_RETRY( creat( path, mode ) ); 482 483 if ( fd < 0 ) 484 return -1; 485 486 close_on_exec(fd); 487 return fd; 488 } 489 #undef creat 490 #define creat ___xxx_creat 491 492 static __inline__ int unix_isatty(int fd) { 493 return isatty(fd); 494 } 495 #define isatty ___xxx_isatty 496 497 // Helper for network_* functions. 498 inline int _fd_set_error_str(int fd, std::string* error) { 499 if (fd == -1) { 500 *error = strerror(errno); 501 } 502 return fd; 503 } 504 505 inline int network_inaddr_any_server(int port, int type, std::string* error) { 506 return _fd_set_error_str(socket_inaddr_any_server(port, type), error); 507 } 508 509 inline int network_local_client(const char* name, int namespace_id, int type, std::string* error) { 510 return _fd_set_error_str(socket_local_client(name, namespace_id, type), error); 511 } 512 513 inline int network_local_server(const char* name, int namespace_id, int type, std::string* error) { 514 return _fd_set_error_str(socket_local_server(name, namespace_id, type), error); 515 } 516 517 inline int network_connect(const std::string& host, int port, int type, 518 int timeout, std::string* error) { 519 int getaddrinfo_error = 0; 520 int fd = socket_network_client_timeout(host.c_str(), port, type, timeout, 521 &getaddrinfo_error); 522 if (fd != -1) { 523 return fd; 524 } 525 if (getaddrinfo_error != 0) { 526 *error = gai_strerror(getaddrinfo_error); 527 } else { 528 *error = strerror(errno); 529 } 530 return -1; 531 } 532 533 static __inline__ int adb_socket_accept(int serverfd, struct sockaddr* addr, socklen_t *addrlen) 534 { 535 int fd; 536 537 fd = TEMP_FAILURE_RETRY( accept( serverfd, addr, addrlen ) ); 538 if (fd >= 0) 539 close_on_exec(fd); 540 541 return fd; 542 } 543 544 #undef accept 545 #define accept ___xxx_accept 546 547 inline int adb_socket_get_local_port(int fd) { 548 return socket_get_local_port(fd); 549 } 550 551 // Operate on a file descriptor returned from unix_open() or a well-known file 552 // descriptor such as STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO. 553 // 554 // On Unix, unix_read(), unix_write(), unix_close() map to adb_read(), 555 // adb_write(), adb_close() (which all map to Unix system calls), but the 556 // Windows implementations (in the ifdef above and in sysdeps_win32.cpp) call 557 // into the C Runtime and its configurable CR/LF translation (which is settable 558 // via _setmode()). 559 #define unix_read adb_read 560 #define unix_write adb_write 561 #define unix_close adb_close 562 563 static __inline__ int adb_thread_setname(const std::string& name) { 564 #ifdef __APPLE__ 565 return pthread_setname_np(name.c_str()); 566 #else 567 // Both bionic and glibc's pthread_setname_np fails rather than truncating long strings. 568 // glibc doesn't have strlcpy, so we have to fake it. 569 char buf[16]; // MAX_TASK_COMM_LEN, but that's not exported by the kernel headers. 570 strncpy(buf, name.c_str(), sizeof(buf) - 1); 571 buf[sizeof(buf) - 1] = '\0'; 572 return pthread_setname_np(pthread_self(), buf); 573 #endif 574 } 575 576 static __inline__ int adb_setsockopt( int fd, int level, int optname, const void* optval, socklen_t optlen ) 577 { 578 return setsockopt( fd, level, optname, optval, optlen ); 579 } 580 581 #undef setsockopt 582 #define setsockopt ___xxx_setsockopt 583 584 static __inline__ int unix_socketpair( int d, int type, int protocol, int sv[2] ) 585 { 586 return socketpair( d, type, protocol, sv ); 587 } 588 589 static __inline__ int adb_socketpair( int sv[2] ) 590 { 591 int rc; 592 593 rc = unix_socketpair( AF_UNIX, SOCK_STREAM, 0, sv ); 594 if (rc < 0) 595 return -1; 596 597 close_on_exec( sv[0] ); 598 close_on_exec( sv[1] ); 599 return 0; 600 } 601 602 #undef socketpair 603 #define socketpair ___xxx_socketpair 604 605 typedef struct pollfd adb_pollfd; 606 static __inline__ int adb_poll(adb_pollfd* fds, size_t nfds, int timeout) { 607 return TEMP_FAILURE_RETRY(poll(fds, nfds, timeout)); 608 } 609 610 #define poll ___xxx_poll 611 612 static __inline__ int adb_mkdir(const std::string& path, int mode) 613 { 614 return mkdir(path.c_str(), mode); 615 } 616 617 #undef mkdir 618 #define mkdir ___xxx_mkdir 619 620 static __inline__ int adb_is_absolute_host_path(const char* path) { 621 return path[0] == '/'; 622 } 623 624 static __inline__ unsigned long adb_thread_id() 625 { 626 return (unsigned long)gettid(); 627 } 628 629 #endif /* !_WIN32 */ 630 631 static inline void disable_tcp_nagle(int fd) { 632 int off = 1; 633 adb_setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &off, sizeof(off)); 634 } 635 636 // Sets TCP socket |fd| to send a keepalive TCP message every |interval_sec| seconds. Set 637 // |interval_sec| to 0 to disable keepalives. If keepalives are enabled, the connection will be 638 // configured to drop after 10 missed keepalives. Returns true on success. 639 bool set_tcp_keepalive(int fd, int interval_sec); 640 641 #if defined(_WIN32) 642 // Win32 defines ERROR, which we don't need, but which conflicts with google3 logging. 643 #undef ERROR 644 #endif 645 646 #endif /* _ADB_SYSDEPS_H */ 647