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