home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / nsprpub / pr / src / md / unix / unix_errors.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  31.8 KB  |  1,485 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 "prtypes.h"
  20. #include "md/_unix_errors.h"
  21. #include "prerror.h"
  22. #include <errno.h>
  23.  
  24. void _MD_unix_map_opendir_error(int err)
  25. {
  26.     switch (err) {
  27.         case ENOTDIR:
  28.             PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
  29.             break;
  30.         case EACCES:
  31.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  32.             break;
  33.         case EMFILE:
  34.             PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
  35.             break;
  36.         case ENFILE:
  37.             PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
  38.             break;
  39.         case EFAULT:
  40.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  41.             break;
  42.         case ELOOP:
  43.             PR_SetError(PR_LOOP_ERROR, err);
  44.             break;
  45.         case ENAMETOOLONG:
  46.             PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
  47.             break;
  48.         case ENOENT:
  49.             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
  50.             break;
  51.         default:
  52.             PR_SetError(PR_UNKNOWN_ERROR, err);
  53.             break;
  54.     }
  55. }
  56.  
  57. void _MD_unix_map_closedir_error(int err)
  58. {
  59.     switch (err) {
  60.         case EINVAL:
  61.         case EBADF:
  62.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  63.             break;
  64.         default:
  65.             PR_SetError(PR_UNKNOWN_ERROR, err);
  66.             break;
  67.     }
  68. }
  69.  
  70. void _MD_unix_readdir_error(int err)
  71. {
  72.  
  73.     switch (err) {
  74.         case ENOENT:
  75.             PR_SetError(PR_NO_MORE_FILES_ERROR, err);
  76.             break;
  77.         case EBADF:
  78.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  79.             break;
  80. #ifdef IRIX
  81. #ifdef IRIX5_3
  82. #else
  83.         case EDIRCORRUPTED:
  84.             PR_SetError(PR_DIRECTORY_CORRUPTED_ERROR, err);
  85.             break;
  86. #endif
  87. #endif
  88. #ifdef EOVERFLOW
  89.         case EOVERFLOW:
  90.             PR_SetError(PR_IO_ERROR, err);
  91.             break;
  92. #endif
  93.         case EINVAL:
  94.             PR_SetError(PR_IO_ERROR, err);
  95.             break;
  96. #ifdef EBADMSG
  97.         case EBADMSG:
  98.             PR_SetError(PR_IO_ERROR, err);
  99.             break;
  100. #endif
  101.         case EDEADLK:
  102.             PR_SetError(PR_DEADLOCK_ERROR, err);
  103.             break;
  104.         case EFAULT:
  105.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  106.             break;
  107.         case EINTR:
  108.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  109.             break;
  110.         case EIO:
  111.             PR_SetError(PR_IO_ERROR, err);
  112.             break;
  113.         case ENOLCK:
  114.             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
  115.             break;
  116. #ifdef ENOLINK
  117.         case ENOLINK:
  118.             PR_SetError(PR_REMOTE_FILE_ERROR, err);
  119.             break;
  120. #endif
  121.         case ENXIO:
  122.             PR_SetError(PR_IO_ERROR, err);
  123.             break;
  124.         default:
  125.             PR_SetError(PR_UNKNOWN_ERROR, err);
  126.             break;
  127.     }
  128. }
  129.  
  130. void _MD_unix_map_unlink_error(int err)
  131. {
  132.     switch (err) {
  133.         case EACCES:
  134.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  135.             break;
  136.         case EBUSY:
  137.             PR_SetError(PR_FILESYSTEM_MOUNTED_ERROR, err);
  138.             break;
  139.         case EFAULT:
  140.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  141.             break;
  142.         case EINTR:
  143.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  144.             break;
  145.         case ELOOP:
  146.             PR_SetError(PR_LOOP_ERROR, err);
  147.             break;
  148.         case ENAMETOOLONG:
  149.             PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
  150.             break;
  151.         case ENOENT:
  152.             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
  153.             break;
  154.         case ENOTDIR:
  155.             PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
  156.             break;
  157.         case EPERM:
  158.             PR_SetError(PR_IS_DIRECTORY_ERROR, err);
  159.             break;
  160.         case EROFS:
  161.             PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
  162.             break;
  163. #if !defined(OSF1) && !defined(FREEBSD) && !defined(BSDI)
  164.         case EMULTIHOP:
  165.         case ENOLINK:
  166.             PR_SetError(PR_REMOTE_FILE_ERROR, err);
  167.             break;
  168. #endif
  169.         default:
  170.             PR_SetError(PR_UNKNOWN_ERROR, err);
  171.             break;
  172.     }
  173. }
  174.  
  175. void _MD_unix_map_stat_error(int err)
  176. {
  177.     switch (err) {
  178.         case EACCES:
  179.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  180.             break;
  181.         case EFAULT:
  182.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  183.             break;
  184.         case EINTR:
  185.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  186.             break;
  187.         case ETIMEDOUT:
  188. #if !defined(OSF1) && !defined(FREEBSD) && !defined(BSDI)
  189.         case EMULTIHOP:
  190.         case ENOLINK:
  191. #endif
  192.             PR_SetError(PR_REMOTE_FILE_ERROR, err);
  193.             break;
  194.         case ELOOP:
  195.             PR_SetError(PR_LOOP_ERROR, err);
  196.             break;
  197.         case ENAMETOOLONG:
  198.             PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
  199.             break;
  200.         case ENOENT:
  201.             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
  202.             break;
  203.         case ENOTDIR:
  204.             PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
  205.             break;
  206. #ifdef EOVERFLOW
  207.         case EOVERFLOW:
  208.             PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
  209.             break;
  210. #endif
  211.         default:
  212.             PR_SetError(PR_UNKNOWN_ERROR, err);
  213.             break;
  214.     }
  215. }
  216.  
  217. void _MD_unix_map_fstat_error(int err)
  218. {
  219.     switch (err) {
  220.         case EBADF:
  221.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  222.             break;
  223.         case EFAULT:
  224.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  225.             break;
  226.         case EINTR:
  227.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  228.             break;
  229.         case ETIMEDOUT:
  230. #ifdef ENOLINK
  231.         case ENOLINK:
  232. #endif
  233.             PR_SetError(PR_REMOTE_FILE_ERROR, err);
  234.             break;
  235. #ifdef EOVERFLOW
  236.         case EOVERFLOW:
  237.             PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
  238.             break;
  239. #endif
  240.         default:
  241.             PR_SetError(PR_UNKNOWN_ERROR, err);
  242.             break;
  243.     }
  244. }
  245.  
  246. void _MD_unix_map_rename_error(int err)
  247. {
  248.     switch (err) {
  249.         case EACCES:
  250.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  251.             break;
  252.         case EBUSY:
  253.             PR_SetError(PR_FILESYSTEM_MOUNTED_ERROR, err);
  254.             break;
  255. #ifdef EDQUOT
  256.         case EDQUOT:
  257.             PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
  258.             break;
  259. #endif
  260.         case EEXIST:
  261.             PR_SetError(PR_DIRECTORY_NOT_EMPTY_ERROR, err);
  262.             break;
  263.         case EFAULT:
  264.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  265.             break;
  266.         case EINTR:
  267.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  268.             break;
  269.         case EINVAL:
  270.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  271.             break;
  272.         case EIO:
  273.             PR_SetError(PR_IO_ERROR, err);
  274.             break;
  275.         case EISDIR:
  276.             PR_SetError(PR_IS_DIRECTORY_ERROR, err);
  277.             break;
  278.         case ELOOP:
  279.             PR_SetError(PR_LOOP_ERROR, err);
  280.             break;
  281. #if !defined(OSF1) && !defined(FREEBSD) && !defined(BSDI)
  282.         case EMULTIHOP:
  283.         case ENOLINK:
  284.             PR_SetError(PR_REMOTE_FILE_ERROR, err);
  285.             break;
  286. #endif
  287.         case ENAMETOOLONG:
  288.             PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
  289.             break;
  290.         case ENOENT:
  291.             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
  292.             break;
  293.         case ENOSPC:
  294.             PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
  295.             break;
  296.         case ENOTDIR:
  297.             PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
  298.             break;
  299.         case EROFS:
  300.             PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
  301.             break;
  302.         case EXDEV:
  303.             PR_SetError(PR_NOT_SAME_DEVICE_ERROR, err);
  304.             break;
  305.         case EMLINK:
  306.             PR_SetError(PR_MAX_DIRECTORY_ENTRIES_ERROR, err);
  307.             break;
  308.         default:
  309.             PR_SetError(PR_UNKNOWN_ERROR, err);
  310.             break;
  311.     }
  312. }
  313.  
  314. void _MD_unix_map_access_error(int err)
  315. {
  316.     switch (err) {
  317.         case EACCES:
  318.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  319.             break;
  320.         case EFAULT:
  321.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  322.             break;
  323.         case EINTR:
  324.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  325.             break;
  326.         case EINVAL:
  327.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  328.             break;
  329.         case ELOOP:
  330.             PR_SetError(PR_LOOP_ERROR, err);
  331.             break;
  332. #if !defined(OSF1) && !defined(FREEBSD) && !defined(BSDI)
  333.         case EMULTIHOP:
  334.         case ENOLINK:
  335. #endif
  336.         case ETIMEDOUT:
  337.             PR_SetError(PR_REMOTE_FILE_ERROR, err);
  338.             break;
  339.         case ENAMETOOLONG:
  340.             PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
  341.             break;
  342.         case ENOENT:
  343.             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
  344.             break;
  345.         case ENOTDIR:
  346.             PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
  347.             break;
  348.         case EROFS:
  349.             PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
  350.             break;
  351.         default:
  352.             PR_SetError(PR_UNKNOWN_ERROR, err);
  353.             break;
  354.     }
  355. }
  356.  
  357. void _MD_unix_map_mkdir_error(int err)
  358. {
  359.     switch (err) {
  360.         case ENOTDIR:
  361.             PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
  362.             break;
  363.         case ENOENT:
  364.             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
  365.             break;
  366.         case ENAMETOOLONG:
  367.             PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
  368.             break;
  369.         case EACCES:
  370.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  371.             break;
  372.         case EEXIST:
  373.             PR_SetError(PR_FILE_EXISTS_ERROR, err);
  374.             break;
  375.         case EROFS:
  376.             PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
  377.             break;
  378.         case EFAULT:
  379.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  380.             break;
  381.         case ELOOP:
  382.             PR_SetError(PR_LOOP_ERROR, err);
  383.             break;
  384.         case EMLINK:
  385.             PR_SetError(PR_MAX_DIRECTORY_ENTRIES_ERROR, err);
  386.             break;
  387.         case ENOSPC:
  388.             PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
  389.             break;
  390. #ifdef EDQUOT
  391.         case EDQUOT:
  392.             PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
  393.             break;
  394. #endif
  395.         case EIO:
  396.             PR_SetError(PR_IO_ERROR, err);
  397.             break;
  398. #if !defined(OSF1) && !defined(FREEBSD) && !defined(BSDI)
  399.         case EMULTIHOP:
  400.         case ENOLINK:
  401.             PR_SetError(PR_REMOTE_FILE_ERROR, err);
  402.             break;
  403. #endif
  404.         default:
  405.             PR_SetError(PR_UNKNOWN_ERROR, err);
  406.             break;
  407.     }
  408. }
  409.  
  410. void _MD_unix_map_rmdir_error(int err)
  411. {
  412.  
  413.     switch (err) {
  414.         case EACCES:
  415.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  416.             break;
  417.         case EBUSY:
  418.             PR_SetError(PR_FILESYSTEM_MOUNTED_ERROR, err);
  419.             break;
  420.         case EEXIST:
  421.             PR_SetError(PR_DIRECTORY_NOT_EMPTY_ERROR, err);
  422.             break;
  423.         case EFAULT:
  424.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  425.             break;
  426.         case EINVAL:
  427.             PR_SetError(PR_DIRECTORY_NOT_EMPTY_ERROR, err);
  428.             break;
  429.         case EIO:
  430.             PR_SetError(PR_IO_ERROR, err);
  431.             break;
  432.         case ELOOP:
  433.             PR_SetError(PR_LOOP_ERROR, err);
  434.             break;
  435. #if !defined(OSF1) && !defined(FREEBSD) && !defined(BSDI)
  436.         case EMULTIHOP:
  437.         case ENOLINK:
  438. #endif
  439.         case ETIMEDOUT:
  440.             PR_SetError(PR_REMOTE_FILE_ERROR, err);
  441.             break;
  442.         case ENAMETOOLONG:
  443.             PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
  444.             break;
  445.         case ENOENT:
  446.             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
  447.             break;
  448.         case ENOTDIR:
  449.             PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
  450.             break;
  451.         case EROFS:
  452.             PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
  453.             break;
  454.         default:
  455.             PR_SetError(PR_UNKNOWN_ERROR, err);
  456.             break;
  457.     }
  458. }
  459.  
  460. void _MD_unix_map_read_error(int err)
  461. {
  462.     switch (err) {
  463.         case EACCES:
  464.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  465.             break;
  466.         case EAGAIN:
  467. #if EWOULDBLOCK != EAGAIN
  468.         case EWOULDBLOCK:
  469. #endif
  470.             PR_SetError(PR_WOULD_BLOCK_ERROR, err);
  471.             break;
  472.         case EBADF:
  473.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  474.             break;
  475. #ifdef EBADMSG
  476.         case EBADMSG:
  477.             PR_SetError(PR_IO_ERROR, err);
  478.             break;
  479. #endif
  480.         case EDEADLK:
  481.             PR_SetError(PR_DEADLOCK_ERROR, err);
  482.             break;
  483.         case EFAULT:
  484.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  485.             break;
  486.         case EINTR:
  487.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  488.             break;
  489.         case EINVAL:
  490.             PR_SetError(PR_INVALID_METHOD_ERROR, err);
  491.             break;
  492.         case EIO:
  493.             PR_SetError(PR_IO_ERROR, err);
  494.             break;
  495.         case ENOLCK:
  496.             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
  497.             break;
  498.         case ENXIO:
  499.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  500.             break;
  501.         case EISDIR:
  502.             PR_SetError(PR_IS_DIRECTORY_ERROR, err);
  503.             break;
  504.         case ECONNRESET:
  505.         case EPIPE:
  506.             PR_SetError(PR_CONNECT_RESET_ERROR, err);
  507.             break;
  508. #ifdef ENOLINK
  509.         case ENOLINK:
  510.             PR_SetError(PR_REMOTE_FILE_ERROR, err);
  511.             break;
  512. #endif
  513.         default:
  514.             PR_SetError(PR_UNKNOWN_ERROR, err);
  515.             break;
  516.     }
  517. }
  518.  
  519. void _MD_unix_map_write_error(int err)
  520. {
  521.     switch (err) {
  522.         case EAGAIN:
  523. #if EWOULDBLOCK != EAGAIN
  524.         case EWOULDBLOCK:
  525. #endif
  526.             PR_SetError(PR_WOULD_BLOCK_ERROR, err);
  527.             break;
  528.         case EBADF:
  529.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  530.             break;
  531.         case EDEADLK:
  532.             PR_SetError(PR_DEADLOCK_ERROR, err);
  533.             break;
  534.         case EFAULT:
  535.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  536.             break;
  537.         case EFBIG:
  538.             PR_SetError(PR_FILE_TOO_BIG_ERROR, err);
  539.             break;
  540.         case EINTR:
  541.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  542.             break;
  543.         case EINVAL:
  544.             PR_SetError(PR_INVALID_METHOD_ERROR, err);
  545.             break;
  546.         case EIO:
  547.             PR_SetError(PR_IO_ERROR, err);
  548.             break;
  549.         case ENOLCK:
  550.             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
  551.             break;
  552. #ifdef ENOSR
  553.         case ENOSR:
  554.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  555.             break;
  556. #endif
  557.         case ENOSPC:
  558.             PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
  559.             break;
  560.         case ENXIO:
  561.             PR_SetError(PR_INVALID_METHOD_ERROR, err);
  562.             break;
  563.         case ERANGE:
  564.             PR_SetError(PR_INVALID_METHOD_ERROR, err);
  565.             break;
  566.         case ETIMEDOUT:
  567.             PR_SetError(PR_REMOTE_FILE_ERROR, err);
  568.             break;
  569.         case ECONNRESET:
  570.         case EPIPE:
  571.             PR_SetError(PR_CONNECT_RESET_ERROR, err);
  572.             break;
  573. #ifdef EDQUOT
  574.         case EDQUOT:
  575.             PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
  576.             break;
  577. #endif
  578. #ifdef ENOLINK
  579.         case ENOLINK:
  580.             PR_SetError(PR_REMOTE_FILE_ERROR, err);
  581.             break;
  582. #endif
  583.         default:
  584.             PR_SetError(PR_UNKNOWN_ERROR, err);
  585.             break;
  586.     }
  587. }
  588.  
  589. void _MD_unix_map_lseek_error(int err)
  590. {
  591.     switch (err) {
  592.         case EBADF:
  593.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  594.             break;
  595.         case ESPIPE:
  596.             PR_SetError(PR_INVALID_METHOD_ERROR, err);
  597.             break;
  598.         case EINVAL:
  599.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  600.             break;
  601.         default:
  602.             PR_SetError(PR_UNKNOWN_ERROR, err);
  603.             break;
  604.     }
  605. }
  606.  
  607. void _MD_unix_map_fsync_error(int err)
  608. {
  609.     switch (err) {
  610.         case EBADF:
  611.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  612.             break;
  613. #ifdef ENOLINK
  614.         case ENOLINK:
  615. #endif
  616.         case ETIMEDOUT:
  617.             PR_SetError(PR_REMOTE_FILE_ERROR, err);
  618.             break;
  619.         case EINTR:
  620.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  621.             break;
  622.         case EIO:
  623.             PR_SetError(PR_IO_ERROR, err);
  624.             break;
  625.         case EINVAL:
  626.             PR_SetError(PR_INVALID_METHOD_ERROR, err);
  627.             break;
  628.         default:
  629.             PR_SetError(PR_UNKNOWN_ERROR, err);
  630.             break;
  631.     }
  632. }
  633.  
  634. void _MD_unix_map_close_error(int err)
  635. {
  636.     switch (err) {
  637.         case EBADF:
  638.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  639.             break;
  640.         case EINTR:
  641.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  642.             break;
  643. #ifdef ENOLINK
  644.         case ENOLINK:
  645. #endif
  646.         case ETIMEDOUT:
  647.             PR_SetError(PR_REMOTE_FILE_ERROR, err);
  648.             break;
  649.         case EIO:
  650.             PR_SetError(PR_IO_ERROR, err);
  651.             break;
  652.         default:
  653.             PR_SetError(PR_UNKNOWN_ERROR, err);
  654.             break;
  655.     }
  656. }
  657.  
  658. void _MD_unix_map_socket_error(int err)
  659. {
  660.     switch (err) {
  661.         case EPROTONOSUPPORT:
  662.             PR_SetError(PR_PROTOCOL_NOT_SUPPORTED_ERROR, err);
  663.             break;
  664.         case EMFILE:
  665.             PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
  666.             break;
  667.         case ENFILE:
  668.             PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
  669.             break;
  670.         case EACCES:
  671.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  672.             break;
  673. #if !defined(SCO_SV)
  674.         case ENOBUFS:
  675. #endif /* !defined(SCO_SV) */
  676.         case ENOMEM:
  677. #ifdef ENOSR
  678.         case ENOSR:
  679.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  680.             break;
  681. #endif
  682.         default:
  683.             PR_SetError(PR_UNKNOWN_ERROR, err);
  684.             break;
  685.     }
  686. }
  687.  
  688. void _MD_unix_map_socketavailable_error(int err)
  689. {
  690.     PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  691. }
  692.  
  693. void _MD_unix_map_recv_error(int err)
  694. {
  695.     switch (err) {
  696.         case EAGAIN:
  697. #if EWOULDBLOCK != EAGAIN
  698.         case EWOULDBLOCK:
  699. #endif
  700.             PR_SetError(PR_WOULD_BLOCK_ERROR, err);
  701.             break;
  702.         case EBADF:
  703.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  704.             break;
  705.         case ENOTSOCK:
  706.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  707.             break;
  708.         case EINTR:
  709.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  710.             break;
  711.         case EFAULT:
  712.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  713.             break;
  714.         case ENOMEM:
  715.             PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
  716.             break;
  717.         case ECONNRESET:
  718.         case EPIPE:
  719.             PR_SetError(PR_CONNECT_RESET_ERROR, err);
  720.             break;
  721. #ifdef ENOSR
  722.         case ENOSR:
  723.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  724.             break;
  725. #endif
  726.         default:
  727.             PR_SetError(PR_UNKNOWN_ERROR, err);
  728.             break;
  729.     }
  730. }
  731.  
  732. void _MD_unix_map_recvfrom_error(int err)
  733. {
  734.     switch (err) {
  735.         case EAGAIN:
  736. #if EWOULDBLOCK != EAGAIN
  737.         case EWOULDBLOCK:
  738. #endif
  739.             PR_SetError(PR_WOULD_BLOCK_ERROR, err);
  740.             break;
  741.         case EBADF:
  742.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  743.             break;
  744.         case ENOTSOCK:
  745.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  746.             break;
  747.         case EINTR:
  748.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  749.             break;
  750.         case EFAULT:
  751.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  752.             break;
  753.         case ENOMEM:
  754.             PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
  755.             break;
  756. #ifdef ENOSR
  757.         case ENOSR:
  758.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  759.             break;
  760. #endif
  761.         case ECONNRESET:
  762.             PR_SetError(PR_CONNECT_RESET_ERROR, err);
  763.             break;
  764.         default:
  765.             PR_SetError(PR_UNKNOWN_ERROR, err);
  766.             break;
  767.     }
  768. }
  769.  
  770. void _MD_unix_map_send_error(int err)
  771. {
  772.     switch (err) {
  773.         case EAGAIN:
  774. #if EWOULDBLOCK != EAGAIN
  775.         case EWOULDBLOCK:
  776. #endif
  777.             PR_SetError(PR_WOULD_BLOCK_ERROR, err);
  778.             break;
  779.         case EBADF:
  780.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  781.             break;
  782.         case ENOTSOCK:
  783.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  784.             break;
  785.         case EMSGSIZE:
  786.         case EINVAL:
  787.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  788.             break;
  789. #if !defined(SCO_SV)
  790.         case ENOBUFS:
  791.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  792.             break;
  793. #endif /* !defined(SCO_SV) */
  794.         case ECONNREFUSED:
  795.             PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
  796.             break;
  797.         case EISCONN:
  798.             PR_SetError(PR_IS_CONNECTED_ERROR, err);
  799.             break;
  800.         case EFAULT:
  801.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  802.             break;
  803.         case EINTR:
  804.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  805.             break;
  806.         case ENOMEM:
  807.             PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
  808.             break;
  809. #ifdef ENOSR
  810.         case ENOSR:
  811.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  812.             break;
  813. #endif
  814.         case ECONNRESET:
  815.         case EPIPE:
  816.             PR_SetError(PR_CONNECT_RESET_ERROR, err);
  817.             break;
  818.         default:
  819.             PR_SetError(PR_UNKNOWN_ERROR, err);
  820.             break;
  821.     }
  822. }
  823.  
  824. void _MD_unix_map_sendto_error(int err)
  825. {
  826.     switch (err) {
  827.         case EAGAIN:
  828. #if EWOULDBLOCK != EAGAIN
  829.         case EWOULDBLOCK:
  830. #endif
  831.             PR_SetError(PR_WOULD_BLOCK_ERROR, err);
  832.             break;
  833.         case EBADF:
  834.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  835.             break;
  836.         case ENOTSOCK:
  837.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  838.             break;
  839.         case EMSGSIZE:
  840.         case EINVAL:
  841.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  842.             break;
  843. #if !defined(SCO_SV)
  844.         case ENOBUFS:
  845.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  846.             break;
  847. #endif /* !defined(SCO_SV) */
  848.         case ECONNREFUSED:
  849.             PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
  850.             break;
  851.         case EISCONN:
  852.             PR_SetError(PR_IS_CONNECTED_ERROR, err);
  853.             break;
  854.         case EFAULT:
  855.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  856.             break;
  857.         case EINTR:
  858.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  859.             break;
  860.         case ENOMEM:
  861.             PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
  862.             break;
  863. #ifdef ENOSR
  864.         case ENOSR:
  865.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  866.             break;
  867. #endif
  868.         case ECONNRESET:
  869.         case EPIPE:
  870.             PR_SetError(PR_CONNECT_RESET_ERROR, err);
  871.             break;
  872.         default:
  873.             PR_SetError(PR_UNKNOWN_ERROR, err);
  874.             break;
  875.     }
  876. }
  877.  
  878. void _MD_unix_map_writev_error(int err)
  879. {
  880.     switch (err) {
  881.         case EAGAIN:
  882. #if EWOULDBLOCK != EAGAIN
  883.         case EWOULDBLOCK:
  884. #endif
  885.             PR_SetError(PR_WOULD_BLOCK_ERROR, err);
  886.             break;
  887.         case EBADF:
  888.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  889.             break;
  890.         case EFAULT:
  891.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  892.             break;
  893.         case EINTR:
  894.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  895.             break;
  896. #ifdef ENOSR
  897.         case ENOSR:
  898.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  899.             break;
  900. #endif
  901.         case EINVAL:
  902.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  903.             break;
  904.         case ECONNRESET:
  905.         case EPIPE:
  906.             PR_SetError(PR_CONNECT_RESET_ERROR, err);
  907.             break;
  908.         default:
  909.             PR_SetError(PR_UNKNOWN_ERROR, err);
  910.             break;
  911.     }
  912. }
  913.  
  914. void _MD_unix_map_accept_error(int err)
  915. {
  916.     switch (err) {
  917.         case EAGAIN:
  918. #if EWOULDBLOCK != EAGAIN
  919.         case EWOULDBLOCK:
  920. #endif
  921.             PR_SetError(PR_WOULD_BLOCK_ERROR, err);
  922.             break;
  923.         case EBADF:
  924.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  925.             break;
  926.         case ENOTSOCK:
  927.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  928.             break;
  929.         case EOPNOTSUPP:
  930.         case ENODEV:
  931.             PR_SetError(PR_NOT_TCP_SOCKET_ERROR, err);
  932.             break;
  933.         case EFAULT:
  934.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  935.             break;
  936.         case EMFILE:
  937.             PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
  938.             break;
  939.         case ENFILE:
  940.             PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
  941.             break;
  942.         case EINTR:
  943.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  944.             break;
  945.         case ENOMEM:
  946.             PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
  947.             break;
  948. #ifdef ENOSR
  949.         case ENOSR:
  950.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  951.             break;
  952. #endif
  953. #ifdef EPROTO
  954.         case EPROTO:
  955.             PR_SetError(PR_IO_ERROR, err);
  956.             break;
  957. #endif
  958.         default:
  959.             PR_SetError(PR_UNKNOWN_ERROR, err);
  960.             break;
  961.     }
  962. }
  963.  
  964. void _MD_unix_map_connect_error(int err)
  965. {
  966.     switch (err) {
  967.         case EBADF:
  968.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  969.             break;
  970.         case EADDRNOTAVAIL:
  971.             PR_SetError(PR_ADDRESS_NOT_AVAILABLE_ERROR, err);
  972.             break;
  973.         case EINPROGRESS:
  974.             PR_SetError(PR_IN_PROGRESS_ERROR, err);
  975.             break;
  976.         case EALREADY:
  977.             PR_SetError(PR_ALREADY_INITIATED_ERROR, err);
  978.             break;
  979.         case ENOTSOCK:
  980.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  981.             break;
  982.         case EAFNOSUPPORT:
  983.             PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
  984.             break;
  985.         case EISCONN:
  986.             PR_SetError(PR_IS_CONNECTED_ERROR, err);
  987.             break;
  988.         case ETIMEDOUT:
  989.             PR_SetError(PR_IO_TIMEOUT_ERROR, err);
  990.             break;
  991.         case ECONNREFUSED:
  992.             PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
  993.             break;
  994.         case ENETUNREACH:
  995.             PR_SetError(PR_NETWORK_UNREACHABLE_ERROR, err);
  996.             break;
  997.         case EADDRINUSE:
  998.             PR_SetError(PR_ADDRESS_IN_USE_ERROR, err);
  999.             break;
  1000.         case EFAULT:
  1001.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  1002.             break;
  1003.         /*
  1004.          * UNIX domain sockets are not supported in NSPR
  1005.          */
  1006.         case EACCES:
  1007.             PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
  1008.             break;
  1009.         case EINTR:
  1010.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  1011.             break;
  1012.         case EINVAL:
  1013.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  1014.             break;
  1015.         case EIO:
  1016. #if defined(UNIXWARE) || defined(SNI) || defined(NEC)
  1017.             /*
  1018.              * On some platforms, if we connect to a port on
  1019.              * the local host (the loopback address) that no
  1020.              * process is listening on, we get EIO instead
  1021.              * of ECONNREFUSED.
  1022.              */
  1023.             PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
  1024. #else
  1025.             PR_SetError(PR_IO_ERROR, err);
  1026. #endif
  1027.             break;
  1028.         case ELOOP:
  1029.             PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
  1030.             break;
  1031.         case ENOENT:
  1032.             PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
  1033.             break;
  1034. #ifdef ENOSR
  1035.         case ENOSR:
  1036.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  1037.             break;
  1038. #endif
  1039.         case ENXIO:
  1040.             PR_SetError(PR_IO_ERROR, err);
  1041.             break;
  1042.         case EPROTOTYPE:
  1043.             PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
  1044.             break;
  1045.         default:
  1046.             PR_SetError(PR_UNKNOWN_ERROR, err);
  1047.             break;
  1048.     }
  1049. }
  1050.  
  1051. void _MD_unix_map_bind_error(int err)
  1052. {
  1053.     switch (err) {
  1054.         case EBADF:
  1055.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  1056.             break;
  1057.         case ENOTSOCK:
  1058.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  1059.             break;
  1060.         case EFAULT:
  1061.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  1062.             break;
  1063.         case EADDRNOTAVAIL:
  1064.             PR_SetError(PR_ADDRESS_NOT_AVAILABLE_ERROR, err);
  1065.             break;
  1066.         case EADDRINUSE:
  1067.             PR_SetError(PR_ADDRESS_IN_USE_ERROR, err);
  1068.             break;
  1069.         case EACCES:
  1070.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  1071.             break;
  1072.         case EINVAL:
  1073.             PR_SetError(PR_SOCKET_ADDRESS_IS_BOUND_ERROR, err);
  1074.             break;
  1075. #ifdef ENOSR
  1076.         case ENOSR:
  1077.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  1078.             break;
  1079. #endif
  1080.         /*
  1081.          * UNIX domain sockets are not supported in NSPR
  1082.          */
  1083.         case EIO:
  1084.         case EISDIR:
  1085.         case ELOOP:
  1086.         case ENOENT:
  1087.         case ENOTDIR:
  1088.         case EROFS:
  1089.             PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
  1090.             break;
  1091.         default:
  1092.             PR_SetError(PR_UNKNOWN_ERROR, err);
  1093.             break;
  1094.     }
  1095. }
  1096.  
  1097. void _MD_unix_map_listen_error(int err)
  1098. {
  1099.     switch (err) {
  1100.         case EBADF:
  1101.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  1102.             break;
  1103.         case ENOTSOCK:
  1104.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  1105.             break;
  1106.         case EOPNOTSUPP:
  1107.             PR_SetError(PR_NOT_TCP_SOCKET_ERROR, err);
  1108.             break;
  1109.         default:
  1110.             PR_SetError(PR_UNKNOWN_ERROR, err);
  1111.             break;
  1112.     }
  1113. }
  1114.  
  1115. void _MD_unix_map_shutdown_error(int err)
  1116. {
  1117.     switch (err) {
  1118.         case EBADF:
  1119.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  1120.             break;
  1121.         case ENOTSOCK:
  1122.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  1123.             break;
  1124.         case ENOTCONN:
  1125.             PR_SetError(PR_NOT_CONNECTED_ERROR, err);
  1126.             break;
  1127.         case ENOMEM:
  1128.             PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
  1129.             break;
  1130. #ifdef ENOSR
  1131.         case ENOSR:
  1132.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  1133.             break;
  1134. #endif
  1135.         default:
  1136.             PR_SetError(PR_UNKNOWN_ERROR, err);
  1137.             break;
  1138.     }
  1139. }
  1140.  
  1141. void _MD_unix_map_socketpair_error(int err)
  1142. {
  1143.     switch (err) {
  1144.         case EMFILE:
  1145.             PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
  1146.             break;
  1147.         case EFAULT:
  1148.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  1149.             break;
  1150.         case ENOMEM:
  1151. #ifdef ENOSR
  1152.         case ENOSR:
  1153. #endif
  1154.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  1155.             break;
  1156.         case EAFNOSUPPORT:
  1157.         case EPROTONOSUPPORT:
  1158.         case EOPNOTSUPP:
  1159.         default:
  1160.             PR_SetError(PR_UNKNOWN_ERROR, err);
  1161.             break;
  1162.     }
  1163. }
  1164.  
  1165. void _MD_unix_map_getsockname_error(int err)
  1166. {
  1167.     switch (err) {
  1168.         case EBADF:
  1169.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  1170.             break;
  1171.         case ENOTSOCK:
  1172.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  1173.             break;
  1174.         case EFAULT:
  1175.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  1176.             break;
  1177. #if !defined(SCO_SV)
  1178.         case ENOBUFS:
  1179. #endif /* !defined(SCO_SV) */
  1180.         case ENOMEM:
  1181. #ifdef ENOSR
  1182.         case ENOSR:
  1183. #endif
  1184.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  1185.             break;
  1186.         default:
  1187.             PR_SetError(PR_UNKNOWN_ERROR, err);
  1188.             break;
  1189.     }
  1190. }
  1191.  
  1192. void _MD_unix_map_getpeername_error(int err)
  1193. {
  1194.  
  1195.     switch (err) {
  1196.         case EBADF:
  1197.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  1198.             break;
  1199.         case ENOTSOCK:
  1200.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  1201.             break;
  1202.         case ENOTCONN:
  1203.             PR_SetError(PR_NOT_CONNECTED_ERROR, err);
  1204.             break;
  1205.         case EFAULT:
  1206.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  1207.             break;
  1208. #if !defined(SCO_SV)
  1209.         case ENOBUFS:
  1210. #endif /* !defined(SCO_SV) */
  1211.         case ENOMEM:
  1212. #ifdef ENOSR
  1213.         case ENOSR:
  1214. #endif
  1215.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  1216.             break;
  1217.         default:
  1218.             PR_SetError(PR_UNKNOWN_ERROR, err);
  1219.             break;
  1220.     }
  1221. }
  1222.  
  1223. void _MD_unix_map_getsockopt_error(int err)
  1224. {
  1225.     switch (err) {
  1226.         case EBADF:
  1227.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  1228.             break;
  1229.         case ENOTSOCK:
  1230.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  1231.             break;
  1232.         case ENOPROTOOPT:
  1233.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  1234.             break;
  1235.         case EFAULT:
  1236.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  1237.             break;
  1238.         case EINVAL:
  1239.             PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
  1240.             break;
  1241.         case ENOMEM:
  1242. #ifdef ENOSR
  1243.         case ENOSR:
  1244. #endif
  1245.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  1246.             break;
  1247.         default:
  1248.             PR_SetError(PR_UNKNOWN_ERROR, err);
  1249.             break;
  1250.     }
  1251. }
  1252.  
  1253. void _MD_unix_map_setsockopt_error(int err)
  1254. {
  1255.     switch (err) {
  1256.         case EBADF:
  1257.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  1258.             break;
  1259.         case ENOTSOCK:
  1260.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  1261.             break;
  1262.         case ENOPROTOOPT:
  1263.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  1264.             break;
  1265.         case EFAULT:
  1266.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  1267.             break;
  1268.         case EINVAL:
  1269.             PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
  1270.             break;
  1271.         case ENOMEM:
  1272. #ifdef ENOSR
  1273.         case ENOSR:
  1274. #endif
  1275.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  1276.             break;
  1277.         default:
  1278.             PR_SetError(PR_UNKNOWN_ERROR, err);
  1279.             break;
  1280.     }
  1281. }
  1282.  
  1283. void _MD_unix_map_open_error(int err)
  1284. {
  1285.     switch (err) {
  1286.         case EACCES:
  1287.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  1288.             break;
  1289.         case EAGAIN:
  1290.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  1291.             break;
  1292.         case EBUSY:
  1293.             PR_SetError(PR_IO_ERROR, err);
  1294.             break;
  1295.         case EEXIST:
  1296.             PR_SetError(PR_FILE_EXISTS_ERROR, err);
  1297.             break;
  1298.         case EFAULT:
  1299.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  1300.             break;
  1301.         case EINTR:
  1302.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  1303.             break;
  1304.         case EINVAL:
  1305.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  1306.             break;
  1307.         case EIO:
  1308.             PR_SetError(PR_IO_ERROR, err);
  1309.             break;
  1310.         case EISDIR:
  1311.             PR_SetError(PR_IS_DIRECTORY_ERROR, err);
  1312.             break;
  1313.         case ELOOP:
  1314.             PR_SetError(PR_LOOP_ERROR, err);
  1315.             break;
  1316.         case EMFILE:
  1317.             PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
  1318.             break;
  1319.         case ENAMETOOLONG:
  1320.             PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
  1321.             break;
  1322.         case ENFILE:
  1323.             PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
  1324.             break;
  1325.         case ENODEV:
  1326.         case ENOENT:
  1327.         case ENXIO:
  1328.             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
  1329.             break;
  1330.         case ENOMEM:
  1331.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  1332.             break;
  1333.         case ENOSPC:
  1334.             PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
  1335.             break;
  1336. #ifdef ENOSR
  1337.         case ENOSR:
  1338. #endif
  1339.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  1340.             break;
  1341.         case ENOTDIR:
  1342.             PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
  1343.             break;
  1344.         case EPERM:
  1345.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  1346.             break;
  1347.         case ETIMEDOUT:
  1348. #if !defined(OSF1) && !defined(FREEBSD) && !defined(BSDI)
  1349.         case EMULTIHOP:
  1350.         case ENOLINK:
  1351. #endif
  1352.             PR_SetError(PR_REMOTE_FILE_ERROR, err);
  1353.             break;
  1354.         case EROFS:
  1355.             PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
  1356.             break;
  1357.         default:
  1358.             PR_SetError(PR_UNKNOWN_ERROR, err);
  1359.             break;
  1360.     }
  1361. }
  1362.  
  1363. void _MD_unix_map_mmap_error(int err)
  1364. {
  1365.  
  1366.     switch (err) {
  1367.         case EBADF:
  1368.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  1369.             break;
  1370.         case EAGAIN:
  1371.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  1372.             break;
  1373.         case EACCES:
  1374.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  1375.             break;
  1376.         case ENOMEM:
  1377.             PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
  1378.             break;
  1379.         default:
  1380.             PR_SetError(PR_UNKNOWN_ERROR, err);
  1381.             break;
  1382.     }
  1383. }
  1384.  
  1385. void _MD_unix_map_gethostname_error(int err)
  1386. {
  1387.     switch (err) {
  1388.         case EFAULT:
  1389.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  1390.             break;
  1391.         default:
  1392.             PR_SetError(PR_UNKNOWN_ERROR, err);
  1393.             break;
  1394.     }
  1395. }
  1396.  
  1397. void _MD_unix_map_select_error(int err)
  1398. {
  1399.     switch (err) {
  1400.         case EBADF:
  1401.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  1402.             break;
  1403.         case EINTR:
  1404.             PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
  1405.             break;
  1406.         case EINVAL:
  1407.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  1408.             break;
  1409.         default:
  1410.             PR_SetError(PR_UNKNOWN_ERROR, err);
  1411.             break;
  1412.     }
  1413. }
  1414.  
  1415. void _MD_unix_map_flock_error(int err)
  1416. {
  1417.     switch (err) {
  1418.         case EBADF:
  1419.         case EINVAL:
  1420.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  1421.             break;
  1422.         case EWOULDBLOCK:
  1423.             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
  1424.             break;
  1425.         default:
  1426.             PR_SetError(PR_UNKNOWN_ERROR, err);
  1427.             break;
  1428.     }
  1429. }
  1430.  
  1431. void _MD_unix_map_lockf_error(int err)
  1432. {
  1433.     switch (err) {
  1434.         case EBADF:
  1435.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  1436.             break;
  1437.         case EACCES:
  1438.             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
  1439.             break;
  1440.         case EDEADLK:
  1441.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  1442.             break;
  1443.         default:
  1444.             PR_SetError(PR_UNKNOWN_ERROR, err);
  1445.             break;
  1446.     }
  1447. }
  1448.  
  1449. #ifdef HPUX11
  1450. void _MD_hpux_map_sendfile_error(int oserror)
  1451. {
  1452.     PRErrorCode prerror;
  1453.  
  1454.     switch (oserror) {
  1455.         case ENOTSOCK:
  1456.             prerror = PR_NOT_SOCKET_ERROR;
  1457.             break;
  1458.         case EFAULT:
  1459.             prerror = PR_ACCESS_FAULT_ERROR;
  1460.             break;
  1461.         case ENOBUFS:
  1462.             prerror = PR_INSUFFICIENT_RESOURCES_ERROR;
  1463.             break;
  1464.         case EINVAL:
  1465.             prerror = PR_INVALID_ARGUMENT_ERROR;
  1466.             break;
  1467.         case ENOTCONN:
  1468.             prerror = PR_NOT_CONNECTED_ERROR;
  1469.             break;
  1470.         case EPIPE:
  1471.             prerror = PR_CONNECT_RESET_ERROR;
  1472.             break;
  1473.         case ENOMEM:
  1474.             prerror = PR_OUT_OF_MEMORY_ERROR;
  1475.             break;
  1476.         case EOPNOTSUPP:
  1477.             prerror = PR_NOT_TCP_SOCKET_ERROR;
  1478.             break;
  1479.         default:
  1480.             prerror = PR_UNKNOWN_ERROR;
  1481.     }
  1482.     PR_SetError(prerror, oserror); 
  1483. }
  1484. #endif /* HPUX11 */
  1485.