unix_err.c (18879B)
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) 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 34 nss_MD_unix_map_opendir_error(int err) 35 { 36 nss_MD_unix_map_default_error(err); 37 } 38 39 void 40 nss_MD_unix_map_closedir_error(int err) 41 { 42 PRErrorCode prError; 43 switch (err) { 44 case EINVAL: 45 prError = PR_BAD_DESCRIPTOR_ERROR; 46 break; 47 default: 48 nss_MD_unix_map_default_error(err); 49 return; 50 } 51 PR_SetError(prError, err); 52 } 53 54 void 55 nss_MD_unix_readdir_error(int err) 56 { 57 PRErrorCode prError; 58 59 switch (err) { 60 case ENOENT: 61 prError = PR_NO_MORE_FILES_ERROR; 62 break; 63 #ifdef EOVERFLOW 64 case EOVERFLOW: 65 prError = PR_IO_ERROR; 66 break; 67 #endif 68 case EINVAL: 69 prError = PR_IO_ERROR; 70 break; 71 case ENXIO: 72 prError = PR_IO_ERROR; 73 break; 74 default: 75 nss_MD_unix_map_default_error(err); 76 return; 77 } 78 PR_SetError(prError, err); 79 } 80 81 void 82 nss_MD_unix_map_unlink_error(int err) 83 { 84 PRErrorCode prError; 85 switch (err) { 86 case EPERM: 87 prError = PR_IS_DIRECTORY_ERROR; 88 break; 89 default: 90 nss_MD_unix_map_default_error(err); 91 return; 92 } 93 PR_SetError(prError, err); 94 } 95 96 void 97 nss_MD_unix_map_stat_error(int err) 98 { 99 PRErrorCode prError; 100 switch (err) { 101 case ETIMEDOUT: 102 prError = PR_REMOTE_FILE_ERROR; 103 break; 104 default: 105 nss_MD_unix_map_default_error(err); 106 return; 107 } 108 PR_SetError(prError, err); 109 } 110 111 void 112 nss_MD_unix_map_fstat_error(int err) 113 { 114 PRErrorCode prError; 115 switch (err) { 116 case ETIMEDOUT: 117 prError = PR_REMOTE_FILE_ERROR; 118 break; 119 default: 120 nss_MD_unix_map_default_error(err); 121 return; 122 } 123 PR_SetError(prError, err); 124 } 125 126 void 127 nss_MD_unix_map_rename_error(int err) 128 { 129 PRErrorCode prError; 130 switch (err) { 131 case EEXIST: 132 prError = PR_DIRECTORY_NOT_EMPTY_ERROR; 133 break; 134 default: 135 nss_MD_unix_map_default_error(err); 136 return; 137 } 138 PR_SetError(prError, err); 139 } 140 141 void 142 nss_MD_unix_map_access_error(int err) 143 { 144 PRErrorCode prError; 145 switch (err) { 146 case ETIMEDOUT: 147 prError = PR_REMOTE_FILE_ERROR; 148 break; 149 default: 150 nss_MD_unix_map_default_error(err); 151 return; 152 } 153 PR_SetError(prError, err); 154 } 155 156 void 157 nss_MD_unix_map_mkdir_error(int err) 158 { 159 nss_MD_unix_map_default_error(err); 160 } 161 162 void 163 nss_MD_unix_map_rmdir_error(int err) 164 { 165 PRErrorCode prError; 166 167 switch (err) { 168 case EEXIST: 169 prError = PR_DIRECTORY_NOT_EMPTY_ERROR; 170 break; 171 case EINVAL: 172 prError = PR_DIRECTORY_NOT_EMPTY_ERROR; 173 break; 174 case ETIMEDOUT: 175 prError = PR_REMOTE_FILE_ERROR; 176 break; 177 default: 178 nss_MD_unix_map_default_error(err); 179 return; 180 } 181 PR_SetError(prError, err); 182 } 183 184 void 185 nss_MD_unix_map_read_error(int err) 186 { 187 PRErrorCode prError; 188 switch (err) { 189 case EINVAL: 190 prError = PR_INVALID_METHOD_ERROR; 191 break; 192 case ENXIO: 193 prError = PR_INVALID_ARGUMENT_ERROR; 194 break; 195 default: 196 nss_MD_unix_map_default_error(err); 197 return; 198 } 199 PR_SetError(prError, err); 200 } 201 202 void 203 nss_MD_unix_map_write_error(int err) 204 { 205 PRErrorCode prError; 206 switch (err) { 207 case EINVAL: 208 prError = PR_INVALID_METHOD_ERROR; 209 break; 210 case ENXIO: 211 prError = PR_INVALID_METHOD_ERROR; 212 break; 213 case ETIMEDOUT: 214 prError = PR_REMOTE_FILE_ERROR; 215 break; 216 default: 217 nss_MD_unix_map_default_error(err); 218 return; 219 } 220 PR_SetError(prError, err); 221 } 222 223 void 224 nss_MD_unix_map_lseek_error(int err) 225 { 226 nss_MD_unix_map_default_error(err); 227 } 228 229 void 230 nss_MD_unix_map_fsync_error(int err) 231 { 232 PRErrorCode prError; 233 switch (err) { 234 case ETIMEDOUT: 235 prError = PR_REMOTE_FILE_ERROR; 236 break; 237 case EINVAL: 238 prError = PR_INVALID_METHOD_ERROR; 239 break; 240 default: 241 nss_MD_unix_map_default_error(err); 242 return; 243 } 244 PR_SetError(prError, err); 245 } 246 247 void 248 nss_MD_unix_map_close_error(int err) 249 { 250 PRErrorCode prError; 251 switch (err) { 252 case ETIMEDOUT: 253 prError = PR_REMOTE_FILE_ERROR; 254 break; 255 default: 256 nss_MD_unix_map_default_error(err); 257 return; 258 } 259 PR_SetError(prError, err); 260 } 261 262 void 263 nss_MD_unix_map_socket_error(int err) 264 { 265 PRErrorCode prError; 266 switch (err) { 267 case ENOMEM: 268 prError = PR_INSUFFICIENT_RESOURCES_ERROR; 269 break; 270 default: 271 nss_MD_unix_map_default_error(err); 272 return; 273 } 274 PR_SetError(prError, err); 275 } 276 277 void 278 nss_MD_unix_map_socketavailable_error(int err) 279 { 280 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err); 281 } 282 283 void 284 nss_MD_unix_map_recv_error(int err) 285 { 286 nss_MD_unix_map_default_error(err); 287 } 288 289 void 290 nss_MD_unix_map_recvfrom_error(int err) 291 { 292 nss_MD_unix_map_default_error(err); 293 } 294 295 void 296 nss_MD_unix_map_send_error(int err) 297 { 298 nss_MD_unix_map_default_error(err); 299 } 300 301 void 302 nss_MD_unix_map_sendto_error(int err) 303 { 304 nss_MD_unix_map_default_error(err); 305 } 306 307 void 308 nss_MD_unix_map_writev_error(int err) 309 { 310 nss_MD_unix_map_default_error(err); 311 } 312 313 void 314 nss_MD_unix_map_accept_error(int err) 315 { 316 PRErrorCode prError; 317 switch (err) { 318 case ENODEV: 319 prError = PR_NOT_TCP_SOCKET_ERROR; 320 break; 321 default: 322 nss_MD_unix_map_default_error(err); 323 return; 324 } 325 PR_SetError(prError, err); 326 } 327 328 void 329 nss_MD_unix_map_connect_error(int err) 330 { 331 PRErrorCode prError; 332 switch (err) { 333 case EACCES: 334 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; 335 break; 336 case ELOOP: 337 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; 338 break; 339 case ENOENT: 340 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; 341 break; 342 case ENXIO: 343 prError = PR_IO_ERROR; 344 break; 345 default: 346 nss_MD_unix_map_default_error(err); 347 return; 348 } 349 PR_SetError(prError, err); 350 } 351 352 void 353 nss_MD_unix_map_bind_error(int err) 354 { 355 PRErrorCode prError; 356 switch (err) { 357 case EINVAL: 358 prError = PR_SOCKET_ADDRESS_IS_BOUND_ERROR; 359 break; 360 /* 361 * UNIX domain sockets are not supported in NSPR 362 */ 363 case EIO: 364 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; 365 break; 366 case EISDIR: 367 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; 368 break; 369 case ELOOP: 370 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; 371 break; 372 case ENOENT: 373 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; 374 break; 375 case ENOTDIR: 376 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; 377 break; 378 case EROFS: 379 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; 380 break; 381 default: 382 nss_MD_unix_map_default_error(err); 383 return; 384 } 385 PR_SetError(prError, err); 386 } 387 388 void 389 nss_MD_unix_map_listen_error(int err) 390 { 391 nss_MD_unix_map_default_error(err); 392 } 393 394 void 395 nss_MD_unix_map_shutdown_error(int err) 396 { 397 nss_MD_unix_map_default_error(err); 398 } 399 400 void 401 nss_MD_unix_map_socketpair_error(int err) 402 { 403 PRErrorCode prError; 404 switch (err) { 405 case ENOMEM: 406 prError = PR_INSUFFICIENT_RESOURCES_ERROR; 407 break; 408 default: 409 nss_MD_unix_map_default_error(err); 410 return; 411 } 412 PR_SetError(prError, err); 413 } 414 415 void 416 nss_MD_unix_map_getsockname_error(int err) 417 { 418 PRErrorCode prError; 419 switch (err) { 420 case ENOMEM: 421 prError = PR_INSUFFICIENT_RESOURCES_ERROR; 422 break; 423 default: 424 nss_MD_unix_map_default_error(err); 425 return; 426 } 427 PR_SetError(prError, err); 428 } 429 430 void 431 nss_MD_unix_map_getpeername_error(int err) 432 { 433 PRErrorCode prError; 434 435 switch (err) { 436 case ENOMEM: 437 prError = PR_INSUFFICIENT_RESOURCES_ERROR; 438 break; 439 default: 440 nss_MD_unix_map_default_error(err); 441 return; 442 } 443 PR_SetError(prError, err); 444 } 445 446 void 447 nss_MD_unix_map_getsockopt_error(int err) 448 { 449 PRErrorCode prError; 450 switch (err) { 451 case EINVAL: 452 prError = PR_BUFFER_OVERFLOW_ERROR; 453 break; 454 case ENOMEM: 455 prError = PR_INSUFFICIENT_RESOURCES_ERROR; 456 break; 457 default: 458 nss_MD_unix_map_default_error(err); 459 return; 460 } 461 PR_SetError(prError, err); 462 } 463 464 void 465 nss_MD_unix_map_setsockopt_error(int err) 466 { 467 PRErrorCode prError; 468 switch (err) { 469 case EINVAL: 470 prError = PR_BUFFER_OVERFLOW_ERROR; 471 break; 472 case ENOMEM: 473 prError = PR_INSUFFICIENT_RESOURCES_ERROR; 474 break; 475 default: 476 nss_MD_unix_map_default_error(err); 477 return; 478 } 479 PR_SetError(prError, err); 480 } 481 482 void 483 nss_MD_unix_map_open_error(int err) 484 { 485 PRErrorCode prError; 486 switch (err) { 487 case EAGAIN: 488 prError = PR_INSUFFICIENT_RESOURCES_ERROR; 489 break; 490 case EBUSY: 491 prError = PR_IO_ERROR; 492 break; 493 case ENODEV: 494 prError = PR_FILE_NOT_FOUND_ERROR; 495 break; 496 case ENOMEM: 497 prError = PR_INSUFFICIENT_RESOURCES_ERROR; 498 break; 499 case ETIMEDOUT: 500 prError = PR_REMOTE_FILE_ERROR; 501 break; 502 default: 503 nss_MD_unix_map_default_error(err); 504 return; 505 } 506 PR_SetError(prError, err); 507 } 508 509 void 510 nss_MD_unix_map_mmap_error(int err) 511 { 512 PRErrorCode prError; 513 switch (err) { 514 case EAGAIN: 515 prError = PR_INSUFFICIENT_RESOURCES_ERROR; 516 break; 517 case EMFILE: 518 prError = PR_INSUFFICIENT_RESOURCES_ERROR; 519 break; 520 case ENODEV: 521 prError = PR_OPERATION_NOT_SUPPORTED_ERROR; 522 break; 523 case ENXIO: 524 prError = PR_INVALID_ARGUMENT_ERROR; 525 break; 526 default: 527 nss_MD_unix_map_default_error(err); 528 return; 529 } 530 PR_SetError(prError, err); 531 } 532 533 void 534 nss_MD_unix_map_gethostname_error(int err) 535 { 536 nss_MD_unix_map_default_error(err); 537 } 538 539 void 540 nss_MD_unix_map_select_error(int err) 541 { 542 nss_MD_unix_map_default_error(err); 543 } 544 545 #ifdef _PR_POLL_AVAILABLE 546 void 547 nss_MD_unix_map_poll_error(int err) 548 { 549 PRErrorCode prError; 550 551 switch (err) { 552 case EAGAIN: 553 prError = PR_INSUFFICIENT_RESOURCES_ERROR; 554 break; 555 default: 556 nss_MD_unix_map_default_error(err); 557 return; 558 } 559 PR_SetError(prError, err); 560 } 561 562 void 563 nss_MD_unix_map_poll_revents_error(int err) 564 { 565 if (err & POLLNVAL) 566 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, EBADF); 567 else if (err & POLLHUP) 568 PR_SetError(PR_CONNECT_RESET_ERROR, EPIPE); 569 else if (err & POLLERR) 570 PR_SetError(PR_IO_ERROR, EIO); 571 else 572 PR_SetError(PR_UNKNOWN_ERROR, err); 573 } 574 #endif /* _PR_POLL_AVAILABLE */ 575 576 void 577 nss_MD_unix_map_flock_error(int err) 578 { 579 PRErrorCode prError; 580 switch (err) { 581 case EINVAL: 582 prError = PR_BAD_DESCRIPTOR_ERROR; 583 break; 584 case EWOULDBLOCK: 585 prError = PR_FILE_IS_LOCKED_ERROR; 586 break; 587 default: 588 nss_MD_unix_map_default_error(err); 589 return; 590 } 591 PR_SetError(prError, err); 592 } 593 594 void 595 nss_MD_unix_map_lockf_error(int err) 596 { 597 PRErrorCode prError; 598 switch (err) { 599 case EACCES: 600 prError = PR_FILE_IS_LOCKED_ERROR; 601 break; 602 case EDEADLK: 603 prError = PR_INSUFFICIENT_RESOURCES_ERROR; 604 break; 605 default: 606 nss_MD_unix_map_default_error(err); 607 return; 608 } 609 PR_SetError(prError, err); 610 } 611 612 #ifdef HPUX11 613 void 614 nss_MD_hpux_map_sendfile_error(int err) 615 { 616 nss_MD_unix_map_default_error(err); 617 } 618 #endif /* HPUX11 */ 619 620 void 621 nss_MD_unix_map_default_error(int err) 622 { 623 PRErrorCode prError; 624 switch (err) { 625 case EACCES: 626 prError = PR_NO_ACCESS_RIGHTS_ERROR; 627 break; 628 case EADDRINUSE: 629 prError = PR_ADDRESS_IN_USE_ERROR; 630 break; 631 case EADDRNOTAVAIL: 632 prError = PR_ADDRESS_NOT_AVAILABLE_ERROR; 633 break; 634 case EAFNOSUPPORT: 635 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; 636 break; 637 case EAGAIN: 638 prError = PR_WOULD_BLOCK_ERROR; 639 break; 640 /* 641 * On QNX and Neutrino, EALREADY is defined as EBUSY. 642 */ 643 #if EALREADY != EBUSY 644 case EALREADY: 645 prError = PR_ALREADY_INITIATED_ERROR; 646 break; 647 #endif 648 case EBADF: 649 prError = PR_BAD_DESCRIPTOR_ERROR; 650 break; 651 #ifdef EBADMSG 652 case EBADMSG: 653 prError = PR_IO_ERROR; 654 break; 655 #endif 656 case EBUSY: 657 prError = PR_FILESYSTEM_MOUNTED_ERROR; 658 break; 659 case ECONNREFUSED: 660 prError = PR_CONNECT_REFUSED_ERROR; 661 break; 662 case ECONNRESET: 663 prError = PR_CONNECT_RESET_ERROR; 664 break; 665 case EDEADLK: 666 prError = PR_DEADLOCK_ERROR; 667 break; 668 #ifdef EDIRCORRUPTED 669 case EDIRCORRUPTED: 670 prError = PR_DIRECTORY_CORRUPTED_ERROR; 671 break; 672 #endif 673 #ifdef EDQUOT 674 case EDQUOT: 675 prError = PR_NO_DEVICE_SPACE_ERROR; 676 break; 677 #endif 678 case EEXIST: 679 prError = PR_FILE_EXISTS_ERROR; 680 break; 681 case EFAULT: 682 prError = PR_ACCESS_FAULT_ERROR; 683 break; 684 case EFBIG: 685 prError = PR_FILE_TOO_BIG_ERROR; 686 break; 687 case EINPROGRESS: 688 prError = PR_IN_PROGRESS_ERROR; 689 break; 690 case EINTR: 691 prError = PR_PENDING_INTERRUPT_ERROR; 692 break; 693 case EINVAL: 694 prError = PR_INVALID_ARGUMENT_ERROR; 695 break; 696 case EIO: 697 prError = PR_IO_ERROR; 698 break; 699 case EISCONN: 700 prError = PR_IS_CONNECTED_ERROR; 701 break; 702 case EISDIR: 703 prError = PR_IS_DIRECTORY_ERROR; 704 break; 705 case ELOOP: 706 prError = PR_LOOP_ERROR; 707 break; 708 case EMFILE: 709 prError = PR_PROC_DESC_TABLE_FULL_ERROR; 710 break; 711 case EMLINK: 712 prError = PR_MAX_DIRECTORY_ENTRIES_ERROR; 713 break; 714 case EMSGSIZE: 715 prError = PR_INVALID_ARGUMENT_ERROR; 716 break; 717 #ifdef EMULTIHOP 718 case EMULTIHOP: 719 prError = PR_REMOTE_FILE_ERROR; 720 break; 721 #endif 722 case ENAMETOOLONG: 723 prError = PR_NAME_TOO_LONG_ERROR; 724 break; 725 case ENETUNREACH: 726 prError = PR_NETWORK_UNREACHABLE_ERROR; 727 break; 728 case ENFILE: 729 prError = PR_SYS_DESC_TABLE_FULL_ERROR; 730 break; 731 case ENOBUFS: 732 prError = PR_INSUFFICIENT_RESOURCES_ERROR; 733 break; 734 case ENODEV: 735 prError = PR_FILE_NOT_FOUND_ERROR; 736 break; 737 case ENOENT: 738 prError = PR_FILE_NOT_FOUND_ERROR; 739 break; 740 case ENOLCK: 741 prError = PR_FILE_IS_LOCKED_ERROR; 742 break; 743 #ifdef ENOLINK 744 case ENOLINK: 745 prError = PR_REMOTE_FILE_ERROR; 746 break; 747 #endif 748 case ENOMEM: 749 prError = PR_OUT_OF_MEMORY_ERROR; 750 break; 751 case ENOPROTOOPT: 752 prError = PR_INVALID_ARGUMENT_ERROR; 753 break; 754 case ENOSPC: 755 prError = PR_NO_DEVICE_SPACE_ERROR; 756 break; 757 #ifdef ENOSR 758 case ENOSR: 759 prError = PR_INSUFFICIENT_RESOURCES_ERROR; 760 break; 761 #endif 762 case ENOTCONN: 763 prError = PR_NOT_CONNECTED_ERROR; 764 break; 765 case ENOTDIR: 766 prError = PR_NOT_DIRECTORY_ERROR; 767 break; 768 case ENOTSOCK: 769 prError = PR_NOT_SOCKET_ERROR; 770 break; 771 case ENXIO: 772 prError = PR_FILE_NOT_FOUND_ERROR; 773 break; 774 case EOPNOTSUPP: 775 prError = PR_NOT_TCP_SOCKET_ERROR; 776 break; 777 #ifdef EOVERFLOW 778 case EOVERFLOW: 779 prError = PR_BUFFER_OVERFLOW_ERROR; 780 break; 781 #endif 782 case EPERM: 783 prError = PR_NO_ACCESS_RIGHTS_ERROR; 784 break; 785 case EPIPE: 786 prError = PR_CONNECT_RESET_ERROR; 787 break; 788 #ifdef EPROTO 789 case EPROTO: 790 prError = PR_IO_ERROR; 791 break; 792 #endif 793 case EPROTONOSUPPORT: 794 prError = PR_PROTOCOL_NOT_SUPPORTED_ERROR; 795 break; 796 case EPROTOTYPE: 797 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; 798 break; 799 case ERANGE: 800 prError = PR_INVALID_METHOD_ERROR; 801 break; 802 case EROFS: 803 prError = PR_READ_ONLY_FILESYSTEM_ERROR; 804 break; 805 case ESPIPE: 806 prError = PR_INVALID_METHOD_ERROR; 807 break; 808 case ETIMEDOUT: 809 prError = PR_IO_TIMEOUT_ERROR; 810 break; 811 #if EWOULDBLOCK != EAGAIN 812 case EWOULDBLOCK: 813 prError = PR_WOULD_BLOCK_ERROR; 814 break; 815 #endif 816 case EXDEV: 817 prError = PR_NOT_SAME_DEVICE_ERROR; 818 break; 819 820 default: 821 prError = PR_UNKNOWN_ERROR; 822 break; 823 } 824 PR_SetError(prError, err); 825 }