nsprpub/pr/src/md/os2/os2_errors.c

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "prerror.h"
   7 #include "primpl.h"
   8
   9 void _MD_os2_map_default_error(PRInt32 err)
  10 {
  11     switch (err) {
  12         case EWOULDBLOCK:
  13             PR_SetError(PR_WOULD_BLOCK_ERROR, err);
  14             break;
  15         case EBADF:
  16             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  17             break;
  18         case ENOTSOCK:
  19             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  20             break;
  21         case EMSGSIZE:
  22         case EINVAL:
  23             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  24             break;
  25         case ENOBUFS:
  26             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  27             break;
  28         case ECONNREFUSED:
  29             PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
  30             break;
  31         case EISCONN:
  32             PR_SetError(PR_IS_CONNECTED_ERROR, err);
  33             break;
  34 #ifdef SOCEFAULT
  35         case SOCEFAULT:
  36             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  37             break;
  38 #endif
  39         case ERROR_NETNAME_DELETED:
  40             PR_SetError(PR_CONNECT_RESET_ERROR, err);
  41             break;
  42         default:
  43             PR_SetError(PR_UNKNOWN_ERROR, err);
  44             break;
  45     }
  46 }
  47 void _MD_os2_map_opendir_error(PRInt32 err)
  48 {
  49     switch (err) {
  50         case ERROR_FILE_NOT_FOUND:
  51         case ERROR_PATH_NOT_FOUND:
  52             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
  53             break;
  54         case ERROR_ACCESS_DENIED:
  55             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  56             break;
  57         case ERROR_INVALID_ADDRESS:
  58         case ERROR_INVALID_ACCESS:
  59             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  60             break;
  61         case ERROR_INVALID_NAME:
  62         case ERROR_INVALID_PARAMETER:
  63             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  64             break;
  65         case ERROR_TOO_MANY_OPEN_FILES:
  66         case ERROR_NOT_DOS_DISK:
  67         case ERROR_NOT_READY:
  68         case ERROR_OPEN_FAILED:
  69         case ERROR_PATH_BUSY:
  70         case ERROR_CANNOT_MAKE:
  71             PR_SetError(PR_IO_ERROR, err);
  72             break;
  73         case ERROR_DRIVE_LOCKED:
  74         case ERROR_DEVICE_IN_USE:
  75             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
  76             break;
  77         case ERROR_FILENAME_EXCED_RANGE:
  78             PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
  79             break;
  80         case ERROR_NOT_ENOUGH_MEMORY:
  81         case ERROR_SHARING_BUFFER_EXCEEDED:
  82             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  83             break;
  84         default:
  85             PR_SetError(PR_UNKNOWN_ERROR, err);
  86             break;
  87     }
  88 }
  89
  90 void _MD_os2_map_closedir_error(PRInt32 err)
  91 {
  92     switch (err) {
  93         case ERROR_FILE_NOT_FOUND:
  94         case ERROR_ACCESS_DENIED:
  95         case ERROR_INVALID_HANDLE:
  96             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  97             break;
  98         default:
  99             PR_SetError(PR_UNKNOWN_ERROR, err);
 100             break;
 101     }
 102 }
 103
 104 void _MD_os2_readdir_error(PRInt32 err)
 105 {
 106
 107     switch (err) {
 108         case ERROR_NO_MORE_FILES:
 109             PR_SetError(PR_NO_MORE_FILES_ERROR, err);
 110             break;
 111         case ERROR_FILE_NOT_FOUND:
 112         case ERROR_INVALID_HANDLE:
 113             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 114             break;
 115         case ERROR_INVALID_ADDRESS:
 116             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 117             break;
 118         case ERROR_NOT_DOS_DISK:
 119         case ERROR_LOCK_VIOLATION:
 120         case ERROR_BROKEN_PIPE:
 121         case ERROR_NOT_READY:
 122             PR_SetError(PR_IO_ERROR, err);
 123             break;
 124         case ERROR_NOT_ENOUGH_MEMORY:
 125         case ERROR_MORE_DATA:
 126             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
 127             break;
 128         default:
 129             PR_SetError(PR_UNKNOWN_ERROR, err);
 130             break;
 131     }
 132 }
 133
 134 void _MD_os2_map_delete_error(PRInt32 err)
 135 {
 136     switch (err) {
 137         case ERROR_FILE_NOT_FOUND:
 138         case ERROR_PATH_NOT_FOUND:
 139             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
 140             break;
 141         case ERROR_ACCESS_DENIED:
 142         case ERROR_WRITE_PROTECT:
 143             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
 144             break;
 145         case ERROR_INVALID_ADDRESS:
 146             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 147             break;
 148         case ERROR_DRIVE_LOCKED:
 149         case ERROR_LOCKED:
 150         case ERROR_SHARING_VIOLATION:
 151             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
 152             break;
 153         default:
 154             PR_SetError(PR_UNKNOWN_ERROR, err);
 155             break;
 156     }
 157 }
 158
 159 /* The error code for stat() is in errno. */
 160 void _MD_os2_map_stat_error(PRInt32 err)
 161 {
 162     switch (err) {
 163         case ENOENT:
 164             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
 165             break;
 166         case EACCES:
 167             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
 168             break;
 169         default:
 170             PR_SetError(PR_UNKNOWN_ERROR, err);
 171     }
 172 }
 173
 174 void _MD_os2_map_fstat_error(PRInt32 err)
 175 {
 176     switch (err) {
 177         case ERROR_ACCESS_DENIED:
 178             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
 179             break;
 180         case ERROR_INVALID_HANDLE:
 181             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 182             break;
 183         case ERROR_INVALID_ADDRESS:
 184             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 185             break;
 186         case ERROR_NOT_READY:
 187         case ERROR_PATH_BUSY:
 188             PR_SetError(PR_IO_ERROR, err);
 189             break;
 190         case ERROR_NOT_ENOUGH_MEMORY:
 191         case ERROR_MORE_DATA:
 192             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
 193             break;
 194         case ERROR_DRIVE_LOCKED:
 195         case ERROR_LOCKED:
 196             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
 197             break;
 198         default:
 199             PR_SetError(PR_UNKNOWN_ERROR, err);
 200             break;
 201     }
 202 }
 203
 204 void _MD_os2_map_rename_error(PRInt32 err)
 205 {
 206     switch (err) {
 207         case ERROR_FILE_NOT_FOUND:
 208         case ERROR_PATH_NOT_FOUND:
 209             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
 210             break;
 211         case ERROR_ACCESS_DENIED:
 212             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
 213             break;
 214         case ERROR_INVALID_ADDRESS:
 215             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 216             break;
 217         case ERROR_INVALID_NAME:
 218             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
 219             break;
 220         case ERROR_NOT_READY:
 221         case ERROR_PATH_BUSY:
 222             PR_SetError(PR_IO_ERROR, err);
 223             break;
 224         case ERROR_DRIVE_LOCKED:
 225             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
 226             break;
 227         case ERROR_FILENAME_EXCED_RANGE:
 228             PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
 229             break;
 230         case ERROR_NOT_ENOUGH_MEMORY:
 231         case ERROR_MORE_DATA:
 232             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
 233             break;
 234         case ERROR_ALREADY_EXISTS:
 235         case ERROR_FILE_EXISTS:
 236             PR_SetError(PR_FILE_EXISTS_ERROR, err);
 237             break;
 238         default:
 239             PR_SetError(PR_UNKNOWN_ERROR, err);
 240             break;
 241     }
 242 }
 243
 244 /* The error code for access() is in errno. */
 245 void _MD_os2_map_access_error(PRInt32 err)
 246 {
 247     switch (err) {
 248         case ENOENT:
 249             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
 250             break;
 251         case EACCES:
 252             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
 253             break;
 254         default:
 255             PR_SetError(PR_UNKNOWN_ERROR, err);
 256     }
 257 }
 258
 259 void _MD_os2_map_mkdir_error(PRInt32 err)
 260 {
 261     switch (err) {
 262         case ERROR_ALREADY_EXISTS:
 263         case ERROR_FILE_EXISTS:
 264             PR_SetError(PR_FILE_EXISTS_ERROR, err);
 265             break;
 266         case ERROR_FILE_NOT_FOUND:
 267             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
 268             break;
 269         case ERROR_ACCESS_DENIED:
 270             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
 271             break;
 272         case ERROR_INVALID_ADDRESS:
 273             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 274             break;
 275         case ERROR_INVALID_NAME:
 276             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
 277             break;
 278         case ERROR_NOT_READY:
 279         case ERROR_PATH_BUSY:
 280             PR_SetError(PR_IO_ERROR, err);
 281             break;
 282         case ERROR_DRIVE_LOCKED:
 283             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
 284             break;
 285         case ERROR_FILENAME_EXCED_RANGE:
 286             PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
 287             break;
 288         case ERROR_TOO_MANY_OPEN_FILES:
 289             PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
 290             break;
 291         case ERROR_PATH_NOT_FOUND:
 292             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
 293             break;
 294         case ERROR_NOT_ENOUGH_MEMORY:
 295         case ERROR_MORE_DATA:
 296             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
 297             break;
 298         case ERROR_DISK_FULL:
 299         case ERROR_HANDLE_DISK_FULL:
 300             PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
 301             break;
 302         case ERROR_WRITE_PROTECT:
 303             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
 304             break;
 305         default:
 306             PR_SetError(PR_UNKNOWN_ERROR, err);
 307             break;
 308     }
 309 }
 310
 311 void _MD_os2_map_rmdir_error(PRInt32 err)
 312 {
 313
 314     switch (err) {
 315         case ERROR_FILE_NOT_FOUND:
 316             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
 317             break;
 318         case ERROR_ACCESS_DENIED:
 319             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
 320             break;
 321         case ERROR_INVALID_ADDRESS:
 322             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 323             break;
 324         case ERROR_INVALID_NAME:
 325             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
 326             break;
 327         case ERROR_NOT_READY:
 328         case ERROR_PATH_BUSY:
 329             PR_SetError(PR_IO_ERROR, err);
 330             break;
 331         case ERROR_DRIVE_LOCKED:
 332             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
 333             break;
 334         case ERROR_FILENAME_EXCED_RANGE:
 335             PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
 336             break;
 337         case ERROR_TOO_MANY_OPEN_FILES:
 338             PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
 339             break;
 340         case ERROR_PATH_NOT_FOUND:
 341             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
 342             break;
 343         case ERROR_NOT_ENOUGH_MEMORY:
 344         case ERROR_MORE_DATA:
 345             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
 346             break;
 347         case ERROR_WRITE_PROTECT:
 348             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
 349             break;
 350         default:
 351             PR_SetError(PR_UNKNOWN_ERROR, err);
 352             break;
 353     }
 354 }
 355
 356 void _MD_os2_map_read_error(PRInt32 err)
 357 {
 358     switch (err) {
 359         case ERROR_ACCESS_DENIED:
 360             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
 361             break;
 362         case ERROR_INVALID_HANDLE:
 363             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 364             break;
 365         case ERROR_INVALID_ADDRESS:
 366             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 367             break;
 368         case ERROR_NOT_READY:
 369         case ERROR_PATH_BUSY:
 370             PR_SetError(PR_IO_ERROR, err);
 371             break;
 372         case ERROR_NOT_ENOUGH_MEMORY:
 373         case ERROR_MORE_DATA:
 374             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
 375             break;
 376         case ERROR_DRIVE_LOCKED:
 377         case ERROR_LOCKED:
 378         case ERROR_SHARING_VIOLATION:
 379             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
 380             break;
 381         case ERROR_NETNAME_DELETED:
 382             PR_SetError(PR_CONNECT_RESET_ERROR, err);
 383             break;
 384         case EBADF:
 385             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 386             break;
 387         case ENOTSOCK:
 388             PR_SetError(PR_NOT_SOCKET_ERROR, err);
 389             break;
 390 #ifdef SOCEFAULT
 391         case SOCEFAULT:
 392             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 393             break;
 394 #endif
 395         default:
 396             PR_SetError(PR_UNKNOWN_ERROR, err);
 397             break;
 398     }
 399 }
 400
 401 void _MD_os2_map_transmitfile_error(PRInt32 err)
 402 {
 403     switch (err) {
 404         case ERROR_ACCESS_DENIED:
 405             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
 406             break;
 407         case ERROR_INVALID_HANDLE:
 408             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 409             break;
 410         case ERROR_INVALID_ADDRESS:
 411             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 412             break;
 413         case ERROR_NOT_READY:
 414         case ERROR_PATH_BUSY:
 415             PR_SetError(PR_IO_ERROR, err);
 416             break;
 417         case ERROR_NOT_ENOUGH_MEMORY:
 418         case ERROR_MORE_DATA:
 419             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
 420             break;
 421         case ERROR_DRIVE_LOCKED:
 422         case ERROR_LOCKED:
 423         case ERROR_SHARING_VIOLATION:
 424             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
 425             break;
 426         case ERROR_FILENAME_EXCED_RANGE:
 427             PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
 428             break;
 429         case ERROR_TOO_MANY_OPEN_FILES:
 430             PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
 431             break;
 432         case ERROR_PATH_NOT_FOUND:
 433             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
 434             break;
 435         case EBADF:
 436             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 437             break;
 438         case ENOTSOCK:
 439             PR_SetError(PR_NOT_SOCKET_ERROR, err);
 440             break;
 441 #ifdef SOCEFAULT
 442         case SOCEFAULT:
 443             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 444             break;
 445 #endif
 446         default:
 447             PR_SetError(PR_UNKNOWN_ERROR, err);
 448             break;
 449     }
 450 }
 451
 452 void _MD_os2_map_write_error(PRInt32 err)
 453 {
 454     switch (err) {
 455         case ERROR_ACCESS_DENIED:
 456         case ERROR_WRITE_PROTECT:
 457             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
 458             break;
 459         case ERROR_INVALID_HANDLE:
 460             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 461             break;
 462         case ERROR_INVALID_ADDRESS:
 463             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 464             break;
 465         case ERROR_NOT_READY:
 466         case ERROR_PATH_BUSY:
 467             PR_SetError(PR_IO_ERROR, err);
 468             break;
 469         case ERROR_DRIVE_LOCKED:
 470         case ERROR_LOCKED:
 471         case ERROR_SHARING_VIOLATION:
 472             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
 473             break;
 474         case ERROR_NOT_ENOUGH_MEMORY:
 475         case ERROR_MORE_DATA:
 476         case ERROR_DISK_FULL:
 477         case ERROR_HANDLE_DISK_FULL:
 478         case ENOSPC:
 479             PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
 480             break;
 481         case ERROR_NETNAME_DELETED:
 482             PR_SetError(PR_CONNECT_RESET_ERROR, err);
 483             break;
 484         case EBADF:
 485             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 486             break;
 487         case ENOTSOCK:
 488             PR_SetError(PR_NOT_SOCKET_ERROR, err);
 489             break;
 490         case EMSGSIZE:
 491         case EINVAL:
 492             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
 493             break;
 494         case ENOBUFS:
 495             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
 496             break;
 497         case ECONNREFUSED:
 498             PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
 499             break;
 500         case EISCONN:
 501             PR_SetError(PR_IS_CONNECTED_ERROR, err);
 502             break;
 503 #ifdef SOCEFAULT
 504         case SOCEFAULT:
 505             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 506             break;
 507 #endif
 508         default:
 509             PR_SetError(PR_UNKNOWN_ERROR, err);
 510             break;
 511     }
 512 }
 513
 514 void _MD_os2_map_lseek_error(PRInt32 err)
 515 {
 516     switch (err) {
 517         case ERROR_INVALID_HANDLE:
 518             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 519             break;
 520         case ERROR_SEEK_ON_DEVICE:
 521             PR_SetError(PR_IO_ERROR, err);
 522             break;
 523         default:
 524             PR_SetError(PR_UNKNOWN_ERROR, err);
 525             break;
 526     }
 527 }
 528
 529 void _MD_os2_map_fsync_error(PRInt32 err)
 530 {
 531     switch (err) {
 532         case ERROR_ACCESS_DENIED:
 533         case ERROR_WRITE_PROTECT:
 534             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
 535             break;
 536         case ERROR_INVALID_HANDLE:
 537             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 538             break;
 539         case ERROR_NOT_ENOUGH_MEMORY:
 540         case ERROR_MORE_DATA:
 541             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
 542             break;
 543         case ERROR_DISK_FULL:
 544         case ERROR_HANDLE_DISK_FULL:
 545             PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
 546             break;
 547         default:
 548             PR_SetError(PR_UNKNOWN_ERROR, err);
 549             break;
 550     }
 551 }
 552
 553 void _MD_os2_map_close_error(PRInt32 err)
 554 {
 555     switch (err) {
 556         case ERROR_INVALID_HANDLE:
 557         case EBADF:
 558             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 559             break;
 560         case ERROR_NOT_READY:
 561         case ERROR_PATH_BUSY:
 562             PR_SetError(PR_IO_ERROR, err);
 563             break;
 564         default:
 565             PR_SetError(PR_UNKNOWN_ERROR, err);
 566             break;
 567     }
 568 }
 569
 570 void _MD_os2_map_socket_error(PRInt32 err)
 571 {
 572     switch (err) {
 573         case EPROTONOSUPPORT:
 574             PR_SetError(PR_PROTOCOL_NOT_SUPPORTED_ERROR, err);
 575             break;
 576         case EACCES:
 577             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
 578             break;
 579         case ERROR_NOT_ENOUGH_MEMORY:
 580         case ERROR_MORE_DATA:
 581         case ENOBUFS:
 582             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
 583             break;
 584         default:
 585             PR_SetError(PR_UNKNOWN_ERROR, err);
 586             break;
 587     }
 588 }
 589
 590 void _MD_os2_map_recv_error(PRInt32 err)
 591 {
 592     switch (err) {
 593         case EWOULDBLOCK:
 594             PR_SetError(PR_WOULD_BLOCK_ERROR, err);
 595             break;
 596         case EBADF:
 597             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 598             break;
 599         case ENOTSOCK:
 600             PR_SetError(PR_NOT_SOCKET_ERROR, err);
 601             break;
 602 #ifdef SOCEFAULT
 603         case SOCEFAULT:
 604             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 605             break;
 606 #endif
 607         case ERROR_NETNAME_DELETED:
 608             PR_SetError(PR_CONNECT_RESET_ERROR, err);
 609             break;
 610         default:
 611             PR_SetError(PR_UNKNOWN_ERROR, err);
 612             break;
 613     }
 614 }
 615
 616 void _MD_os2_map_recvfrom_error(PRInt32 err)
 617 {
 618     switch (err) {
 619         case EWOULDBLOCK:
 620             PR_SetError(PR_WOULD_BLOCK_ERROR, err);
 621             break;
 622         case EBADF:
 623             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 624             break;
 625         case ENOTSOCK:
 626             PR_SetError(PR_NOT_SOCKET_ERROR, err);
 627             break;
 628 #ifdef SOCEFAULT
 629         case SOCEFAULT:
 630             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 631             break;
 632 #endif
 633         case ERROR_NETNAME_DELETED:
 634             PR_SetError(PR_CONNECT_RESET_ERROR, err);
 635             break;
 636         default:
 637             PR_SetError(PR_UNKNOWN_ERROR, err);
 638             break;
 639     }
 640 }
 641
 642 void _MD_os2_map_send_error(PRInt32 err)
 643 {
 644     switch (err) {
 645         case EWOULDBLOCK:
 646             PR_SetError(PR_WOULD_BLOCK_ERROR, err);
 647             break;
 648         case EBADF:
 649             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 650             break;
 651         case ENOTSOCK:
 652             PR_SetError(PR_NOT_SOCKET_ERROR, err);
 653             break;
 654         case EMSGSIZE:
 655         case EINVAL:
 656             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
 657             break;
 658         case ENOBUFS:
 659             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
 660             break;
 661         case ECONNREFUSED:
 662             PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
 663             break;
 664         case EISCONN:
 665             PR_SetError(PR_IS_CONNECTED_ERROR, err);
 666             break;
 667 #ifdef SOCEFAULT
 668         case SOCEFAULT:
 669             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 670             break;
 671 #endif
 672         case ERROR_NETNAME_DELETED:
 673             PR_SetError(PR_CONNECT_RESET_ERROR, err);
 674             break;
 675         default:
 676             PR_SetError(PR_UNKNOWN_ERROR, err);
 677             break;
 678     }
 679 }
 680
 681 void _MD_os2_map_sendto_error(PRInt32 err)
 682 {
 683     _MD_os2_map_default_error(err);
 684 }
 685
 686 void _MD_os2_map_writev_error(int err)
 687 {
 688     _MD_os2_map_default_error(err);
 689 }
 690
 691 void _MD_os2_map_accept_error(PRInt32 err)
 692 {
 693     _MD_os2_map_default_error(err);
 694 }
 695
 696 void _MD_os2_map_acceptex_error(PRInt32 err)
 697 {
 698     switch (err) {
 699         case ERROR_INVALID_HANDLE:
 700             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 701             break;
 702         case ERROR_INVALID_ADDRESS:
 703             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 704             break;
 705         case ERROR_NOT_ENOUGH_MEMORY:
 706         case ERROR_MORE_DATA:
 707             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
 708             break;
 709         default:
 710             PR_SetError(PR_UNKNOWN_ERROR, err);
 711             break;
 712     }
 713 }
 714
 715 /*
 716  * An error code of 0 means that the nonblocking connect succeeded.
 717  */
 718
 719 int _MD_os2_get_nonblocking_connect_error(int osfd)
 720 {
 721     int err;
 722     int len = sizeof(err);
 723     if (getsockopt(osfd, SOL_SOCKET, SO_ERROR, (char *) &err, &len) == -1) {
 724         return sock_errno();
 725     } else {
 726         return err;
 727     }
 728 }
 729
 730 void _MD_os2_map_connect_error(PRInt32 err)
 731 {
 732     switch (err) {
 733         case EWOULDBLOCK:
 734             PR_SetError(PR_WOULD_BLOCK_ERROR, err);
 735             break;
 736         case EINPROGRESS:
 737             PR_SetError(PR_IN_PROGRESS_ERROR, err);
 738             break;
 739         case EALREADY:
 740         case EINVAL:
 741             PR_SetError(PR_ALREADY_INITIATED_ERROR, err);
 742             break;
 743         case EBADF:
 744             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 745             break;
 746         case EADDRNOTAVAIL:
 747             PR_SetError(PR_ADDRESS_NOT_AVAILABLE_ERROR, err);
 748             break;
 749         case ENOTSOCK:
 750             PR_SetError(PR_NOT_SOCKET_ERROR, err);
 751             break;
 752         case EAFNOSUPPORT:
 753             PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
 754             break;
 755         case ETIMEDOUT:
 756             PR_SetError(PR_IO_TIMEOUT_ERROR, err);
 757             break;
 758         case ECONNREFUSED:
 759             PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
 760             break;
 761         case ENETUNREACH:
 762             PR_SetError(PR_NETWORK_UNREACHABLE_ERROR, err);
 763             break;
 764         case EADDRINUSE:
 765             PR_SetError(PR_ADDRESS_IN_USE_ERROR, err);
 766             break;
 767         case EISCONN:
 768             PR_SetError(PR_IS_CONNECTED_ERROR, err);
 769             break;
 770 #ifdef SOCEFAULT
 771         case SOCEFAULT:
 772             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 773             break;
 774 #endif
 775         default:
 776             PR_SetError(PR_UNKNOWN_ERROR, err);
 777             break;
 778     }
 779 }
 780
 781 void _MD_os2_map_bind_error(PRInt32 err)
 782 {
 783     switch (err) {
 784         case EBADF:
 785             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 786             break;
 787         case ENOTSOCK:
 788             PR_SetError(PR_NOT_SOCKET_ERROR, err);
 789             break;
 790 #ifdef SOCEFAULT
 791         case SOCEFAULT:
 792             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 793             break;
 794 #endif
 795         case EADDRNOTAVAIL:
 796             PR_SetError(PR_ADDRESS_NOT_AVAILABLE_ERROR, err);
 797             break;
 798         case EADDRINUSE:
 799             PR_SetError(PR_ADDRESS_IN_USE_ERROR, err);
 800             break;
 801         case EACCES:
 802             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
 803             break;
 804         case EINVAL:
 805             PR_SetError(PR_SOCKET_ADDRESS_IS_BOUND_ERROR, err);
 806             break;
 807         default:
 808             PR_SetError(PR_UNKNOWN_ERROR, err);
 809             break;
 810     }
 811 }
 812
 813 void _MD_os2_map_listen_error(PRInt32 err)
 814 {
 815     switch (err) {
 816         case EBADF:
 817             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 818             break;
 819         case ENOTSOCK:
 820             PR_SetError(PR_NOT_SOCKET_ERROR, err);
 821             break;
 822         case EOPNOTSUPP:
 823             PR_SetError(PR_NOT_TCP_SOCKET_ERROR, err);
 824             break;
 825         default:
 826             PR_SetError(PR_UNKNOWN_ERROR, err);
 827             break;
 828     }
 829 }
 830
 831 void _MD_os2_map_shutdown_error(PRInt32 err)
 832 {
 833     switch (err) {
 834         case EBADF:
 835             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 836             break;
 837         case ENOTSOCK:
 838             PR_SetError(PR_NOT_SOCKET_ERROR, err);
 839             break;
 840         case ENOTCONN:
 841             PR_SetError(PR_NOT_CONNECTED_ERROR, err);
 842             break;
 843         default:
 844             PR_SetError(PR_UNKNOWN_ERROR, err);
 845             break;
 846     }
 847 }
 848
 849 void _MD_os2_map_socketpair_error(PRInt32 err)
 850 {
 851     switch (err) {
 852         case ENOMEM:
 853             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
 854             break;
 855         case EAFNOSUPPORT:
 856             PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
 857             break;
 858         case EPROTONOSUPPORT:
 859             PR_SetError(PR_PROTOCOL_NOT_SUPPORTED_ERROR, err);
 860             break;
 861         case EOPNOTSUPP:
 862             PR_SetError(PR_NOT_TCP_SOCKET_ERROR, err);
 863             break;
 864         case EPROTOTYPE:
 865             PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
 866             break;
 867         default:
 868             _MD_os2_map_default_error(err);
 869             return;
 870     }
 871 }
 872
 873 void _MD_os2_map_getsockname_error(PRInt32 err)
 874 {
 875     switch (err) {
 876         case EBADF:
 877             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 878             break;
 879         case ENOTSOCK:
 880             PR_SetError(PR_NOT_SOCKET_ERROR, err);
 881             break;
 882 #ifdef SOCEFAULT
 883         case SOCEFAULT:
 884             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 885             break;
 886 #endif
 887         case ENOBUFS:
 888             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
 889             break;
 890         default:
 891             PR_SetError(PR_UNKNOWN_ERROR, err);
 892             break;
 893     }
 894 }
 895
 896 void _MD_os2_map_getpeername_error(PRInt32 err)
 897 {
 898
 899     switch (err) {
 900         case EBADF:
 901             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 902             break;
 903         case ENOTSOCK:
 904             PR_SetError(PR_NOT_SOCKET_ERROR, err);
 905             break;
 906         case ENOTCONN:
 907             PR_SetError(PR_NOT_CONNECTED_ERROR, err);
 908             break;
 909 #ifdef SOCEFAULT
 910         case SOCEFAULT:
 911             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 912             break;
 913 #endif
 914         case ENOBUFS:
 915             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
 916             break;
 917         default:
 918             PR_SetError(PR_UNKNOWN_ERROR, err);
 919             break;
 920     }
 921 }
 922
 923 void _MD_os2_map_getsockopt_error(PRInt32 err)
 924 {
 925     switch (err) {
 926         case EBADF:
 927             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 928             break;
 929         case ENOTSOCK:
 930             PR_SetError(PR_NOT_SOCKET_ERROR, err);
 931             break;
 932         case ENOPROTOOPT:
 933             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
 934             break;
 935 #ifdef SOCEFAULT
 936         case SOCEFAULT:
 937             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 938             break;
 939 #endif
 940         case EINVAL:
 941             PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
 942             break;
 943         default:
 944             PR_SetError(PR_UNKNOWN_ERROR, err);
 945             break;
 946     }
 947 }
 948
 949 void _MD_os2_map_setsockopt_error(PRInt32 err)
 950 {
 951     switch (err) {
 952         case EBADF:
 953             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
 954             break;
 955         case ENOTSOCK:
 956             PR_SetError(PR_NOT_SOCKET_ERROR, err);
 957             break;
 958         case ENOPROTOOPT:
 959             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
 960             break;
 961 #ifdef SOCEFAULT
 962         case SOCEFAULT:
 963             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 964             break;
 965 #endif
 966         case EINVAL:
 967             PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
 968             break;
 969         default:
 970             PR_SetError(PR_UNKNOWN_ERROR, err);
 971             break;
 972     }
 973 }
 974
 975 void _MD_os2_map_open_error(PRInt32 err)
 976 {
 977     switch (err) {
 978         case ERROR_ALREADY_EXISTS:
 979         case ERROR_FILE_EXISTS:
 980             PR_SetError(PR_FILE_EXISTS_ERROR, err);
 981             break;
 982         case ERROR_FILE_NOT_FOUND:
 983             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
 984             break;
 985         case ERROR_ACCESS_DENIED:
 986             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
 987             break;
 988         case ERROR_INVALID_ADDRESS:
 989             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
 990             break;
 991         case ERROR_INVALID_NAME:
 992             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
 993             break;
 994         case ERROR_NOT_READY:
 995         case ERROR_OPEN_FAILED:
 996         case ERROR_PATH_BUSY:
 997             PR_SetError(PR_IO_ERROR, err);
 998             break;
 999         case ERROR_DRIVE_LOCKED:
1000             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
1001             break;
1002         case ERROR_FILENAME_EXCED_RANGE:
1003             PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
1004             break;
1005         case ERROR_TOO_MANY_OPEN_FILES:
1006             PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
1007             break;
1008         case ERROR_PATH_NOT_FOUND:
1009             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
1010             break;
1011         case ERROR_NOT_ENOUGH_MEMORY:
1012         case ERROR_MORE_DATA:
1013             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
1014             break;
1015         case ERROR_DISK_FULL:
1016         case ERROR_HANDLE_DISK_FULL:
1017             PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
1018             break;
1019         case ERROR_WRITE_PROTECT:
1020             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
1021             break;
1022         default:
1023             PR_SetError(PR_UNKNOWN_ERROR, err);
1024             break;
1025     }
1026 }
1027
1028 void _MD_os2_map_gethostname_error(PRInt32 err)
1029 {
1030     switch (err) {
1031 #ifdef SOCEFAULT
1032         case SOCEFAULT:
1033             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
1034             break;
1035 #endif
1036         case ENETDOWN:
1037         case EINPROGRESS:
1038         default:
1039             PR_SetError(PR_UNKNOWN_ERROR, err);
1040             break;
1041     }
1042 }
1043
1044 void _MD_os2_map_select_error(PRInt32 err)
1045 {
1046     PRErrorCode prerror;
1047
1048     switch (err) {
1049         /*
1050          * OS/2 select() only works on sockets.  So in this
1051          * context, ENOTSOCK is equivalent to EBADF on Unix.
1052          */
1053         case ENOTSOCK:
1054             prerror = PR_BAD_DESCRIPTOR_ERROR;
1055             break;
1056         case EINVAL:
1057             prerror = PR_INVALID_ARGUMENT_ERROR;
1058             break;
1059 #ifdef SOCEFAULT
1060         case SOCEFAULT:
1061             prerror = PR_ACCESS_FAULT_ERROR;
1062             break;
1063 #endif
1064         default:
1065             prerror = PR_UNKNOWN_ERROR;
1066     }
1067     PR_SetError(prerror, err);
1068 }
1069
1070 void _MD_os2_map_lockf_error(PRInt32 err)
1071 {
1072     switch (err) {
1073         case ERROR_ACCESS_DENIED:
1074             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
1075             break;
1076         case ERROR_INVALID_HANDLE:
1077             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
1078             break;
1079         case ERROR_INVALID_ADDRESS:
1080             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
1081             break;
1082         case ERROR_DRIVE_LOCKED:
1083         case ERROR_LOCKED:
1084         case ERROR_SHARING_VIOLATION:
1085             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
1086             break;
1087         case ERROR_NOT_ENOUGH_MEMORY:
1088         case ERROR_MORE_DATA:
1089             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
1090             break;
1091         default:
1092             PR_SetError(PR_UNKNOWN_ERROR, err);
1093             break;
1094     }
1095 }