tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

win32_errors.c (12372B)

      1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* This Source Code Form is subject to the terms of the Mozilla Public
      3 * License, v. 2.0. If a copy of the MPL was not distributed with this
      4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      5 
      6 #include "prerror.h"
      7 #include "prlog.h"
      8 #include <errno.h>
      9 #include <windows.h>
     10 
     11 /*
     12 * On Win32, we map three kinds of error codes:
     13 * - GetLastError(): for Win32 functions
     14 * - WSAGetLastError(): for Winsock functions
     15 * - errno: for standard C library functions
     16 *
     17 * GetLastError() and WSAGetLastError() return error codes in
     18 * non-overlapping ranges, so their error codes (ERROR_* and
     19 * WSAE*) can be mapped by the same function.  On the other hand,
     20 * errno and GetLastError() have overlapping ranges, so we need
     21 * to use a separate function to map errno.
     22 *
     23 * We do not check for WSAEINPROGRESS and WSAEINTR because we do not
     24 * use blocking Winsock 1.1 calls.
     25 *
     26 * Except for the 'socket' call, we do not check for WSAEINITIALISED.
     27 * It is assumed that if Winsock is not initialized, that fact will
     28 * be detected at the time we create new sockets.
     29 */
     30 
     31 static void _MD_win32_map_default_errno(PRInt32 err) {
     32  PRErrorCode prError;
     33 
     34  switch (err) {
     35    case EACCES:
     36      prError = PR_NO_ACCESS_RIGHTS_ERROR;
     37      break;
     38    case ENOENT:
     39      prError = PR_FILE_NOT_FOUND_ERROR;
     40      break;
     41    default:
     42      prError = PR_UNKNOWN_ERROR;
     43      break;
     44  }
     45  PR_SetError(prError, err);
     46 }
     47 
     48 void _MD_win32_map_default_error(PRInt32 err) {
     49  PRErrorCode prError;
     50 
     51  switch (err) {
     52    case ERROR_ACCESS_DENIED:
     53      prError = PR_NO_ACCESS_RIGHTS_ERROR;
     54      break;
     55    case ERROR_ALREADY_EXISTS:
     56      prError = PR_FILE_EXISTS_ERROR;
     57      break;
     58    case ERROR_CALL_NOT_IMPLEMENTED:
     59      prError = PR_NOT_IMPLEMENTED_ERROR;
     60      break;
     61    case ERROR_DISK_CORRUPT:
     62      prError = PR_IO_ERROR;
     63      break;
     64    case ERROR_DISK_FULL:
     65      prError = PR_NO_DEVICE_SPACE_ERROR;
     66      break;
     67    case ERROR_DISK_OPERATION_FAILED:
     68      prError = PR_IO_ERROR;
     69      break;
     70    case ERROR_DRIVE_LOCKED:
     71      prError = PR_FILE_IS_LOCKED_ERROR;
     72      break;
     73    case ERROR_FILENAME_EXCED_RANGE:
     74      prError = PR_NAME_TOO_LONG_ERROR;
     75      break;
     76    case ERROR_FILE_CORRUPT:
     77      prError = PR_IO_ERROR;
     78      break;
     79    case ERROR_FILE_EXISTS:
     80      prError = PR_FILE_EXISTS_ERROR;
     81      break;
     82    case ERROR_FILE_INVALID:
     83      prError = PR_BAD_DESCRIPTOR_ERROR;
     84      break;
     85    case ERROR_FILE_NOT_FOUND:
     86      prError = PR_FILE_NOT_FOUND_ERROR;
     87      break;
     88    case ERROR_HANDLE_DISK_FULL:
     89      prError = PR_NO_DEVICE_SPACE_ERROR;
     90      break;
     91    case ERROR_INVALID_ADDRESS:
     92      prError = PR_ACCESS_FAULT_ERROR;
     93      break;
     94    case ERROR_INVALID_HANDLE:
     95      prError = PR_BAD_DESCRIPTOR_ERROR;
     96      break;
     97    case ERROR_INVALID_NAME:
     98      prError = PR_INVALID_ARGUMENT_ERROR;
     99      break;
    100    case ERROR_INVALID_PARAMETER:
    101      prError = PR_INVALID_ARGUMENT_ERROR;
    102      break;
    103    case ERROR_INVALID_USER_BUFFER:
    104      prError = PR_INSUFFICIENT_RESOURCES_ERROR;
    105      break;
    106    case ERROR_LOCKED:
    107      prError = PR_FILE_IS_LOCKED_ERROR;
    108      break;
    109    case ERROR_NETNAME_DELETED:
    110      prError = PR_CONNECT_RESET_ERROR;
    111      break;
    112    case ERROR_NOACCESS:
    113      prError = PR_ACCESS_FAULT_ERROR;
    114      break;
    115    case ERROR_NOT_ENOUGH_MEMORY:
    116      prError = PR_INSUFFICIENT_RESOURCES_ERROR;
    117      break;
    118    case ERROR_NOT_ENOUGH_QUOTA:
    119      prError = PR_OUT_OF_MEMORY_ERROR;
    120      break;
    121    case ERROR_NOT_READY:
    122      prError = PR_IO_ERROR;
    123      break;
    124    case ERROR_NO_MORE_FILES:
    125      prError = PR_NO_MORE_FILES_ERROR;
    126      break;
    127    case ERROR_OPEN_FAILED:
    128      prError = PR_IO_ERROR;
    129      break;
    130    case ERROR_OPEN_FILES:
    131      prError = PR_IO_ERROR;
    132      break;
    133    case ERROR_OPERATION_ABORTED:
    134      prError = PR_OPERATION_ABORTED_ERROR;
    135      break;
    136    case ERROR_OUTOFMEMORY:
    137      prError = PR_INSUFFICIENT_RESOURCES_ERROR;
    138      break;
    139    case ERROR_PATH_BUSY:
    140      prError = PR_IO_ERROR;
    141      break;
    142    case ERROR_PATH_NOT_FOUND:
    143      prError = PR_FILE_NOT_FOUND_ERROR;
    144      break;
    145    case ERROR_SEEK_ON_DEVICE:
    146      prError = PR_IO_ERROR;
    147      break;
    148    case ERROR_SHARING_VIOLATION:
    149      prError = PR_FILE_IS_BUSY_ERROR;
    150      break;
    151    case ERROR_STACK_OVERFLOW:
    152      prError = PR_ACCESS_FAULT_ERROR;
    153      break;
    154    case ERROR_TOO_MANY_OPEN_FILES:
    155      prError = PR_SYS_DESC_TABLE_FULL_ERROR;
    156      break;
    157    case ERROR_WRITE_PROTECT:
    158      prError = PR_NO_ACCESS_RIGHTS_ERROR;
    159      break;
    160    case WSAEACCES:
    161      prError = PR_NO_ACCESS_RIGHTS_ERROR;
    162      break;
    163    case WSAEADDRINUSE:
    164      prError = PR_ADDRESS_IN_USE_ERROR;
    165      break;
    166    case WSAEADDRNOTAVAIL:
    167    case ERROR_INVALID_NETNAME:
    168      prError = PR_ADDRESS_NOT_AVAILABLE_ERROR;
    169      break;
    170    case WSAEAFNOSUPPORT:
    171    case ERROR_INCORRECT_ADDRESS:
    172      prError = PR_ADDRESS_NOT_SUPPORTED_ERROR;
    173      break;
    174    case WSAEALREADY:
    175    case ERROR_ALREADY_INITIALIZED:
    176      prError = PR_ALREADY_INITIATED_ERROR;
    177      break;
    178    case WSAEBADF:
    179      prError = PR_BAD_DESCRIPTOR_ERROR;
    180      break;
    181    case WSAECONNABORTED:
    182    case ERROR_CONNECTION_ABORTED:
    183      prError = PR_CONNECT_ABORTED_ERROR;
    184      break;
    185    case WSAECONNREFUSED:
    186    case ERROR_CONNECTION_REFUSED:
    187      prError = PR_CONNECT_REFUSED_ERROR;
    188      break;
    189    case WSAECONNRESET:
    190      prError = PR_CONNECT_RESET_ERROR;
    191      break;
    192    case WSAEDESTADDRREQ:
    193      prError = PR_INVALID_ARGUMENT_ERROR;
    194      break;
    195    case WSAEFAULT:
    196      prError = PR_ACCESS_FAULT_ERROR;
    197      break;
    198    case WSAEHOSTUNREACH:
    199    case ERROR_HOST_UNREACHABLE:
    200      prError = PR_HOST_UNREACHABLE_ERROR;
    201      break;
    202    case WSAEINVAL:
    203      prError = PR_INVALID_ARGUMENT_ERROR;
    204      break;
    205    case WSAEISCONN:
    206      prError = PR_IS_CONNECTED_ERROR;
    207      break;
    208    case WSAEMFILE:
    209      prError = PR_PROC_DESC_TABLE_FULL_ERROR;
    210      break;
    211    case WSAEMSGSIZE:
    212      prError = PR_BUFFER_OVERFLOW_ERROR;
    213      break;
    214    case WSAENETDOWN:
    215    case ERROR_NO_NETWORK:
    216      prError = PR_NETWORK_DOWN_ERROR;
    217      break;
    218    case WSAENETRESET:
    219      prError = PR_CONNECT_ABORTED_ERROR;
    220      break;
    221    case WSAENETUNREACH:
    222    case ERROR_NETWORK_UNREACHABLE:
    223      prError = PR_NETWORK_UNREACHABLE_ERROR;
    224      break;
    225    case WSAENOBUFS:
    226      prError = PR_INSUFFICIENT_RESOURCES_ERROR;
    227      break;
    228    case WSAENOPROTOOPT:
    229      prError = PR_INVALID_ARGUMENT_ERROR;
    230      break;
    231    case WSAENOTCONN:
    232      prError = PR_NOT_CONNECTED_ERROR;
    233      break;
    234    case WSAENOTSOCK:
    235      prError = PR_NOT_SOCKET_ERROR;
    236      break;
    237    case WSAEOPNOTSUPP:
    238      prError = PR_OPERATION_NOT_SUPPORTED_ERROR;
    239      break;
    240    case WSAEPROTONOSUPPORT:
    241      prError = PR_PROTOCOL_NOT_SUPPORTED_ERROR;
    242      break;
    243    case WSAEPROTOTYPE:
    244      prError = PR_INVALID_ARGUMENT_ERROR;
    245      break;
    246    case WSAESHUTDOWN:
    247      prError = PR_SOCKET_SHUTDOWN_ERROR;
    248      break;
    249    case WSAESOCKTNOSUPPORT:
    250      prError = PR_INVALID_ARGUMENT_ERROR;
    251      break;
    252    case WSAETIMEDOUT:
    253      prError = PR_CONNECT_ABORTED_ERROR;
    254      break;
    255    case WSAEWOULDBLOCK:
    256      prError = PR_WOULD_BLOCK_ERROR;
    257      break;
    258    default:
    259      prError = PR_UNKNOWN_ERROR;
    260      break;
    261  }
    262  PR_SetError(prError, err);
    263 }
    264 
    265 void _MD_win32_map_opendir_error(PRInt32 err) {
    266  _MD_win32_map_default_error(err);
    267 }
    268 
    269 void _MD_win32_map_closedir_error(PRInt32 err) {
    270  _MD_win32_map_default_error(err);
    271 }
    272 
    273 void _MD_unix_readdir_error(PRInt32 err) { _MD_win32_map_default_error(err); }
    274 
    275 void _MD_win32_map_delete_error(PRInt32 err) {
    276  _MD_win32_map_default_error(err);
    277 }
    278 
    279 /* The error code for stat() is in errno. */
    280 void _MD_win32_map_stat_error(PRInt32 err) { _MD_win32_map_default_errno(err); }
    281 
    282 void _MD_win32_map_fstat_error(PRInt32 err) {
    283  _MD_win32_map_default_error(err);
    284 }
    285 
    286 void _MD_win32_map_rename_error(PRInt32 err) {
    287  _MD_win32_map_default_error(err);
    288 }
    289 
    290 /* The error code for access() is in errno. */
    291 void _MD_win32_map_access_error(PRInt32 err) {
    292  _MD_win32_map_default_errno(err);
    293 }
    294 
    295 void _MD_win32_map_mkdir_error(PRInt32 err) {
    296  _MD_win32_map_default_error(err);
    297 }
    298 
    299 void _MD_win32_map_rmdir_error(PRInt32 err) {
    300  _MD_win32_map_default_error(err);
    301 }
    302 
    303 void _MD_win32_map_read_error(PRInt32 err) { _MD_win32_map_default_error(err); }
    304 
    305 void _MD_win32_map_transmitfile_error(PRInt32 err) {
    306  _MD_win32_map_default_error(err);
    307 }
    308 
    309 void _MD_win32_map_write_error(PRInt32 err) {
    310  _MD_win32_map_default_error(err);
    311 }
    312 
    313 void _MD_win32_map_lseek_error(PRInt32 err) {
    314  _MD_win32_map_default_error(err);
    315 }
    316 
    317 void _MD_win32_map_fsync_error(PRInt32 err) {
    318  _MD_win32_map_default_error(err);
    319 }
    320 
    321 /*
    322 * For both CloseHandle() and closesocket().
    323 */
    324 void _MD_win32_map_close_error(PRInt32 err) {
    325  _MD_win32_map_default_error(err);
    326 }
    327 
    328 void _MD_win32_map_socket_error(PRInt32 err) {
    329  PR_ASSERT(err != WSANOTINITIALISED);
    330  _MD_win32_map_default_error(err);
    331 }
    332 
    333 void _MD_win32_map_recv_error(PRInt32 err) { _MD_win32_map_default_error(err); }
    334 
    335 void _MD_win32_map_recvfrom_error(PRInt32 err) {
    336  _MD_win32_map_default_error(err);
    337 }
    338 
    339 void _MD_win32_map_send_error(PRInt32 err) {
    340  PRErrorCode prError;
    341 
    342  switch (err) {
    343    case WSAEMSGSIZE:
    344      prError = PR_INVALID_ARGUMENT_ERROR;
    345      break;
    346    default:
    347      _MD_win32_map_default_error(err);
    348      return;
    349  }
    350  PR_SetError(prError, err);
    351 }
    352 
    353 void _MD_win32_map_sendto_error(PRInt32 err) {
    354  PRErrorCode prError;
    355 
    356  switch (err) {
    357    case WSAEMSGSIZE:
    358      prError = PR_INVALID_ARGUMENT_ERROR;
    359      break;
    360    default:
    361      _MD_win32_map_default_error(err);
    362      return;
    363  }
    364  PR_SetError(prError, err);
    365 }
    366 
    367 void _MD_win32_map_accept_error(PRInt32 err) {
    368  PRErrorCode prError;
    369 
    370  switch (err) {
    371    case WSAEOPNOTSUPP:
    372      prError = PR_NOT_TCP_SOCKET_ERROR;
    373      break;
    374    case WSAEINVAL:
    375      prError = PR_INVALID_STATE_ERROR;
    376      break;
    377    default:
    378      _MD_win32_map_default_error(err);
    379      return;
    380  }
    381  PR_SetError(prError, err);
    382 }
    383 
    384 void _MD_win32_map_acceptex_error(PRInt32 err) {
    385  _MD_win32_map_default_error(err);
    386 }
    387 
    388 void _MD_win32_map_connect_error(PRInt32 err) {
    389  PRErrorCode prError;
    390 
    391  switch (err) {
    392    case WSAEWOULDBLOCK:
    393      prError = PR_IN_PROGRESS_ERROR;
    394      break;
    395    case WSAEINVAL:
    396      prError = PR_ALREADY_INITIATED_ERROR;
    397      break;
    398    case WSAETIMEDOUT:
    399      prError = PR_IO_TIMEOUT_ERROR;
    400      break;
    401    default:
    402      _MD_win32_map_default_error(err);
    403      return;
    404  }
    405  PR_SetError(prError, err);
    406 }
    407 
    408 void _MD_win32_map_bind_error(PRInt32 err) {
    409  PRErrorCode prError;
    410 
    411  switch (err) {
    412    case WSAEINVAL:
    413      prError = PR_SOCKET_ADDRESS_IS_BOUND_ERROR;
    414      break;
    415    default:
    416      _MD_win32_map_default_error(err);
    417      return;
    418  }
    419  PR_SetError(prError, err);
    420 }
    421 
    422 void _MD_win32_map_listen_error(PRInt32 err) {
    423  PRErrorCode prError;
    424 
    425  switch (err) {
    426    case WSAEOPNOTSUPP:
    427      prError = PR_NOT_TCP_SOCKET_ERROR;
    428      break;
    429    case WSAEINVAL:
    430      prError = PR_INVALID_STATE_ERROR;
    431      break;
    432    default:
    433      _MD_win32_map_default_error(err);
    434      return;
    435  }
    436  PR_SetError(prError, err);
    437 }
    438 
    439 void _MD_win32_map_shutdown_error(PRInt32 err) {
    440  _MD_win32_map_default_error(err);
    441 }
    442 
    443 void _MD_win32_map_getsockname_error(PRInt32 err) {
    444  PRErrorCode prError;
    445 
    446  switch (err) {
    447    case WSAEINVAL:
    448      prError = PR_INVALID_STATE_ERROR;
    449      break;
    450    default:
    451      _MD_win32_map_default_error(err);
    452      return;
    453  }
    454  PR_SetError(prError, err);
    455 }
    456 
    457 void _MD_win32_map_getpeername_error(PRInt32 err) {
    458  _MD_win32_map_default_error(err);
    459 }
    460 
    461 void _MD_win32_map_getsockopt_error(PRInt32 err) {
    462  _MD_win32_map_default_error(err);
    463 }
    464 
    465 void _MD_win32_map_setsockopt_error(PRInt32 err) {
    466  _MD_win32_map_default_error(err);
    467 }
    468 
    469 void _MD_win32_map_open_error(PRInt32 err) { _MD_win32_map_default_error(err); }
    470 
    471 void _MD_win32_map_gethostname_error(PRInt32 err) {
    472  _MD_win32_map_default_error(err);
    473 }
    474 
    475 /* Win32 select() only works on sockets.  So in this
    476 ** context, WSAENOTSOCK is equivalent to EBADF on Unix.
    477 */
    478 void _MD_win32_map_select_error(PRInt32 err) {
    479  PRErrorCode prError;
    480 
    481  switch (err) {
    482    case WSAENOTSOCK:
    483      prError = PR_BAD_DESCRIPTOR_ERROR;
    484      break;
    485    default:
    486      _MD_win32_map_default_error(err);
    487      return;
    488  }
    489  PR_SetError(prError, err);
    490 }
    491 
    492 void _MD_win32_map_lockf_error(PRInt32 err) {
    493  _MD_win32_map_default_error(err);
    494 }