| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 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 #if defined(UNIXWARE) || defined(SNI) || defined(NEC) | |
| 337 /* | |
| 338 * On some platforms, if we connect to a port on the local host | |
| 339 * (the loopback address) that no process is listening on, we get | |
| 340 * EIO instead of ECONNREFUSED. | |
| 341 */ | |
| 342 case EIO: | |
| 343 prError = PR_CONNECT_REFUSED_ERROR; | |
| 344 break; | |
| 345 #endif | |
| 346 case ELOOP: | |
| 347 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
| 348 break; | |
| 349 case ENOENT: | |
| 350 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
| 351 break; | |
| 352 case ENXIO: | |
| 353 prError = PR_IO_ERROR; | |
| 354 break; | |
| 355 default: | |
| 356 nss_MD_unix_map_default_error(err); | |
| 357 return; | |
| 358 } | |
| 359 PR_SetError(prError, err); | |
| 360 } | |
| 361 | |
| 362 void | |
| 363 nss_MD_unix_map_bind_error(int err) | |
| 364 { | |
| 365 PRErrorCode prError; | |
| 366 switch (err) { | |
| 367 case EINVAL: | |
| 368 prError = PR_SOCKET_ADDRESS_IS_BOUND_ERROR; | |
| 369 break; | |
| 370 /* | |
| 371 * UNIX domain sockets are not supported in NSPR | |
| 372 */ | |
| 373 case EIO: | |
| 374 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
| 375 break; | |
| 376 case EISDIR: | |
| 377 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
| 378 break; | |
| 379 case ELOOP: | |
| 380 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
| 381 break; | |
| 382 case ENOENT: | |
| 383 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
| 384 break; | |
| 385 case ENOTDIR: | |
| 386 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
| 387 break; | |
| 388 case EROFS: | |
| 389 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
| 390 break; | |
| 391 default: | |
| 392 nss_MD_unix_map_default_error(err); | |
| 393 return; | |
| 394 } | |
| 395 PR_SetError(prError, err); | |
| 396 } | |
| 397 | |
| 398 void | |
| 399 nss_MD_unix_map_listen_error(int err) | |
| 400 { | |
| 401 nss_MD_unix_map_default_error(err); | |
| 402 } | |
| 403 | |
| 404 void | |
| 405 nss_MD_unix_map_shutdown_error(int err) | |
| 406 { | |
| 407 nss_MD_unix_map_default_error(err); | |
| 408 } | |
| 409 | |
| 410 void | |
| 411 nss_MD_unix_map_socketpair_error(int err) | |
| 412 { | |
| 413 PRErrorCode prError; | |
| 414 switch (err) { | |
| 415 case ENOMEM: | |
| 416 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
| 417 break; | |
| 418 default: | |
| 419 nss_MD_unix_map_default_error(err); | |
| 420 return; | |
| 421 } | |
| 422 PR_SetError(prError, err); | |
| 423 } | |
| 424 | |
| 425 void | |
| 426 nss_MD_unix_map_getsockname_error(int err) | |
| 427 { | |
| 428 PRErrorCode prError; | |
| 429 switch (err) { | |
| 430 case ENOMEM: | |
| 431 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
| 432 break; | |
| 433 default: | |
| 434 nss_MD_unix_map_default_error(err); | |
| 435 return; | |
| 436 } | |
| 437 PR_SetError(prError, err); | |
| 438 } | |
| 439 | |
| 440 void | |
| 441 nss_MD_unix_map_getpeername_error(int err) | |
| 442 { | |
| 443 PRErrorCode prError; | |
| 444 | |
| 445 switch (err) { | |
| 446 case ENOMEM: | |
| 447 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
| 448 break; | |
| 449 default: | |
| 450 nss_MD_unix_map_default_error(err); | |
| 451 return; | |
| 452 } | |
| 453 PR_SetError(prError, err); | |
| 454 } | |
| 455 | |
| 456 void | |
| 457 nss_MD_unix_map_getsockopt_error(int err) | |
| 458 { | |
| 459 PRErrorCode prError; | |
| 460 switch (err) { | |
| 461 case EINVAL: | |
| 462 prError = PR_BUFFER_OVERFLOW_ERROR; | |
| 463 break; | |
| 464 case ENOMEM: | |
| 465 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
| 466 break; | |
| 467 default: | |
| 468 nss_MD_unix_map_default_error(err); | |
| 469 return; | |
| 470 } | |
| 471 PR_SetError(prError, err); | |
| 472 } | |
| 473 | |
| 474 void | |
| 475 nss_MD_unix_map_setsockopt_error(int err) | |
| 476 { | |
| 477 PRErrorCode prError; | |
| 478 switch (err) { | |
| 479 case EINVAL: | |
| 480 prError = PR_BUFFER_OVERFLOW_ERROR; | |
| 481 break; | |
| 482 case ENOMEM: | |
| 483 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
| 484 break; | |
| 485 default: | |
| 486 nss_MD_unix_map_default_error(err); | |
| 487 return; | |
| 488 } | |
| 489 PR_SetError(prError, err); | |
| 490 } | |
| 491 | |
| 492 void | |
| 493 nss_MD_unix_map_open_error(int err) | |
| 494 { | |
| 495 PRErrorCode prError; | |
| 496 switch (err) { | |
| 497 case EAGAIN: | |
| 498 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
| 499 break; | |
| 500 case EBUSY: | |
| 501 prError = PR_IO_ERROR; | |
| 502 break; | |
| 503 case ENODEV: | |
| 504 prError = PR_FILE_NOT_FOUND_ERROR; | |
| 505 break; | |
| 506 case ENOMEM: | |
| 507 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
| 508 break; | |
| 509 case ETIMEDOUT: | |
| 510 prError = PR_REMOTE_FILE_ERROR; | |
| 511 break; | |
| 512 default: | |
| 513 nss_MD_unix_map_default_error(err); | |
| 514 return; | |
| 515 } | |
| 516 PR_SetError(prError, err); | |
| 517 } | |
| 518 | |
| 519 void | |
| 520 nss_MD_unix_map_mmap_error(int err) | |
| 521 { | |
| 522 PRErrorCode prError; | |
| 523 switch (err) { | |
| 524 case EAGAIN: | |
| 525 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
| 526 break; | |
| 527 case EMFILE: | |
| 528 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
| 529 break; | |
| 530 case ENODEV: | |
| 531 prError = PR_OPERATION_NOT_SUPPORTED_ERROR; | |
| 532 break; | |
| 533 case ENXIO: | |
| 534 prError = PR_INVALID_ARGUMENT_ERROR; | |
| 535 break; | |
| 536 default: | |
| 537 nss_MD_unix_map_default_error(err); | |
| 538 return; | |
| 539 } | |
| 540 PR_SetError(prError, err); | |
| 541 } | |
| 542 | |
| 543 void | |
| 544 nss_MD_unix_map_gethostname_error(int err) | |
| 545 { | |
| 546 nss_MD_unix_map_default_error(err); | |
| 547 } | |
| 548 | |
| 549 void | |
| 550 nss_MD_unix_map_select_error(int err) | |
| 551 { | |
| 552 nss_MD_unix_map_default_error(err); | |
| 553 } | |
| 554 | |
| 555 #ifdef _PR_POLL_AVAILABLE | |
| 556 void | |
| 557 nss_MD_unix_map_poll_error(int err) | |
| 558 { | |
| 559 PRErrorCode prError; | |
| 560 | |
| 561 switch (err) { | |
| 562 case EAGAIN: | |
| 563 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
| 564 break; | |
| 565 default: | |
| 566 nss_MD_unix_map_default_error(err); | |
| 567 return; | |
| 568 } | |
| 569 PR_SetError(prError, err); | |
| 570 } | |
| 571 | |
| 572 void | |
| 573 nss_MD_unix_map_poll_revents_error(int err) | |
| 574 { | |
| 575 if (err & POLLNVAL) | |
| 576 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, EBADF); | |
| 577 else if (err & POLLHUP) | |
| 578 PR_SetError(PR_CONNECT_RESET_ERROR, EPIPE); | |
| 579 else if (err & POLLERR) | |
| 580 PR_SetError(PR_IO_ERROR, EIO); | |
| 581 else | |
| 582 PR_SetError(PR_UNKNOWN_ERROR, err); | |
| 583 } | |
| 584 #endif /* _PR_POLL_AVAILABLE */ | |
| 585 | |
| 586 void | |
| 587 nss_MD_unix_map_flock_error(int err) | |
| 588 { | |
| 589 PRErrorCode prError; | |
| 590 switch (err) { | |
| 591 case EINVAL: | |
| 592 prError = PR_BAD_DESCRIPTOR_ERROR; | |
| 593 break; | |
| 594 case EWOULDBLOCK: | |
| 595 prError = PR_FILE_IS_LOCKED_ERROR; | |
| 596 break; | |
| 597 default: | |
| 598 nss_MD_unix_map_default_error(err); | |
| 599 return; | |
| 600 } | |
| 601 PR_SetError(prError, err); | |
| 602 } | |
| 603 | |
| 604 void | |
| 605 nss_MD_unix_map_lockf_error(int err) | |
| 606 { | |
| 607 PRErrorCode prError; | |
| 608 switch (err) { | |
| 609 case EACCES: | |
| 610 prError = PR_FILE_IS_LOCKED_ERROR; | |
| 611 break; | |
| 612 case EDEADLK: | |
| 613 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
| 614 break; | |
| 615 default: | |
| 616 nss_MD_unix_map_default_error(err); | |
| 617 return; | |
| 618 } | |
| 619 PR_SetError(prError, err); | |
| 620 } | |
| 621 | |
| 622 #ifdef HPUX11 | |
| 623 void | |
| 624 nss_MD_hpux_map_sendfile_error(int err) | |
| 625 { | |
| 626 nss_MD_unix_map_default_error(err); | |
| 627 } | |
| 628 #endif /* HPUX11 */ | |
| 629 | |
| 630 void | |
| 631 nss_MD_unix_map_default_error(int err) | |
| 632 { | |
| 633 PRErrorCode prError; | |
| 634 switch (err) { | |
| 635 case EACCES: | |
| 636 prError = PR_NO_ACCESS_RIGHTS_ERROR; | |
| 637 break; | |
| 638 case EADDRINUSE: | |
| 639 prError = PR_ADDRESS_IN_USE_ERROR; | |
| 640 break; | |
| 641 case EADDRNOTAVAIL: | |
| 642 prError = PR_ADDRESS_NOT_AVAILABLE_ERROR; | |
| 643 break; | |
| 644 case EAFNOSUPPORT: | |
| 645 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
| 646 break; | |
| 647 case EAGAIN: | |
| 648 prError = PR_WOULD_BLOCK_ERROR; | |
| 649 break; | |
| 650 /* | |
| 651 * On QNX and Neutrino, EALREADY is defined as EBUSY. | |
| 652 */ | |
| 653 #if EALREADY != EBUSY | |
| 654 case EALREADY: | |
| 655 prError = PR_ALREADY_INITIATED_ERROR; | |
| 656 break; | |
| 657 #endif | |
| 658 case EBADF: | |
| 659 prError = PR_BAD_DESCRIPTOR_ERROR; | |
| 660 break; | |
| 661 #ifdef EBADMSG | |
| 662 case EBADMSG: | |
| 663 prError = PR_IO_ERROR; | |
| 664 break; | |
| 665 #endif | |
| 666 case EBUSY: | |
| 667 prError = PR_FILESYSTEM_MOUNTED_ERROR; | |
| 668 break; | |
| 669 case ECONNREFUSED: | |
| 670 prError = PR_CONNECT_REFUSED_ERROR; | |
| 671 break; | |
| 672 case ECONNRESET: | |
| 673 prError = PR_CONNECT_RESET_ERROR; | |
| 674 break; | |
| 675 case EDEADLK: | |
| 676 prError = PR_DEADLOCK_ERROR; | |
| 677 break; | |
| 678 #ifdef EDIRCORRUPTED | |
| 679 case EDIRCORRUPTED: | |
| 680 prError = PR_DIRECTORY_CORRUPTED_ERROR; | |
| 681 break; | |
| 682 #endif | |
| 683 #ifdef EDQUOT | |
| 684 case EDQUOT: | |
| 685 prError = PR_NO_DEVICE_SPACE_ERROR; | |
| 686 break; | |
| 687 #endif | |
| 688 case EEXIST: | |
| 689 prError = PR_FILE_EXISTS_ERROR; | |
| 690 break; | |
| 691 case EFAULT: | |
| 692 prError = PR_ACCESS_FAULT_ERROR; | |
| 693 break; | |
| 694 case EFBIG: | |
| 695 prError = PR_FILE_TOO_BIG_ERROR; | |
| 696 break; | |
| 697 case EINPROGRESS: | |
| 698 prError = PR_IN_PROGRESS_ERROR; | |
| 699 break; | |
| 700 case EINTR: | |
| 701 prError = PR_PENDING_INTERRUPT_ERROR; | |
| 702 break; | |
| 703 case EINVAL: | |
| 704 prError = PR_INVALID_ARGUMENT_ERROR; | |
| 705 break; | |
| 706 case EIO: | |
| 707 prError = PR_IO_ERROR; | |
| 708 break; | |
| 709 case EISCONN: | |
| 710 prError = PR_IS_CONNECTED_ERROR; | |
| 711 break; | |
| 712 case EISDIR: | |
| 713 prError = PR_IS_DIRECTORY_ERROR; | |
| 714 break; | |
| 715 case ELOOP: | |
| 716 prError = PR_LOOP_ERROR; | |
| 717 break; | |
| 718 case EMFILE: | |
| 719 prError = PR_PROC_DESC_TABLE_FULL_ERROR; | |
| 720 break; | |
| 721 case EMLINK: | |
| 722 prError = PR_MAX_DIRECTORY_ENTRIES_ERROR; | |
| 723 break; | |
| 724 case EMSGSIZE: | |
| 725 prError = PR_INVALID_ARGUMENT_ERROR; | |
| 726 break; | |
| 727 #ifdef EMULTIHOP | |
| 728 case EMULTIHOP: | |
| 729 prError = PR_REMOTE_FILE_ERROR; | |
| 730 break; | |
| 731 #endif | |
| 732 case ENAMETOOLONG: | |
| 733 prError = PR_NAME_TOO_LONG_ERROR; | |
| 734 break; | |
| 735 case ENETUNREACH: | |
| 736 prError = PR_NETWORK_UNREACHABLE_ERROR; | |
| 737 break; | |
| 738 case ENFILE: | |
| 739 prError = PR_SYS_DESC_TABLE_FULL_ERROR; | |
| 740 break; | |
| 741 #if !defined(SCO) | |
| 742 case ENOBUFS: | |
| 743 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
| 744 break; | |
| 745 #endif | |
| 746 case ENODEV: | |
| 747 prError = PR_FILE_NOT_FOUND_ERROR; | |
| 748 break; | |
| 749 case ENOENT: | |
| 750 prError = PR_FILE_NOT_FOUND_ERROR; | |
| 751 break; | |
| 752 case ENOLCK: | |
| 753 prError = PR_FILE_IS_LOCKED_ERROR; | |
| 754 break; | |
| 755 #ifdef ENOLINK | |
| 756 case ENOLINK: | |
| 757 prError = PR_REMOTE_FILE_ERROR; | |
| 758 break; | |
| 759 #endif | |
| 760 case ENOMEM: | |
| 761 prError = PR_OUT_OF_MEMORY_ERROR; | |
| 762 break; | |
| 763 case ENOPROTOOPT: | |
| 764 prError = PR_INVALID_ARGUMENT_ERROR; | |
| 765 break; | |
| 766 case ENOSPC: | |
| 767 prError = PR_NO_DEVICE_SPACE_ERROR; | |
| 768 break; | |
| 769 #ifdef ENOSR | |
| 770 case ENOSR: | |
| 771 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
| 772 break; | |
| 773 #endif | |
| 774 case ENOTCONN: | |
| 775 prError = PR_NOT_CONNECTED_ERROR; | |
| 776 break; | |
| 777 case ENOTDIR: | |
| 778 prError = PR_NOT_DIRECTORY_ERROR; | |
| 779 break; | |
| 780 case ENOTSOCK: | |
| 781 prError = PR_NOT_SOCKET_ERROR; | |
| 782 break; | |
| 783 case ENXIO: | |
| 784 prError = PR_FILE_NOT_FOUND_ERROR; | |
| 785 break; | |
| 786 case EOPNOTSUPP: | |
| 787 prError = PR_NOT_TCP_SOCKET_ERROR; | |
| 788 break; | |
| 789 #ifdef EOVERFLOW | |
| 790 case EOVERFLOW: | |
| 791 prError = PR_BUFFER_OVERFLOW_ERROR; | |
| 792 break; | |
| 793 #endif | |
| 794 case EPERM: | |
| 795 prError = PR_NO_ACCESS_RIGHTS_ERROR; | |
| 796 break; | |
| 797 case EPIPE: | |
| 798 prError = PR_CONNECT_RESET_ERROR; | |
| 799 break; | |
| 800 #ifdef EPROTO | |
| 801 case EPROTO: | |
| 802 prError = PR_IO_ERROR; | |
| 803 break; | |
| 804 #endif | |
| 805 case EPROTONOSUPPORT: | |
| 806 prError = PR_PROTOCOL_NOT_SUPPORTED_ERROR; | |
| 807 break; | |
| 808 case EPROTOTYPE: | |
| 809 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
| 810 break; | |
| 811 case ERANGE: | |
| 812 prError = PR_INVALID_METHOD_ERROR; | |
| 813 break; | |
| 814 case EROFS: | |
| 815 prError = PR_READ_ONLY_FILESYSTEM_ERROR; | |
| 816 break; | |
| 817 case ESPIPE: | |
| 818 prError = PR_INVALID_METHOD_ERROR; | |
| 819 break; | |
| 820 case ETIMEDOUT: | |
| 821 prError = PR_IO_TIMEOUT_ERROR; | |
| 822 break; | |
| 823 #if EWOULDBLOCK != EAGAIN | |
| 824 case EWOULDBLOCK: | |
| 825 prError = PR_WOULD_BLOCK_ERROR; | |
| 826 break; | |
| 827 #endif | |
| 828 case EXDEV: | |
| 829 prError = PR_NOT_SAME_DEVICE_ERROR; | |
| 830 break; | |
| 831 | |
| 832 default: | |
| 833 prError = PR_UNKNOWN_ERROR; | |
| 834 break; | |
| 835 } | |
| 836 PR_SetError(prError, err); | |
| 837 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1882433002:
Removing NSS files and USE_OPENSSL flag (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master