The Tor Browser: security/nss/lib/ssl/os2

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/. */

    14 #include "prerror.h"

    15 #include "prlog.h"

    16 #include <errno.h>

    19 /*

    20  * Based on win32err.c

    21  * OS2TODO Stub everything for now to build. HCT

    22  */

    24 /* forward declaration. */

    25 void nss_MD_os2_map_default_error(PRInt32 err);

    27 void nss_MD_os2_map_opendir_error(PRInt32 err)

    28 {

    29     nss_MD_os2_map_default_error(err);

    30 }

    32 void nss_MD_os2_map_closedir_error(PRInt32 err)

    33 {

    34     nss_MD_os2_map_default_error(err);

    35 }

    37 void nss_MD_os2_map_readdir_error(PRInt32 err)

    38 {

    39     nss_MD_os2_map_default_error(err);

    40 }

    42 void nss_MD_os2_map_delete_error(PRInt32 err)

    43 {

    44     nss_MD_os2_map_default_error(err);

    45 }

    47 /* The error code for stat() is in errno. */

    48 void nss_MD_os2_map_stat_error(PRInt32 err)

    49 {

    50     nss_MD_os2_map_default_error(err);

    51 }

    53 void nss_MD_os2_map_fstat_error(PRInt32 err)

    54 {

    55     nss_MD_os2_map_default_error(err);

    56 }

    58 void nss_MD_os2_map_rename_error(PRInt32 err)

    59 {

    60     nss_MD_os2_map_default_error(err);

    61 }

    63 /* The error code for access() is in errno. */

    64 void nss_MD_os2_map_access_error(PRInt32 err)

    65 {

    66     nss_MD_os2_map_default_error(err);

    67 }

    69 void nss_MD_os2_map_mkdir_error(PRInt32 err)

    70 {

    71     nss_MD_os2_map_default_error(err);

    72 }

    74 void nss_MD_os2_map_rmdir_error(PRInt32 err)

    75 {

    76     nss_MD_os2_map_default_error(err);

    77 }

    79 void nss_MD_os2_map_read_error(PRInt32 err)

    80 {

    81     nss_MD_os2_map_default_error(err);

    82 }

    84 void nss_MD_os2_map_transmitfile_error(PRInt32 err)

    85 {

    86     nss_MD_os2_map_default_error(err);

    87 }

    89 void nss_MD_os2_map_write_error(PRInt32 err)

    90 {

    91     nss_MD_os2_map_default_error(err);

    92 }

    94 void nss_MD_os2_map_lseek_error(PRInt32 err)

    95 {

    96     nss_MD_os2_map_default_error(err);

    97 }

    99 void nss_MD_os2_map_fsync_error(PRInt32 err)

   100 {

   101     nss_MD_os2_map_default_error(err);

   102 }

   104 /*

   105  * For both CloseHandle() and closesocket().

   106  */

   107 void nss_MD_os2_map_close_error(PRInt32 err)

   108 {

   109     nss_MD_os2_map_default_error(err);

   110 }

   112 void nss_MD_os2_map_socket_error(PRInt32 err)

   113 {

   114 //  PR_ASSERT(err != WSANOTINITIALISED);

   115     nss_MD_os2_map_default_error(err);

   116 }

   118 void nss_MD_os2_map_recv_error(PRInt32 err)

   119 {

   120     nss_MD_os2_map_default_error(err);

   121 }

   123 void nss_MD_os2_map_recvfrom_error(PRInt32 err)

   124 {

   125     nss_MD_os2_map_default_error(err);

   126 }

   128 void nss_MD_os2_map_send_error(PRInt32 err)

   129 {

   130     PRErrorCode prError;

   131     switch (err) {

   132 //     case WSAEMSGSIZE: 	prError = PR_INVALID_ARGUMENT_ERROR; break;

   133     default:		nss_MD_os2_map_default_error(err); return;

   134     }

   135     PR_SetError(prError, err);

   136 }

   138 void nss_MD_os2_map_sendto_error(PRInt32 err)

   139 {

   140     PRErrorCode prError;

   141     switch (err) {

   142 //    case WSAEMSGSIZE: 	prError = PR_INVALID_ARGUMENT_ERROR; break;

   143     default:		nss_MD_os2_map_default_error(err); return;

   144     }

   145     PR_SetError(prError, err);

   146 }

   148 void nss_MD_os2_map_accept_error(PRInt32 err)

   149 {

   150     PRErrorCode prError;

   151     switch (err) {

   152 //    case WSAEOPNOTSUPP: prError = PR_NOT_TCP_SOCKET_ERROR; break;

   153 //    case WSAEINVAL: 	prError = PR_INVALID_STATE_ERROR; break;

   154     default:		nss_MD_os2_map_default_error(err); return;

   155     }

   156     PR_SetError(prError, err);

   157 }

   159 void nss_MD_os2_map_acceptex_error(PRInt32 err)

   160 {

   161     nss_MD_os2_map_default_error(err);

   162 }

   164 void nss_MD_os2_map_connect_error(PRInt32 err)

   165 {

   166     PRErrorCode prError;

   167     switch (err) {

   168 //    case WSAEWOULDBLOCK: prError = PR_IN_PROGRESS_ERROR; break;

   169 //    case WSAEINVAL: 	prError = PR_ALREADY_INITIATED_ERROR; break;

   170 //    case WSAETIMEDOUT: 	prError = PR_IO_TIMEOUT_ERROR; break;

   171     default:		nss_MD_os2_map_default_error(err); return;

   172     }

   173     PR_SetError(prError, err);

   174 }

   176 void nss_MD_os2_map_bind_error(PRInt32 err)

   177 {

   178     PRErrorCode prError;

   179     switch (err) {

   180 //  case WSAEINVAL: 	prError = PR_SOCKET_ADDRESS_IS_BOUND_ERROR; break;

   181     default:		nss_MD_os2_map_default_error(err); return;

   182     }

   183     PR_SetError(prError, err);

   184 }

   186 void nss_MD_os2_map_listen_error(PRInt32 err)

   187 {

   188     PRErrorCode prError;

   189     switch (err) {

   190 //    case WSAEOPNOTSUPP: prError = PR_NOT_TCP_SOCKET_ERROR; break;

   191 //    case WSAEINVAL: 	prError = PR_INVALID_STATE_ERROR; break;

   192     default:		nss_MD_os2_map_default_error(err); return;

   193     }

   194     PR_SetError(prError, err);

   195 }

   197 void nss_MD_os2_map_shutdown_error(PRInt32 err)

   198 {

   199     nss_MD_os2_map_default_error(err);

   200 }

   202 void nss_MD_os2_map_getsockname_error(PRInt32 err)

   203 {

   204     PRErrorCode prError;

   205     switch (err) {

   206 //    case WSAEINVAL: 	prError = PR_INVALID_STATE_ERROR; break;

   207     default:		nss_MD_os2_map_default_error(err); return;

   208     }

   209     PR_SetError(prError, err);

   210 }

   212 void nss_MD_os2_map_getpeername_error(PRInt32 err)

   213 {

   214     nss_MD_os2_map_default_error(err);

   215 }

   217 void nss_MD_os2_map_getsockopt_error(PRInt32 err)

   218 {

   219     nss_MD_os2_map_default_error(err);

   220 }

   222 void nss_MD_os2_map_setsockopt_error(PRInt32 err)

   223 {

   224     nss_MD_os2_map_default_error(err);

   225 }

   227 void nss_MD_os2_map_open_error(PRInt32 err)

   228 {

   229     nss_MD_os2_map_default_error(err);

   230 }

   232 void nss_MD_os2_map_gethostname_error(PRInt32 err)

   233 {

   234     nss_MD_os2_map_default_error(err);

   235 }

   237 /* Win32 select() only works on sockets.  So in this

   238 ** context, WSAENOTSOCK is equivalent to EBADF on Unix.

   239 */

   240 void nss_MD_os2_map_select_error(PRInt32 err)

   241 {

   242     PRErrorCode prError;

   243     switch (err) {

   244 //    case WSAENOTSOCK:	prError = PR_BAD_DESCRIPTOR_ERROR; break;

   245     default:		nss_MD_os2_map_default_error(err); return;

   246     }

   247     PR_SetError(prError, err);

   248 }

   250 void nss_MD_os2_map_lockf_error(PRInt32 err)

   251 {

   252     nss_MD_os2_map_default_error(err);

   253 }

   257 void nss_MD_os2_map_default_error(PRInt32 err)

   258 {

   259     PRErrorCode prError;

   261     switch (err) {

   262 //    case ENOENT: 		prError = PR_FILE_NOT_FOUND_ERROR; break;

   263 //    case ERROR_ACCESS_DENIED: 	prError = PR_NO_ACCESS_RIGHTS_ERROR; break;

   264 //    case ERROR_ALREADY_EXISTS: 	prError = PR_FILE_EXISTS_ERROR; break;

   265 //    case ERROR_DISK_CORRUPT: 	prError = PR_IO_ERROR; break;

   266 //    case ERROR_DISK_FULL: 	prError = PR_NO_DEVICE_SPACE_ERROR; break;

   267 //    case ERROR_DISK_OPERATION_FAILED: prError = PR_IO_ERROR; break;

   268 //    case ERROR_DRIVE_LOCKED: 	prError = PR_FILE_IS_LOCKED_ERROR; break;

   269 //    case ERROR_FILENAME_EXCED_RANGE: prError = PR_NAME_TOO_LONG_ERROR; break;

   270 //    case ERROR_FILE_CORRUPT: 	prError = PR_IO_ERROR; break;

   271 //    case ERROR_FILE_EXISTS: 	prError = PR_FILE_EXISTS_ERROR; break;

   272 //    case ERROR_FILE_INVALID: 	prError = PR_BAD_DESCRIPTOR_ERROR; break;

   273 #if ERROR_FILE_NOT_FOUND != ENOENT

   274 //    case ERROR_FILE_NOT_FOUND: 	prError = PR_FILE_NOT_FOUND_ERROR; break;

   275 #endif

   276     default: 			prError = PR_UNKNOWN_ERROR; break;

   277     }

   278     PR_SetError(prError, err);

   279 }

The Tor Browser / file revision

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

security/nss/lib/ssl/os2_err.c