home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / nsprpub / pr / src / md / windows / win32_errors.c < prev   
Encoding:
C/C++ Source or Header  |  1998-04-08  |  26.7 KB  |  1,105 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 <errno.h>
  21.  
  22. void _MD_win32_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.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  34.             break;
  35.         case ERROR_INVALID_NAME:
  36.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  37.             break;
  38.         case ERROR_DISK_CORRUPT:
  39.         case ERROR_DISK_OPERATION_FAILED:
  40.         case ERROR_FILE_CORRUPT:
  41.         case ERROR_NOT_READY:
  42.         case ERROR_OPEN_FAILED:
  43.         case ERROR_OPEN_FILES:
  44.         case ERROR_PATH_BUSY:
  45.             PR_SetError(PR_IO_ERROR, err);
  46.             break;
  47.         case ERROR_DRIVE_LOCKED:
  48.             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
  49.             break;
  50.         case ERROR_FILENAME_EXCED_RANGE:
  51.             PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
  52.             break;
  53.         case ERROR_NOT_ENOUGH_MEMORY:
  54.         case ERROR_OUTOFMEMORY:
  55.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  56.             break;
  57.         default:
  58.             PR_SetError(PR_UNKNOWN_ERROR, err);
  59.             break;
  60.     }
  61. }
  62.  
  63. void _MD_win32_map_closedir_error(PRInt32 err)
  64. {
  65.     switch (err) {
  66.         case ERROR_FILE_INVALID:
  67.         case ERROR_INVALID_HANDLE:
  68.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  69.             break;
  70.         default:
  71.             PR_SetError(PR_UNKNOWN_ERROR, err);
  72.             break;
  73.     }
  74. }
  75.  
  76. void _MD_unix_readdir_error(PRInt32 err)
  77. {
  78.  
  79.     switch (err) {
  80.         case ERROR_NO_MORE_FILES:
  81.             PR_SetError(PR_NO_MORE_FILES_ERROR, err);
  82.             break;
  83.         case ERROR_FILE_INVALID:
  84.         case ERROR_INVALID_HANDLE:
  85.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  86.             break;
  87.         case ERROR_INVALID_ADDRESS:
  88.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  89.             break;
  90.         case ERROR_DISK_CORRUPT:
  91.         case ERROR_DISK_OPERATION_FAILED:
  92.         case ERROR_FILE_CORRUPT:
  93.         case ERROR_NOT_READY:
  94.         case ERROR_PATH_BUSY:
  95.             PR_SetError(PR_IO_ERROR, err);
  96.             break;
  97.         case ERROR_NOT_ENOUGH_MEMORY:
  98.         case ERROR_OUTOFMEMORY:
  99.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  100.             break;
  101.         default:
  102.             PR_SetError(PR_UNKNOWN_ERROR, err);
  103.             break;
  104.     }
  105. }
  106.  
  107. void _MD_win32_map_delete_error(PRInt32 err)
  108. {
  109.     switch (err) {
  110.         case ERROR_FILE_NOT_FOUND:
  111.         case ERROR_PATH_NOT_FOUND:
  112.             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
  113.             break;
  114.         case ERROR_ACCESS_DENIED:
  115.         case ERROR_WRITE_PROTECT:
  116.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  117.             break;
  118.         case ERROR_INVALID_ADDRESS:
  119.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  120.             break;
  121.         case ERROR_DRIVE_LOCKED:
  122.         case ERROR_LOCKED:
  123.         case ERROR_SHARING_VIOLATION:
  124.             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
  125.             break;
  126.         default:
  127.             PR_SetError(PR_UNKNOWN_ERROR, err);
  128.             break;
  129.     }
  130. }
  131.  
  132. /* The error code for stat() is in errno. */
  133. void _MD_win32_map_stat_error(PRInt32 err)
  134. {
  135.     switch (err) {
  136.         case ENOENT:
  137.             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
  138.             break;
  139.         case EACCES:
  140.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  141.             break;
  142.         default:
  143.             PR_SetError(PR_UNKNOWN_ERROR, err);
  144.     }
  145. }
  146.  
  147. void _MD_win32_map_fstat_error(PRInt32 err)
  148. {
  149.     switch (err) {
  150.         case ERROR_ACCESS_DENIED:
  151.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  152.             break;
  153.         case ERROR_FILE_INVALID:
  154.         case ERROR_INVALID_HANDLE:
  155.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  156.             break;
  157.         case ERROR_INVALID_ADDRESS:
  158.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  159.             break;
  160.         case ERROR_DISK_CORRUPT:
  161.         case ERROR_DISK_OPERATION_FAILED:
  162.         case ERROR_FILE_CORRUPT:
  163.         case ERROR_NOT_READY:
  164.         case ERROR_PATH_BUSY:
  165.             PR_SetError(PR_IO_ERROR, err);
  166.             break;
  167.         case ERROR_NOT_ENOUGH_MEMORY:
  168.         case ERROR_OUTOFMEMORY:
  169.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  170.             break;
  171.         case ERROR_DRIVE_LOCKED:
  172.         case ERROR_LOCKED:
  173.             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
  174.             break;
  175.         default:
  176.             PR_SetError(PR_UNKNOWN_ERROR, err);
  177.             break;
  178.     }
  179. }
  180.  
  181. void _MD_win32_map_rename_error(PRInt32 err)
  182. {
  183.     switch (err) {
  184.         case ERROR_FILE_NOT_FOUND:
  185.         case ERROR_PATH_NOT_FOUND:
  186.             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
  187.             break;
  188.         case ERROR_ACCESS_DENIED:
  189.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  190.             break;
  191.         case ERROR_INVALID_ADDRESS:
  192.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  193.             break;
  194.         case ERROR_INVALID_NAME:
  195.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  196.             break;
  197.         case ERROR_DISK_CORRUPT:
  198.         case ERROR_DISK_OPERATION_FAILED:
  199.         case ERROR_FILE_CORRUPT:
  200.         case ERROR_NOT_READY:
  201.         case ERROR_PATH_BUSY:
  202.             PR_SetError(PR_IO_ERROR, err);
  203.             break;
  204.         case ERROR_DRIVE_LOCKED:
  205.             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
  206.             break;
  207.         case ERROR_FILENAME_EXCED_RANGE:
  208.             PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
  209.             break;
  210.         case ERROR_NOT_ENOUGH_MEMORY:
  211.         case ERROR_OUTOFMEMORY:
  212.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  213.             break;
  214.         case ERROR_ALREADY_EXISTS:
  215.         case ERROR_FILE_EXISTS:
  216.             PR_SetError(PR_FILE_EXISTS_ERROR, err);
  217.             break;
  218.         default:
  219.             PR_SetError(PR_UNKNOWN_ERROR, err);
  220.             break;
  221.     }
  222. }
  223.  
  224. /* The error code for access() is in errno. */
  225. void _MD_win32_map_access_error(PRInt32 err)
  226. {
  227.     switch (err) {
  228.         case ENOENT:
  229.             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
  230.             break;
  231.         case EACCES:
  232.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  233.             break;
  234.         default:
  235.             PR_SetError(PR_UNKNOWN_ERROR, err);
  236.     }
  237. }
  238.  
  239. void _MD_win32_map_mkdir_error(PRInt32 err)
  240. {
  241.     switch (err) {
  242.         case ERROR_ALREADY_EXISTS:
  243.         case ERROR_FILE_EXISTS:
  244.             PR_SetError(PR_FILE_EXISTS_ERROR, err);
  245.             break;
  246.         case ERROR_FILE_NOT_FOUND:
  247.             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
  248.             break;
  249.         case ERROR_ACCESS_DENIED:
  250.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  251.             break;
  252.         case ERROR_INVALID_ADDRESS:
  253.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  254.             break;
  255.         case ERROR_INVALID_NAME:
  256.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  257.             break;
  258.         case ERROR_DISK_CORRUPT:
  259.         case ERROR_DISK_OPERATION_FAILED:
  260.         case ERROR_FILE_CORRUPT:
  261.         case ERROR_NOT_READY:
  262.         case ERROR_PATH_BUSY:
  263.             PR_SetError(PR_IO_ERROR, err);
  264.             break;
  265.         case ERROR_DRIVE_LOCKED:
  266.             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
  267.             break;
  268.         case ERROR_FILENAME_EXCED_RANGE:
  269.             PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
  270.             break;
  271.         case ERROR_TOO_MANY_OPEN_FILES:
  272.             PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
  273.             break;
  274.         case ERROR_PATH_NOT_FOUND:
  275.             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
  276.             break;
  277.         case ERROR_NOT_ENOUGH_MEMORY:
  278.         case ERROR_OUTOFMEMORY:
  279.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  280.             break;
  281.         case ERROR_DISK_FULL:
  282.         case ERROR_HANDLE_DISK_FULL:
  283.             PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
  284.             break;
  285.         case ERROR_WRITE_PROTECT:
  286.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  287.             break;
  288.         default:
  289.             PR_SetError(PR_UNKNOWN_ERROR, err);
  290.             break;
  291.     }
  292. }
  293.  
  294. void _MD_win32_map_rmdir_error(PRInt32 err)
  295. {
  296.  
  297.     switch (err) {
  298.         case ERROR_FILE_NOT_FOUND:
  299.             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
  300.             break;
  301.         case ERROR_ACCESS_DENIED:
  302.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  303.             break;
  304.         case ERROR_INVALID_ADDRESS:
  305.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  306.             break;
  307.         case ERROR_INVALID_NAME:
  308.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  309.             break;
  310.         case ERROR_DISK_CORRUPT:
  311.         case ERROR_DISK_OPERATION_FAILED:
  312.         case ERROR_FILE_CORRUPT:
  313.         case ERROR_NOT_READY:
  314.         case ERROR_PATH_BUSY:
  315.             PR_SetError(PR_IO_ERROR, err);
  316.             break;
  317.         case ERROR_DRIVE_LOCKED:
  318.             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
  319.             break;
  320.         case ERROR_FILENAME_EXCED_RANGE:
  321.             PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
  322.             break;
  323.         case ERROR_TOO_MANY_OPEN_FILES:
  324.             PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
  325.             break;
  326.         case ERROR_PATH_NOT_FOUND:
  327.             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
  328.             break;
  329.         case ERROR_NOT_ENOUGH_MEMORY:
  330.         case ERROR_OUTOFMEMORY:
  331.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  332.             break;
  333.         case ERROR_WRITE_PROTECT:
  334.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  335.             break;
  336.         default:
  337.             PR_SetError(PR_UNKNOWN_ERROR, err);
  338.             break;
  339.     }
  340. }
  341.  
  342. void _MD_win32_map_read_error(PRInt32 err)
  343. {
  344.     switch (err) {
  345.         case ERROR_ACCESS_DENIED:
  346.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  347.             break;
  348.         case ERROR_FILE_INVALID:
  349.         case ERROR_INVALID_HANDLE:
  350.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  351.             break;
  352.         case ERROR_INVALID_ADDRESS:
  353.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  354.             break;
  355.         case ERROR_DISK_CORRUPT:
  356.         case ERROR_DISK_OPERATION_FAILED:
  357.         case ERROR_FILE_CORRUPT:
  358.         case ERROR_NOT_READY:
  359.         case ERROR_PATH_BUSY:
  360.             PR_SetError(PR_IO_ERROR, err);
  361.             break;
  362.         case ERROR_NOT_ENOUGH_MEMORY:
  363.         case ERROR_OUTOFMEMORY:
  364.         case ERROR_INVALID_USER_BUFFER:
  365.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  366.             break;
  367.         case ERROR_NOT_ENOUGH_QUOTA:
  368.             PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
  369.             break;
  370.         case ERROR_DRIVE_LOCKED:
  371.         case ERROR_LOCKED:
  372.         case ERROR_SHARING_VIOLATION:
  373.             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
  374.             break;
  375.         case ERROR_NETNAME_DELETED:
  376.             PR_SetError(PR_CONNECT_RESET_ERROR, err);
  377.             break;
  378.         case WSAEBADF:
  379.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  380.             break;
  381.         case WSAENOTSOCK:
  382.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  383.             break;
  384.         case WSAEFAULT:
  385.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  386.             break;
  387.         default:
  388.             PR_SetError(PR_UNKNOWN_ERROR, err);
  389.             break;
  390.     }
  391. }
  392.  
  393. void _MD_win32_map_transmitfile_error(PRInt32 err)
  394. {
  395.     switch (err) {
  396.         case ERROR_ACCESS_DENIED:
  397.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  398.             break;
  399.         case ERROR_FILE_INVALID:
  400.         case ERROR_INVALID_HANDLE:
  401.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  402.             break;
  403.         case ERROR_INVALID_ADDRESS:
  404.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  405.             break;
  406.         case ERROR_DISK_CORRUPT:
  407.         case ERROR_DISK_OPERATION_FAILED:
  408.         case ERROR_FILE_CORRUPT:
  409.         case ERROR_NOT_READY:
  410.         case ERROR_PATH_BUSY:
  411.             PR_SetError(PR_IO_ERROR, err);
  412.             break;
  413.         case ERROR_NOT_ENOUGH_MEMORY:
  414.         case ERROR_OUTOFMEMORY:
  415.         case ERROR_INVALID_USER_BUFFER:
  416.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  417.             break;
  418.         case ERROR_NOT_ENOUGH_QUOTA:
  419.             PR_SetError(PR_OUT_OF_MEMORY_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 WSAEBADF:
  436.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  437.             break;
  438.         case WSAENOTSOCK:
  439.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  440.             break;
  441.         case WSAEFAULT:
  442.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  443.             break;
  444.         default:
  445.             PR_SetError(PR_UNKNOWN_ERROR, err);
  446.             break;
  447.     }
  448. }
  449.  
  450. void _MD_win32_map_write_error(PRInt32 err)
  451. {
  452.     switch (err) {
  453.         case ERROR_ACCESS_DENIED:
  454.         case ERROR_WRITE_PROTECT:
  455.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  456.             break;
  457.         case ERROR_FILE_INVALID:
  458.         case ERROR_INVALID_HANDLE:
  459.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  460.             break;
  461.         case ERROR_INVALID_ADDRESS:
  462.         case ERROR_STACK_OVERFLOW:
  463.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  464.             break;
  465.         case ERROR_DISK_CORRUPT:
  466.         case ERROR_DISK_OPERATION_FAILED:
  467.         case ERROR_FILE_CORRUPT:
  468.         case ERROR_NOT_READY:
  469.         case ERROR_PATH_BUSY:
  470.             PR_SetError(PR_IO_ERROR, err);
  471.             break;
  472.         case ERROR_DRIVE_LOCKED:
  473.         case ERROR_LOCKED:
  474.         case ERROR_SHARING_VIOLATION:
  475.             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
  476.             break;
  477.         case ERROR_NOT_ENOUGH_MEMORY:
  478.         case ERROR_OUTOFMEMORY:
  479.         case ERROR_INVALID_USER_BUFFER:
  480.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  481.             break;
  482.         case ERROR_NOT_ENOUGH_QUOTA:
  483.             PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
  484.             break;
  485.         case ERROR_DISK_FULL:
  486.         case ERROR_HANDLE_DISK_FULL:
  487.             PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
  488.             break;
  489.         case ERROR_NETNAME_DELETED:
  490.             PR_SetError(PR_CONNECT_RESET_ERROR, err);
  491.             break;
  492.         case WSAEBADF:
  493.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  494.             break;
  495.         case WSAENOTSOCK:
  496.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  497.             break;
  498.         case WSAEMSGSIZE:
  499.         case WSAEINVAL:
  500.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  501.             break;
  502.         case WSAENOBUFS:
  503.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  504.             break;
  505.         case WSAECONNREFUSED:
  506.             PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
  507.             break;
  508.         case WSAEISCONN:
  509.             PR_SetError(PR_IS_CONNECTED_ERROR, err);
  510.             break;
  511.         case WSAEFAULT:
  512.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  513.             break;
  514.         default:
  515.             PR_SetError(PR_UNKNOWN_ERROR, err);
  516.             break;
  517.     }
  518. }
  519.  
  520. void _MD_win32_map_lseek_error(PRInt32 err)
  521. {
  522.     switch (err) {
  523.         case ERROR_FILE_INVALID:
  524.         case ERROR_INVALID_HANDLE:
  525.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  526.             break;
  527.         case ERROR_SEEK_ON_DEVICE:
  528.             PR_SetError(PR_IO_ERROR, err);
  529.             break;
  530.         default:
  531.             PR_SetError(PR_UNKNOWN_ERROR, err);
  532.             break;
  533.     }
  534. }
  535.  
  536. void _MD_win32_map_fsync_error(PRInt32 err)
  537. {
  538.     switch (err) {
  539.         case ERROR_ACCESS_DENIED:
  540.         case ERROR_WRITE_PROTECT:
  541.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  542.             break;
  543.         case ERROR_FILE_INVALID:
  544.         case ERROR_INVALID_HANDLE:
  545.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  546.             break;
  547.         case ERROR_NOT_ENOUGH_MEMORY:
  548.         case ERROR_OUTOFMEMORY:
  549.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  550.             break;
  551.         case ERROR_DISK_FULL:
  552.         case ERROR_HANDLE_DISK_FULL:
  553.             PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
  554.             break;
  555.         default:
  556.             PR_SetError(PR_UNKNOWN_ERROR, err);
  557.             break;
  558.     }
  559. }
  560.  
  561. void _MD_win32_map_close_error(PRInt32 err)
  562. {
  563.     switch (err) {
  564.         case ERROR_FILE_INVALID:
  565.         case ERROR_INVALID_HANDLE:
  566.         case WSAEBADF:
  567.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  568.             break;
  569.         case ERROR_DISK_OPERATION_FAILED:
  570.         case ERROR_NOT_READY:
  571.         case ERROR_PATH_BUSY:
  572.             PR_SetError(PR_IO_ERROR, err);
  573.             break;
  574.         default:
  575.             PR_SetError(PR_UNKNOWN_ERROR, err);
  576.             break;
  577.     }
  578. }
  579.  
  580. void _MD_win32_map_socket_error(PRInt32 err)
  581. {
  582.     switch (err) {
  583.         case WSAEPROTONOSUPPORT:
  584.             PR_SetError(PR_PROTOCOL_NOT_SUPPORTED_ERROR, err);
  585.             break;
  586.         case WSAEACCES:
  587.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  588.             break;
  589.         case ERROR_NOT_ENOUGH_MEMORY:
  590.         case ERROR_OUTOFMEMORY:
  591.         case WSAENOBUFS:
  592.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  593.             break;
  594.         default:
  595.             PR_SetError(PR_UNKNOWN_ERROR, err);
  596.             break;
  597.     }
  598. }
  599.  
  600. void _MD_win32_map_recv_error(PRInt32 err)
  601. {
  602.     switch (err) {
  603.         case WSAEWOULDBLOCK:
  604.             PR_SetError(PR_WOULD_BLOCK_ERROR, err);
  605.             break;
  606.         case WSAEBADF:
  607.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  608.             break;
  609.         case WSAENOTSOCK:
  610.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  611.             break;
  612.         case WSAEFAULT:
  613.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  614.             break;
  615.         case ERROR_NETNAME_DELETED:
  616.             PR_SetError(PR_CONNECT_RESET_ERROR, err);
  617.             break;
  618.         default:
  619.             PR_SetError(PR_UNKNOWN_ERROR, err);
  620.             break;
  621.     }
  622. }
  623.  
  624. void _MD_win32_map_recvfrom_error(PRInt32 err)
  625. {
  626.     switch (err) {
  627.         case WSAEWOULDBLOCK:
  628.             PR_SetError(PR_WOULD_BLOCK_ERROR, err);
  629.             break;
  630.         case WSAEBADF:
  631.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  632.             break;
  633.         case WSAENOTSOCK:
  634.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  635.             break;
  636.         case WSAEFAULT:
  637.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  638.             break;
  639.         case ERROR_NETNAME_DELETED:
  640.             PR_SetError(PR_CONNECT_RESET_ERROR, err);
  641.             break;
  642.         default:
  643.             PR_SetError(PR_UNKNOWN_ERROR, err);
  644.             break;
  645.     }
  646. }
  647.  
  648. void _MD_win32_map_send_error(PRInt32 err)
  649. {
  650.     switch (err) {
  651.         case WSAEWOULDBLOCK:
  652.             PR_SetError(PR_WOULD_BLOCK_ERROR, err);
  653.             break;
  654.         case WSAEBADF:
  655.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  656.             break;
  657.         case WSAENOTSOCK:
  658.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  659.             break;
  660.         case WSAEMSGSIZE:
  661.         case WSAEINVAL:
  662.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  663.             break;
  664.         case WSAENOBUFS:
  665.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  666.             break;
  667.         case WSAECONNREFUSED:
  668.             PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
  669.             break;
  670.         case WSAEISCONN:
  671.             PR_SetError(PR_IS_CONNECTED_ERROR, err);
  672.             break;
  673.         case WSAEFAULT:
  674.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  675.             break;
  676.         case ERROR_NETNAME_DELETED:
  677.             PR_SetError(PR_CONNECT_RESET_ERROR, err);
  678.             break;
  679.         default:
  680.             PR_SetError(PR_UNKNOWN_ERROR, err);
  681.             break;
  682.     }
  683. }
  684.  
  685. void _MD_win32_map_sendto_error(PRInt32 err)
  686. {
  687.     switch (err) {
  688.         case WSAEWOULDBLOCK:
  689.             PR_SetError(PR_WOULD_BLOCK_ERROR, err);
  690.             break;
  691.         case WSAEBADF:
  692.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  693.             break;
  694.         case WSAENOTSOCK:
  695.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  696.             break;
  697.         case WSAEMSGSIZE:
  698.         case WSAEINVAL:
  699.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  700.             break;
  701.         case WSAENOBUFS:
  702.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  703.             break;
  704.         case WSAECONNREFUSED:
  705.             PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
  706.             break;
  707.         case WSAEISCONN:
  708.             PR_SetError(PR_IS_CONNECTED_ERROR, err);
  709.             break;
  710.         case WSAEFAULT:
  711.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  712.             break;
  713.         case ERROR_NETNAME_DELETED:
  714.             PR_SetError(PR_CONNECT_RESET_ERROR, err);
  715.             break;
  716.         default:
  717.             PR_SetError(PR_UNKNOWN_ERROR, err);
  718.             break;
  719.     }
  720. }
  721.  
  722. void _MD_win32_map_accept_error(PRInt32 err)
  723. {
  724.     switch (err) {
  725.         case WSAEWOULDBLOCK:
  726.             PR_SetError(PR_WOULD_BLOCK_ERROR, err);
  727.             break;
  728.         case WSAEBADF:
  729.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  730.             break;
  731.         case WSAENOTSOCK:
  732.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  733.             break;
  734.         case WSAEOPNOTSUPP:
  735.             PR_SetError(PR_NOT_TCP_SOCKET_ERROR, err);
  736.             break;
  737.         case WSAEFAULT:
  738.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  739.             break;
  740.         case WSAEMFILE:
  741.             PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
  742.             break;
  743.         case WSAENOBUFS:
  744.             PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
  745.             break;
  746.         default:
  747.             PR_SetError(PR_UNKNOWN_ERROR, err);
  748.             break;
  749.     }
  750. }
  751.  
  752. void _MD_win32_map_acceptex_error(PRInt32 err)
  753. {
  754.     switch (err) {
  755.         case ERROR_FILE_INVALID:
  756.         case ERROR_INVALID_HANDLE:
  757.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  758.             break;
  759.         case ERROR_INVALID_ADDRESS:
  760.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  761.             break;
  762.         case ERROR_NOT_ENOUGH_MEMORY:
  763.         case ERROR_OUTOFMEMORY:
  764.         case ERROR_INVALID_USER_BUFFER:
  765.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  766.             break;
  767.         default:
  768.             PR_SetError(PR_UNKNOWN_ERROR, err);
  769.             break;
  770.     }
  771. }
  772.  
  773. void _MD_win32_map_connect_error(PRInt32 err)
  774. {
  775.     switch (err) {
  776.         case WSAEWOULDBLOCK:
  777.             PR_SetError(PR_IN_PROGRESS_ERROR, err);
  778.             break;
  779.         case WSAEALREADY:
  780.         case WSAEINVAL:
  781.             PR_SetError(PR_ALREADY_INITIATED_ERROR, err);
  782.             break;
  783.         case WSAEBADF:
  784.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  785.             break;
  786.         case WSAEADDRNOTAVAIL:
  787.             PR_SetError(PR_ADDRESS_NOT_AVAILABLE_ERROR, err);
  788.             break;
  789.         case WSAENOTSOCK:
  790.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  791.             break;
  792.         case WSAEAFNOSUPPORT:
  793.             PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
  794.             break;
  795.         case WSAEISCONN:
  796.             PR_SetError(PR_IS_CONNECTED_ERROR, err);
  797.             break;
  798.         case WSAETIMEDOUT:
  799.             PR_SetError(PR_IO_TIMEOUT_ERROR, err);
  800.             break;
  801.         case WSAECONNREFUSED:
  802.             PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
  803.             break;
  804.         case WSAENETUNREACH:
  805.             PR_SetError(PR_NETWORK_UNREACHABLE_ERROR, err);
  806.             break;
  807.         case WSAEADDRINUSE:
  808.             PR_SetError(PR_ADDRESS_IN_USE_ERROR, err);
  809.             break;
  810.         case WSAEFAULT:
  811.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  812.             break;
  813.         default:
  814.             PR_SetError(PR_UNKNOWN_ERROR, err);
  815.             break;
  816.     }
  817. }
  818.  
  819. void _MD_win32_map_bind_error(PRInt32 err)
  820. {
  821.     switch (err) {
  822.         case WSAEBADF:
  823.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  824.             break;
  825.         case WSAENOTSOCK:
  826.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  827.             break;
  828.         case WSAEFAULT:
  829.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  830.             break;
  831.         case WSAEADDRNOTAVAIL:
  832.             PR_SetError(PR_ADDRESS_NOT_AVAILABLE_ERROR, err);
  833.             break;
  834.         case WSAEADDRINUSE:
  835.             PR_SetError(PR_ADDRESS_IN_USE_ERROR, err);
  836.             break;
  837.         case WSAEACCES:
  838.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  839.             break;
  840.         case WSAEINVAL:
  841.             PR_SetError(PR_SOCKET_ADDRESS_IS_BOUND_ERROR, err);
  842.             break;
  843.         default:
  844.             PR_SetError(PR_UNKNOWN_ERROR, err);
  845.             break;
  846.     }
  847. }
  848.  
  849. void _MD_win32_map_listen_error(PRInt32 err)
  850. {
  851.     switch (err) {
  852.         case WSAEBADF:
  853.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  854.             break;
  855.         case WSAENOTSOCK:
  856.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  857.             break;
  858.         case WSAEOPNOTSUPP:
  859.             PR_SetError(PR_NOT_TCP_SOCKET_ERROR, err);
  860.             break;
  861.         default:
  862.             PR_SetError(PR_UNKNOWN_ERROR, err);
  863.             break;
  864.     }
  865. }
  866.  
  867. void _MD_win32_map_shutdown_error(PRInt32 err)
  868. {
  869.     switch (err) {
  870.         case WSAEBADF:
  871.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  872.             break;
  873.         case WSAENOTSOCK:
  874.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  875.             break;
  876.         case WSAENOTCONN:
  877.             PR_SetError(PR_NOT_CONNECTED_ERROR, err);
  878.             break;
  879.         default:
  880.             PR_SetError(PR_UNKNOWN_ERROR, err);
  881.             break;
  882.     }
  883. }
  884.  
  885. void _MD_win32_map_getsockname_error(PRInt32 err)
  886. {
  887.     switch (err) {
  888.         case WSAEBADF:
  889.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  890.             break;
  891.         case WSAENOTSOCK:
  892.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  893.             break;
  894.         case WSAEFAULT:
  895.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  896.             break;
  897.         case WSAENOBUFS:
  898.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  899.             break;
  900.         default:
  901.             PR_SetError(PR_UNKNOWN_ERROR, err);
  902.             break;
  903.     }
  904. }
  905.  
  906. void _MD_win32_map_getpeername_error(PRInt32 err)
  907. {
  908.  
  909.     switch (err) {
  910.         case WSAEBADF:
  911.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  912.             break;
  913.         case WSAENOTSOCK:
  914.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  915.             break;
  916.         case WSAENOTCONN:
  917.             PR_SetError(PR_NOT_CONNECTED_ERROR, err);
  918.             break;
  919.         case WSAEFAULT:
  920.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  921.             break;
  922.         case WSAENOBUFS:
  923.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  924.             break;
  925.         default:
  926.             PR_SetError(PR_UNKNOWN_ERROR, err);
  927.             break;
  928.     }
  929. }
  930.  
  931. void _MD_win32_map_getsockopt_error(PRInt32 err)
  932. {
  933.     switch (err) {
  934.         case WSAEBADF:
  935.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  936.             break;
  937.         case WSAENOTSOCK:
  938.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  939.             break;
  940.         case WSAENOPROTOOPT:
  941.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  942.             break;
  943.         case WSAEFAULT:
  944.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  945.             break;
  946.         case WSAEINVAL:
  947.             PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
  948.             break;
  949.         default:
  950.             PR_SetError(PR_UNKNOWN_ERROR, err);
  951.             break;
  952.     }
  953. }
  954.  
  955. void _MD_win32_map_setsockopt_error(PRInt32 err)
  956. {
  957.     switch (err) {
  958.         case WSAEBADF:
  959.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  960.             break;
  961.         case WSAENOTSOCK:
  962.             PR_SetError(PR_NOT_SOCKET_ERROR, err);
  963.             break;
  964.         case WSAENOPROTOOPT:
  965.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  966.             break;
  967.         case WSAEFAULT:
  968.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  969.             break;
  970.         case WSAEINVAL:
  971.             PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
  972.             break;
  973.         default:
  974.             PR_SetError(PR_UNKNOWN_ERROR, err);
  975.             break;
  976.     }
  977. }
  978.  
  979. void _MD_win32_map_open_error(PRInt32 err)
  980. {
  981.     switch (err) {
  982.         case ERROR_ALREADY_EXISTS:
  983.         case ERROR_FILE_EXISTS:
  984.             PR_SetError(PR_FILE_EXISTS_ERROR, err);
  985.             break;
  986.         case ERROR_FILE_NOT_FOUND:
  987.             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
  988.             break;
  989.         case ERROR_ACCESS_DENIED:
  990.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  991.             break;
  992.         case ERROR_INVALID_ADDRESS:
  993.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  994.             break;
  995.         case ERROR_INVALID_NAME:
  996.             PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
  997.             break;
  998.         case ERROR_DISK_CORRUPT:
  999.         case ERROR_DISK_OPERATION_FAILED:
  1000.         case ERROR_FILE_CORRUPT:
  1001.         case ERROR_NOT_READY:
  1002.         case ERROR_OPEN_FAILED:
  1003.         case ERROR_OPEN_FILES:
  1004.         case ERROR_PATH_BUSY:
  1005.             PR_SetError(PR_IO_ERROR, err);
  1006.             break;
  1007.         case ERROR_DRIVE_LOCKED:
  1008.             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
  1009.             break;
  1010.         case ERROR_FILENAME_EXCED_RANGE:
  1011.             PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
  1012.             break;
  1013.         case ERROR_TOO_MANY_OPEN_FILES:
  1014.             PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
  1015.             break;
  1016.         case ERROR_PATH_NOT_FOUND:
  1017.             PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
  1018.             break;
  1019.         case ERROR_NOT_ENOUGH_MEMORY:
  1020.         case ERROR_OUTOFMEMORY:
  1021.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  1022.             break;
  1023.         case ERROR_DISK_FULL:
  1024.         case ERROR_HANDLE_DISK_FULL:
  1025.             PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
  1026.             break;
  1027.         case ERROR_WRITE_PROTECT:
  1028.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  1029.             break;
  1030.         default:
  1031.             PR_SetError(PR_UNKNOWN_ERROR, err);
  1032.             break;
  1033.     }
  1034. }
  1035.  
  1036. void _MD_win32_map_gethostname_error(PRInt32 err)
  1037. {
  1038.     switch (err) {
  1039.         case WSAEFAULT:
  1040.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  1041.             break;
  1042.         case WSAENETDOWN:
  1043.         case WSAEINPROGRESS:
  1044.         default:
  1045.             PR_SetError(PR_UNKNOWN_ERROR, err);
  1046.             break;
  1047.     }
  1048. }
  1049.  
  1050. void _MD_win32_map_select_error(PRInt32 err)
  1051. {
  1052.     PRErrorCode prerror;
  1053.  
  1054.     switch (err) {
  1055.         /*
  1056.          * Win32 select() only works on sockets.  So in this
  1057.          * context, WSAENOTSOCK is equivalent to EBADF on Unix.
  1058.          */
  1059.         case WSAENOTSOCK:
  1060.             prerror = PR_BAD_DESCRIPTOR_ERROR;
  1061.             break;
  1062.         case WSAEINVAL:
  1063.             prerror = PR_INVALID_ARGUMENT_ERROR;
  1064.             break;
  1065.         case WSAEFAULT:
  1066.             prerror = PR_ACCESS_FAULT_ERROR;
  1067.             break;
  1068.         default:
  1069.             prerror = PR_UNKNOWN_ERROR;
  1070.     }
  1071.     PR_SetError(prerror, err);
  1072. }
  1073.  
  1074. void _MD_win32_map_lockf_error(PRInt32 err)
  1075. {
  1076.     switch (err) {
  1077.         case ERROR_ACCESS_DENIED:
  1078.             PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
  1079.             break;
  1080.         case ERROR_FILE_INVALID:
  1081.         case ERROR_INVALID_HANDLE:
  1082.             PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  1083.             break;
  1084.         case ERROR_INVALID_ADDRESS:
  1085.         case ERROR_STACK_OVERFLOW:
  1086.             PR_SetError(PR_ACCESS_FAULT_ERROR, err);
  1087.             break;
  1088.         case ERROR_DRIVE_LOCKED:
  1089.         case ERROR_LOCKED:
  1090.         case ERROR_SHARING_VIOLATION:
  1091.             PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
  1092.             break;
  1093.         case ERROR_NOT_ENOUGH_MEMORY:
  1094.         case ERROR_OUTOFMEMORY:
  1095.             PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
  1096.             break;
  1097.         case ERROR_NOT_ENOUGH_QUOTA:
  1098.             PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
  1099.             break;
  1100.         default:
  1101.             PR_SetError(PR_UNKNOWN_ERROR, err);
  1102.             break;
  1103.     }
  1104. }
  1105.