The Tor Browser / file revision

security/nss/lib/ssl/unix_err.c@b8a032363ba2

security/nss/lib/ssl/unix_err.c

Thu, 22 Jan 2015 13:21:57 +0100

author
Michael Schloh von Bennewitz <michael@schloh.com>
date
Thu, 22 Jan 2015 13:21:57 +0100
branch
TOR_BUG_9701
changeset 15
b8a032363ba2
permissions
-rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

     1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

     2 /*

     3  * This file essentially replicates NSPR's source for the functions that

     4  * map system-specific error codes to NSPR error codes.  We would use 

     5  * NSPR's functions, instead of duplicating them, but they're private.

     6  * As long as SSL's server session cache code must do platform native I/O

     7  * to accomplish its job, and NSPR's error mapping functions remain private,

     8  * this code will continue to need to be replicated.

     9  * 

    10  * This Source Code Form is subject to the terms of the Mozilla Public

    11  * License, v. 2.0. If a copy of the MPL was not distributed with this

    12  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

    13 

    14 #if 0

    15 #include "primpl.h"

    16 #else

    17 #define _PR_POLL_AVAILABLE 1

    18 #include "prerror.h"

    19 #endif

    20 

    21 #if defined (__bsdi__) || defined(NTO) || defined(DARWIN) || defined(BEOS)

    22 #undef _PR_POLL_AVAILABLE

    23 #endif

    24 

    25 #if defined(_PR_POLL_AVAILABLE)

    26 #include <poll.h>

    27 #endif

    28 #include <errno.h>

    29 

    30 /* forward declarations. */

    31 void nss_MD_unix_map_default_error(int err);

    32 

    33 void nss_MD_unix_map_opendir_error(int err)

    34 {

    35     nss_MD_unix_map_default_error(err);

    36 }

    37 

    38 void nss_MD_unix_map_closedir_error(int err)

    39 {

    40     PRErrorCode prError;

    41     switch (err) {

    42     case EINVAL:	prError = PR_BAD_DESCRIPTOR_ERROR; break;

    43     default:		nss_MD_unix_map_default_error(err); return;

    44     }

    45     PR_SetError(prError, err);

    46 }

    47 

    48 void nss_MD_unix_readdir_error(int err)

    49 {

    50     PRErrorCode prError;

    51 

    52     switch (err) {

    53     case ENOENT:	prError = PR_NO_MORE_FILES_ERROR; break;

    54 #ifdef EOVERFLOW

    55     case EOVERFLOW:	prError = PR_IO_ERROR; break;

    56 #endif

    57     case EINVAL:	prError = PR_IO_ERROR; break;

    58     case ENXIO:		prError = PR_IO_ERROR; break;

    59     default:		nss_MD_unix_map_default_error(err); return;

    60     }

    61     PR_SetError(prError, err);

    62 }

    63 

    64 void nss_MD_unix_map_unlink_error(int err)

    65 {

    66     PRErrorCode prError;

    67     switch (err) {

    68     case EPERM:		prError = PR_IS_DIRECTORY_ERROR; break;

    69     default:		nss_MD_unix_map_default_error(err); return;

    70     }

    71     PR_SetError(prError, err);

    72 }

    73 

    74 void nss_MD_unix_map_stat_error(int err)

    75 {

    76     PRErrorCode prError;

    77     switch (err) {

    78     case ETIMEDOUT:	prError = PR_REMOTE_FILE_ERROR; break;

    79     default:		nss_MD_unix_map_default_error(err); return;

    80     }

    81     PR_SetError(prError, err);

    82 }

    83 

    84 void nss_MD_unix_map_fstat_error(int err)

    85 {

    86     PRErrorCode prError;

    87     switch (err) {

    88     case ETIMEDOUT:	prError = PR_REMOTE_FILE_ERROR; break;

    89     default:		nss_MD_unix_map_default_error(err); return;

    90     }

    91     PR_SetError(prError, err);

    92 }

    93 

    94 void nss_MD_unix_map_rename_error(int err)

    95 {

    96     PRErrorCode prError;

    97     switch (err) {

    98     case EEXIST:	prError = PR_DIRECTORY_NOT_EMPTY_ERROR; break;

    99     default:		nss_MD_unix_map_default_error(err); return;

   100     }

   101     PR_SetError(prError, err);

   102 }

   103 

   104 void nss_MD_unix_map_access_error(int err)

   105 {

   106     PRErrorCode prError;

   107     switch (err) {

   108     case ETIMEDOUT:	prError = PR_REMOTE_FILE_ERROR; break;

   109     default:		nss_MD_unix_map_default_error(err); return;

   110     }

   111     PR_SetError(prError, err);

   112 }

   113 

   114 void nss_MD_unix_map_mkdir_error(int err)

   115 {

   116     nss_MD_unix_map_default_error(err);

   117 }

   118 

   119 void nss_MD_unix_map_rmdir_error(int err)

   120 {

   121     PRErrorCode prError;

   122 

   123     switch (err) {

   124     case EEXIST:	prError = PR_DIRECTORY_NOT_EMPTY_ERROR; break;

   125     case EINVAL:	prError = PR_DIRECTORY_NOT_EMPTY_ERROR; break;

   126     case ETIMEDOUT:	prError = PR_REMOTE_FILE_ERROR; break;

   127     default:		nss_MD_unix_map_default_error(err); return;

   128     }

   129     PR_SetError(prError, err);

   130 }

   131 

   132 void nss_MD_unix_map_read_error(int err)

   133 {

   134     PRErrorCode prError;

   135     switch (err) {

   136     case EINVAL:	prError = PR_INVALID_METHOD_ERROR; break;

   137     case ENXIO:		prError = PR_INVALID_ARGUMENT_ERROR; break;

   138     default:		nss_MD_unix_map_default_error(err); return;

   139     }

   140     PR_SetError(prError, err);

   141 }

   142 

   143 void nss_MD_unix_map_write_error(int err)

   144 {

   145     PRErrorCode prError;

   146     switch (err) {

   147     case EINVAL:	prError = PR_INVALID_METHOD_ERROR; break;

   148     case ENXIO:		prError = PR_INVALID_METHOD_ERROR; break;

   149     case ETIMEDOUT:	prError = PR_REMOTE_FILE_ERROR; break;

   150     default:		nss_MD_unix_map_default_error(err); return;

   151     }

   152     PR_SetError(prError, err);

   153 }

   154 

   155 void nss_MD_unix_map_lseek_error(int err)

   156 {

   157     nss_MD_unix_map_default_error(err);

   158 }

   159 

   160 void nss_MD_unix_map_fsync_error(int err)

   161 {

   162     PRErrorCode prError;

   163     switch (err) {

   164     case ETIMEDOUT:	prError = PR_REMOTE_FILE_ERROR; break;

   165     case EINVAL:	prError = PR_INVALID_METHOD_ERROR; break;

   166     default:		nss_MD_unix_map_default_error(err); return;

   167     }

   168     PR_SetError(prError, err);

   169 }

   170 

   171 void nss_MD_unix_map_close_error(int err)

   172 {

   173     PRErrorCode prError;

   174     switch (err) {

   175     case ETIMEDOUT:	prError = PR_REMOTE_FILE_ERROR; break;

   176     default:		nss_MD_unix_map_default_error(err); return;

   177     }

   178     PR_SetError(prError, err);

   179 }

   180 

   181 void nss_MD_unix_map_socket_error(int err)

   182 {

   183     PRErrorCode prError;

   184     switch (err) {

   185     case ENOMEM:	prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;

   186     default:		nss_MD_unix_map_default_error(err); return;

   187     }

   188     PR_SetError(prError, err);

   189 }

   190 

   191 void nss_MD_unix_map_socketavailable_error(int err)

   192 {

   193     PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);

   194 }

   195 

   196 void nss_MD_unix_map_recv_error(int err)

   197 {

   198     nss_MD_unix_map_default_error(err);

   199 }

   200 

   201 void nss_MD_unix_map_recvfrom_error(int err)

   202 {

   203     nss_MD_unix_map_default_error(err);

   204 }

   205 

   206 void nss_MD_unix_map_send_error(int err)

   207 {

   208     nss_MD_unix_map_default_error(err);

   209 }

   210 

   211 void nss_MD_unix_map_sendto_error(int err)

   212 {

   213     nss_MD_unix_map_default_error(err);

   214 }

   215 

   216 void nss_MD_unix_map_writev_error(int err)

   217 {

   218     nss_MD_unix_map_default_error(err);

   219 }

   220 

   221 void nss_MD_unix_map_accept_error(int err)

   222 {

   223     PRErrorCode prError;

   224     switch (err) {

   225     case ENODEV:	prError = PR_NOT_TCP_SOCKET_ERROR; break;

   226     default:		nss_MD_unix_map_default_error(err); return;

   227     }

   228     PR_SetError(prError, err);

   229 }

   230 

   231 void nss_MD_unix_map_connect_error(int err)

   232 {

   233     PRErrorCode prError;

   234     switch (err) {

   235     case EACCES:	prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;

   236 #if defined(UNIXWARE) || defined(SNI) || defined(NEC)

   237     /*

   238      * On some platforms, if we connect to a port on the local host 

   239      * (the loopback address) that no process is listening on, we get 

   240      * EIO instead of ECONNREFUSED.

   241      */

   242     case EIO:		prError = PR_CONNECT_REFUSED_ERROR; break;

   243 #endif

   244     case ELOOP:		prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;

   245     case ENOENT:	prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;

   246     case ENXIO:		prError = PR_IO_ERROR; break;

   247     default:		nss_MD_unix_map_default_error(err); return;

   248     }

   249     PR_SetError(prError, err);

   250 }

   251 

   252 void nss_MD_unix_map_bind_error(int err)

   253 {

   254     PRErrorCode prError;

   255     switch (err) {

   256     case EINVAL:	prError = PR_SOCKET_ADDRESS_IS_BOUND_ERROR; break;

   257         /*

   258          * UNIX domain sockets are not supported in NSPR

   259          */

   260     case EIO:		prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;

   261     case EISDIR:	prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;

   262     case ELOOP:		prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;

   263     case ENOENT:	prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;

   264     case ENOTDIR:	prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;

   265     case EROFS:		prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;

   266     default:		nss_MD_unix_map_default_error(err); return;

   267     }

   268     PR_SetError(prError, err);

   269 }

   270 

   271 void nss_MD_unix_map_listen_error(int err)

   272 {

   273     nss_MD_unix_map_default_error(err);

   274 }

   275 

   276 void nss_MD_unix_map_shutdown_error(int err)

   277 {

   278     nss_MD_unix_map_default_error(err);

   279 }

   280 

   281 void nss_MD_unix_map_socketpair_error(int err)

   282 {

   283     PRErrorCode prError;

   284     switch (err) {

   285     case ENOMEM:	prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;

   286     default:		nss_MD_unix_map_default_error(err); return;

   287     }

   288     PR_SetError(prError, err);

   289 }

   290 

   291 void nss_MD_unix_map_getsockname_error(int err)

   292 {

   293     PRErrorCode prError;

   294     switch (err) {

   295     case ENOMEM:	prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;

   296     default:		nss_MD_unix_map_default_error(err); return;

   297     }

   298     PR_SetError(prError, err);

   299 }

   300 

   301 void nss_MD_unix_map_getpeername_error(int err)

   302 {

   303     PRErrorCode prError;

   304 

   305     switch (err) {

   306     case ENOMEM:	prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;

   307     default:		nss_MD_unix_map_default_error(err); return;

   308     }

   309     PR_SetError(prError, err);

   310 }

   311 

   312 void nss_MD_unix_map_getsockopt_error(int err)

   313 {

   314     PRErrorCode prError;

   315     switch (err) {

   316     case EINVAL:	prError = PR_BUFFER_OVERFLOW_ERROR; break;

   317     case ENOMEM:	prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;

   318     default:		nss_MD_unix_map_default_error(err); return;

   319     }

   320     PR_SetError(prError, err);

   321 }

   322 

   323 void nss_MD_unix_map_setsockopt_error(int err)

   324 {

   325     PRErrorCode prError;

   326     switch (err) {

   327     case EINVAL:	prError = PR_BUFFER_OVERFLOW_ERROR; break;

   328     case ENOMEM:	prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;

   329     default:		nss_MD_unix_map_default_error(err); return;

   330     }

   331     PR_SetError(prError, err);

   332 }

   333 

   334 void nss_MD_unix_map_open_error(int err)

   335 {

   336     PRErrorCode prError;

   337     switch (err) {

   338     case EAGAIN:	prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;

   339     case EBUSY:		prError = PR_IO_ERROR; break;

   340     case ENODEV:	prError = PR_FILE_NOT_FOUND_ERROR; break;

   341     case ENOMEM:	prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;

   342     case ETIMEDOUT:	prError = PR_REMOTE_FILE_ERROR; break;

   343     default:		nss_MD_unix_map_default_error(err); return;

   344     }

   345     PR_SetError(prError, err);

   346 }

   347 

   348 void nss_MD_unix_map_mmap_error(int err)

   349 {

   350     PRErrorCode prError;

   351     switch (err) {

   352     case EAGAIN:	prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;

   353     case EMFILE:	prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;

   354     case ENODEV:	prError = PR_OPERATION_NOT_SUPPORTED_ERROR; break;

   355     case ENXIO:		prError = PR_INVALID_ARGUMENT_ERROR; break;

   356     default:		nss_MD_unix_map_default_error(err); return;

   357     }

   358     PR_SetError(prError, err);

   359 }

   360 

   361 void nss_MD_unix_map_gethostname_error(int err)

   362 {

   363     nss_MD_unix_map_default_error(err);

   364 }

   365 

   366 void nss_MD_unix_map_select_error(int err)

   367 {

   368     nss_MD_unix_map_default_error(err);

   369 }

   370 

   371 #ifdef _PR_POLL_AVAILABLE

   372 void nss_MD_unix_map_poll_error(int err)

   373 {

   374     PRErrorCode prError;

   375 

   376     switch (err) {

   377     case EAGAIN:	prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;

   378     default:		nss_MD_unix_map_default_error(err); return;

   379     }

   380     PR_SetError(prError, err);

   381 }

   382 

   383 void nss_MD_unix_map_poll_revents_error(int err)

   384 {

   385     if (err & POLLNVAL)

   386         PR_SetError(PR_BAD_DESCRIPTOR_ERROR, EBADF);

   387     else if (err & POLLHUP)

   388         PR_SetError(PR_CONNECT_RESET_ERROR, EPIPE);

   389     else if (err & POLLERR)

   390         PR_SetError(PR_IO_ERROR, EIO);

   391     else

   392         PR_SetError(PR_UNKNOWN_ERROR, err);

   393 }

   394 #endif /* _PR_POLL_AVAILABLE */

   395 

   396 

   397 void nss_MD_unix_map_flock_error(int err)

   398 {

   399     PRErrorCode prError;

   400     switch (err) {

   401     case EINVAL:	prError = PR_BAD_DESCRIPTOR_ERROR; break;

   402     case EWOULDBLOCK:	prError = PR_FILE_IS_LOCKED_ERROR; break;

   403     default:		nss_MD_unix_map_default_error(err); return;

   404     }

   405     PR_SetError(prError, err);

   406 }

   407 

   408 void nss_MD_unix_map_lockf_error(int err)

   409 {

   410     PRErrorCode prError;

   411     switch (err) {

   412     case EACCES:	prError = PR_FILE_IS_LOCKED_ERROR; break;

   413     case EDEADLK:	prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;

   414     default:		nss_MD_unix_map_default_error(err); return;

   415     }

   416     PR_SetError(prError, err);

   417 }

   418 

   419 #ifdef HPUX11

   420 void nss_MD_hpux_map_sendfile_error(int err)

   421 {

   422     nss_MD_unix_map_default_error(err);

   423 }

   424 #endif /* HPUX11 */

   425 

   426 

   427 void nss_MD_unix_map_default_error(int err)

   428 {

   429     PRErrorCode prError;

   430     switch (err ) {

   431     case EACCES:	prError = PR_NO_ACCESS_RIGHTS_ERROR; break;

   432     case EADDRINUSE:	prError = PR_ADDRESS_IN_USE_ERROR; break;

   433     case EADDRNOTAVAIL:	prError = PR_ADDRESS_NOT_AVAILABLE_ERROR; break;

   434     case EAFNOSUPPORT:	prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;

   435     case EAGAIN:	prError = PR_WOULD_BLOCK_ERROR; break;

   436     /*

   437      * On QNX and Neutrino, EALREADY is defined as EBUSY.

   438      */

   439 #if EALREADY != EBUSY

   440     case EALREADY:	prError = PR_ALREADY_INITIATED_ERROR; break;

   441 #endif

   442     case EBADF:		prError = PR_BAD_DESCRIPTOR_ERROR; break;

   443 #ifdef EBADMSG

   444     case EBADMSG:	prError = PR_IO_ERROR; break;

   445 #endif

   446     case EBUSY:		prError = PR_FILESYSTEM_MOUNTED_ERROR; break;

   447     case ECONNREFUSED:	prError = PR_CONNECT_REFUSED_ERROR; break;

   448     case ECONNRESET:	prError = PR_CONNECT_RESET_ERROR; break;

   449     case EDEADLK:	prError = PR_DEADLOCK_ERROR; break;

   450 #ifdef EDIRCORRUPTED

   451     case EDIRCORRUPTED:	prError = PR_DIRECTORY_CORRUPTED_ERROR; break;

   452 #endif

   453 #ifdef EDQUOT

   454     case EDQUOT:	prError = PR_NO_DEVICE_SPACE_ERROR; break;

   455 #endif

   456     case EEXIST:	prError = PR_FILE_EXISTS_ERROR; break;

   457     case EFAULT:	prError = PR_ACCESS_FAULT_ERROR; break;

   458     case EFBIG:		prError = PR_FILE_TOO_BIG_ERROR; break;

   459     case EINPROGRESS:	prError = PR_IN_PROGRESS_ERROR; break;

   460     case EINTR:		prError = PR_PENDING_INTERRUPT_ERROR; break;

   461     case EINVAL:	prError = PR_INVALID_ARGUMENT_ERROR; break;

   462     case EIO:		prError = PR_IO_ERROR; break;

   463     case EISCONN:	prError = PR_IS_CONNECTED_ERROR; break;

   464     case EISDIR:	prError = PR_IS_DIRECTORY_ERROR; break;

   465     case ELOOP:		prError = PR_LOOP_ERROR; break;

   466     case EMFILE:	prError = PR_PROC_DESC_TABLE_FULL_ERROR; break;

   467     case EMLINK:	prError = PR_MAX_DIRECTORY_ENTRIES_ERROR; break;

   468     case EMSGSIZE:	prError = PR_INVALID_ARGUMENT_ERROR; break;

   469 #ifdef EMULTIHOP

   470     case EMULTIHOP:	prError = PR_REMOTE_FILE_ERROR; break;

   471 #endif

   472     case ENAMETOOLONG:	prError = PR_NAME_TOO_LONG_ERROR; break;

   473     case ENETUNREACH:	prError = PR_NETWORK_UNREACHABLE_ERROR; break;

   474     case ENFILE:	prError = PR_SYS_DESC_TABLE_FULL_ERROR; break;

   475 #if !defined(SCO)

   476     case ENOBUFS:	prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;

   477 #endif

   478     case ENODEV:	prError = PR_FILE_NOT_FOUND_ERROR; break;

   479     case ENOENT:	prError = PR_FILE_NOT_FOUND_ERROR; break;

   480     case ENOLCK:	prError = PR_FILE_IS_LOCKED_ERROR; break;

   481 #ifdef ENOLINK 

   482     case ENOLINK:	prError = PR_REMOTE_FILE_ERROR; break;

   483 #endif

   484     case ENOMEM:	prError = PR_OUT_OF_MEMORY_ERROR; break;

   485     case ENOPROTOOPT:	prError = PR_INVALID_ARGUMENT_ERROR; break;

   486     case ENOSPC:	prError = PR_NO_DEVICE_SPACE_ERROR; break;

   487 #ifdef ENOSR 

   488     case ENOSR:		prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;

   489 #endif

   490     case ENOTCONN:	prError = PR_NOT_CONNECTED_ERROR; break;

   491     case ENOTDIR:	prError = PR_NOT_DIRECTORY_ERROR; break;

   492     case ENOTSOCK:	prError = PR_NOT_SOCKET_ERROR; break;

   493     case ENXIO:		prError = PR_FILE_NOT_FOUND_ERROR; break;

   494     case EOPNOTSUPP:	prError = PR_NOT_TCP_SOCKET_ERROR; break;

   495 #ifdef EOVERFLOW

   496     case EOVERFLOW:	prError = PR_BUFFER_OVERFLOW_ERROR; break;

   497 #endif

   498     case EPERM:		prError = PR_NO_ACCESS_RIGHTS_ERROR; break;

   499     case EPIPE:		prError = PR_CONNECT_RESET_ERROR; break;

   500 #ifdef EPROTO

   501     case EPROTO:	prError = PR_IO_ERROR; break;

   502 #endif

   503     case EPROTONOSUPPORT: prError = PR_PROTOCOL_NOT_SUPPORTED_ERROR; break;

   504     case EPROTOTYPE:	prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;

   505     case ERANGE:	prError = PR_INVALID_METHOD_ERROR; break;

   506     case EROFS:		prError = PR_READ_ONLY_FILESYSTEM_ERROR; break;

   507     case ESPIPE:	prError = PR_INVALID_METHOD_ERROR; break;

   508     case ETIMEDOUT:	prError = PR_IO_TIMEOUT_ERROR; break;

   509 #if EWOULDBLOCK != EAGAIN

   510     case EWOULDBLOCK:	prError = PR_WOULD_BLOCK_ERROR; break;

   511 #endif

   512     case EXDEV:		prError = PR_NOT_SAME_DEVICE_ERROR; break;

   513 

   514     default:		prError = PR_UNKNOWN_ERROR; break;

   515     }

   516     PR_SetError(prError, err);

   517 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial