win32err.c (13713B)
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 #include "prerror.h" 15 #include "prlog.h" 16 #include <errno.h> 17 #include <windows.h> 18 19 /* 20 * On Win32, we map three kinds of error codes: 21 * - GetLastError(): for Win32 functions 22 * - WSAGetLastError(): for Winsock functions 23 * - errno: for standard C library functions 24 * 25 * We do not check for WSAEINPROGRESS and WSAEINTR because we do not 26 * use blocking Winsock 1.1 calls. 27 * 28 * Except for the 'socket' call, we do not check for WSAEINITIALISED. 29 * It is assumed that if Winsock is not initialized, that fact will 30 * be detected at the time we create new sockets. 31 */ 32 33 /* forward declaration. */ 34 void nss_MD_win32_map_default_error(PRInt32 err); 35 36 void 37 nss_MD_win32_map_opendir_error(PRInt32 err) 38 { 39 nss_MD_win32_map_default_error(err); 40 } 41 42 void 43 nss_MD_win32_map_closedir_error(PRInt32 err) 44 { 45 nss_MD_win32_map_default_error(err); 46 } 47 48 void 49 nss_MD_win32_map_readdir_error(PRInt32 err) 50 { 51 nss_MD_win32_map_default_error(err); 52 } 53 54 void 55 nss_MD_win32_map_delete_error(PRInt32 err) 56 { 57 nss_MD_win32_map_default_error(err); 58 } 59 60 /* The error code for stat() is in errno. */ 61 void 62 nss_MD_win32_map_stat_error(PRInt32 err) 63 { 64 nss_MD_win32_map_default_error(err); 65 } 66 67 void 68 nss_MD_win32_map_fstat_error(PRInt32 err) 69 { 70 nss_MD_win32_map_default_error(err); 71 } 72 73 void 74 nss_MD_win32_map_rename_error(PRInt32 err) 75 { 76 nss_MD_win32_map_default_error(err); 77 } 78 79 /* The error code for access() is in errno. */ 80 void 81 nss_MD_win32_map_access_error(PRInt32 err) 82 { 83 nss_MD_win32_map_default_error(err); 84 } 85 86 void 87 nss_MD_win32_map_mkdir_error(PRInt32 err) 88 { 89 nss_MD_win32_map_default_error(err); 90 } 91 92 void 93 nss_MD_win32_map_rmdir_error(PRInt32 err) 94 { 95 nss_MD_win32_map_default_error(err); 96 } 97 98 void 99 nss_MD_win32_map_read_error(PRInt32 err) 100 { 101 nss_MD_win32_map_default_error(err); 102 } 103 104 void 105 nss_MD_win32_map_transmitfile_error(PRInt32 err) 106 { 107 nss_MD_win32_map_default_error(err); 108 } 109 110 void 111 nss_MD_win32_map_write_error(PRInt32 err) 112 { 113 nss_MD_win32_map_default_error(err); 114 } 115 116 void 117 nss_MD_win32_map_lseek_error(PRInt32 err) 118 { 119 nss_MD_win32_map_default_error(err); 120 } 121 122 void 123 nss_MD_win32_map_fsync_error(PRInt32 err) 124 { 125 nss_MD_win32_map_default_error(err); 126 } 127 128 /* 129 * For both CloseHandle() and closesocket(). 130 */ 131 void 132 nss_MD_win32_map_close_error(PRInt32 err) 133 { 134 nss_MD_win32_map_default_error(err); 135 } 136 137 void 138 nss_MD_win32_map_socket_error(PRInt32 err) 139 { 140 PR_ASSERT(err != WSANOTINITIALISED); 141 nss_MD_win32_map_default_error(err); 142 } 143 144 void 145 nss_MD_win32_map_recv_error(PRInt32 err) 146 { 147 nss_MD_win32_map_default_error(err); 148 } 149 150 void 151 nss_MD_win32_map_recvfrom_error(PRInt32 err) 152 { 153 nss_MD_win32_map_default_error(err); 154 } 155 156 void 157 nss_MD_win32_map_send_error(PRInt32 err) 158 { 159 PRErrorCode prError; 160 switch (err) { 161 case WSAEMSGSIZE: 162 prError = PR_INVALID_ARGUMENT_ERROR; 163 break; 164 default: 165 nss_MD_win32_map_default_error(err); 166 return; 167 } 168 PR_SetError(prError, err); 169 } 170 171 void 172 nss_MD_win32_map_sendto_error(PRInt32 err) 173 { 174 PRErrorCode prError; 175 switch (err) { 176 case WSAEMSGSIZE: 177 prError = PR_INVALID_ARGUMENT_ERROR; 178 break; 179 default: 180 nss_MD_win32_map_default_error(err); 181 return; 182 } 183 PR_SetError(prError, err); 184 } 185 186 void 187 nss_MD_win32_map_accept_error(PRInt32 err) 188 { 189 PRErrorCode prError; 190 switch (err) { 191 case WSAEOPNOTSUPP: 192 prError = PR_NOT_TCP_SOCKET_ERROR; 193 break; 194 case WSAEINVAL: 195 prError = PR_INVALID_STATE_ERROR; 196 break; 197 default: 198 nss_MD_win32_map_default_error(err); 199 return; 200 } 201 PR_SetError(prError, err); 202 } 203 204 void 205 nss_MD_win32_map_acceptex_error(PRInt32 err) 206 { 207 nss_MD_win32_map_default_error(err); 208 } 209 210 void 211 nss_MD_win32_map_connect_error(PRInt32 err) 212 { 213 PRErrorCode prError; 214 switch (err) { 215 case WSAEWOULDBLOCK: 216 prError = PR_IN_PROGRESS_ERROR; 217 break; 218 case WSAEINVAL: 219 prError = PR_ALREADY_INITIATED_ERROR; 220 break; 221 case WSAETIMEDOUT: 222 prError = PR_IO_TIMEOUT_ERROR; 223 break; 224 default: 225 nss_MD_win32_map_default_error(err); 226 return; 227 } 228 PR_SetError(prError, err); 229 } 230 231 void 232 nss_MD_win32_map_bind_error(PRInt32 err) 233 { 234 PRErrorCode prError; 235 switch (err) { 236 case WSAEINVAL: 237 prError = PR_SOCKET_ADDRESS_IS_BOUND_ERROR; 238 break; 239 default: 240 nss_MD_win32_map_default_error(err); 241 return; 242 } 243 PR_SetError(prError, err); 244 } 245 246 void 247 nss_MD_win32_map_listen_error(PRInt32 err) 248 { 249 PRErrorCode prError; 250 switch (err) { 251 case WSAEOPNOTSUPP: 252 prError = PR_NOT_TCP_SOCKET_ERROR; 253 break; 254 case WSAEINVAL: 255 prError = PR_INVALID_STATE_ERROR; 256 break; 257 default: 258 nss_MD_win32_map_default_error(err); 259 return; 260 } 261 PR_SetError(prError, err); 262 } 263 264 void 265 nss_MD_win32_map_shutdown_error(PRInt32 err) 266 { 267 nss_MD_win32_map_default_error(err); 268 } 269 270 void 271 nss_MD_win32_map_getsockname_error(PRInt32 err) 272 { 273 PRErrorCode prError; 274 switch (err) { 275 case WSAEINVAL: 276 prError = PR_INVALID_STATE_ERROR; 277 break; 278 default: 279 nss_MD_win32_map_default_error(err); 280 return; 281 } 282 PR_SetError(prError, err); 283 } 284 285 void 286 nss_MD_win32_map_getpeername_error(PRInt32 err) 287 { 288 nss_MD_win32_map_default_error(err); 289 } 290 291 void 292 nss_MD_win32_map_getsockopt_error(PRInt32 err) 293 { 294 nss_MD_win32_map_default_error(err); 295 } 296 297 void 298 nss_MD_win32_map_setsockopt_error(PRInt32 err) 299 { 300 nss_MD_win32_map_default_error(err); 301 } 302 303 void 304 nss_MD_win32_map_open_error(PRInt32 err) 305 { 306 nss_MD_win32_map_default_error(err); 307 } 308 309 void 310 nss_MD_win32_map_gethostname_error(PRInt32 err) 311 { 312 nss_MD_win32_map_default_error(err); 313 } 314 315 /* Win32 select() only works on sockets. So in this 316 ** context, WSAENOTSOCK is equivalent to EBADF on Unix. 317 */ 318 void 319 nss_MD_win32_map_select_error(PRInt32 err) 320 { 321 PRErrorCode prError; 322 switch (err) { 323 case WSAENOTSOCK: 324 prError = PR_BAD_DESCRIPTOR_ERROR; 325 break; 326 default: 327 nss_MD_win32_map_default_error(err); 328 return; 329 } 330 PR_SetError(prError, err); 331 } 332 333 void 334 nss_MD_win32_map_lockf_error(PRInt32 err) 335 { 336 nss_MD_win32_map_default_error(err); 337 } 338 339 void 340 nss_MD_win32_map_default_error(PRInt32 err) 341 { 342 PRErrorCode prError; 343 344 switch (err) { 345 case EACCES: 346 prError = PR_NO_ACCESS_RIGHTS_ERROR; 347 break; 348 case ENOENT: 349 prError = PR_FILE_NOT_FOUND_ERROR; 350 break; 351 case ERROR_ACCESS_DENIED: 352 prError = PR_NO_ACCESS_RIGHTS_ERROR; 353 break; 354 case ERROR_ALREADY_EXISTS: 355 prError = PR_FILE_EXISTS_ERROR; 356 break; 357 case ERROR_DISK_CORRUPT: 358 prError = PR_IO_ERROR; 359 break; 360 case ERROR_DISK_FULL: 361 prError = PR_NO_DEVICE_SPACE_ERROR; 362 break; 363 case ERROR_DISK_OPERATION_FAILED: 364 prError = PR_IO_ERROR; 365 break; 366 case ERROR_DRIVE_LOCKED: 367 prError = PR_FILE_IS_LOCKED_ERROR; 368 break; 369 case ERROR_FILENAME_EXCED_RANGE: 370 prError = PR_NAME_TOO_LONG_ERROR; 371 break; 372 case ERROR_FILE_CORRUPT: 373 prError = PR_IO_ERROR; 374 break; 375 case ERROR_FILE_EXISTS: 376 prError = PR_FILE_EXISTS_ERROR; 377 break; 378 case ERROR_FILE_INVALID: 379 prError = PR_BAD_DESCRIPTOR_ERROR; 380 break; 381 #if ERROR_FILE_NOT_FOUND != ENOENT 382 case ERROR_FILE_NOT_FOUND: 383 prError = PR_FILE_NOT_FOUND_ERROR; 384 break; 385 #endif 386 case ERROR_HANDLE_DISK_FULL: 387 prError = PR_NO_DEVICE_SPACE_ERROR; 388 break; 389 case ERROR_INVALID_ADDRESS: 390 prError = PR_ACCESS_FAULT_ERROR; 391 break; 392 case ERROR_INVALID_HANDLE: 393 prError = PR_BAD_DESCRIPTOR_ERROR; 394 break; 395 case ERROR_INVALID_NAME: 396 prError = PR_INVALID_ARGUMENT_ERROR; 397 break; 398 case ERROR_INVALID_PARAMETER: 399 prError = PR_INVALID_ARGUMENT_ERROR; 400 break; 401 case ERROR_INVALID_USER_BUFFER: 402 prError = PR_INSUFFICIENT_RESOURCES_ERROR; 403 break; 404 case ERROR_LOCKED: 405 prError = PR_FILE_IS_LOCKED_ERROR; 406 break; 407 case ERROR_NETNAME_DELETED: 408 prError = PR_CONNECT_RESET_ERROR; 409 break; 410 case ERROR_NOACCESS: 411 prError = PR_ACCESS_FAULT_ERROR; 412 break; 413 case ERROR_NOT_ENOUGH_MEMORY: 414 prError = PR_INSUFFICIENT_RESOURCES_ERROR; 415 break; 416 case ERROR_NOT_ENOUGH_QUOTA: 417 prError = PR_OUT_OF_MEMORY_ERROR; 418 break; 419 case ERROR_NOT_READY: 420 prError = PR_IO_ERROR; 421 break; 422 case ERROR_NO_MORE_FILES: 423 prError = PR_NO_MORE_FILES_ERROR; 424 break; 425 case ERROR_OPEN_FAILED: 426 prError = PR_IO_ERROR; 427 break; 428 case ERROR_OPEN_FILES: 429 prError = PR_IO_ERROR; 430 break; 431 case ERROR_OUTOFMEMORY: 432 prError = PR_INSUFFICIENT_RESOURCES_ERROR; 433 break; 434 case ERROR_PATH_BUSY: 435 prError = PR_IO_ERROR; 436 break; 437 case ERROR_PATH_NOT_FOUND: 438 prError = PR_FILE_NOT_FOUND_ERROR; 439 break; 440 case ERROR_SEEK_ON_DEVICE: 441 prError = PR_IO_ERROR; 442 break; 443 case ERROR_SHARING_VIOLATION: 444 prError = PR_FILE_IS_BUSY_ERROR; 445 break; 446 case ERROR_STACK_OVERFLOW: 447 prError = PR_ACCESS_FAULT_ERROR; 448 break; 449 case ERROR_TOO_MANY_OPEN_FILES: 450 prError = PR_SYS_DESC_TABLE_FULL_ERROR; 451 break; 452 case ERROR_WRITE_PROTECT: 453 prError = PR_NO_ACCESS_RIGHTS_ERROR; 454 break; 455 case WSAEACCES: 456 prError = PR_NO_ACCESS_RIGHTS_ERROR; 457 break; 458 case WSAEADDRINUSE: 459 prError = PR_ADDRESS_IN_USE_ERROR; 460 break; 461 case WSAEADDRNOTAVAIL: 462 prError = PR_ADDRESS_NOT_AVAILABLE_ERROR; 463 break; 464 case WSAEAFNOSUPPORT: 465 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; 466 break; 467 case WSAEALREADY: 468 prError = PR_ALREADY_INITIATED_ERROR; 469 break; 470 case WSAEBADF: 471 prError = PR_BAD_DESCRIPTOR_ERROR; 472 break; 473 case WSAECONNABORTED: 474 prError = PR_CONNECT_ABORTED_ERROR; 475 break; 476 case WSAECONNREFUSED: 477 prError = PR_CONNECT_REFUSED_ERROR; 478 break; 479 case WSAECONNRESET: 480 prError = PR_CONNECT_RESET_ERROR; 481 break; 482 case WSAEDESTADDRREQ: 483 prError = PR_INVALID_ARGUMENT_ERROR; 484 break; 485 case WSAEFAULT: 486 prError = PR_ACCESS_FAULT_ERROR; 487 break; 488 case WSAEHOSTUNREACH: 489 prError = PR_HOST_UNREACHABLE_ERROR; 490 break; 491 case WSAEINVAL: 492 prError = PR_INVALID_ARGUMENT_ERROR; 493 break; 494 case WSAEISCONN: 495 prError = PR_IS_CONNECTED_ERROR; 496 break; 497 case WSAEMFILE: 498 prError = PR_PROC_DESC_TABLE_FULL_ERROR; 499 break; 500 case WSAEMSGSIZE: 501 prError = PR_BUFFER_OVERFLOW_ERROR; 502 break; 503 case WSAENETDOWN: 504 prError = PR_NETWORK_DOWN_ERROR; 505 break; 506 case WSAENETRESET: 507 prError = PR_CONNECT_ABORTED_ERROR; 508 break; 509 case WSAENETUNREACH: 510 prError = PR_NETWORK_UNREACHABLE_ERROR; 511 break; 512 case WSAENOBUFS: 513 prError = PR_INSUFFICIENT_RESOURCES_ERROR; 514 break; 515 case WSAENOPROTOOPT: 516 prError = PR_INVALID_ARGUMENT_ERROR; 517 break; 518 case WSAENOTCONN: 519 prError = PR_NOT_CONNECTED_ERROR; 520 break; 521 case WSAENOTSOCK: 522 prError = PR_NOT_SOCKET_ERROR; 523 break; 524 case WSAEOPNOTSUPP: 525 prError = PR_OPERATION_NOT_SUPPORTED_ERROR; 526 break; 527 case WSAEPROTONOSUPPORT: 528 prError = PR_PROTOCOL_NOT_SUPPORTED_ERROR; 529 break; 530 case WSAEPROTOTYPE: 531 prError = PR_INVALID_ARGUMENT_ERROR; 532 break; 533 case WSAESHUTDOWN: 534 prError = PR_SOCKET_SHUTDOWN_ERROR; 535 break; 536 case WSAESOCKTNOSUPPORT: 537 prError = PR_INVALID_ARGUMENT_ERROR; 538 break; 539 case WSAETIMEDOUT: 540 prError = PR_CONNECT_ABORTED_ERROR; 541 break; 542 case WSAEWOULDBLOCK: 543 prError = PR_WOULD_BLOCK_ERROR; 544 break; 545 default: 546 prError = PR_UNKNOWN_ERROR; 547 break; 548 } 549 PR_SetError(prError, err); 550 }