Home | History | Annotate | Download | only in adb
      1 /*
      2  * Copyright (C) 2015 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 #define TRACE_TAG SYSDEPS
     18 
     19 #include "sysdeps.h"
     20 
     21 #include <winsock2.h> /* winsock.h *must* be included before windows.h. */
     22 #include <windows.h>
     23 
     24 #include <errno.h>
     25 #include <stdio.h>
     26 #include <stdlib.h>
     27 
     28 #include <algorithm>
     29 #include <memory>
     30 #include <mutex>
     31 #include <string>
     32 #include <unordered_map>
     33 #include <vector>
     34 
     35 #include <cutils/sockets.h>
     36 
     37 #include <android-base/errors.h>
     38 #include <android-base/logging.h>
     39 #include <android-base/stringprintf.h>
     40 #include <android-base/strings.h>
     41 #include <android-base/utf8.h>
     42 
     43 #include "adb.h"
     44 #include "adb_utils.h"
     45 
     46 extern void fatal(const char *fmt, ...);
     47 
     48 /* forward declarations */
     49 
     50 typedef const struct FHClassRec_* FHClass;
     51 typedef struct FHRec_* FH;
     52 typedef struct EventHookRec_* EventHook;
     53 
     54 typedef struct FHClassRec_ {
     55     void (*_fh_init)(FH);
     56     int (*_fh_close)(FH);
     57     int (*_fh_lseek)(FH, int, int);
     58     int (*_fh_read)(FH, void*, int);
     59     int (*_fh_write)(FH, const void*, int);
     60 } FHClassRec;
     61 
     62 static void _fh_file_init(FH);
     63 static int _fh_file_close(FH);
     64 static int _fh_file_lseek(FH, int, int);
     65 static int _fh_file_read(FH, void*, int);
     66 static int _fh_file_write(FH, const void*, int);
     67 
     68 static const FHClassRec _fh_file_class = {
     69     _fh_file_init,
     70     _fh_file_close,
     71     _fh_file_lseek,
     72     _fh_file_read,
     73     _fh_file_write,
     74 };
     75 
     76 static void _fh_socket_init(FH);
     77 static int _fh_socket_close(FH);
     78 static int _fh_socket_lseek(FH, int, int);
     79 static int _fh_socket_read(FH, void*, int);
     80 static int _fh_socket_write(FH, const void*, int);
     81 
     82 static const FHClassRec _fh_socket_class = {
     83     _fh_socket_init,
     84     _fh_socket_close,
     85     _fh_socket_lseek,
     86     _fh_socket_read,
     87     _fh_socket_write,
     88 };
     89 
     90 #define assert(cond)                                                                       \
     91     do {                                                                                   \
     92         if (!(cond)) fatal("assertion failed '%s' on %s:%d\n", #cond, __FILE__, __LINE__); \
     93     } while (0)
     94 
     95 void handle_deleter::operator()(HANDLE h) {
     96     // CreateFile() is documented to return INVALID_HANDLE_FILE on error,
     97     // implying that NULL is a valid handle, but this is probably impossible.
     98     // Other APIs like CreateEvent() are documented to return NULL on error,
     99     // implying that INVALID_HANDLE_VALUE is a valid handle, but this is also
    100     // probably impossible. Thus, consider both NULL and INVALID_HANDLE_VALUE
    101     // as invalid handles. std::unique_ptr won't call a deleter with NULL, so we
    102     // only need to check for INVALID_HANDLE_VALUE.
    103     if (h != INVALID_HANDLE_VALUE) {
    104         if (!CloseHandle(h)) {
    105             D("CloseHandle(%p) failed: %s", h,
    106               android::base::SystemErrorCodeToString(GetLastError()).c_str());
    107         }
    108     }
    109 }
    110 
    111 /**************************************************************************/
    112 /**************************************************************************/
    113 /*****                                                                *****/
    114 /*****    common file descriptor handling                             *****/
    115 /*****                                                                *****/
    116 /**************************************************************************/
    117 /**************************************************************************/
    118 
    119 typedef struct FHRec_
    120 {
    121     FHClass    clazz;
    122     int        used;
    123     int        eof;
    124     union {
    125         HANDLE      handle;
    126         SOCKET      socket;
    127     } u;
    128 
    129     char  name[32];
    130 } FHRec;
    131 
    132 #define  fh_handle  u.handle
    133 #define  fh_socket  u.socket
    134 
    135 #define  WIN32_FH_BASE    2048
    136 #define  WIN32_MAX_FHS    2048
    137 
    138 static  std::mutex&  _win32_lock = *new std::mutex();
    139 static  FHRec        _win32_fhs[ WIN32_MAX_FHS ];
    140 static  int          _win32_fh_next;  // where to start search for free FHRec
    141 
    142 static FH
    143 _fh_from_int( int   fd, const char*   func )
    144 {
    145     FH  f;
    146 
    147     fd -= WIN32_FH_BASE;
    148 
    149     if (fd < 0 || fd >= WIN32_MAX_FHS) {
    150         D( "_fh_from_int: invalid fd %d passed to %s", fd + WIN32_FH_BASE,
    151            func );
    152         errno = EBADF;
    153         return NULL;
    154     }
    155 
    156     f = &_win32_fhs[fd];
    157 
    158     if (f->used == 0) {
    159         D( "_fh_from_int: invalid fd %d passed to %s", fd + WIN32_FH_BASE,
    160            func );
    161         errno = EBADF;
    162         return NULL;
    163     }
    164 
    165     return f;
    166 }
    167 
    168 
    169 static int
    170 _fh_to_int( FH  f )
    171 {
    172     if (f && f->used && f >= _win32_fhs && f < _win32_fhs + WIN32_MAX_FHS)
    173         return (int)(f - _win32_fhs) + WIN32_FH_BASE;
    174 
    175     return -1;
    176 }
    177 
    178 static FH
    179 _fh_alloc( FHClass  clazz )
    180 {
    181     FH   f = NULL;
    182 
    183     std::lock_guard<std::mutex> lock(_win32_lock);
    184 
    185     for (int i = _win32_fh_next; i < WIN32_MAX_FHS; ++i) {
    186         if (_win32_fhs[i].clazz == NULL) {
    187             f = &_win32_fhs[i];
    188             _win32_fh_next = i + 1;
    189             f->clazz = clazz;
    190             f->used = 1;
    191             f->eof = 0;
    192             f->name[0] = '\0';
    193             clazz->_fh_init(f);
    194             return f;
    195         }
    196     }
    197 
    198     D("_fh_alloc: no more free file descriptors");
    199     errno = EMFILE;  // Too many open files
    200     return nullptr;
    201 }
    202 
    203 
    204 static int
    205 _fh_close( FH   f )
    206 {
    207     // Use lock so that closing only happens once and so that _fh_alloc can't
    208     // allocate a FH that we're in the middle of closing.
    209     std::lock_guard<std::mutex> lock(_win32_lock);
    210 
    211     int offset = f - _win32_fhs;
    212     if (_win32_fh_next > offset) {
    213         _win32_fh_next = offset;
    214     }
    215 
    216     if (f->used) {
    217         f->clazz->_fh_close( f );
    218         f->name[0] = '\0';
    219         f->eof     = 0;
    220         f->used    = 0;
    221         f->clazz   = NULL;
    222     }
    223     return 0;
    224 }
    225 
    226 // Deleter for unique_fh.
    227 class fh_deleter {
    228  public:
    229   void operator()(struct FHRec_* fh) {
    230     // We're called from a destructor and destructors should not overwrite
    231     // errno because callers may do:
    232     //   errno = EBLAH;
    233     //   return -1; // calls destructor, which should not overwrite errno
    234     const int saved_errno = errno;
    235     _fh_close(fh);
    236     errno = saved_errno;
    237   }
    238 };
    239 
    240 // Like std::unique_ptr, but calls _fh_close() instead of operator delete().
    241 typedef std::unique_ptr<struct FHRec_, fh_deleter> unique_fh;
    242 
    243 /**************************************************************************/
    244 /**************************************************************************/
    245 /*****                                                                *****/
    246 /*****    file-based descriptor handling                              *****/
    247 /*****                                                                *****/
    248 /**************************************************************************/
    249 /**************************************************************************/
    250 
    251 static void _fh_file_init( FH  f ) {
    252     f->fh_handle = INVALID_HANDLE_VALUE;
    253 }
    254 
    255 static int _fh_file_close( FH  f ) {
    256     CloseHandle( f->fh_handle );
    257     f->fh_handle = INVALID_HANDLE_VALUE;
    258     return 0;
    259 }
    260 
    261 static int _fh_file_read( FH  f,  void*  buf, int   len ) {
    262     DWORD  read_bytes;
    263 
    264     if ( !ReadFile( f->fh_handle, buf, (DWORD)len, &read_bytes, NULL ) ) {
    265         D( "adb_read: could not read %d bytes from %s", len, f->name );
    266         errno = EIO;
    267         return -1;
    268     } else if (read_bytes < (DWORD)len) {
    269         f->eof = 1;
    270     }
    271     return (int)read_bytes;
    272 }
    273 
    274 static int _fh_file_write( FH  f,  const void*  buf, int   len ) {
    275     DWORD  wrote_bytes;
    276 
    277     if ( !WriteFile( f->fh_handle, buf, (DWORD)len, &wrote_bytes, NULL ) ) {
    278         D( "adb_file_write: could not write %d bytes from %s", len, f->name );
    279         errno = EIO;
    280         return -1;
    281     } else if (wrote_bytes < (DWORD)len) {
    282         f->eof = 1;
    283     }
    284     return  (int)wrote_bytes;
    285 }
    286 
    287 static int _fh_file_lseek( FH  f, int  pos, int  origin ) {
    288     DWORD  method;
    289     DWORD  result;
    290 
    291     switch (origin)
    292     {
    293         case SEEK_SET:  method = FILE_BEGIN; break;
    294         case SEEK_CUR:  method = FILE_CURRENT; break;
    295         case SEEK_END:  method = FILE_END; break;
    296         default:
    297             errno = EINVAL;
    298             return -1;
    299     }
    300 
    301     result = SetFilePointer( f->fh_handle, pos, NULL, method );
    302     if (result == INVALID_SET_FILE_POINTER) {
    303         errno = EIO;
    304         return -1;
    305     } else {
    306         f->eof = 0;
    307     }
    308     return (int)result;
    309 }
    310 
    311 
    312 /**************************************************************************/
    313 /**************************************************************************/
    314 /*****                                                                *****/
    315 /*****    file-based descriptor handling                              *****/
    316 /*****                                                                *****/
    317 /**************************************************************************/
    318 /**************************************************************************/
    319 
    320 int  adb_open(const char*  path, int  options)
    321 {
    322     FH  f;
    323 
    324     DWORD  desiredAccess       = 0;
    325     DWORD  shareMode           = FILE_SHARE_READ | FILE_SHARE_WRITE;
    326 
    327     switch (options) {
    328         case O_RDONLY:
    329             desiredAccess = GENERIC_READ;
    330             break;
    331         case O_WRONLY:
    332             desiredAccess = GENERIC_WRITE;
    333             break;
    334         case O_RDWR:
    335             desiredAccess = GENERIC_READ | GENERIC_WRITE;
    336             break;
    337         default:
    338             D("adb_open: invalid options (0x%0x)", options);
    339             errno = EINVAL;
    340             return -1;
    341     }
    342 
    343     f = _fh_alloc( &_fh_file_class );
    344     if ( !f ) {
    345         return -1;
    346     }
    347 
    348     std::wstring path_wide;
    349     if (!android::base::UTF8ToWide(path, &path_wide)) {
    350         return -1;
    351     }
    352     f->fh_handle = CreateFileW( path_wide.c_str(), desiredAccess, shareMode,
    353                                 NULL, OPEN_EXISTING, 0, NULL );
    354 
    355     if ( f->fh_handle == INVALID_HANDLE_VALUE ) {
    356         const DWORD err = GetLastError();
    357         _fh_close(f);
    358         D( "adb_open: could not open '%s': ", path );
    359         switch (err) {
    360             case ERROR_FILE_NOT_FOUND:
    361                 D( "file not found" );
    362                 errno = ENOENT;
    363                 return -1;
    364 
    365             case ERROR_PATH_NOT_FOUND:
    366                 D( "path not found" );
    367                 errno = ENOTDIR;
    368                 return -1;
    369 
    370             default:
    371                 D("unknown error: %s", android::base::SystemErrorCodeToString(err).c_str());
    372                 errno = ENOENT;
    373                 return -1;
    374         }
    375     }
    376 
    377     snprintf( f->name, sizeof(f->name), "%d(%s)", _fh_to_int(f), path );
    378     D( "adb_open: '%s' => fd %d", path, _fh_to_int(f) );
    379     return _fh_to_int(f);
    380 }
    381 
    382 /* ignore mode on Win32 */
    383 int  adb_creat(const char*  path, int  mode)
    384 {
    385     FH  f;
    386 
    387     f = _fh_alloc( &_fh_file_class );
    388     if ( !f ) {
    389         return -1;
    390     }
    391 
    392     std::wstring path_wide;
    393     if (!android::base::UTF8ToWide(path, &path_wide)) {
    394         return -1;
    395     }
    396     f->fh_handle = CreateFileW( path_wide.c_str(), GENERIC_WRITE,
    397                                 FILE_SHARE_READ | FILE_SHARE_WRITE,
    398                                 NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,
    399                                 NULL );
    400 
    401     if ( f->fh_handle == INVALID_HANDLE_VALUE ) {
    402         const DWORD err = GetLastError();
    403         _fh_close(f);
    404         D( "adb_creat: could not open '%s': ", path );
    405         switch (err) {
    406             case ERROR_FILE_NOT_FOUND:
    407                 D( "file not found" );
    408                 errno = ENOENT;
    409                 return -1;
    410 
    411             case ERROR_PATH_NOT_FOUND:
    412                 D( "path not found" );
    413                 errno = ENOTDIR;
    414                 return -1;
    415 
    416             default:
    417                 D("unknown error: %s", android::base::SystemErrorCodeToString(err).c_str());
    418                 errno = ENOENT;
    419                 return -1;
    420         }
    421     }
    422     snprintf( f->name, sizeof(f->name), "%d(%s)", _fh_to_int(f), path );
    423     D( "adb_creat: '%s' => fd %d", path, _fh_to_int(f) );
    424     return _fh_to_int(f);
    425 }
    426 
    427 
    428 int  adb_read(int  fd, void* buf, int len)
    429 {
    430     FH     f = _fh_from_int(fd, __func__);
    431 
    432     if (f == NULL) {
    433         return -1;
    434     }
    435 
    436     return f->clazz->_fh_read( f, buf, len );
    437 }
    438 
    439 
    440 int  adb_write(int  fd, const void*  buf, int  len)
    441 {
    442     FH     f = _fh_from_int(fd, __func__);
    443 
    444     if (f == NULL) {
    445         return -1;
    446     }
    447 
    448     return f->clazz->_fh_write(f, buf, len);
    449 }
    450 
    451 
    452 int  adb_lseek(int  fd, int  pos, int  where)
    453 {
    454     FH     f = _fh_from_int(fd, __func__);
    455 
    456     if (!f) {
    457         return -1;
    458     }
    459 
    460     return f->clazz->_fh_lseek(f, pos, where);
    461 }
    462 
    463 
    464 int  adb_close(int  fd)
    465 {
    466     FH   f = _fh_from_int(fd, __func__);
    467 
    468     if (!f) {
    469         return -1;
    470     }
    471 
    472     D( "adb_close: %s", f->name);
    473     _fh_close(f);
    474     return 0;
    475 }
    476 
    477 /**************************************************************************/
    478 /**************************************************************************/
    479 /*****                                                                *****/
    480 /*****    socket-based file descriptors                               *****/
    481 /*****                                                                *****/
    482 /**************************************************************************/
    483 /**************************************************************************/
    484 
    485 #undef setsockopt
    486 
    487 static void _socket_set_errno( const DWORD err ) {
    488     // Because the Windows C Runtime (MSVCRT.DLL) strerror() does not support a
    489     // lot of POSIX and socket error codes, some of the resulting error codes
    490     // are mapped to strings by adb_strerror().
    491     switch ( err ) {
    492     case 0:              errno = 0; break;
    493     // Don't map WSAEINTR since that is only for Winsock 1.1 which we don't use.
    494     // case WSAEINTR:    errno = EINTR; break;
    495     case WSAEFAULT:      errno = EFAULT; break;
    496     case WSAEINVAL:      errno = EINVAL; break;
    497     case WSAEMFILE:      errno = EMFILE; break;
    498     // Mapping WSAEWOULDBLOCK to EAGAIN is absolutely critical because
    499     // non-blocking sockets can cause an error code of WSAEWOULDBLOCK and
    500     // callers check specifically for EAGAIN.
    501     case WSAEWOULDBLOCK: errno = EAGAIN; break;
    502     case WSAENOTSOCK:    errno = ENOTSOCK; break;
    503     case WSAENOPROTOOPT: errno = ENOPROTOOPT; break;
    504     case WSAEOPNOTSUPP:  errno = EOPNOTSUPP; break;
    505     case WSAENETDOWN:    errno = ENETDOWN; break;
    506     case WSAENETRESET:   errno = ENETRESET; break;
    507     // Map WSAECONNABORTED to EPIPE instead of ECONNABORTED because POSIX seems
    508     // to use EPIPE for these situations and there are some callers that look
    509     // for EPIPE.
    510     case WSAECONNABORTED: errno = EPIPE; break;
    511     case WSAECONNRESET:  errno = ECONNRESET; break;
    512     case WSAENOBUFS:     errno = ENOBUFS; break;
    513     case WSAENOTCONN:    errno = ENOTCONN; break;
    514     // Don't map WSAETIMEDOUT because we don't currently use SO_RCVTIMEO or
    515     // SO_SNDTIMEO which would cause WSAETIMEDOUT to be returned. Future
    516     // considerations: Reportedly send() can return zero on timeout, and POSIX
    517     // code may expect EAGAIN instead of ETIMEDOUT on timeout.
    518     // case WSAETIMEDOUT: errno = ETIMEDOUT; break;
    519     case WSAEHOSTUNREACH: errno = EHOSTUNREACH; break;
    520     default:
    521         errno = EINVAL;
    522         D( "_socket_set_errno: mapping Windows error code %lu to errno %d",
    523            err, errno );
    524     }
    525 }
    526 
    527 extern int adb_poll(adb_pollfd* fds, size_t nfds, int timeout) {
    528     // WSAPoll doesn't handle invalid/non-socket handles, so we need to handle them ourselves.
    529     int skipped = 0;
    530     std::vector<WSAPOLLFD> sockets;
    531     std::vector<adb_pollfd*> original;
    532     for (size_t i = 0; i < nfds; ++i) {
    533         FH fh = _fh_from_int(fds[i].fd, __func__);
    534         if (!fh || !fh->used || fh->clazz != &_fh_socket_class) {
    535             D("adb_poll received bad FD %d", fds[i].fd);
    536             fds[i].revents = POLLNVAL;
    537             ++skipped;
    538         } else {
    539             WSAPOLLFD wsapollfd = {
    540                 .fd = fh->u.socket,
    541                 .events = static_cast<short>(fds[i].events)
    542             };
    543             sockets.push_back(wsapollfd);
    544             original.push_back(&fds[i]);
    545         }
    546     }
    547 
    548     if (sockets.empty()) {
    549         return skipped;
    550     }
    551 
    552     int result = WSAPoll(sockets.data(), sockets.size(), timeout);
    553     if (result == SOCKET_ERROR) {
    554         _socket_set_errno(WSAGetLastError());
    555         return -1;
    556     }
    557 
    558     // Map the results back onto the original set.
    559     for (size_t i = 0; i < sockets.size(); ++i) {
    560         original[i]->revents = sockets[i].revents;
    561     }
    562 
    563     // WSAPoll appears to return the number of unique FDs with avaiable events, instead of how many
    564     // of the pollfd elements have a non-zero revents field, which is what it and poll are specified
    565     // to do. Ignore its result and calculate the proper return value.
    566     result = 0;
    567     for (size_t i = 0; i < nfds; ++i) {
    568         if (fds[i].revents != 0) {
    569             ++result;
    570         }
    571     }
    572     return result;
    573 }
    574 
    575 static void _fh_socket_init(FH f) {
    576     f->fh_socket = INVALID_SOCKET;
    577 }
    578 
    579 static int _fh_socket_close( FH  f ) {
    580     if (f->fh_socket != INVALID_SOCKET) {
    581         /* gently tell any peer that we're closing the socket */
    582         if (shutdown(f->fh_socket, SD_BOTH) == SOCKET_ERROR) {
    583             // If the socket is not connected, this returns an error. We want to
    584             // minimize logging spam, so don't log these errors for now.
    585 #if 0
    586             D("socket shutdown failed: %s",
    587               android::base::SystemErrorCodeToString(WSAGetLastError()).c_str());
    588 #endif
    589         }
    590         if (closesocket(f->fh_socket) == SOCKET_ERROR) {
    591             // Don't set errno here, since adb_close will ignore it.
    592             const DWORD err = WSAGetLastError();
    593             D("closesocket failed: %s", android::base::SystemErrorCodeToString(err).c_str());
    594         }
    595         f->fh_socket = INVALID_SOCKET;
    596     }
    597     return 0;
    598 }
    599 
    600 static int _fh_socket_lseek( FH  f, int pos, int origin ) {
    601     errno = EPIPE;
    602     return -1;
    603 }
    604 
    605 static int _fh_socket_read(FH f, void* buf, int len) {
    606     int  result = recv(f->fh_socket, reinterpret_cast<char*>(buf), len, 0);
    607     if (result == SOCKET_ERROR) {
    608         const DWORD err = WSAGetLastError();
    609         // WSAEWOULDBLOCK is normal with a non-blocking socket, so don't trace
    610         // that to reduce spam and confusion.
    611         if (err != WSAEWOULDBLOCK) {
    612             D("recv fd %d failed: %s", _fh_to_int(f),
    613               android::base::SystemErrorCodeToString(err).c_str());
    614         }
    615         _socket_set_errno(err);
    616         result = -1;
    617     }
    618     return  result;
    619 }
    620 
    621 static int _fh_socket_write(FH f, const void* buf, int len) {
    622     int  result = send(f->fh_socket, reinterpret_cast<const char*>(buf), len, 0);
    623     if (result == SOCKET_ERROR) {
    624         const DWORD err = WSAGetLastError();
    625         // WSAEWOULDBLOCK is normal with a non-blocking socket, so don't trace
    626         // that to reduce spam and confusion.
    627         if (err != WSAEWOULDBLOCK) {
    628             D("send fd %d failed: %s", _fh_to_int(f),
    629               android::base::SystemErrorCodeToString(err).c_str());
    630         }
    631         _socket_set_errno(err);
    632         result = -1;
    633     } else {
    634         // According to https://code.google.com/p/chromium/issues/detail?id=27870
    635         // Winsock Layered Service Providers may cause this.
    636         CHECK_LE(result, len) << "Tried to write " << len << " bytes to "
    637                               << f->name << ", but " << result
    638                               << " bytes reportedly written";
    639     }
    640     return result;
    641 }
    642 
    643 /**************************************************************************/
    644 /**************************************************************************/
    645 /*****                                                                *****/
    646 /*****    replacement for libs/cutils/socket_xxxx.c                   *****/
    647 /*****                                                                *****/
    648 /**************************************************************************/
    649 /**************************************************************************/
    650 
    651 #include <winsock2.h>
    652 
    653 static int  _winsock_init;
    654 
    655 static void
    656 _init_winsock( void )
    657 {
    658     // TODO: Multiple threads calling this may potentially cause multiple calls
    659     // to WSAStartup() which offers no real benefit.
    660     if (!_winsock_init) {
    661         WSADATA  wsaData;
    662         int      rc = WSAStartup( MAKEWORD(2,2), &wsaData);
    663         if (rc != 0) {
    664             fatal("adb: could not initialize Winsock: %s",
    665                   android::base::SystemErrorCodeToString(rc).c_str());
    666         }
    667         _winsock_init = 1;
    668 
    669         // Note that we do not call atexit() to register WSACleanup to be called
    670         // at normal process termination because:
    671         // 1) When exit() is called, there are still threads actively using
    672         //    Winsock because we don't cleanly shutdown all threads, so it
    673         //    doesn't make sense to call WSACleanup() and may cause problems
    674         //    with those threads.
    675         // 2) A deadlock can occur when exit() holds a C Runtime lock, then it
    676         //    calls WSACleanup() which tries to unload a DLL, which tries to
    677         //    grab the LoaderLock. This conflicts with the device_poll_thread
    678         //    which holds the LoaderLock because AdbWinApi.dll calls
    679         //    setupapi.dll which tries to load wintrust.dll which tries to load
    680         //    crypt32.dll which calls atexit() which tries to acquire the C
    681         //    Runtime lock that the other thread holds.
    682     }
    683 }
    684 
    685 // Map a socket type to an explicit socket protocol instead of using the socket
    686 // protocol of 0. Explicit socket protocols are used by most apps and we should
    687 // do the same to reduce the chance of exercising uncommon code-paths that might
    688 // have problems or that might load different Winsock service providers that
    689 // have problems.
    690 static int GetSocketProtocolFromSocketType(int type) {
    691     switch (type) {
    692         case SOCK_STREAM:
    693             return IPPROTO_TCP;
    694         case SOCK_DGRAM:
    695             return IPPROTO_UDP;
    696         default:
    697             LOG(FATAL) << "Unknown socket type: " << type;
    698             return 0;
    699     }
    700 }
    701 
    702 int network_loopback_client(int port, int type, std::string* error) {
    703     struct sockaddr_in addr;
    704     SOCKET s;
    705 
    706     unique_fh f(_fh_alloc(&_fh_socket_class));
    707     if (!f) {
    708         *error = strerror(errno);
    709         return -1;
    710     }
    711 
    712     if (!_winsock_init) _init_winsock();
    713 
    714     memset(&addr, 0, sizeof(addr));
    715     addr.sin_family = AF_INET;
    716     addr.sin_port = htons(port);
    717     addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    718 
    719     s = socket(AF_INET, type, GetSocketProtocolFromSocketType(type));
    720     if (s == INVALID_SOCKET) {
    721         const DWORD err = WSAGetLastError();
    722         *error = android::base::StringPrintf("cannot create socket: %s",
    723                                              android::base::SystemErrorCodeToString(err).c_str());
    724         D("%s", error->c_str());
    725         _socket_set_errno(err);
    726         return -1;
    727     }
    728     f->fh_socket = s;
    729 
    730     if (connect(s, (struct sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) {
    731         // Save err just in case inet_ntoa() or ntohs() changes the last error.
    732         const DWORD err = WSAGetLastError();
    733         *error = android::base::StringPrintf("cannot connect to %s:%u: %s",
    734                                              inet_ntoa(addr.sin_addr), ntohs(addr.sin_port),
    735                                              android::base::SystemErrorCodeToString(err).c_str());
    736         D("could not connect to %s:%d: %s", type != SOCK_STREAM ? "udp" : "tcp", port,
    737           error->c_str());
    738         _socket_set_errno(err);
    739         return -1;
    740     }
    741 
    742     const int fd = _fh_to_int(f.get());
    743     snprintf(f->name, sizeof(f->name), "%d(lo-client:%s%d)", fd, type != SOCK_STREAM ? "udp:" : "",
    744              port);
    745     D("port %d type %s => fd %d", port, type != SOCK_STREAM ? "udp" : "tcp", fd);
    746     f.release();
    747     return fd;
    748 }
    749 
    750 // interface_address is INADDR_LOOPBACK or INADDR_ANY.
    751 static int _network_server(int port, int type, u_long interface_address, std::string* error) {
    752     struct sockaddr_in addr;
    753     SOCKET s;
    754     int n;
    755 
    756     unique_fh f(_fh_alloc(&_fh_socket_class));
    757     if (!f) {
    758         *error = strerror(errno);
    759         return -1;
    760     }
    761 
    762     if (!_winsock_init) _init_winsock();
    763 
    764     memset(&addr, 0, sizeof(addr));
    765     addr.sin_family = AF_INET;
    766     addr.sin_port = htons(port);
    767     addr.sin_addr.s_addr = htonl(interface_address);
    768 
    769     // TODO: Consider using dual-stack socket that can simultaneously listen on
    770     // IPv4 and IPv6.
    771     s = socket(AF_INET, type, GetSocketProtocolFromSocketType(type));
    772     if (s == INVALID_SOCKET) {
    773         const DWORD err = WSAGetLastError();
    774         *error = android::base::StringPrintf("cannot create socket: %s",
    775                                              android::base::SystemErrorCodeToString(err).c_str());
    776         D("%s", error->c_str());
    777         _socket_set_errno(err);
    778         return -1;
    779     }
    780 
    781     f->fh_socket = s;
    782 
    783     // Note: SO_REUSEADDR on Windows allows multiple processes to bind to the
    784     // same port, so instead use SO_EXCLUSIVEADDRUSE.
    785     n = 1;
    786     if (setsockopt(s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (const char*)&n, sizeof(n)) == SOCKET_ERROR) {
    787         const DWORD err = WSAGetLastError();
    788         *error = android::base::StringPrintf("cannot set socket option SO_EXCLUSIVEADDRUSE: %s",
    789                                              android::base::SystemErrorCodeToString(err).c_str());
    790         D("%s", error->c_str());
    791         _socket_set_errno(err);
    792         return -1;
    793     }
    794 
    795     if (bind(s, (struct sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) {
    796         // Save err just in case inet_ntoa() or ntohs() changes the last error.
    797         const DWORD err = WSAGetLastError();
    798         *error = android::base::StringPrintf("cannot bind to %s:%u: %s", inet_ntoa(addr.sin_addr),
    799                                              ntohs(addr.sin_port),
    800                                              android::base::SystemErrorCodeToString(err).c_str());
    801         D("could not bind to %s:%d: %s", type != SOCK_STREAM ? "udp" : "tcp", port, error->c_str());
    802         _socket_set_errno(err);
    803         return -1;
    804     }
    805     if (type == SOCK_STREAM) {
    806         if (listen(s, SOMAXCONN) == SOCKET_ERROR) {
    807             const DWORD err = WSAGetLastError();
    808             *error = android::base::StringPrintf(
    809                 "cannot listen on socket: %s", android::base::SystemErrorCodeToString(err).c_str());
    810             D("could not listen on %s:%d: %s", type != SOCK_STREAM ? "udp" : "tcp", port,
    811               error->c_str());
    812             _socket_set_errno(err);
    813             return -1;
    814         }
    815     }
    816     const int fd = _fh_to_int(f.get());
    817     snprintf(f->name, sizeof(f->name), "%d(%s-server:%s%d)", fd,
    818              interface_address == INADDR_LOOPBACK ? "lo" : "any", type != SOCK_STREAM ? "udp:" : "",
    819              port);
    820     D("port %d type %s => fd %d", port, type != SOCK_STREAM ? "udp" : "tcp", fd);
    821     f.release();
    822     return fd;
    823 }
    824 
    825 int network_loopback_server(int port, int type, std::string* error) {
    826     return _network_server(port, type, INADDR_LOOPBACK, error);
    827 }
    828 
    829 int network_inaddr_any_server(int port, int type, std::string* error) {
    830     return _network_server(port, type, INADDR_ANY, error);
    831 }
    832 
    833 int network_connect(const std::string& host, int port, int type, int timeout, std::string* error) {
    834     unique_fh f(_fh_alloc(&_fh_socket_class));
    835     if (!f) {
    836         *error = strerror(errno);
    837         return -1;
    838     }
    839 
    840     if (!_winsock_init) _init_winsock();
    841 
    842     struct addrinfo hints;
    843     memset(&hints, 0, sizeof(hints));
    844     hints.ai_family = AF_UNSPEC;
    845     hints.ai_socktype = type;
    846     hints.ai_protocol = GetSocketProtocolFromSocketType(type);
    847 
    848     char port_str[16];
    849     snprintf(port_str, sizeof(port_str), "%d", port);
    850 
    851     struct addrinfo* addrinfo_ptr = nullptr;
    852 
    853 #if (NTDDI_VERSION >= NTDDI_WINXPSP2) || (_WIN32_WINNT >= _WIN32_WINNT_WS03)
    854 // TODO: When the Android SDK tools increases the Windows system
    855 // requirements >= WinXP SP2, switch to android::base::UTF8ToWide() + GetAddrInfoW().
    856 #else
    857 // Otherwise, keep using getaddrinfo(), or do runtime API detection
    858 // with GetProcAddress("GetAddrInfoW").
    859 #endif
    860     if (getaddrinfo(host.c_str(), port_str, &hints, &addrinfo_ptr) != 0) {
    861         const DWORD err = WSAGetLastError();
    862         *error = android::base::StringPrintf("cannot resolve host '%s' and port %s: %s",
    863                                              host.c_str(), port_str,
    864                                              android::base::SystemErrorCodeToString(err).c_str());
    865 
    866         D("%s", error->c_str());
    867         _socket_set_errno(err);
    868         return -1;
    869     }
    870     std::unique_ptr<struct addrinfo, decltype(&freeaddrinfo)> addrinfo(addrinfo_ptr, freeaddrinfo);
    871     addrinfo_ptr = nullptr;
    872 
    873     // TODO: Try all the addresses if there's more than one? This just uses
    874     // the first. Or, could call WSAConnectByName() (Windows Vista and newer)
    875     // which tries all addresses, takes a timeout and more.
    876     SOCKET s = socket(addrinfo->ai_family, addrinfo->ai_socktype, addrinfo->ai_protocol);
    877     if (s == INVALID_SOCKET) {
    878         const DWORD err = WSAGetLastError();
    879         *error = android::base::StringPrintf("cannot create socket: %s",
    880                                              android::base::SystemErrorCodeToString(err).c_str());
    881         D("%s", error->c_str());
    882         _socket_set_errno(err);
    883         return -1;
    884     }
    885     f->fh_socket = s;
    886 
    887     // TODO: Implement timeouts for Windows. Seems like the default in theory
    888     // (according to http://serverfault.com/a/671453) and in practice is 21 sec.
    889     if (connect(s, addrinfo->ai_addr, addrinfo->ai_addrlen) == SOCKET_ERROR) {
    890         // TODO: Use WSAAddressToString or inet_ntop on address.
    891         const DWORD err = WSAGetLastError();
    892         *error = android::base::StringPrintf("cannot connect to %s:%s: %s", host.c_str(), port_str,
    893                                              android::base::SystemErrorCodeToString(err).c_str());
    894         D("could not connect to %s:%s:%s: %s", type != SOCK_STREAM ? "udp" : "tcp", host.c_str(),
    895           port_str, error->c_str());
    896         _socket_set_errno(err);
    897         return -1;
    898     }
    899 
    900     const int fd = _fh_to_int(f.get());
    901     snprintf(f->name, sizeof(f->name), "%d(net-client:%s%d)", fd, type != SOCK_STREAM ? "udp:" : "",
    902              port);
    903     D("host '%s' port %d type %s => fd %d", host.c_str(), port, type != SOCK_STREAM ? "udp" : "tcp",
    904       fd);
    905     f.release();
    906     return fd;
    907 }
    908 
    909 int  adb_register_socket(SOCKET s) {
    910     FH f = _fh_alloc( &_fh_socket_class );
    911     f->fh_socket = s;
    912     return _fh_to_int(f);
    913 }
    914 
    915 #undef accept
    916 int  adb_socket_accept(int  serverfd, struct sockaddr*  addr, socklen_t  *addrlen)
    917 {
    918     FH   serverfh = _fh_from_int(serverfd, __func__);
    919 
    920     if ( !serverfh || serverfh->clazz != &_fh_socket_class ) {
    921         D("adb_socket_accept: invalid fd %d", serverfd);
    922         errno = EBADF;
    923         return -1;
    924     }
    925 
    926     unique_fh fh(_fh_alloc( &_fh_socket_class ));
    927     if (!fh) {
    928         PLOG(ERROR) << "adb_socket_accept: failed to allocate accepted socket "
    929                        "descriptor";
    930         return -1;
    931     }
    932 
    933     fh->fh_socket = accept( serverfh->fh_socket, addr, addrlen );
    934     if (fh->fh_socket == INVALID_SOCKET) {
    935         const DWORD err = WSAGetLastError();
    936         LOG(ERROR) << "adb_socket_accept: accept on fd " << serverfd <<
    937                       " failed: " + android::base::SystemErrorCodeToString(err);
    938         _socket_set_errno( err );
    939         return -1;
    940     }
    941 
    942     const int fd = _fh_to_int(fh.get());
    943     snprintf( fh->name, sizeof(fh->name), "%d(accept:%s)", fd, serverfh->name );
    944     D( "adb_socket_accept on fd %d returns fd %d", serverfd, fd );
    945     fh.release();
    946     return  fd;
    947 }
    948 
    949 
    950 int  adb_setsockopt( int  fd, int  level, int  optname, const void*  optval, socklen_t  optlen )
    951 {
    952     FH   fh = _fh_from_int(fd, __func__);
    953 
    954     if ( !fh || fh->clazz != &_fh_socket_class ) {
    955         D("adb_setsockopt: invalid fd %d", fd);
    956         errno = EBADF;
    957         return -1;
    958     }
    959 
    960     // TODO: Once we can assume Windows Vista or later, if the caller is trying
    961     // to set SOL_SOCKET, SO_SNDBUF/SO_RCVBUF, ignore it since the OS has
    962     // auto-tuning.
    963 
    964     int result = setsockopt( fh->fh_socket, level, optname,
    965                              reinterpret_cast<const char*>(optval), optlen );
    966     if ( result == SOCKET_ERROR ) {
    967         const DWORD err = WSAGetLastError();
    968         D("adb_setsockopt: setsockopt on fd %d level %d optname %d failed: %s\n",
    969           fd, level, optname, android::base::SystemErrorCodeToString(err).c_str());
    970         _socket_set_errno( err );
    971         result = -1;
    972     }
    973     return result;
    974 }
    975 
    976 int adb_getsockname(int fd, struct sockaddr* sockaddr, socklen_t* optlen) {
    977     FH fh = _fh_from_int(fd, __func__);
    978 
    979     if (!fh || fh->clazz != &_fh_socket_class) {
    980         D("adb_getsockname: invalid fd %d", fd);
    981         errno = EBADF;
    982         return -1;
    983     }
    984 
    985     int result = getsockname(fh->fh_socket, sockaddr, optlen);
    986     if (result == SOCKET_ERROR) {
    987         const DWORD err = WSAGetLastError();
    988         D("adb_getsockname: setsockopt on fd %d failed: %s\n", fd,
    989           android::base::SystemErrorCodeToString(err).c_str());
    990         _socket_set_errno(err);
    991         result = -1;
    992     }
    993     return result;
    994 }
    995 
    996 int adb_socket_get_local_port(int fd) {
    997     sockaddr_storage addr_storage;
    998     socklen_t addr_len = sizeof(addr_storage);
    999 
   1000     if (adb_getsockname(fd, reinterpret_cast<sockaddr*>(&addr_storage), &addr_len) < 0) {
   1001         D("adb_socket_get_local_port: adb_getsockname failed: %s", strerror(errno));
   1002         return -1;
   1003     }
   1004 
   1005     if (!(addr_storage.ss_family == AF_INET || addr_storage.ss_family == AF_INET6)) {
   1006         D("adb_socket_get_local_port: unknown address family received: %d", addr_storage.ss_family);
   1007         errno = ECONNABORTED;
   1008         return -1;
   1009     }
   1010 
   1011     return ntohs(reinterpret_cast<sockaddr_in*>(&addr_storage)->sin_port);
   1012 }
   1013 
   1014 int adb_shutdown(int fd, int direction) {
   1015     FH f = _fh_from_int(fd, __func__);
   1016 
   1017     if (!f || f->clazz != &_fh_socket_class) {
   1018         D("adb_shutdown: invalid fd %d", fd);
   1019         errno = EBADF;
   1020         return -1;
   1021     }
   1022 
   1023     D("adb_shutdown: %s", f->name);
   1024     if (shutdown(f->fh_socket, direction) == SOCKET_ERROR) {
   1025         const DWORD err = WSAGetLastError();
   1026         D("socket shutdown fd %d failed: %s", fd,
   1027           android::base::SystemErrorCodeToString(err).c_str());
   1028         _socket_set_errno(err);
   1029         return -1;
   1030     }
   1031     return 0;
   1032 }
   1033 
   1034 // Emulate socketpair(2) by binding and connecting to a socket.
   1035 int adb_socketpair(int sv[2]) {
   1036     int server = -1;
   1037     int client = -1;
   1038     int accepted = -1;
   1039     int local_port = -1;
   1040     std::string error;
   1041 
   1042     server = network_loopback_server(0, SOCK_STREAM, &error);
   1043     if (server < 0) {
   1044         D("adb_socketpair: failed to create server: %s", error.c_str());
   1045         goto fail;
   1046     }
   1047 
   1048     local_port = adb_socket_get_local_port(server);
   1049     if (local_port < 0) {
   1050         D("adb_socketpair: failed to get server port number: %s", error.c_str());
   1051         goto fail;
   1052     }
   1053     D("adb_socketpair: bound on port %d", local_port);
   1054 
   1055     client = network_loopback_client(local_port, SOCK_STREAM, &error);
   1056     if (client < 0) {
   1057         D("adb_socketpair: failed to connect client: %s", error.c_str());
   1058         goto fail;
   1059     }
   1060 
   1061     accepted = adb_socket_accept(server, nullptr, nullptr);
   1062     if (accepted < 0) {
   1063         D("adb_socketpair: failed to accept: %s", strerror(errno));
   1064         goto fail;
   1065     }
   1066     adb_close(server);
   1067     sv[0] = client;
   1068     sv[1] = accepted;
   1069     return 0;
   1070 
   1071 fail:
   1072     if (server >= 0) {
   1073         adb_close(server);
   1074     }
   1075     if (client >= 0) {
   1076         adb_close(client);
   1077     }
   1078     if (accepted >= 0) {
   1079         adb_close(accepted);
   1080     }
   1081     return -1;
   1082 }
   1083 
   1084 bool set_file_block_mode(int fd, bool block) {
   1085     FH fh = _fh_from_int(fd, __func__);
   1086 
   1087     if (!fh || !fh->used) {
   1088         errno = EBADF;
   1089         D("Setting nonblocking on bad file descriptor %d", fd);
   1090         return false;
   1091     }
   1092 
   1093     if (fh->clazz == &_fh_socket_class) {
   1094         u_long x = !block;
   1095         if (ioctlsocket(fh->u.socket, FIONBIO, &x) != 0) {
   1096             int error = WSAGetLastError();
   1097             _socket_set_errno(error);
   1098             D("Setting %d nonblocking failed (%d)", fd, error);
   1099             return false;
   1100         }
   1101         return true;
   1102     } else {
   1103         errno = ENOTSOCK;
   1104         D("Setting nonblocking on non-socket %d", fd);
   1105         return false;
   1106     }
   1107 }
   1108 
   1109 bool set_tcp_keepalive(int fd, int interval_sec) {
   1110     FH fh = _fh_from_int(fd, __func__);
   1111 
   1112     if (!fh || fh->clazz != &_fh_socket_class) {
   1113         D("set_tcp_keepalive(%d) failed: invalid fd", fd);
   1114         errno = EBADF;
   1115         return false;
   1116     }
   1117 
   1118     tcp_keepalive keepalive;
   1119     keepalive.onoff = (interval_sec > 0);
   1120     keepalive.keepalivetime = interval_sec * 1000;
   1121     keepalive.keepaliveinterval = interval_sec * 1000;
   1122 
   1123     DWORD bytes_returned = 0;
   1124     if (WSAIoctl(fh->fh_socket, SIO_KEEPALIVE_VALS, &keepalive, sizeof(keepalive), nullptr, 0,
   1125                  &bytes_returned, nullptr, nullptr) != 0) {
   1126         const DWORD err = WSAGetLastError();
   1127         D("set_tcp_keepalive(%d) failed: %s", fd,
   1128           android::base::SystemErrorCodeToString(err).c_str());
   1129         _socket_set_errno(err);
   1130         return false;
   1131     }
   1132 
   1133     return true;
   1134 }
   1135 
   1136 /**************************************************************************/
   1137 /**************************************************************************/
   1138 /*****                                                                *****/
   1139 /*****      Console Window Terminal Emulation                         *****/
   1140 /*****                                                                *****/
   1141 /**************************************************************************/
   1142 /**************************************************************************/
   1143 
   1144 // This reads input from a Win32 console window and translates it into Unix
   1145 // terminal-style sequences. This emulates mostly Gnome Terminal (in Normal
   1146 // mode, not Application mode), which itself emulates xterm. Gnome Terminal
   1147 // is emulated instead of xterm because it is probably more popular than xterm:
   1148 // Ubuntu's default Ctrl-Alt-T shortcut opens Gnome Terminal, Gnome Terminal
   1149 // supports modern fonts, etc. It seems best to emulate the terminal that most
   1150 // Android developers use because they'll fix apps (the shell, etc.) to keep
   1151 // working with that terminal's emulation.
   1152 //
   1153 // The point of this emulation is not to be perfect or to solve all issues with
   1154 // console windows on Windows, but to be better than the original code which
   1155 // just called read() (which called ReadFile(), which called ReadConsoleA())
   1156 // which did not support Ctrl-C, tab completion, shell input line editing
   1157 // keys, server echo, and more.
   1158 //
   1159 // This implementation reconfigures the console with SetConsoleMode(), then
   1160 // calls ReadConsoleInput() to get raw input which it remaps to Unix
   1161 // terminal-style sequences which is returned via unix_read() which is used
   1162 // by the 'adb shell' command.
   1163 //
   1164 // Code organization:
   1165 //
   1166 // * _get_console_handle() and unix_isatty() provide console information.
   1167 // * stdin_raw_init() and stdin_raw_restore() reconfigure the console.
   1168 // * unix_read() detects console windows (as opposed to pipes, files, etc.).
   1169 // * _console_read() is the main code of the emulation.
   1170 
   1171 // Returns a console HANDLE if |fd| is a console, otherwise returns nullptr.
   1172 // If a valid HANDLE is returned and |mode| is not null, |mode| is also filled
   1173 // with the console mode. Requires GENERIC_READ access to the underlying HANDLE.
   1174 static HANDLE _get_console_handle(int fd, DWORD* mode=nullptr) {
   1175     // First check isatty(); this is very fast and eliminates most non-console
   1176     // FDs, but returns 1 for both consoles and character devices like NUL.
   1177 #pragma push_macro("isatty")
   1178 #undef isatty
   1179     if (!isatty(fd)) {
   1180         return nullptr;
   1181     }
   1182 #pragma pop_macro("isatty")
   1183 
   1184     // To differentiate between character devices and consoles we need to get
   1185     // the underlying HANDLE and use GetConsoleMode(), which is what requires
   1186     // GENERIC_READ permissions.
   1187     const intptr_t intptr_handle = _get_osfhandle(fd);
   1188     if (intptr_handle == -1) {
   1189         return nullptr;
   1190     }
   1191     const HANDLE handle = reinterpret_cast<const HANDLE>(intptr_handle);
   1192     DWORD temp_mode = 0;
   1193     if (!GetConsoleMode(handle, mode ? mode : &temp_mode)) {
   1194         return nullptr;
   1195     }
   1196 
   1197     return handle;
   1198 }
   1199 
   1200 // Returns a console handle if |stream| is a console, otherwise returns nullptr.
   1201 static HANDLE _get_console_handle(FILE* const stream) {
   1202     // Save and restore errno to make it easier for callers to prevent from overwriting errno.
   1203     android::base::ErrnoRestorer er;
   1204     const int fd = fileno(stream);
   1205     if (fd < 0) {
   1206         return nullptr;
   1207     }
   1208     return _get_console_handle(fd);
   1209 }
   1210 
   1211 int unix_isatty(int fd) {
   1212     return _get_console_handle(fd) ? 1 : 0;
   1213 }
   1214 
   1215 // Get the next KEY_EVENT_RECORD that should be processed.
   1216 static bool _get_key_event_record(const HANDLE console, INPUT_RECORD* const input_record) {
   1217     for (;;) {
   1218         DWORD read_count = 0;
   1219         memset(input_record, 0, sizeof(*input_record));
   1220         if (!ReadConsoleInputA(console, input_record, 1, &read_count)) {
   1221             D("_get_key_event_record: ReadConsoleInputA() failed: %s\n",
   1222               android::base::SystemErrorCodeToString(GetLastError()).c_str());
   1223             errno = EIO;
   1224             return false;
   1225         }
   1226 
   1227         if (read_count == 0) {   // should be impossible
   1228             fatal("ReadConsoleInputA returned 0");
   1229         }
   1230 
   1231         if (read_count != 1) {   // should be impossible
   1232             fatal("ReadConsoleInputA did not return one input record");
   1233         }
   1234 
   1235         // If the console window is resized, emulate SIGWINCH by breaking out
   1236         // of read() with errno == EINTR. Note that there is no event on
   1237         // vertical resize because we don't give the console our own custom
   1238         // screen buffer (with CreateConsoleScreenBuffer() +
   1239         // SetConsoleActiveScreenBuffer()). Instead, we use the default which
   1240         // supports scrollback, but doesn't seem to raise an event for vertical
   1241         // window resize.
   1242         if (input_record->EventType == WINDOW_BUFFER_SIZE_EVENT) {
   1243             errno = EINTR;
   1244             return false;
   1245         }
   1246 
   1247         if ((input_record->EventType == KEY_EVENT) &&
   1248             (input_record->Event.KeyEvent.bKeyDown)) {
   1249             if (input_record->Event.KeyEvent.wRepeatCount == 0) {
   1250                 fatal("ReadConsoleInputA returned a key event with zero repeat"
   1251                       " count");
   1252             }
   1253 
   1254             // Got an interesting INPUT_RECORD, so return
   1255             return true;
   1256         }
   1257     }
   1258 }
   1259 
   1260 static __inline__ bool _is_shift_pressed(const DWORD control_key_state) {
   1261     return (control_key_state & SHIFT_PRESSED) != 0;
   1262 }
   1263 
   1264 static __inline__ bool _is_ctrl_pressed(const DWORD control_key_state) {
   1265     return (control_key_state & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)) != 0;
   1266 }
   1267 
   1268 static __inline__ bool _is_alt_pressed(const DWORD control_key_state) {
   1269     return (control_key_state & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED)) != 0;
   1270 }
   1271 
   1272 static __inline__ bool _is_numlock_on(const DWORD control_key_state) {
   1273     return (control_key_state & NUMLOCK_ON) != 0;
   1274 }
   1275 
   1276 static __inline__ bool _is_capslock_on(const DWORD control_key_state) {
   1277     return (control_key_state & CAPSLOCK_ON) != 0;
   1278 }
   1279 
   1280 static __inline__ bool _is_enhanced_key(const DWORD control_key_state) {
   1281     return (control_key_state & ENHANCED_KEY) != 0;
   1282 }
   1283 
   1284 // Constants from MSDN for ToAscii().
   1285 static const BYTE TOASCII_KEY_OFF = 0x00;
   1286 static const BYTE TOASCII_KEY_DOWN = 0x80;
   1287 static const BYTE TOASCII_KEY_TOGGLED_ON = 0x01;   // for CapsLock
   1288 
   1289 // Given a key event, ignore a modifier key and return the character that was
   1290 // entered without the modifier. Writes to *ch and returns the number of bytes
   1291 // written.
   1292 static size_t _get_char_ignoring_modifier(char* const ch,
   1293     const KEY_EVENT_RECORD* const key_event, const DWORD control_key_state,
   1294     const WORD modifier) {
   1295     // If there is no character from Windows, try ignoring the specified
   1296     // modifier and look for a character. Note that if AltGr is being used,
   1297     // there will be a character from Windows.
   1298     if (key_event->uChar.AsciiChar == '\0') {
   1299         // Note that we read the control key state from the passed in argument
   1300         // instead of from key_event since the argument has been normalized.
   1301         if (((modifier == VK_SHIFT)   &&
   1302             _is_shift_pressed(control_key_state)) ||
   1303             ((modifier == VK_CONTROL) &&
   1304             _is_ctrl_pressed(control_key_state)) ||
   1305             ((modifier == VK_MENU)    && _is_alt_pressed(control_key_state))) {
   1306 
   1307             BYTE key_state[256]   = {0};
   1308             key_state[VK_SHIFT]   = _is_shift_pressed(control_key_state) ?
   1309                 TOASCII_KEY_DOWN : TOASCII_KEY_OFF;
   1310             key_state[VK_CONTROL] = _is_ctrl_pressed(control_key_state)  ?
   1311                 TOASCII_KEY_DOWN : TOASCII_KEY_OFF;
   1312             key_state[VK_MENU]    = _is_alt_pressed(control_key_state)   ?
   1313                 TOASCII_KEY_DOWN : TOASCII_KEY_OFF;
   1314             key_state[VK_CAPITAL] = _is_capslock_on(control_key_state)   ?
   1315                 TOASCII_KEY_TOGGLED_ON : TOASCII_KEY_OFF;
   1316 
   1317             // cause this modifier to be ignored
   1318             key_state[modifier]   = TOASCII_KEY_OFF;
   1319 
   1320             WORD translated = 0;
   1321             if (ToAscii(key_event->wVirtualKeyCode,
   1322                 key_event->wVirtualScanCode, key_state, &translated, 0) == 1) {
   1323                 // Ignoring the modifier, we found a character.
   1324                 *ch = (CHAR)translated;
   1325                 return 1;
   1326             }
   1327         }
   1328     }
   1329 
   1330     // Just use whatever Windows told us originally.
   1331     *ch = key_event->uChar.AsciiChar;
   1332 
   1333     // If the character from Windows is NULL, return a size of zero.
   1334     return (*ch == '\0') ? 0 : 1;
   1335 }
   1336 
   1337 // If a Ctrl key is pressed, lookup the character, ignoring the Ctrl key,
   1338 // but taking into account the shift key. This is because for a sequence like
   1339 // Ctrl-Alt-0, we want to find the character '0' and for Ctrl-Alt-Shift-0,
   1340 // we want to find the character ')'.
   1341 //
   1342 // Note that Windows doesn't seem to pass bKeyDown for Ctrl-Shift-NoAlt-0
   1343 // because it is the default key-sequence to switch the input language.
   1344 // This is configurable in the Region and Language control panel.
   1345 static __inline__ size_t _get_non_control_char(char* const ch,
   1346     const KEY_EVENT_RECORD* const key_event, const DWORD control_key_state) {
   1347     return _get_char_ignoring_modifier(ch, key_event, control_key_state,
   1348         VK_CONTROL);
   1349 }
   1350 
   1351 // Get without Alt.
   1352 static __inline__ size_t _get_non_alt_char(char* const ch,
   1353     const KEY_EVENT_RECORD* const key_event, const DWORD control_key_state) {
   1354     return _get_char_ignoring_modifier(ch, key_event, control_key_state,
   1355         VK_MENU);
   1356 }
   1357 
   1358 // Ignore the control key, find the character from Windows, and apply any
   1359 // Control key mappings (for example, Ctrl-2 is a NULL character). Writes to
   1360 // *pch and returns number of bytes written.
   1361 static size_t _get_control_character(char* const pch,
   1362     const KEY_EVENT_RECORD* const key_event, const DWORD control_key_state) {
   1363     const size_t len = _get_non_control_char(pch, key_event,
   1364         control_key_state);
   1365 
   1366     if ((len == 1) && _is_ctrl_pressed(control_key_state)) {
   1367         char ch = *pch;
   1368         switch (ch) {
   1369         case '2':
   1370         case '@':
   1371         case '`':
   1372             ch = '\0';
   1373             break;
   1374         case '3':
   1375         case '[':
   1376         case '{':
   1377             ch = '\x1b';
   1378             break;
   1379         case '4':
   1380         case '\\':
   1381         case '|':
   1382             ch = '\x1c';
   1383             break;
   1384         case '5':
   1385         case ']':
   1386         case '}':
   1387             ch = '\x1d';
   1388             break;
   1389         case '6':
   1390         case '^':
   1391         case '~':
   1392             ch = '\x1e';
   1393             break;
   1394         case '7':
   1395         case '-':
   1396         case '_':
   1397             ch = '\x1f';
   1398             break;
   1399         case '8':
   1400             ch = '\x7f';
   1401             break;
   1402         case '/':
   1403             if (!_is_alt_pressed(control_key_state)) {
   1404                 ch = '\x1f';
   1405             }
   1406             break;
   1407         case '?':
   1408             if (!_is_alt_pressed(control_key_state)) {
   1409                 ch = '\x7f';
   1410             }
   1411             break;
   1412         }
   1413         *pch = ch;
   1414     }
   1415 
   1416     return len;
   1417 }
   1418 
   1419 static DWORD _normalize_altgr_control_key_state(
   1420     const KEY_EVENT_RECORD* const key_event) {
   1421     DWORD control_key_state = key_event->dwControlKeyState;
   1422 
   1423     // If we're in an AltGr situation where the AltGr key is down (depending on
   1424     // the keyboard layout, that might be the physical right alt key which
   1425     // produces a control_key_state where Right-Alt and Left-Ctrl are down) or
   1426     // AltGr-equivalent keys are down (any Ctrl key + any Alt key), and we have
   1427     // a character (which indicates that there was an AltGr mapping), then act
   1428     // as if alt and control are not really down for the purposes of modifiers.
   1429     // This makes it so that if the user with, say, a German keyboard layout
   1430     // presses AltGr-] (which we see as Right-Alt + Left-Ctrl + key), we just
   1431     // output the key and we don't see the Alt and Ctrl keys.
   1432     if (_is_ctrl_pressed(control_key_state) &&
   1433         _is_alt_pressed(control_key_state)
   1434         && (key_event->uChar.AsciiChar != '\0')) {
   1435         // Try to remove as few bits as possible to improve our chances of
   1436         // detecting combinations like Left-Alt + AltGr, Right-Ctrl + AltGr, or
   1437         // Left-Alt + Right-Ctrl + AltGr.
   1438         if ((control_key_state & RIGHT_ALT_PRESSED) != 0) {
   1439             // Remove Right-Alt.
   1440             control_key_state &= ~RIGHT_ALT_PRESSED;
   1441             // If uChar is set, a Ctrl key is pressed, and Right-Alt is
   1442             // pressed, Left-Ctrl is almost always set, except if the user
   1443             // presses Right-Ctrl, then AltGr (in that specific order) for
   1444             // whatever reason. At any rate, make sure the bit is not set.
   1445             control_key_state &= ~LEFT_CTRL_PRESSED;
   1446         } else if ((control_key_state & LEFT_ALT_PRESSED) != 0) {
   1447             // Remove Left-Alt.
   1448             control_key_state &= ~LEFT_ALT_PRESSED;
   1449             // Whichever Ctrl key is down, remove it from the state. We only
   1450             // remove one key, to improve our chances of detecting the
   1451             // corner-case of Left-Ctrl + Left-Alt + Right-Ctrl.
   1452             if ((control_key_state & LEFT_CTRL_PRESSED) != 0) {
   1453                 // Remove Left-Ctrl.
   1454                 control_key_state &= ~LEFT_CTRL_PRESSED;
   1455             } else if ((control_key_state & RIGHT_CTRL_PRESSED) != 0) {
   1456                 // Remove Right-Ctrl.
   1457                 control_key_state &= ~RIGHT_CTRL_PRESSED;
   1458             }
   1459         }
   1460 
   1461         // Note that this logic isn't 100% perfect because Windows doesn't
   1462         // allow us to detect all combinations because a physical AltGr key
   1463         // press shows up as two bits, plus some combinations are ambiguous
   1464         // about what is actually physically pressed.
   1465     }
   1466 
   1467     return control_key_state;
   1468 }
   1469 
   1470 // If NumLock is on and Shift is pressed, SHIFT_PRESSED is not set in
   1471 // dwControlKeyState for the following keypad keys: period, 0-9. If we detect
   1472 // this scenario, set the SHIFT_PRESSED bit so we can add modifiers
   1473 // appropriately.
   1474 static DWORD _normalize_keypad_control_key_state(const WORD vk,
   1475     const DWORD control_key_state) {
   1476     if (!_is_numlock_on(control_key_state)) {
   1477         return control_key_state;
   1478     }
   1479     if (!_is_enhanced_key(control_key_state)) {
   1480         switch (vk) {
   1481             case VK_INSERT: // 0
   1482             case VK_DELETE: // .
   1483             case VK_END:    // 1
   1484             case VK_DOWN:   // 2
   1485             case VK_NEXT:   // 3
   1486             case VK_LEFT:   // 4
   1487             case VK_CLEAR:  // 5
   1488             case VK_RIGHT:  // 6
   1489             case VK_HOME:   // 7
   1490             case VK_UP:     // 8
   1491             case VK_PRIOR:  // 9
   1492                 return control_key_state | SHIFT_PRESSED;
   1493         }
   1494     }
   1495 
   1496     return control_key_state;
   1497 }
   1498 
   1499 static const char* _get_keypad_sequence(const DWORD control_key_state,
   1500     const char* const normal, const char* const shifted) {
   1501     if (_is_shift_pressed(control_key_state)) {
   1502         // Shift is pressed and NumLock is off
   1503         return shifted;
   1504     } else {
   1505         // Shift is not pressed and NumLock is off, or,
   1506         // Shift is pressed and NumLock is on, in which case we want the
   1507         // NumLock and Shift to neutralize each other, thus, we want the normal
   1508         // sequence.
   1509         return normal;
   1510     }
   1511     // If Shift is not pressed and NumLock is on, a different virtual key code
   1512     // is returned by Windows, which can be taken care of by a different case
   1513     // statement in _console_read().
   1514 }
   1515 
   1516 // Write sequence to buf and return the number of bytes written.
   1517 static size_t _get_modifier_sequence(char* const buf, const WORD vk,
   1518     DWORD control_key_state, const char* const normal) {
   1519     // Copy the base sequence into buf.
   1520     const size_t len = strlen(normal);
   1521     memcpy(buf, normal, len);
   1522 
   1523     int code = 0;
   1524 
   1525     control_key_state = _normalize_keypad_control_key_state(vk,
   1526         control_key_state);
   1527 
   1528     if (_is_shift_pressed(control_key_state)) {
   1529         code |= 0x1;
   1530     }
   1531     if (_is_alt_pressed(control_key_state)) {   // any alt key pressed
   1532         code |= 0x2;
   1533     }
   1534     if (_is_ctrl_pressed(control_key_state)) {  // any control key pressed
   1535         code |= 0x4;
   1536     }
   1537     // If some modifier was held down, then we need to insert the modifier code
   1538     if (code != 0) {
   1539         if (len == 0) {
   1540             // Should be impossible because caller should pass a string of
   1541             // non-zero length.
   1542             return 0;
   1543         }
   1544         size_t index = len - 1;
   1545         const char lastChar = buf[index];
   1546         if (lastChar != '~') {
   1547             buf[index++] = '1';
   1548         }
   1549         buf[index++] = ';';         // modifier separator
   1550         // 2 = shift, 3 = alt, 4 = shift & alt, 5 = control,
   1551         // 6 = shift & control, 7 = alt & control, 8 = shift & alt & control
   1552         buf[index++] = '1' + code;
   1553         buf[index++] = lastChar;    // move ~ (or other last char) to the end
   1554         return index;
   1555     }
   1556     return len;
   1557 }
   1558 
   1559 // Write sequence to buf and return the number of bytes written.
   1560 static size_t _get_modifier_keypad_sequence(char* const buf, const WORD vk,
   1561     const DWORD control_key_state, const char* const normal,
   1562     const char shifted) {
   1563     if (_is_shift_pressed(control_key_state)) {
   1564         // Shift is pressed and NumLock is off
   1565         if (shifted != '\0') {
   1566             buf[0] = shifted;
   1567             return sizeof(buf[0]);
   1568         } else {
   1569             return 0;
   1570         }
   1571     } else {
   1572         // Shift is not pressed and NumLock is off, or,
   1573         // Shift is pressed and NumLock is on, in which case we want the
   1574         // NumLock and Shift to neutralize each other, thus, we want the normal
   1575         // sequence.
   1576         return _get_modifier_sequence(buf, vk, control_key_state, normal);
   1577     }
   1578     // If Shift is not pressed and NumLock is on, a different virtual key code
   1579     // is returned by Windows, which can be taken care of by a different case
   1580     // statement in _console_read().
   1581 }
   1582 
   1583 // The decimal key on the keypad produces a '.' for U.S. English and a ',' for
   1584 // Standard German. Figure this out at runtime so we know what to output for
   1585 // Shift-VK_DELETE.
   1586 static char _get_decimal_char() {
   1587     return (char)MapVirtualKeyA(VK_DECIMAL, MAPVK_VK_TO_CHAR);
   1588 }
   1589 
   1590 // Prefix the len bytes in buf with the escape character, and then return the
   1591 // new buffer length.
   1592 size_t _escape_prefix(char* const buf, const size_t len) {
   1593     // If nothing to prefix, don't do anything. We might be called with
   1594     // len == 0, if alt was held down with a dead key which produced nothing.
   1595     if (len == 0) {
   1596         return 0;
   1597     }
   1598 
   1599     memmove(&buf[1], buf, len);
   1600     buf[0] = '\x1b';
   1601     return len + 1;
   1602 }
   1603 
   1604 // Internal buffer to satisfy future _console_read() calls.
   1605 static auto& g_console_input_buffer = *new std::vector<char>();
   1606 
   1607 // Writes to buffer buf (of length len), returning number of bytes written or -1 on error. Never
   1608 // returns zero on console closure because Win32 consoles are never 'closed' (as far as I can tell).
   1609 static int _console_read(const HANDLE console, void* buf, size_t len) {
   1610     for (;;) {
   1611         // Read of zero bytes should not block waiting for something from the console.
   1612         if (len == 0) {
   1613             return 0;
   1614         }
   1615 
   1616         // Flush as much as possible from input buffer.
   1617         if (!g_console_input_buffer.empty()) {
   1618             const int bytes_read = std::min(len, g_console_input_buffer.size());
   1619             memcpy(buf, g_console_input_buffer.data(), bytes_read);
   1620             const auto begin = g_console_input_buffer.begin();
   1621             g_console_input_buffer.erase(begin, begin + bytes_read);
   1622             return bytes_read;
   1623         }
   1624 
   1625         // Read from the actual console. This may block until input.
   1626         INPUT_RECORD input_record;
   1627         if (!_get_key_event_record(console, &input_record)) {
   1628             return -1;
   1629         }
   1630 
   1631         KEY_EVENT_RECORD* const key_event = &input_record.Event.KeyEvent;
   1632         const WORD vk = key_event->wVirtualKeyCode;
   1633         const CHAR ch = key_event->uChar.AsciiChar;
   1634         const DWORD control_key_state = _normalize_altgr_control_key_state(
   1635             key_event);
   1636 
   1637         // The following emulation code should write the output sequence to
   1638         // either seqstr or to seqbuf and seqbuflen.
   1639         const char* seqstr = NULL;  // NULL terminated C-string
   1640         // Enough space for max sequence string below, plus modifiers and/or
   1641         // escape prefix.
   1642         char seqbuf[16];
   1643         size_t seqbuflen = 0;       // Space used in seqbuf.
   1644 
   1645 #define MATCH(vk, normal) \
   1646             case (vk): \
   1647             { \
   1648                 seqstr = (normal); \
   1649             } \
   1650             break;
   1651 
   1652         // Modifier keys should affect the output sequence.
   1653 #define MATCH_MODIFIER(vk, normal) \
   1654             case (vk): \
   1655             { \
   1656                 seqbuflen = _get_modifier_sequence(seqbuf, (vk), \
   1657                     control_key_state, (normal)); \
   1658             } \
   1659             break;
   1660 
   1661         // The shift key should affect the output sequence.
   1662 #define MATCH_KEYPAD(vk, normal, shifted) \
   1663             case (vk): \
   1664             { \
   1665                 seqstr = _get_keypad_sequence(control_key_state, (normal), \
   1666                     (shifted)); \
   1667             } \
   1668             break;
   1669 
   1670         // The shift key and other modifier keys should affect the output
   1671         // sequence.
   1672 #define MATCH_MODIFIER_KEYPAD(vk, normal, shifted) \
   1673             case (vk): \
   1674             { \
   1675                 seqbuflen = _get_modifier_keypad_sequence(seqbuf, (vk), \
   1676                     control_key_state, (normal), (shifted)); \
   1677             } \
   1678             break;
   1679 
   1680 #define ESC "\x1b"
   1681 #define CSI ESC "["
   1682 #define SS3 ESC "O"
   1683 
   1684         // Only support normal mode, not application mode.
   1685 
   1686         // Enhanced keys:
   1687         // * 6-pack: insert, delete, home, end, page up, page down
   1688         // * cursor keys: up, down, right, left
   1689         // * keypad: divide, enter
   1690         // * Undocumented: VK_PAUSE (Ctrl-NumLock), VK_SNAPSHOT,
   1691         //   VK_CANCEL (Ctrl-Pause/Break), VK_NUMLOCK
   1692         if (_is_enhanced_key(control_key_state)) {
   1693             switch (vk) {
   1694                 case VK_RETURN: // Enter key on keypad
   1695                     if (_is_ctrl_pressed(control_key_state)) {
   1696                         seqstr = "\n";
   1697                     } else {
   1698                         seqstr = "\r";
   1699                     }
   1700                     break;
   1701 
   1702                 MATCH_MODIFIER(VK_PRIOR, CSI "5~"); // Page Up
   1703                 MATCH_MODIFIER(VK_NEXT,  CSI "6~"); // Page Down
   1704 
   1705                 // gnome-terminal currently sends SS3 "F" and SS3 "H", but that
   1706                 // will be fixed soon to match xterm which sends CSI "F" and
   1707                 // CSI "H". https://bugzilla.redhat.com/show_bug.cgi?id=1119764
   1708                 MATCH(VK_END,  CSI "F");
   1709                 MATCH(VK_HOME, CSI "H");
   1710 
   1711                 MATCH_MODIFIER(VK_LEFT,  CSI "D");
   1712                 MATCH_MODIFIER(VK_UP,    CSI "A");
   1713                 MATCH_MODIFIER(VK_RIGHT, CSI "C");
   1714                 MATCH_MODIFIER(VK_DOWN,  CSI "B");
   1715 
   1716                 MATCH_MODIFIER(VK_INSERT, CSI "2~");
   1717                 MATCH_MODIFIER(VK_DELETE, CSI "3~");
   1718 
   1719                 MATCH(VK_DIVIDE, "/");
   1720             }
   1721         } else {    // Non-enhanced keys:
   1722             switch (vk) {
   1723                 case VK_BACK:   // backspace
   1724                     if (_is_alt_pressed(control_key_state)) {
   1725                         seqstr = ESC "\x7f";
   1726                     } else {
   1727                         seqstr = "\x7f";
   1728                     }
   1729                     break;
   1730 
   1731                 case VK_TAB:
   1732                     if (_is_shift_pressed(control_key_state)) {
   1733                         seqstr = CSI "Z";
   1734                     } else {
   1735                         seqstr = "\t";
   1736                     }
   1737                     break;
   1738 
   1739                 // Number 5 key in keypad when NumLock is off, or if NumLock is
   1740                 // on and Shift is down.
   1741                 MATCH_KEYPAD(VK_CLEAR, CSI "E", "5");
   1742 
   1743                 case VK_RETURN:     // Enter key on main keyboard
   1744                     if (_is_alt_pressed(control_key_state)) {
   1745                         seqstr = ESC "\n";
   1746                     } else if (_is_ctrl_pressed(control_key_state)) {
   1747                         seqstr = "\n";
   1748                     } else {
   1749                         seqstr = "\r";
   1750                     }
   1751                     break;
   1752 
   1753                 // VK_ESCAPE: Don't do any special handling. The OS uses many
   1754                 // of the sequences with Escape and many of the remaining
   1755                 // sequences don't produce bKeyDown messages, only !bKeyDown
   1756                 // for whatever reason.
   1757 
   1758                 case VK_SPACE:
   1759                     if (_is_alt_pressed(control_key_state)) {
   1760                         seqstr = ESC " ";
   1761                     } else if (_is_ctrl_pressed(control_key_state)) {
   1762                         seqbuf[0] = '\0';   // NULL char
   1763                         seqbuflen = 1;
   1764                     } else {
   1765                         seqstr = " ";
   1766                     }
   1767                     break;
   1768 
   1769                 MATCH_MODIFIER_KEYPAD(VK_PRIOR, CSI "5~", '9'); // Page Up
   1770                 MATCH_MODIFIER_KEYPAD(VK_NEXT,  CSI "6~", '3'); // Page Down
   1771 
   1772                 MATCH_KEYPAD(VK_END,  CSI "4~", "1");
   1773                 MATCH_KEYPAD(VK_HOME, CSI "1~", "7");
   1774 
   1775                 MATCH_MODIFIER_KEYPAD(VK_LEFT,  CSI "D", '4');
   1776                 MATCH_MODIFIER_KEYPAD(VK_UP,    CSI "A", '8');
   1777                 MATCH_MODIFIER_KEYPAD(VK_RIGHT, CSI "C", '6');
   1778                 MATCH_MODIFIER_KEYPAD(VK_DOWN,  CSI "B", '2');
   1779 
   1780                 MATCH_MODIFIER_KEYPAD(VK_INSERT, CSI "2~", '0');
   1781                 MATCH_MODIFIER_KEYPAD(VK_DELETE, CSI "3~",
   1782                     _get_decimal_char());
   1783 
   1784                 case 0x30:          // 0
   1785                 case 0x31:          // 1
   1786                 case 0x39:          // 9
   1787                 case VK_OEM_1:      // ;:
   1788                 case VK_OEM_PLUS:   // =+
   1789                 case VK_OEM_COMMA:  // ,<
   1790                 case VK_OEM_PERIOD: // .>
   1791                 case VK_OEM_7:      // '"
   1792                 case VK_OEM_102:    // depends on keyboard, could be <> or \|
   1793                 case VK_OEM_2:      // /?
   1794                 case VK_OEM_3:      // `~
   1795                 case VK_OEM_4:      // [{
   1796                 case VK_OEM_5:      // \|
   1797                 case VK_OEM_6:      // ]}
   1798                 {
   1799                     seqbuflen = _get_control_character(seqbuf, key_event,
   1800                         control_key_state);
   1801 
   1802                     if (_is_alt_pressed(control_key_state)) {
   1803                         seqbuflen = _escape_prefix(seqbuf, seqbuflen);
   1804                     }
   1805                 }
   1806                 break;
   1807 
   1808                 case 0x32:          // 2
   1809                 case 0x33:          // 3
   1810                 case 0x34:          // 4
   1811                 case 0x35:          // 5
   1812                 case 0x36:          // 6
   1813                 case 0x37:          // 7
   1814                 case 0x38:          // 8
   1815                 case VK_OEM_MINUS:  // -_
   1816                 {
   1817                     seqbuflen = _get_control_character(seqbuf, key_event,
   1818                         control_key_state);
   1819 
   1820                     // If Alt is pressed and it isn't Ctrl-Alt-ShiftUp, then
   1821                     // prefix with escape.
   1822                     if (_is_alt_pressed(control_key_state) &&
   1823                         !(_is_ctrl_pressed(control_key_state) &&
   1824                         !_is_shift_pressed(control_key_state))) {
   1825                         seqbuflen = _escape_prefix(seqbuf, seqbuflen);
   1826                     }
   1827                 }
   1828                 break;
   1829 
   1830                 case 0x41:  // a
   1831                 case 0x42:  // b
   1832                 case 0x43:  // c
   1833                 case 0x44:  // d
   1834                 case 0x45:  // e
   1835                 case 0x46:  // f
   1836                 case 0x47:  // g
   1837                 case 0x48:  // h
   1838                 case 0x49:  // i
   1839                 case 0x4a:  // j
   1840                 case 0x4b:  // k
   1841                 case 0x4c:  // l
   1842                 case 0x4d:  // m
   1843                 case 0x4e:  // n
   1844                 case 0x4f:  // o
   1845                 case 0x50:  // p
   1846                 case 0x51:  // q
   1847                 case 0x52:  // r
   1848                 case 0x53:  // s
   1849                 case 0x54:  // t
   1850                 case 0x55:  // u
   1851                 case 0x56:  // v
   1852                 case 0x57:  // w
   1853                 case 0x58:  // x
   1854                 case 0x59:  // y
   1855                 case 0x5a:  // z
   1856                 {
   1857                     seqbuflen = _get_non_alt_char(seqbuf, key_event,
   1858                         control_key_state);
   1859 
   1860                     // If Alt is pressed, then prefix with escape.
   1861                     if (_is_alt_pressed(control_key_state)) {
   1862                         seqbuflen = _escape_prefix(seqbuf, seqbuflen);
   1863                     }
   1864                 }
   1865                 break;
   1866 
   1867                 // These virtual key codes are generated by the keys on the
   1868                 // keypad *when NumLock is on* and *Shift is up*.
   1869                 MATCH(VK_NUMPAD0, "0");
   1870                 MATCH(VK_NUMPAD1, "1");
   1871                 MATCH(VK_NUMPAD2, "2");
   1872                 MATCH(VK_NUMPAD3, "3");
   1873                 MATCH(VK_NUMPAD4, "4");
   1874                 MATCH(VK_NUMPAD5, "5");
   1875                 MATCH(VK_NUMPAD6, "6");
   1876                 MATCH(VK_NUMPAD7, "7");
   1877                 MATCH(VK_NUMPAD8, "8");
   1878                 MATCH(VK_NUMPAD9, "9");
   1879 
   1880                 MATCH(VK_MULTIPLY, "*");
   1881                 MATCH(VK_ADD,      "+");
   1882                 MATCH(VK_SUBTRACT, "-");
   1883                 // VK_DECIMAL is generated by the . key on the keypad *when
   1884                 // NumLock is on* and *Shift is up* and the sequence is not
   1885                 // Ctrl-Alt-NoShift-. (which causes Ctrl-Alt-Del and the
   1886                 // Windows Security screen to come up).
   1887                 case VK_DECIMAL:
   1888                     // U.S. English uses '.', Germany German uses ','.
   1889                     seqbuflen = _get_non_control_char(seqbuf, key_event,
   1890                         control_key_state);
   1891                     break;
   1892 
   1893                 MATCH_MODIFIER(VK_F1,  SS3 "P");
   1894                 MATCH_MODIFIER(VK_F2,  SS3 "Q");
   1895                 MATCH_MODIFIER(VK_F3,  SS3 "R");
   1896                 MATCH_MODIFIER(VK_F4,  SS3 "S");
   1897                 MATCH_MODIFIER(VK_F5,  CSI "15~");
   1898                 MATCH_MODIFIER(VK_F6,  CSI "17~");
   1899                 MATCH_MODIFIER(VK_F7,  CSI "18~");
   1900                 MATCH_MODIFIER(VK_F8,  CSI "19~");
   1901                 MATCH_MODIFIER(VK_F9,  CSI "20~");
   1902                 MATCH_MODIFIER(VK_F10, CSI "21~");
   1903                 MATCH_MODIFIER(VK_F11, CSI "23~");
   1904                 MATCH_MODIFIER(VK_F12, CSI "24~");
   1905 
   1906                 MATCH_MODIFIER(VK_F13, CSI "25~");
   1907                 MATCH_MODIFIER(VK_F14, CSI "26~");
   1908                 MATCH_MODIFIER(VK_F15, CSI "28~");
   1909                 MATCH_MODIFIER(VK_F16, CSI "29~");
   1910                 MATCH_MODIFIER(VK_F17, CSI "31~");
   1911                 MATCH_MODIFIER(VK_F18, CSI "32~");
   1912                 MATCH_MODIFIER(VK_F19, CSI "33~");
   1913                 MATCH_MODIFIER(VK_F20, CSI "34~");
   1914 
   1915                 // MATCH_MODIFIER(VK_F21, ???);
   1916                 // MATCH_MODIFIER(VK_F22, ???);
   1917                 // MATCH_MODIFIER(VK_F23, ???);
   1918                 // MATCH_MODIFIER(VK_F24, ???);
   1919             }
   1920         }
   1921 
   1922 #undef MATCH
   1923 #undef MATCH_MODIFIER
   1924 #undef MATCH_KEYPAD
   1925 #undef MATCH_MODIFIER_KEYPAD
   1926 #undef ESC
   1927 #undef CSI
   1928 #undef SS3
   1929 
   1930         const char* out;
   1931         size_t outlen;
   1932 
   1933         // Check for output in any of:
   1934         // * seqstr is set (and strlen can be used to determine the length).
   1935         // * seqbuf and seqbuflen are set
   1936         // Fallback to ch from Windows.
   1937         if (seqstr != NULL) {
   1938             out = seqstr;
   1939             outlen = strlen(seqstr);
   1940         } else if (seqbuflen > 0) {
   1941             out = seqbuf;
   1942             outlen = seqbuflen;
   1943         } else if (ch != '\0') {
   1944             // Use whatever Windows told us it is.
   1945             seqbuf[0] = ch;
   1946             seqbuflen = 1;
   1947             out = seqbuf;
   1948             outlen = seqbuflen;
   1949         } else {
   1950             // No special handling for the virtual key code and Windows isn't
   1951             // telling us a character code, then we don't know how to translate
   1952             // the key press.
   1953             //
   1954             // Consume the input and 'continue' to cause us to get a new key
   1955             // event.
   1956             D("_console_read: unknown virtual key code: %d, enhanced: %s",
   1957                 vk, _is_enhanced_key(control_key_state) ? "true" : "false");
   1958             continue;
   1959         }
   1960 
   1961         // put output wRepeatCount times into g_console_input_buffer
   1962         while (key_event->wRepeatCount-- > 0) {
   1963             g_console_input_buffer.insert(g_console_input_buffer.end(), out, out + outlen);
   1964         }
   1965 
   1966         // Loop around and try to flush g_console_input_buffer
   1967     }
   1968 }
   1969 
   1970 static DWORD _old_console_mode; // previous GetConsoleMode() result
   1971 static HANDLE _console_handle;  // when set, console mode should be restored
   1972 
   1973 void stdin_raw_init() {
   1974     const HANDLE in = _get_console_handle(STDIN_FILENO, &_old_console_mode);
   1975     if (in == nullptr) {
   1976         return;
   1977     }
   1978 
   1979     // Disable ENABLE_PROCESSED_INPUT so that Ctrl-C is read instead of
   1980     // calling the process Ctrl-C routine (configured by
   1981     // SetConsoleCtrlHandler()).
   1982     // Disable ENABLE_LINE_INPUT so that input is immediately sent.
   1983     // Disable ENABLE_ECHO_INPUT to disable local echo. Disabling this
   1984     // flag also seems necessary to have proper line-ending processing.
   1985     DWORD new_console_mode = _old_console_mode & ~(ENABLE_PROCESSED_INPUT |
   1986                                                    ENABLE_LINE_INPUT |
   1987                                                    ENABLE_ECHO_INPUT);
   1988     // Enable ENABLE_WINDOW_INPUT to get window resizes.
   1989     new_console_mode |= ENABLE_WINDOW_INPUT;
   1990 
   1991     if (!SetConsoleMode(in, new_console_mode)) {
   1992         // This really should not fail.
   1993         D("stdin_raw_init: SetConsoleMode() failed: %s",
   1994           android::base::SystemErrorCodeToString(GetLastError()).c_str());
   1995     }
   1996 
   1997     // Once this is set, it means that stdin has been configured for
   1998     // reading from and that the old console mode should be restored later.
   1999     _console_handle = in;
   2000 
   2001     // Note that we don't need to configure C Runtime line-ending
   2002     // translation because _console_read() does not call the C Runtime to
   2003     // read from the console.
   2004 }
   2005 
   2006 void stdin_raw_restore() {
   2007     if (_console_handle != NULL) {
   2008         const HANDLE in = _console_handle;
   2009         _console_handle = NULL;  // clear state
   2010 
   2011         if (!SetConsoleMode(in, _old_console_mode)) {
   2012             // This really should not fail.
   2013             D("stdin_raw_restore: SetConsoleMode() failed: %s",
   2014               android::base::SystemErrorCodeToString(GetLastError()).c_str());
   2015         }
   2016     }
   2017 }
   2018 
   2019 // Called by 'adb shell' and 'adb exec-in' (via unix_read()) to read from stdin.
   2020 int unix_read_interruptible(int fd, void* buf, size_t len) {
   2021     if ((fd == STDIN_FILENO) && (_console_handle != NULL)) {
   2022         // If it is a request to read from stdin, and stdin_raw_init() has been
   2023         // called, and it successfully configured the console, then read from
   2024         // the console using Win32 console APIs and partially emulate a unix
   2025         // terminal.
   2026         return _console_read(_console_handle, buf, len);
   2027     } else {
   2028         // On older versions of Windows (definitely 7, definitely not 10),
   2029         // ReadConsole() with a size >= 31367 fails, so if |fd| is a console
   2030         // we need to limit the read size.
   2031         if (len > 4096 && unix_isatty(fd)) {
   2032             len = 4096;
   2033         }
   2034         // Just call into C Runtime which can read from pipes/files and which
   2035         // can do LF/CR translation (which is overridable with _setmode()).
   2036         // Undefine the macro that is set in sysdeps.h which bans calls to
   2037         // plain read() in favor of unix_read() or adb_read().
   2038 #pragma push_macro("read")
   2039 #undef read
   2040         return read(fd, buf, len);
   2041 #pragma pop_macro("read")
   2042     }
   2043 }
   2044 
   2045 /**************************************************************************/
   2046 /**************************************************************************/
   2047 /*****                                                                *****/
   2048 /*****      Unicode support                                           *****/
   2049 /*****                                                                *****/
   2050 /**************************************************************************/
   2051 /**************************************************************************/
   2052 
   2053 // This implements support for using files with Unicode filenames and for
   2054 // outputting Unicode text to a Win32 console window. This is inspired from
   2055 // http://utf8everywhere.org/.
   2056 //
   2057 // Background
   2058 // ----------
   2059 //
   2060 // On POSIX systems, to deal with files with Unicode filenames, just pass UTF-8
   2061 // filenames to APIs such as open(). This works because filenames are largely
   2062 // opaque 'cookies' (perhaps excluding path separators).
   2063 //
   2064 // On Windows, the native file APIs such as CreateFileW() take 2-byte wchar_t
   2065 // UTF-16 strings. There is an API, CreateFileA() that takes 1-byte char
   2066 // strings, but the strings are in the ANSI codepage and not UTF-8. (The
   2067 // CreateFile() API is really just a macro that adds the W/A based on whether
   2068 // the UNICODE preprocessor symbol is defined).
   2069 //
   2070 // Options
   2071 // -------
   2072 //
   2073 // Thus, to write a portable program, there are a few options:
   2074 //
   2075 // 1. Write the program with wchar_t filenames (wchar_t path[256];).
   2076 //    For Windows, just call CreateFileW(). For POSIX, write a wrapper openW()
   2077 //    that takes a wchar_t string, converts it to UTF-8 and then calls the real
   2078 //    open() API.
   2079 //
   2080 // 2. Write the program with a TCHAR typedef that is 2 bytes on Windows and
   2081 //    1 byte on POSIX. Make T-* wrappers for various OS APIs and call those,
   2082 //    potentially touching a lot of code.
   2083 //
   2084 // 3. Write the program with a 1-byte char filenames (char path[256];) that are
   2085 //    UTF-8. For POSIX, just call open(). For Windows, write a wrapper that
   2086 //    takes a UTF-8 string, converts it to UTF-16 and then calls the real OS
   2087 //    or C Runtime API.
   2088 //
   2089 // The Choice
   2090 // ----------
   2091 //
   2092 // The code below chooses option 3, the UTF-8 everywhere strategy. It uses
   2093 // android::base::WideToUTF8() which converts UTF-16 to UTF-8. This is used by the
   2094 // NarrowArgs helper class that is used to convert wmain() args into UTF-8
   2095 // args that are passed to main() at the beginning of program startup. We also use
   2096 // android::base::UTF8ToWide() which converts from UTF-8 to UTF-16. This is used to
   2097 // implement wrappers below that call UTF-16 OS and C Runtime APIs.
   2098 //
   2099 // Unicode console output
   2100 // ----------------------
   2101 //
   2102 // The way to output Unicode to a Win32 console window is to call
   2103 // WriteConsoleW() with UTF-16 text. (The user must also choose a proper font
   2104 // such as Lucida Console or Consolas, and in the case of East Asian languages
   2105 // (such as Chinese, Japanese, Korean), the user must go to the Control Panel
   2106 // and change the "system locale" to Chinese, etc., which allows a Chinese, etc.
   2107 // font to be used in console windows.)
   2108 //
   2109 // The problem is getting the C Runtime to make fprintf and related APIs call
   2110 // WriteConsoleW() under the covers. The C Runtime API, _setmode() sounds
   2111 // promising, but the various modes have issues:
   2112 //
   2113 // 1. _setmode(_O_TEXT) (the default) does not use WriteConsoleW() so UTF-8 and
   2114 //    UTF-16 do not display properly.
   2115 // 2. _setmode(_O_BINARY) does not use WriteConsoleW() and the text comes out
   2116 //    totally wrong.
   2117 // 3. _setmode(_O_U8TEXT) seems to cause the C Runtime _invalid_parameter
   2118 //    handler to be called (upon a later I/O call), aborting the process.
   2119 // 4. _setmode(_O_U16TEXT) and _setmode(_O_WTEXT) cause non-wide printf/fprintf
   2120 //    to output nothing.
   2121 //
   2122 // So the only solution is to write our own adb_fprintf() that converts UTF-8
   2123 // to UTF-16 and then calls WriteConsoleW().
   2124 
   2125 
   2126 // Constructor for helper class to convert wmain() UTF-16 args to UTF-8 to
   2127 // be passed to main().
   2128 NarrowArgs::NarrowArgs(const int argc, wchar_t** const argv) {
   2129     narrow_args = new char*[argc + 1];
   2130 
   2131     for (int i = 0; i < argc; ++i) {
   2132         std::string arg_narrow;
   2133         if (!android::base::WideToUTF8(argv[i], &arg_narrow)) {
   2134             fatal_errno("cannot convert argument from UTF-16 to UTF-8");
   2135         }
   2136         narrow_args[i] = strdup(arg_narrow.c_str());
   2137     }
   2138     narrow_args[argc] = nullptr;   // terminate
   2139 }
   2140 
   2141 NarrowArgs::~NarrowArgs() {
   2142     if (narrow_args != nullptr) {
   2143         for (char** argp = narrow_args; *argp != nullptr; ++argp) {
   2144             free(*argp);
   2145         }
   2146         delete[] narrow_args;
   2147         narrow_args = nullptr;
   2148     }
   2149 }
   2150 
   2151 int unix_open(const char* path, int options, ...) {
   2152     std::wstring path_wide;
   2153     if (!android::base::UTF8ToWide(path, &path_wide)) {
   2154         return -1;
   2155     }
   2156     if ((options & O_CREAT) == 0) {
   2157         return _wopen(path_wide.c_str(), options);
   2158     } else {
   2159         int      mode;
   2160         va_list  args;
   2161         va_start(args, options);
   2162         mode = va_arg(args, int);
   2163         va_end(args);
   2164         return _wopen(path_wide.c_str(), options, mode);
   2165     }
   2166 }
   2167 
   2168 // Version of opendir() that takes a UTF-8 path.
   2169 DIR* adb_opendir(const char* path) {
   2170     std::wstring path_wide;
   2171     if (!android::base::UTF8ToWide(path, &path_wide)) {
   2172         return nullptr;
   2173     }
   2174 
   2175     // Just cast _WDIR* to DIR*. This doesn't work if the caller reads any of
   2176     // the fields, but right now all the callers treat the structure as
   2177     // opaque.
   2178     return reinterpret_cast<DIR*>(_wopendir(path_wide.c_str()));
   2179 }
   2180 
   2181 // Version of readdir() that returns UTF-8 paths.
   2182 struct dirent* adb_readdir(DIR* dir) {
   2183     _WDIR* const wdir = reinterpret_cast<_WDIR*>(dir);
   2184     struct _wdirent* const went = _wreaddir(wdir);
   2185     if (went == nullptr) {
   2186         return nullptr;
   2187     }
   2188 
   2189     // Convert from UTF-16 to UTF-8.
   2190     std::string name_utf8;
   2191     if (!android::base::WideToUTF8(went->d_name, &name_utf8)) {
   2192         return nullptr;
   2193     }
   2194 
   2195     // Cast the _wdirent* to dirent* and overwrite the d_name field (which has
   2196     // space for UTF-16 wchar_t's) with UTF-8 char's.
   2197     struct dirent* ent = reinterpret_cast<struct dirent*>(went);
   2198 
   2199     if (name_utf8.length() + 1 > sizeof(went->d_name)) {
   2200         // Name too big to fit in existing buffer.
   2201         errno = ENOMEM;
   2202         return nullptr;
   2203     }
   2204 
   2205     // Note that sizeof(_wdirent::d_name) is bigger than sizeof(dirent::d_name)
   2206     // because _wdirent contains wchar_t instead of char. So even if name_utf8
   2207     // can fit in _wdirent::d_name, the resulting dirent::d_name field may be
   2208     // bigger than the caller expects because they expect a dirent structure
   2209     // which has a smaller d_name field. Ignore this since the caller should be
   2210     // resilient.
   2211 
   2212     // Rewrite the UTF-16 d_name field to UTF-8.
   2213     strcpy(ent->d_name, name_utf8.c_str());
   2214 
   2215     return ent;
   2216 }
   2217 
   2218 // Version of closedir() to go with our version of adb_opendir().
   2219 int adb_closedir(DIR* dir) {
   2220     return _wclosedir(reinterpret_cast<_WDIR*>(dir));
   2221 }
   2222 
   2223 // Version of unlink() that takes a UTF-8 path.
   2224 int adb_unlink(const char* path) {
   2225     std::wstring wpath;
   2226     if (!android::base::UTF8ToWide(path, &wpath)) {
   2227         return -1;
   2228     }
   2229 
   2230     int  rc = _wunlink(wpath.c_str());
   2231 
   2232     if (rc == -1 && errno == EACCES) {
   2233         /* unlink returns EACCES when the file is read-only, so we first */
   2234         /* try to make it writable, then unlink again...                 */
   2235         rc = _wchmod(wpath.c_str(), _S_IREAD | _S_IWRITE);
   2236         if (rc == 0)
   2237             rc = _wunlink(wpath.c_str());
   2238     }
   2239     return rc;
   2240 }
   2241 
   2242 // Version of mkdir() that takes a UTF-8 path.
   2243 int adb_mkdir(const std::string& path, int mode) {
   2244     std::wstring path_wide;
   2245     if (!android::base::UTF8ToWide(path, &path_wide)) {
   2246         return -1;
   2247     }
   2248 
   2249     return _wmkdir(path_wide.c_str());
   2250 }
   2251 
   2252 // Version of utime() that takes a UTF-8 path.
   2253 int adb_utime(const char* path, struct utimbuf* u) {
   2254     std::wstring path_wide;
   2255     if (!android::base::UTF8ToWide(path, &path_wide)) {
   2256         return -1;
   2257     }
   2258 
   2259     static_assert(sizeof(struct utimbuf) == sizeof(struct _utimbuf),
   2260         "utimbuf and _utimbuf should be the same size because they both "
   2261         "contain the same types, namely time_t");
   2262     return _wutime(path_wide.c_str(), reinterpret_cast<struct _utimbuf*>(u));
   2263 }
   2264 
   2265 // Version of chmod() that takes a UTF-8 path.
   2266 int adb_chmod(const char* path, int mode) {
   2267     std::wstring path_wide;
   2268     if (!android::base::UTF8ToWide(path, &path_wide)) {
   2269         return -1;
   2270     }
   2271 
   2272     return _wchmod(path_wide.c_str(), mode);
   2273 }
   2274 
   2275 // From libutils/Unicode.cpp, get the length of a UTF-8 sequence given the lead byte.
   2276 static inline size_t utf8_codepoint_len(uint8_t ch) {
   2277     return ((0xe5000000 >> ((ch >> 3) & 0x1e)) & 3) + 1;
   2278 }
   2279 
   2280 namespace internal {
   2281 
   2282 // Given a sequence of UTF-8 bytes (denoted by the range [first, last)), return the number of bytes
   2283 // (from the beginning) that are complete UTF-8 sequences and append the remaining bytes to
   2284 // remaining_bytes.
   2285 size_t ParseCompleteUTF8(const char* const first, const char* const last,
   2286                          std::vector<char>* const remaining_bytes) {
   2287     // Walk backwards from the end of the sequence looking for the beginning of a UTF-8 sequence.
   2288     // Current_after points one byte past the current byte to be examined.
   2289     for (const char* current_after = last; current_after != first; --current_after) {
   2290         const char* const current = current_after - 1;
   2291         const char ch = *current;
   2292         const char kHighBit = 0x80u;
   2293         const char kTwoHighestBits = 0xC0u;
   2294         if ((ch & kHighBit) == 0) { // high bit not set
   2295             // The buffer ends with a one-byte UTF-8 sequence, possibly followed by invalid trailing
   2296             // bytes with no leading byte, so return the entire buffer.
   2297             break;
   2298         } else if ((ch & kTwoHighestBits) == kTwoHighestBits) { // top two highest bits set
   2299             // Lead byte in UTF-8 sequence, so check if we have all the bytes in the sequence.
   2300             const size_t bytes_available = last - current;
   2301             if (bytes_available < utf8_codepoint_len(ch)) {
   2302                 // We don't have all the bytes in the UTF-8 sequence, so return all the bytes
   2303                 // preceding the current incomplete UTF-8 sequence and append the remaining bytes
   2304                 // to remaining_bytes.
   2305                 remaining_bytes->insert(remaining_bytes->end(), current, last);
   2306                 return current - first;
   2307             } else {
   2308                 // The buffer ends with a complete UTF-8 sequence, possibly followed by invalid
   2309                 // trailing bytes with no lead byte, so return the entire buffer.
   2310                 break;
   2311             }
   2312         } else {
   2313             // Trailing byte, so keep going backwards looking for the lead byte.
   2314         }
   2315     }
   2316 
   2317     // Return the size of the entire buffer. It is possible that we walked backward past invalid
   2318     // trailing bytes with no lead byte, in which case we want to return all those invalid bytes
   2319     // so that they can be processed.
   2320     return last - first;
   2321 }
   2322 
   2323 }
   2324 
   2325 // Bytes that have not yet been output to the console because they are incomplete UTF-8 sequences.
   2326 // Note that we use only one buffer even though stderr and stdout are logically separate streams.
   2327 // This matches the behavior of Linux.
   2328 
   2329 // Internal helper function to write UTF-8 bytes to a console. Returns -1 on error.
   2330 static int _console_write_utf8(const char* const buf, const size_t buf_size, FILE* stream,
   2331                                HANDLE console) {
   2332     static std::mutex& console_output_buffer_lock = *new std::mutex();
   2333     static auto& console_output_buffer = *new std::vector<char>();
   2334 
   2335     const int saved_errno = errno;
   2336     std::vector<char> combined_buffer;
   2337 
   2338     // Complete UTF-8 sequences that should be immediately written to the console.
   2339     const char* utf8;
   2340     size_t utf8_size;
   2341 
   2342     {
   2343         std::lock_guard<std::mutex> lock(console_output_buffer_lock);
   2344         if (console_output_buffer.empty()) {
   2345             // If console_output_buffer doesn't have a buffered up incomplete UTF-8 sequence (the
   2346             // common case with plain ASCII), parse buf directly.
   2347             utf8 = buf;
   2348             utf8_size = internal::ParseCompleteUTF8(buf, buf + buf_size, &console_output_buffer);
   2349         } else {
   2350             // If console_output_buffer has a buffered up incomplete UTF-8 sequence, move it to
   2351             // combined_buffer (and effectively clear console_output_buffer) and append buf to
   2352             // combined_buffer, then parse it all together.
   2353             combined_buffer.swap(console_output_buffer);
   2354             combined_buffer.insert(combined_buffer.end(), buf, buf + buf_size);
   2355 
   2356             utf8 = combined_buffer.data();
   2357             utf8_size = internal::ParseCompleteUTF8(utf8, utf8 + combined_buffer.size(),
   2358                                                     &console_output_buffer);
   2359         }
   2360     }
   2361 
   2362     std::wstring utf16;
   2363 
   2364     // Try to convert from data that might be UTF-8 to UTF-16, ignoring errors (just like Linux
   2365     // which does not return an error on bad UTF-8). Data might not be UTF-8 if the user cat's
   2366     // random data, runs dmesg (which might have non-UTF-8), etc.
   2367     // This could throw std::bad_alloc.
   2368     (void)android::base::UTF8ToWide(utf8, utf8_size, &utf16);
   2369 
   2370     // Note that this does not do \n => \r\n translation because that
   2371     // doesn't seem necessary for the Windows console. For the Windows
   2372     // console \r moves to the beginning of the line and \n moves to a new
   2373     // line.
   2374 
   2375     // Flush any stream buffering so that our output is afterwards which
   2376     // makes sense because our call is afterwards.
   2377     (void)fflush(stream);
   2378 
   2379     // Write UTF-16 to the console.
   2380     DWORD written = 0;
   2381     if (!WriteConsoleW(console, utf16.c_str(), utf16.length(), &written, NULL)) {
   2382         errno = EIO;
   2383         return -1;
   2384     }
   2385 
   2386     // Return the size of the original buffer passed in, signifying that we consumed it all, even
   2387     // if nothing was displayed, in the case of being passed an incomplete UTF-8 sequence. This
   2388     // matches the Linux behavior.
   2389     errno = saved_errno;
   2390     return buf_size;
   2391 }
   2392 
   2393 // Function prototype because attributes cannot be placed on func definitions.
   2394 static int _console_vfprintf(const HANDLE console, FILE* stream,
   2395                              const char *format, va_list ap)
   2396     __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 3, 0)));
   2397 
   2398 // Internal function to format a UTF-8 string and write it to a Win32 console.
   2399 // Returns -1 on error.
   2400 static int _console_vfprintf(const HANDLE console, FILE* stream,
   2401                              const char *format, va_list ap) {
   2402     const int saved_errno = errno;
   2403     std::string output_utf8;
   2404 
   2405     // Format the string.
   2406     // This could throw std::bad_alloc.
   2407     android::base::StringAppendV(&output_utf8, format, ap);
   2408 
   2409     const int result = _console_write_utf8(output_utf8.c_str(), output_utf8.length(), stream,
   2410                                            console);
   2411     if (result != -1) {
   2412         errno = saved_errno;
   2413     } else {
   2414         // If -1 was returned, errno has been set.
   2415     }
   2416     return result;
   2417 }
   2418 
   2419 // Version of vfprintf() that takes UTF-8 and can write Unicode to a
   2420 // Windows console.
   2421 int adb_vfprintf(FILE *stream, const char *format, va_list ap) {
   2422     const HANDLE console = _get_console_handle(stream);
   2423 
   2424     // If there is an associated Win32 console, write to it specially,
   2425     // otherwise defer to the regular C Runtime, passing it UTF-8.
   2426     if (console != NULL) {
   2427         return _console_vfprintf(console, stream, format, ap);
   2428     } else {
   2429         // If vfprintf is a macro, undefine it, so we can call the real
   2430         // C Runtime API.
   2431 #pragma push_macro("vfprintf")
   2432 #undef vfprintf
   2433         return vfprintf(stream, format, ap);
   2434 #pragma pop_macro("vfprintf")
   2435     }
   2436 }
   2437 
   2438 // Version of vprintf() that takes UTF-8 and can write Unicode to a Windows console.
   2439 int adb_vprintf(const char *format, va_list ap) {
   2440     return adb_vfprintf(stdout, format, ap);
   2441 }
   2442 
   2443 // Version of fprintf() that takes UTF-8 and can write Unicode to a
   2444 // Windows console.
   2445 int adb_fprintf(FILE *stream, const char *format, ...) {
   2446     va_list ap;
   2447     va_start(ap, format);
   2448     const int result = adb_vfprintf(stream, format, ap);
   2449     va_end(ap);
   2450 
   2451     return result;
   2452 }
   2453 
   2454 // Version of printf() that takes UTF-8 and can write Unicode to a
   2455 // Windows console.
   2456 int adb_printf(const char *format, ...) {
   2457     va_list ap;
   2458     va_start(ap, format);
   2459     const int result = adb_vfprintf(stdout, format, ap);
   2460     va_end(ap);
   2461 
   2462     return result;
   2463 }
   2464 
   2465 // Version of fputs() that takes UTF-8 and can write Unicode to a
   2466 // Windows console.
   2467 int adb_fputs(const char* buf, FILE* stream) {
   2468     // adb_fprintf returns -1 on error, which is conveniently the same as EOF
   2469     // which fputs (and hence adb_fputs) should return on error.
   2470     static_assert(EOF == -1, "EOF is not -1, so this code needs to be fixed");
   2471     return adb_fprintf(stream, "%s", buf);
   2472 }
   2473 
   2474 // Version of fputc() that takes UTF-8 and can write Unicode to a
   2475 // Windows console.
   2476 int adb_fputc(int ch, FILE* stream) {
   2477     const int result = adb_fprintf(stream, "%c", ch);
   2478     if (result == -1) {
   2479         return EOF;
   2480     }
   2481     // For success, fputc returns the char, cast to unsigned char, then to int.
   2482     return static_cast<unsigned char>(ch);
   2483 }
   2484 
   2485 // Version of putchar() that takes UTF-8 and can write Unicode to a Windows console.
   2486 int adb_putchar(int ch) {
   2487     return adb_fputc(ch, stdout);
   2488 }
   2489 
   2490 // Version of puts() that takes UTF-8 and can write Unicode to a Windows console.
   2491 int adb_puts(const char* buf) {
   2492     // adb_printf returns -1 on error, which is conveniently the same as EOF
   2493     // which puts (and hence adb_puts) should return on error.
   2494     static_assert(EOF == -1, "EOF is not -1, so this code needs to be fixed");
   2495     return adb_printf("%s\n", buf);
   2496 }
   2497 
   2498 // Internal function to write UTF-8 to a Win32 console. Returns the number of
   2499 // items (of length size) written. On error, returns a short item count or 0.
   2500 static size_t _console_fwrite(const void* ptr, size_t size, size_t nmemb,
   2501                               FILE* stream, HANDLE console) {
   2502     const int result = _console_write_utf8(reinterpret_cast<const char*>(ptr), size * nmemb, stream,
   2503                                            console);
   2504     if (result == -1) {
   2505         return 0;
   2506     }
   2507     return result / size;
   2508 }
   2509 
   2510 // Version of fwrite() that takes UTF-8 and can write Unicode to a
   2511 // Windows console.
   2512 size_t adb_fwrite(const void* ptr, size_t size, size_t nmemb, FILE* stream) {
   2513     const HANDLE console = _get_console_handle(stream);
   2514 
   2515     // If there is an associated Win32 console, write to it specially,
   2516     // otherwise defer to the regular C Runtime, passing it UTF-8.
   2517     if (console != NULL) {
   2518         return _console_fwrite(ptr, size, nmemb, stream, console);
   2519     } else {
   2520         // If fwrite is a macro, undefine it, so we can call the real
   2521         // C Runtime API.
   2522 #pragma push_macro("fwrite")
   2523 #undef fwrite
   2524         return fwrite(ptr, size, nmemb, stream);
   2525 #pragma pop_macro("fwrite")
   2526     }
   2527 }
   2528 
   2529 // Version of fopen() that takes a UTF-8 filename and can access a file with
   2530 // a Unicode filename.
   2531 FILE* adb_fopen(const char* path, const char* mode) {
   2532     std::wstring path_wide;
   2533     if (!android::base::UTF8ToWide(path, &path_wide)) {
   2534         return nullptr;
   2535     }
   2536 
   2537     std::wstring mode_wide;
   2538     if (!android::base::UTF8ToWide(mode, &mode_wide)) {
   2539         return nullptr;
   2540     }
   2541 
   2542     return _wfopen(path_wide.c_str(), mode_wide.c_str());
   2543 }
   2544 
   2545 // Return a lowercase version of the argument. Uses C Runtime tolower() on
   2546 // each byte which is not UTF-8 aware, and theoretically uses the current C
   2547 // Runtime locale (which in practice is not changed, so this becomes a ASCII
   2548 // conversion).
   2549 static std::string ToLower(const std::string& anycase) {
   2550     // copy string
   2551     std::string str(anycase);
   2552     // transform the copy
   2553     std::transform(str.begin(), str.end(), str.begin(), tolower);
   2554     return str;
   2555 }
   2556 
   2557 extern "C" int main(int argc, char** argv);
   2558 
   2559 // Link with -municode to cause this wmain() to be used as the program
   2560 // entrypoint. It will convert the args from UTF-16 to UTF-8 and call the
   2561 // regular main() with UTF-8 args.
   2562 extern "C" int wmain(int argc, wchar_t **argv) {
   2563     // Convert args from UTF-16 to UTF-8 and pass that to main().
   2564     NarrowArgs narrow_args(argc, argv);
   2565     return main(argc, narrow_args.data());
   2566 }
   2567 
   2568 // Shadow UTF-8 environment variable name/value pairs that are created from
   2569 // _wenviron the first time that adb_getenv() is called. Note that this is not
   2570 // currently updated if putenv, setenv, unsetenv are called. Note that no
   2571 // thread synchronization is done, but we're called early enough in
   2572 // single-threaded startup that things work ok.
   2573 static auto& g_environ_utf8 = *new std::unordered_map<std::string, char*>();
   2574 
   2575 // Make sure that shadow UTF-8 environment variables are setup.
   2576 static void _ensure_env_setup() {
   2577     // If some name/value pairs exist, then we've already done the setup below.
   2578     if (g_environ_utf8.size() != 0) {
   2579         return;
   2580     }
   2581 
   2582     if (_wenviron == nullptr) {
   2583         // If _wenviron is null, then -municode probably wasn't used. That
   2584         // linker flag will cause the entry point to setup _wenviron. It will
   2585         // also require an implementation of wmain() (which we provide above).
   2586         fatal("_wenviron is not set, did you link with -municode?");
   2587     }
   2588 
   2589     // Read name/value pairs from UTF-16 _wenviron and write new name/value
   2590     // pairs to UTF-8 g_environ_utf8. Note that it probably does not make sense
   2591     // to use the D() macro here because that tracing only works if the
   2592     // ADB_TRACE environment variable is setup, but that env var can't be read
   2593     // until this code completes.
   2594     for (wchar_t** env = _wenviron; *env != nullptr; ++env) {
   2595         wchar_t* const equal = wcschr(*env, L'=');
   2596         if (equal == nullptr) {
   2597             // Malformed environment variable with no equal sign. Shouldn't
   2598             // really happen, but we should be resilient to this.
   2599             continue;
   2600         }
   2601 
   2602         // If we encounter an error converting UTF-16, don't error-out on account of a single env
   2603         // var because the program might never even read this particular variable.
   2604         std::string name_utf8;
   2605         if (!android::base::WideToUTF8(*env, equal - *env, &name_utf8)) {
   2606             continue;
   2607         }
   2608 
   2609         // Store lowercase name so that we can do case-insensitive searches.
   2610         name_utf8 = ToLower(name_utf8);
   2611 
   2612         std::string value_utf8;
   2613         if (!android::base::WideToUTF8(equal + 1, &value_utf8)) {
   2614             continue;
   2615         }
   2616 
   2617         char* const value_dup = strdup(value_utf8.c_str());
   2618 
   2619         // Don't overwrite a previus env var with the same name. In reality,
   2620         // the system probably won't let two env vars with the same name exist
   2621         // in _wenviron.
   2622         g_environ_utf8.insert({name_utf8, value_dup});
   2623     }
   2624 }
   2625 
   2626 // Version of getenv() that takes a UTF-8 environment variable name and
   2627 // retrieves a UTF-8 value. Case-insensitive to match getenv() on Windows.
   2628 char* adb_getenv(const char* name) {
   2629     _ensure_env_setup();
   2630 
   2631     // Case-insensitive search by searching for lowercase name in a map of
   2632     // lowercase names.
   2633     const auto it = g_environ_utf8.find(ToLower(std::string(name)));
   2634     if (it == g_environ_utf8.end()) {
   2635         return nullptr;
   2636     }
   2637 
   2638     return it->second;
   2639 }
   2640 
   2641 // Version of getcwd() that returns the current working directory in UTF-8.
   2642 char* adb_getcwd(char* buf, int size) {
   2643     wchar_t* wbuf = _wgetcwd(nullptr, 0);
   2644     if (wbuf == nullptr) {
   2645         return nullptr;
   2646     }
   2647 
   2648     std::string buf_utf8;
   2649     const bool narrow_result = android::base::WideToUTF8(wbuf, &buf_utf8);
   2650     free(wbuf);
   2651     wbuf = nullptr;
   2652 
   2653     if (!narrow_result) {
   2654         return nullptr;
   2655     }
   2656 
   2657     // If size was specified, make sure all the chars will fit.
   2658     if (size != 0) {
   2659         if (size < static_cast<int>(buf_utf8.length() + 1)) {
   2660             errno = ERANGE;
   2661             return nullptr;
   2662         }
   2663     }
   2664 
   2665     // If buf was not specified, allocate storage.
   2666     if (buf == nullptr) {
   2667         if (size == 0) {
   2668             size = buf_utf8.length() + 1;
   2669         }
   2670         buf = reinterpret_cast<char*>(malloc(size));
   2671         if (buf == nullptr) {
   2672             return nullptr;
   2673         }
   2674     }
   2675 
   2676     // Destination buffer was allocated with enough space, or we've already
   2677     // checked an existing buffer size for enough space.
   2678     strcpy(buf, buf_utf8.c_str());
   2679 
   2680     return buf;
   2681 }
   2682