tor-browser

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

unix_errors.c (16063B)

      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 "primpl.h"
      7 #if defined(_PR_POLL_AVAILABLE)
      8 #  include <poll.h>
      9 #endif
     10 #include <errno.h>
     11 
     12 void _MD_unix_map_default_error(int err) {
     13  PRErrorCode prError;
     14 
     15  switch (err) {
     16    case EACCES:
     17      prError = PR_NO_ACCESS_RIGHTS_ERROR;
     18      break;
     19    case EADDRINUSE:
     20      prError = PR_ADDRESS_IN_USE_ERROR;
     21      break;
     22    case EADDRNOTAVAIL:
     23      prError = PR_ADDRESS_NOT_AVAILABLE_ERROR;
     24      break;
     25    case EAFNOSUPPORT:
     26      prError = PR_ADDRESS_NOT_SUPPORTED_ERROR;
     27      break;
     28    case EAGAIN:
     29      prError = PR_WOULD_BLOCK_ERROR;
     30      break;
     31      /*
     32       * On QNX and Neutrino, EALREADY is defined as EBUSY.
     33       */
     34 #if EALREADY != EBUSY
     35    case EALREADY:
     36      prError = PR_ALREADY_INITIATED_ERROR;
     37      break;
     38 #endif
     39    case EBADF:
     40      prError = PR_BAD_DESCRIPTOR_ERROR;
     41      break;
     42 #ifdef EBADMSG
     43    case EBADMSG:
     44      prError = PR_IO_ERROR;
     45      break;
     46 #endif
     47    case EBUSY:
     48      prError = PR_FILESYSTEM_MOUNTED_ERROR;
     49      break;
     50    case ECONNABORTED:
     51      prError = PR_CONNECT_ABORTED_ERROR;
     52      break;
     53    case ECONNREFUSED:
     54      prError = PR_CONNECT_REFUSED_ERROR;
     55      break;
     56    case ECONNRESET:
     57      prError = PR_CONNECT_RESET_ERROR;
     58      break;
     59    case EDEADLK:
     60      prError = PR_DEADLOCK_ERROR;
     61      break;
     62 #ifdef EDIRCORRUPTED
     63    case EDIRCORRUPTED:
     64      prError = PR_DIRECTORY_CORRUPTED_ERROR;
     65      break;
     66 #endif
     67 #ifdef EDQUOT
     68    case EDQUOT:
     69      prError = PR_NO_DEVICE_SPACE_ERROR;
     70      break;
     71 #endif
     72    case EEXIST:
     73      prError = PR_FILE_EXISTS_ERROR;
     74      break;
     75    case EFAULT:
     76      prError = PR_ACCESS_FAULT_ERROR;
     77      break;
     78    case EFBIG:
     79      prError = PR_FILE_TOO_BIG_ERROR;
     80      break;
     81    case EHOSTUNREACH:
     82    case EHOSTDOWN:
     83      prError = PR_HOST_UNREACHABLE_ERROR;
     84      break;
     85    case EINPROGRESS:
     86      prError = PR_IN_PROGRESS_ERROR;
     87      break;
     88    case EINTR:
     89      prError = PR_PENDING_INTERRUPT_ERROR;
     90      break;
     91    case EINVAL:
     92      prError = PR_INVALID_ARGUMENT_ERROR;
     93      break;
     94    case EIO:
     95      prError = PR_IO_ERROR;
     96      break;
     97    case EISCONN:
     98      prError = PR_IS_CONNECTED_ERROR;
     99      break;
    100    case EISDIR:
    101      prError = PR_IS_DIRECTORY_ERROR;
    102      break;
    103    case ELOOP:
    104      prError = PR_LOOP_ERROR;
    105      break;
    106    case EMFILE:
    107      prError = PR_PROC_DESC_TABLE_FULL_ERROR;
    108      break;
    109    case EMLINK:
    110      prError = PR_MAX_DIRECTORY_ENTRIES_ERROR;
    111      break;
    112    case EMSGSIZE:
    113      prError = PR_INVALID_ARGUMENT_ERROR;
    114      break;
    115 #ifdef EMULTIHOP
    116    case EMULTIHOP:
    117      prError = PR_REMOTE_FILE_ERROR;
    118      break;
    119 #endif
    120    case ENAMETOOLONG:
    121      prError = PR_NAME_TOO_LONG_ERROR;
    122      break;
    123    case ENETUNREACH:
    124      prError = PR_NETWORK_UNREACHABLE_ERROR;
    125      break;
    126    case ENFILE:
    127      prError = PR_SYS_DESC_TABLE_FULL_ERROR;
    128      break;
    129      /*
    130       * On SCO OpenServer 5, ENOBUFS is defined as ENOSR.
    131       */
    132 #if defined(ENOBUFS) && (ENOBUFS != ENOSR)
    133    case ENOBUFS:
    134      prError = PR_INSUFFICIENT_RESOURCES_ERROR;
    135      break;
    136 #endif
    137    case ENODEV:
    138      prError = PR_FILE_NOT_FOUND_ERROR;
    139      break;
    140    case ENOENT:
    141      prError = PR_FILE_NOT_FOUND_ERROR;
    142      break;
    143    case ENOLCK:
    144      prError = PR_FILE_IS_LOCKED_ERROR;
    145      break;
    146 #ifdef ENOLINK
    147    case ENOLINK:
    148      prError = PR_REMOTE_FILE_ERROR;
    149      break;
    150 #endif
    151    case ENOMEM:
    152      prError = PR_OUT_OF_MEMORY_ERROR;
    153      break;
    154    case ENOPROTOOPT:
    155      prError = PR_INVALID_ARGUMENT_ERROR;
    156      break;
    157    case ENOSPC:
    158      prError = PR_NO_DEVICE_SPACE_ERROR;
    159      break;
    160 #ifdef ENOSR
    161    case ENOSR:
    162      prError = PR_INSUFFICIENT_RESOURCES_ERROR;
    163      break;
    164 #endif
    165    case ENOSYS:
    166      prError = PR_NOT_IMPLEMENTED_ERROR;
    167      break;
    168    case ENOTCONN:
    169      prError = PR_NOT_CONNECTED_ERROR;
    170      break;
    171    case ENOTDIR:
    172      prError = PR_NOT_DIRECTORY_ERROR;
    173      break;
    174    case ENOTSOCK:
    175      prError = PR_NOT_SOCKET_ERROR;
    176      break;
    177    case ENXIO:
    178      prError = PR_FILE_NOT_FOUND_ERROR;
    179      break;
    180    case EOPNOTSUPP:
    181      prError = PR_NOT_TCP_SOCKET_ERROR;
    182      break;
    183 #ifdef EOVERFLOW
    184    case EOVERFLOW:
    185      prError = PR_BUFFER_OVERFLOW_ERROR;
    186      break;
    187 #endif
    188    case EPERM:
    189      prError = PR_NO_ACCESS_RIGHTS_ERROR;
    190      break;
    191    case EPIPE:
    192      prError = PR_CONNECT_RESET_ERROR;
    193      break;
    194 #ifdef EPROTO
    195    case EPROTO:
    196      prError = PR_IO_ERROR;
    197      break;
    198 #endif
    199    case EPROTONOSUPPORT:
    200      prError = PR_PROTOCOL_NOT_SUPPORTED_ERROR;
    201      break;
    202    case EPROTOTYPE:
    203      prError = PR_ADDRESS_NOT_SUPPORTED_ERROR;
    204      break;
    205    case ERANGE:
    206      prError = PR_INVALID_METHOD_ERROR;
    207      break;
    208    case EROFS:
    209      prError = PR_READ_ONLY_FILESYSTEM_ERROR;
    210      break;
    211    case ESPIPE:
    212      prError = PR_INVALID_METHOD_ERROR;
    213      break;
    214    case ETIMEDOUT:
    215      prError = PR_IO_TIMEOUT_ERROR;
    216      break;
    217 #if EWOULDBLOCK != EAGAIN
    218    case EWOULDBLOCK:
    219      prError = PR_WOULD_BLOCK_ERROR;
    220      break;
    221 #endif
    222    case EXDEV:
    223      prError = PR_NOT_SAME_DEVICE_ERROR;
    224      break;
    225    default:
    226      prError = PR_UNKNOWN_ERROR;
    227      break;
    228  }
    229  PR_SetError(prError, err);
    230 }
    231 
    232 void _MD_unix_map_opendir_error(int err) { _MD_unix_map_default_error(err); }
    233 
    234 void _MD_unix_map_closedir_error(int err) {
    235  PRErrorCode prError;
    236 
    237  switch (err) {
    238    case EINVAL:
    239      prError = PR_BAD_DESCRIPTOR_ERROR;
    240      break;
    241    default:
    242      _MD_unix_map_default_error(err);
    243      return;
    244  }
    245  PR_SetError(prError, err);
    246 }
    247 
    248 void _MD_unix_readdir_error(int err) {
    249  PRErrorCode prError;
    250 
    251  switch (err) {
    252    case 0:
    253    case ENOENT:
    254      prError = PR_NO_MORE_FILES_ERROR;
    255      break;
    256 #ifdef EOVERFLOW
    257    case EOVERFLOW:
    258      prError = PR_IO_ERROR;
    259      break;
    260 #endif
    261    case EINVAL:
    262      prError = PR_IO_ERROR;
    263      break;
    264    case ENXIO:
    265      prError = PR_IO_ERROR;
    266      break;
    267    default:
    268      _MD_unix_map_default_error(err);
    269      return;
    270  }
    271  PR_SetError(prError, err);
    272 }
    273 
    274 void _MD_unix_map_unlink_error(int err) {
    275  PRErrorCode prError;
    276 
    277  switch (err) {
    278    case EPERM:
    279      prError = PR_IS_DIRECTORY_ERROR;
    280      break;
    281    default:
    282      _MD_unix_map_default_error(err);
    283      return;
    284  }
    285  PR_SetError(prError, err);
    286 }
    287 
    288 void _MD_unix_map_stat_error(int err) {
    289  PRErrorCode prError;
    290 
    291  switch (err) {
    292    case ETIMEDOUT:
    293      prError = PR_REMOTE_FILE_ERROR;
    294      break;
    295    default:
    296      _MD_unix_map_default_error(err);
    297      return;
    298  }
    299  PR_SetError(prError, err);
    300 }
    301 
    302 void _MD_unix_map_fstat_error(int err) {
    303  PRErrorCode prError;
    304 
    305  switch (err) {
    306    case ETIMEDOUT:
    307      prError = PR_REMOTE_FILE_ERROR;
    308      break;
    309    default:
    310      _MD_unix_map_default_error(err);
    311      return;
    312  }
    313  PR_SetError(prError, err);
    314 }
    315 
    316 void _MD_unix_map_rename_error(int err) {
    317  PRErrorCode prError;
    318 
    319  switch (err) {
    320    case EEXIST:
    321      prError = PR_DIRECTORY_NOT_EMPTY_ERROR;
    322      break;
    323    default:
    324      _MD_unix_map_default_error(err);
    325      return;
    326  }
    327  PR_SetError(prError, err);
    328 }
    329 
    330 void _MD_unix_map_access_error(int err) {
    331  PRErrorCode prError;
    332 
    333  switch (err) {
    334    case ETIMEDOUT:
    335      prError = PR_REMOTE_FILE_ERROR;
    336      break;
    337    default:
    338      _MD_unix_map_default_error(err);
    339      return;
    340  }
    341  PR_SetError(prError, err);
    342 }
    343 
    344 void _MD_unix_map_mkdir_error(int err) { _MD_unix_map_default_error(err); }
    345 
    346 void _MD_unix_map_rmdir_error(int err) {
    347  PRErrorCode prError;
    348 
    349  switch (err) {
    350    /*
    351     * On AIX 4.3, ENOTEMPTY is defined as EEXIST.
    352     */
    353 #if ENOTEMPTY != EEXIST
    354    case ENOTEMPTY:
    355      prError = PR_DIRECTORY_NOT_EMPTY_ERROR;
    356      break;
    357 #endif
    358    case EEXIST:
    359      prError = PR_DIRECTORY_NOT_EMPTY_ERROR;
    360      break;
    361    case EINVAL:
    362      prError = PR_DIRECTORY_NOT_EMPTY_ERROR;
    363      break;
    364    case ETIMEDOUT:
    365      prError = PR_REMOTE_FILE_ERROR;
    366      break;
    367    default:
    368      _MD_unix_map_default_error(err);
    369      return;
    370  }
    371  PR_SetError(prError, err);
    372 }
    373 
    374 void _MD_unix_map_read_error(int err) {
    375  PRErrorCode prError;
    376 
    377  switch (err) {
    378    case EINVAL:
    379      prError = PR_INVALID_METHOD_ERROR;
    380      break;
    381    case ENXIO:
    382      prError = PR_INVALID_ARGUMENT_ERROR;
    383      break;
    384    default:
    385      _MD_unix_map_default_error(err);
    386      return;
    387  }
    388  PR_SetError(prError, err);
    389 }
    390 
    391 void _MD_unix_map_write_error(int err) {
    392  PRErrorCode prError;
    393 
    394  switch (err) {
    395    case EINVAL:
    396      prError = PR_INVALID_METHOD_ERROR;
    397      break;
    398    case ENXIO:
    399      prError = PR_INVALID_METHOD_ERROR;
    400      break;
    401    case ETIMEDOUT:
    402      prError = PR_REMOTE_FILE_ERROR;
    403      break;
    404    default:
    405      _MD_unix_map_default_error(err);
    406      return;
    407  }
    408  PR_SetError(prError, err);
    409 }
    410 
    411 void _MD_unix_map_lseek_error(int err) { _MD_unix_map_default_error(err); }
    412 
    413 void _MD_unix_map_fsync_error(int err) {
    414  PRErrorCode prError;
    415 
    416  switch (err) {
    417    case ETIMEDOUT:
    418      prError = PR_REMOTE_FILE_ERROR;
    419      break;
    420    case EINVAL:
    421      prError = PR_INVALID_METHOD_ERROR;
    422      break;
    423    default:
    424      _MD_unix_map_default_error(err);
    425      return;
    426  }
    427  PR_SetError(prError, err);
    428 }
    429 
    430 void _MD_unix_map_close_error(int err) {
    431  PRErrorCode prError;
    432 
    433  switch (err) {
    434    case ETIMEDOUT:
    435      prError = PR_REMOTE_FILE_ERROR;
    436      break;
    437    default:
    438      _MD_unix_map_default_error(err);
    439      return;
    440  }
    441  PR_SetError(prError, err);
    442 }
    443 
    444 void _MD_unix_map_socket_error(int err) {
    445  PRErrorCode prError;
    446 
    447  switch (err) {
    448    case ENOMEM:
    449      prError = PR_INSUFFICIENT_RESOURCES_ERROR;
    450      break;
    451    default:
    452      _MD_unix_map_default_error(err);
    453      return;
    454  }
    455  PR_SetError(prError, err);
    456 }
    457 
    458 void _MD_unix_map_socketavailable_error(int err) {
    459  PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
    460 }
    461 
    462 void _MD_unix_map_recv_error(int err) { _MD_unix_map_default_error(err); }
    463 
    464 void _MD_unix_map_recvfrom_error(int err) { _MD_unix_map_default_error(err); }
    465 
    466 void _MD_unix_map_send_error(int err) { _MD_unix_map_default_error(err); }
    467 
    468 void _MD_unix_map_sendto_error(int err) { _MD_unix_map_default_error(err); }
    469 
    470 void _MD_unix_map_writev_error(int err) { _MD_unix_map_default_error(err); }
    471 
    472 void _MD_unix_map_accept_error(int err) {
    473  PRErrorCode prError;
    474 
    475  switch (err) {
    476    case ENODEV:
    477      prError = PR_NOT_TCP_SOCKET_ERROR;
    478      break;
    479    default:
    480      _MD_unix_map_default_error(err);
    481      return;
    482  }
    483  PR_SetError(prError, err);
    484 }
    485 
    486 void _MD_unix_map_connect_error(int err) {
    487  PRErrorCode prError;
    488 
    489  switch (err) {
    490    case ENXIO:
    491      prError = PR_IO_ERROR;
    492      break;
    493    default:
    494      _MD_unix_map_default_error(err);
    495      return;
    496  }
    497  PR_SetError(prError, err);
    498 }
    499 
    500 void _MD_unix_map_bind_error(int err) {
    501  PRErrorCode prError;
    502 
    503  switch (err) {
    504    case EINVAL:
    505      prError = PR_SOCKET_ADDRESS_IS_BOUND_ERROR;
    506      break;
    507    default:
    508      _MD_unix_map_default_error(err);
    509      return;
    510  }
    511  PR_SetError(prError, err);
    512 }
    513 
    514 void _MD_unix_map_listen_error(int err) { _MD_unix_map_default_error(err); }
    515 
    516 void _MD_unix_map_shutdown_error(int err) { _MD_unix_map_default_error(err); }
    517 
    518 void _MD_unix_map_socketpair_error(int err) {
    519  PRErrorCode prError;
    520 
    521  switch (err) {
    522    case ENOMEM:
    523      prError = PR_INSUFFICIENT_RESOURCES_ERROR;
    524      break;
    525    default:
    526      _MD_unix_map_default_error(err);
    527      return;
    528  }
    529  PR_SetError(prError, err);
    530 }
    531 
    532 void _MD_unix_map_getsockname_error(int err) {
    533  PRErrorCode prError;
    534 
    535  switch (err) {
    536    case ENOMEM:
    537      prError = PR_INSUFFICIENT_RESOURCES_ERROR;
    538      break;
    539    default:
    540      _MD_unix_map_default_error(err);
    541      return;
    542  }
    543  PR_SetError(prError, err);
    544 }
    545 
    546 void _MD_unix_map_getpeername_error(int err) {
    547  PRErrorCode prError;
    548 
    549  switch (err) {
    550    case ENOMEM:
    551      prError = PR_INSUFFICIENT_RESOURCES_ERROR;
    552      break;
    553    default:
    554      _MD_unix_map_default_error(err);
    555      return;
    556  }
    557  PR_SetError(prError, err);
    558 }
    559 
    560 void _MD_unix_map_getsockopt_error(int err) {
    561  PRErrorCode prError;
    562 
    563  switch (err) {
    564    case EINVAL:
    565      prError = PR_BUFFER_OVERFLOW_ERROR;
    566      break;
    567    case ENOMEM:
    568      prError = PR_INSUFFICIENT_RESOURCES_ERROR;
    569      break;
    570    default:
    571      _MD_unix_map_default_error(err);
    572      return;
    573  }
    574  PR_SetError(prError, err);
    575 }
    576 
    577 void _MD_unix_map_setsockopt_error(int err) {
    578  PRErrorCode prError;
    579 
    580  switch (err) {
    581    case EINVAL:
    582      prError = PR_BUFFER_OVERFLOW_ERROR;
    583      break;
    584    case ENOMEM:
    585      prError = PR_INSUFFICIENT_RESOURCES_ERROR;
    586      break;
    587    default:
    588      _MD_unix_map_default_error(err);
    589      return;
    590  }
    591  PR_SetError(prError, err);
    592 }
    593 
    594 void _MD_unix_map_open_error(int err) {
    595  PRErrorCode prError;
    596 
    597  switch (err) {
    598    case EAGAIN:
    599      prError = PR_INSUFFICIENT_RESOURCES_ERROR;
    600      break;
    601    case EBUSY:
    602      prError = PR_IO_ERROR;
    603      break;
    604    case ENODEV:
    605      prError = PR_FILE_NOT_FOUND_ERROR;
    606      break;
    607    case ENOMEM:
    608      prError = PR_INSUFFICIENT_RESOURCES_ERROR;
    609      break;
    610 #ifdef EOVERFLOW
    611    case EOVERFLOW:
    612      prError = PR_FILE_TOO_BIG_ERROR;
    613      break;
    614 #endif
    615    case ETIMEDOUT:
    616      prError = PR_REMOTE_FILE_ERROR;
    617      break;
    618    default:
    619      _MD_unix_map_default_error(err);
    620      return;
    621  }
    622  PR_SetError(prError, err);
    623 }
    624 
    625 void _MD_unix_map_mmap_error(int err) {
    626  PRErrorCode prError;
    627 
    628  switch (err) {
    629    case EAGAIN:
    630      prError = PR_INSUFFICIENT_RESOURCES_ERROR;
    631      break;
    632    case EMFILE:
    633      prError = PR_INSUFFICIENT_RESOURCES_ERROR;
    634      break;
    635    case ENODEV:
    636      prError = PR_OPERATION_NOT_SUPPORTED_ERROR;
    637      break;
    638    case ENXIO:
    639      prError = PR_INVALID_ARGUMENT_ERROR;
    640      break;
    641    default:
    642      _MD_unix_map_default_error(err);
    643      return;
    644  }
    645  PR_SetError(prError, err);
    646 }
    647 
    648 void _MD_unix_map_gethostname_error(int err) {
    649  _MD_unix_map_default_error(err);
    650 }
    651 
    652 void _MD_unix_map_select_error(int err) { _MD_unix_map_default_error(err); }
    653 
    654 #if defined(_PR_POLL_AVAILABLE) || defined(_PR_NEED_FAKE_POLL)
    655 void _MD_unix_map_poll_error(int err) {
    656  PRErrorCode prError;
    657 
    658  switch (err) {
    659    case EAGAIN:
    660      prError = PR_INSUFFICIENT_RESOURCES_ERROR;
    661      break;
    662    default:
    663      _MD_unix_map_default_error(err);
    664      return;
    665  }
    666  PR_SetError(prError, err);
    667 }
    668 
    669 void _MD_unix_map_poll_revents_error(int err) {
    670  if (err & POLLNVAL) {
    671    PR_SetError(PR_BAD_DESCRIPTOR_ERROR, EBADF);
    672  } else if (err & POLLHUP) {
    673    PR_SetError(PR_CONNECT_RESET_ERROR, EPIPE);
    674  } else if (err & POLLERR) {
    675    PR_SetError(PR_IO_ERROR, EIO);
    676  } else {
    677    PR_SetError(PR_UNKNOWN_ERROR, err);
    678  }
    679 }
    680 #endif /* _PR_POLL_AVAILABLE || _PR_NEED_FAKE_POLL */
    681 
    682 void _MD_unix_map_flock_error(int err) {
    683  PRErrorCode prError;
    684 
    685  switch (err) {
    686    case EINVAL:
    687      prError = PR_BAD_DESCRIPTOR_ERROR;
    688      break;
    689    case EWOULDBLOCK:
    690      prError = PR_FILE_IS_LOCKED_ERROR;
    691      break;
    692    default:
    693      _MD_unix_map_default_error(err);
    694      return;
    695  }
    696  PR_SetError(prError, err);
    697 }
    698 
    699 void _MD_unix_map_lockf_error(int err) {
    700  PRErrorCode prError;
    701 
    702  switch (err) {
    703    case EACCES:
    704      prError = PR_FILE_IS_LOCKED_ERROR;
    705      break;
    706    case EDEADLK:
    707      prError = PR_INSUFFICIENT_RESOURCES_ERROR;
    708      break;
    709    default:
    710      _MD_unix_map_default_error(err);
    711      return;
    712  }
    713  PR_SetError(prError, err);
    714 }
    715 
    716 #ifdef AIX
    717 void _MD_aix_map_sendfile_error(int err) { _MD_unix_map_default_error(err); }
    718 #endif /* AIX */
    719 
    720 #ifdef HPUX11
    721 void _MD_hpux_map_sendfile_error(int err) { _MD_unix_map_default_error(err); }
    722 #endif /* HPUX11 */
    723 
    724 #ifdef SOLARIS
    725 void _MD_solaris_map_sendfile_error(int err) {
    726  PRErrorCode prError;
    727 
    728  switch (err) {
    729    /*
    730     * Solaris defines a 0 return value for sendfile to mean end-of-file.
    731     */
    732    case 0:
    733      prError = PR_END_OF_FILE_ERROR;
    734      break;
    735 
    736    default:
    737      _MD_unix_map_default_error(err);
    738      return;
    739  }
    740  PR_SetError(prError, err);
    741 }
    742 #endif /* SOLARIS */
    743 
    744 #ifdef LINUX
    745 void _MD_linux_map_sendfile_error(int err) { _MD_unix_map_default_error(err); }
    746 #endif /* LINUX */