开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
win32err.c
资源名称：nss-3.1.1.tar.gz　[点击查看]
上传用户：lyxiangda
上传日期：2007-01-12
资源大小：3042k
文件大小：12k
源码类别：

CA认证

开发平台：

WINDOWS

win32err.c：源码内容
  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
  2. /*
  3.  * This file essentially replicates NSPR's source for the functions that
  4.  * map system-specific error codes to NSPR error codes.  We would use 
  5.  * NSPR's functions, instead of duplicating them, but they're private.
  6.  * As long as SSL's server session cache code must do platform native I/O
  7.  * to accomplish its job, and NSPR's error mapping functions remain private,
  8.  * this code will continue to need to be replicated.
  9.  * 
  10.  * The contents of this file are subject to the Mozilla Public
  11.  * License Version 1.1 (the "License"); you may not use this file
  12.  * except in compliance with the License. You may obtain a copy of
  13.  * the License at http://www.mozilla.org/MPL/
  14.  * 
  15.  * Software distributed under the License is distributed on an "AS
  16.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  17.  * implied. See the License for the specific language governing
  18.  * rights and limitations under the License.
  19.  * 
  20.  * The Original Code is the Netscape security libraries.
  21.  * 
  22.  * The Initial Developer of the Original Code is Netscape
  23.  * Communications Corporation.  Portions created by Netscape are 
  24.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  25.  * Rights Reserved.
  26.  * 
  27.  * Contributor(s):
  28.  * 
  29.  * Alternatively, the contents of this file may be used under the
  30.  * terms of the GNU General Public License Version 2 or later (the
  31.  * "GPL"), in which case the provisions of the GPL are applicable 
  32.  * instead of those above.  If you wish to allow use of your 
  33.  * version of this file only under the terms of the GPL and not to
  34.  * allow others to use your version of this file under the MPL,
  35.  * indicate your decision by deleting the provisions above and
  36.  * replace them with the notice and other provisions required by
  37.  * the GPL.  If you do not delete the provisions above, a recipient
  38.  * may use your version of this file under either the MPL or the
  39.  * GPL.
  40.  *
  41.  * $Id: win32err.c,v 1.1 2000/03/31 19:37:19 relyea%netscape.com Exp $
  42.  */
  44. #include "prerror.h"
  45. #include "prlog.h"
  46. #include <errno.h>
  47. #include <windows.h>
  49. /*
  50.  * On Win32, we map three kinds of error codes:
  51.  * - GetLastError(): for Win32 functions
  52.  * - WSAGetLastError(): for Winsock functions
  53.  * - errno: for standard C library functions
  54.  *
  55.  * We do not check for WSAEINPROGRESS and WSAEINTR because we do not
  56.  * use blocking Winsock 1.1 calls.
  57.  *
  58.  * Except for the 'socket' call, we do not check for WSAEINITIALISED.
  59.  * It is assumed that if Winsock is not initialized, that fact will
  60.  * be detected at the time we create new sockets.
  61.  */
  63. /* forward declaration. */
  64. void nss_MD_win32_map_default_error(PRInt32 err);
  66. void nss_MD_win32_map_opendir_error(PRInt32 err)
  67. {
  68.     nss_MD_win32_map_default_error(err);
  69. }
  71. void nss_MD_win32_map_closedir_error(PRInt32 err)
  72. {
  73.     nss_MD_win32_map_default_error(err);
  74. }
  76. void nss_MD_win32_map_readdir_error(PRInt32 err)
  77. {
  78.     nss_MD_win32_map_default_error(err);
  79. }
  81. void nss_MD_win32_map_delete_error(PRInt32 err)
  82. {
  83.     nss_MD_win32_map_default_error(err);
  84. }
  86. /* The error code for stat() is in errno. */
  87. void nss_MD_win32_map_stat_error(PRInt32 err)
  88. {
  89.     nss_MD_win32_map_default_error(err);
  90. }
  92. void nss_MD_win32_map_fstat_error(PRInt32 err)
  93. {
  94.     nss_MD_win32_map_default_error(err);
  95. }
  97. void nss_MD_win32_map_rename_error(PRInt32 err)
  98. {
  99.     nss_MD_win32_map_default_error(err);
  100. }
  102. /* The error code for access() is in errno. */
  103. void nss_MD_win32_map_access_error(PRInt32 err)
  104. {
  105.     nss_MD_win32_map_default_error(err);
  106. }
  108. void nss_MD_win32_map_mkdir_error(PRInt32 err)
  109. {
  110.     nss_MD_win32_map_default_error(err);
  111. }
  113. void nss_MD_win32_map_rmdir_error(PRInt32 err)
  114. {
  115.     nss_MD_win32_map_default_error(err);
  116. }
  118. void nss_MD_win32_map_read_error(PRInt32 err)
  119. {
  120.     nss_MD_win32_map_default_error(err);
  121. }
  123. void nss_MD_win32_map_transmitfile_error(PRInt32 err)
  124. {
  125.     nss_MD_win32_map_default_error(err);
  126. }
  128. void nss_MD_win32_map_write_error(PRInt32 err)
  129. {
  130.     nss_MD_win32_map_default_error(err);
  131. }
  133. void nss_MD_win32_map_lseek_error(PRInt32 err)
  134. {
  135.     nss_MD_win32_map_default_error(err);
  136. }
  138. void nss_MD_win32_map_fsync_error(PRInt32 err)
  139. {
  140.     nss_MD_win32_map_default_error(err);
  141. }
  143. /*
  144.  * For both CloseHandle() and closesocket().
  145.  */
  146. void nss_MD_win32_map_close_error(PRInt32 err)
  147. {
  148.     nss_MD_win32_map_default_error(err);
  149. }
  151. void nss_MD_win32_map_socket_error(PRInt32 err)
  152. {
  153.     PR_ASSERT(err != WSANOTINITIALISED);
  154.     nss_MD_win32_map_default_error(err);
  155. }
  157. void nss_MD_win32_map_recv_error(PRInt32 err)
  158. {
  159.     nss_MD_win32_map_default_error(err);
  160. }
  162. void nss_MD_win32_map_recvfrom_error(PRInt32 err)
  163. {
  164.     nss_MD_win32_map_default_error(err);
  165. }
  167. void nss_MD_win32_map_send_error(PRInt32 err)
  168. {
  169.     PRErrorCode prError;
  170.     switch (err) {
  171.     case WSAEMSGSIZE:  prError = PR_INVALID_ARGUMENT_ERROR; break;
  172.     default: nss_MD_win32_map_default_error(err); return;
  173.     }
  174.     PR_SetError(prError, err);
  175. }
  177. void nss_MD_win32_map_sendto_error(PRInt32 err)
  178. {
  179.     PRErrorCode prError;
  180.     switch (err) {
  181.     case WSAEMSGSIZE:  prError = PR_INVALID_ARGUMENT_ERROR; break;
  182.     default: nss_MD_win32_map_default_error(err); return;
  183.     }
  184.     PR_SetError(prError, err);
  185. }
  187. void nss_MD_win32_map_accept_error(PRInt32 err)
  188. {
  189.     PRErrorCode prError;
  190.     switch (err) {
  191.     case WSAEOPNOTSUPP: prError = PR_NOT_TCP_SOCKET_ERROR; break;
  192.     case WSAEINVAL:  prError = PR_INVALID_STATE_ERROR; break;
  193.     default: nss_MD_win32_map_default_error(err); return;
  194.     }
  195.     PR_SetError(prError, err);
  196. }
  198. void nss_MD_win32_map_acceptex_error(PRInt32 err)
  199. {
  200.     nss_MD_win32_map_default_error(err);
  201. }
  203. void nss_MD_win32_map_connect_error(PRInt32 err)
  204. {
  205.     PRErrorCode prError;
  206.     switch (err) {
  207.     case WSAEWOULDBLOCK: prError = PR_IN_PROGRESS_ERROR; break;
  208.     case WSAEINVAL:  prError = PR_ALREADY_INITIATED_ERROR; break;
  209.     case WSAETIMEDOUT:  prError = PR_IO_TIMEOUT_ERROR; break;
  210.     default: nss_MD_win32_map_default_error(err); return;
  211.     }
  212.     PR_SetError(prError, err);
  213. }
  215. void nss_MD_win32_map_bind_error(PRInt32 err)
  216. {
  217.     PRErrorCode prError;
  218.     switch (err) {
  219.     case WSAEINVAL:  prError = PR_SOCKET_ADDRESS_IS_BOUND_ERROR; break;
  220.     default: nss_MD_win32_map_default_error(err); return;
  221.     }
  222.     PR_SetError(prError, err);
  223. }
  225. void nss_MD_win32_map_listen_error(PRInt32 err)
  226. {
  227.     PRErrorCode prError;
  228.     switch (err) {
  229.     case WSAEOPNOTSUPP: prError = PR_NOT_TCP_SOCKET_ERROR; break;
  230.     case WSAEINVAL:  prError = PR_INVALID_STATE_ERROR; break;
  231.     default: nss_MD_win32_map_default_error(err); return;
  232.     }
  233.     PR_SetError(prError, err);
  234. }
  236. void nss_MD_win32_map_shutdown_error(PRInt32 err)
  237. {
  238.     nss_MD_win32_map_default_error(err);
  239. }
  241. void nss_MD_win32_map_getsockname_error(PRInt32 err)
  242. {
  243.     PRErrorCode prError;
  244.     switch (err) {
  245.     case WSAEINVAL:  prError = PR_INVALID_STATE_ERROR; break;
  246.     default: nss_MD_win32_map_default_error(err); return;
  247.     }
  248.     PR_SetError(prError, err);
  249. }
  251. void nss_MD_win32_map_getpeername_error(PRInt32 err)
  252. {
  253.     nss_MD_win32_map_default_error(err);
  254. }
  256. void nss_MD_win32_map_getsockopt_error(PRInt32 err)
  257. {
  258.     nss_MD_win32_map_default_error(err);
  259. }
  261. void nss_MD_win32_map_setsockopt_error(PRInt32 err)
  262. {
  263.     nss_MD_win32_map_default_error(err);
  264. }
  266. void nss_MD_win32_map_open_error(PRInt32 err)
  267. {
  268.     nss_MD_win32_map_default_error(err);
  269. }
  271. void nss_MD_win32_map_gethostname_error(PRInt32 err)
  272. {
  273.     nss_MD_win32_map_default_error(err);
  274. }
  276. /* Win32 select() only works on sockets.  So in this
  277. ** context, WSAENOTSOCK is equivalent to EBADF on Unix.  
  278. */
  279. void nss_MD_win32_map_select_error(PRInt32 err)
  280. {
  281.     PRErrorCode prError;
  282.     switch (err) {
  283.     case WSAENOTSOCK: prError = PR_BAD_DESCRIPTOR_ERROR; break;
  284.     default: nss_MD_win32_map_default_error(err); return;
  285.     }
  286.     PR_SetError(prError, err);
  287. }
  289. void nss_MD_win32_map_lockf_error(PRInt32 err)
  290. {
  291.     nss_MD_win32_map_default_error(err);
  292. }
  296. void nss_MD_win32_map_default_error(PRInt32 err)
  297. {
  298.     PRErrorCode prError;
  300.     switch (err) {
  301.     case EACCES:  prError = PR_NO_ACCESS_RIGHTS_ERROR; break;
  302.     case ENOENT:  prError = PR_FILE_NOT_FOUND_ERROR; break;
  303.     case ERROR_ACCESS_DENIED:  prError = PR_NO_ACCESS_RIGHTS_ERROR; break;
  304.     case ERROR_ALREADY_EXISTS:  prError = PR_FILE_EXISTS_ERROR; break;
  305.     case ERROR_DISK_CORRUPT:  prError = PR_IO_ERROR; break;
  306.     case ERROR_DISK_FULL:  prError = PR_NO_DEVICE_SPACE_ERROR; break;
  307.     case ERROR_DISK_OPERATION_FAILED: prError = PR_IO_ERROR; break;
  308.     case ERROR_DRIVE_LOCKED:  prError = PR_FILE_IS_LOCKED_ERROR; break;
  309.     case ERROR_FILENAME_EXCED_RANGE: prError = PR_NAME_TOO_LONG_ERROR; break;
  310.     case ERROR_FILE_CORRUPT:  prError = PR_IO_ERROR; break;
  311.     case ERROR_FILE_EXISTS:  prError = PR_FILE_EXISTS_ERROR; break;
  312.     case ERROR_FILE_INVALID:  prError = PR_BAD_DESCRIPTOR_ERROR; break;
  313. #if ERROR_FILE_NOT_FOUND != ENOENT
  314.     case ERROR_FILE_NOT_FOUND:  prError = PR_FILE_NOT_FOUND_ERROR; break;
  315. #endif
  316.     case ERROR_HANDLE_DISK_FULL: prError = PR_NO_DEVICE_SPACE_ERROR; break;
  317.     case ERROR_INVALID_ADDRESS: prError = PR_ACCESS_FAULT_ERROR; break;
  318.     case ERROR_INVALID_HANDLE:  prError = PR_BAD_DESCRIPTOR_ERROR; break;
  319.     case ERROR_INVALID_NAME:  prError = PR_INVALID_ARGUMENT_ERROR; break;
  320.     case ERROR_INVALID_PARAMETER: prError = PR_INVALID_ARGUMENT_ERROR; break;
  321.     case ERROR_INVALID_USER_BUFFER: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
  322.     case ERROR_LOCKED:   prError = PR_FILE_IS_LOCKED_ERROR; break;
  323.     case ERROR_NETNAME_DELETED: prError = PR_CONNECT_RESET_ERROR; break;
  324.     case ERROR_NOACCESS:  prError = PR_ACCESS_FAULT_ERROR; break;
  325.     case ERROR_NOT_ENOUGH_MEMORY: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
  326.     case ERROR_NOT_ENOUGH_QUOTA: prError = PR_OUT_OF_MEMORY_ERROR; break;
  327.     case ERROR_NOT_READY:  prError = PR_IO_ERROR; break;
  328.     case ERROR_NO_MORE_FILES:  prError = PR_NO_MORE_FILES_ERROR; break;
  329.     case ERROR_OPEN_FAILED:  prError = PR_IO_ERROR; break;
  330.     case ERROR_OPEN_FILES:  prError = PR_IO_ERROR; break;
  331.     case ERROR_OUTOFMEMORY:  prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
  332.     case ERROR_PATH_BUSY:  prError = PR_IO_ERROR; break;
  333.     case ERROR_PATH_NOT_FOUND:  prError = PR_FILE_NOT_FOUND_ERROR; break;
  334.     case ERROR_SEEK_ON_DEVICE:  prError = PR_IO_ERROR; break;
  335.     case ERROR_SHARING_VIOLATION: prError = PR_FILE_IS_BUSY_ERROR; break;
  336.     case ERROR_STACK_OVERFLOW:  prError = PR_ACCESS_FAULT_ERROR; break;
  337.     case ERROR_TOO_MANY_OPEN_FILES: prError = PR_SYS_DESC_TABLE_FULL_ERROR; break;
  338.     case ERROR_WRITE_PROTECT:  prError = PR_NO_ACCESS_RIGHTS_ERROR; break;
  339.     case WSAEACCES:  prError = PR_NO_ACCESS_RIGHTS_ERROR; break;
  340.     case WSAEADDRINUSE:  prError = PR_ADDRESS_IN_USE_ERROR; break;
  341.     case WSAEADDRNOTAVAIL:  prError = PR_ADDRESS_NOT_AVAILABLE_ERROR; break;
  342.     case WSAEAFNOSUPPORT:  prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
  343.     case WSAEALREADY:  prError = PR_ALREADY_INITIATED_ERROR; break;
  344.     case WSAEBADF:  prError = PR_BAD_DESCRIPTOR_ERROR; break;
  345.     case WSAECONNABORTED:  prError = PR_CONNECT_ABORTED_ERROR; break;
  346.     case WSAECONNREFUSED:  prError = PR_CONNECT_REFUSED_ERROR; break;
  347.     case WSAECONNRESET:  prError = PR_CONNECT_RESET_ERROR; break;
  348.     case WSAEDESTADDRREQ:  prError = PR_INVALID_ARGUMENT_ERROR; break;
  349.     case WSAEFAULT:  prError = PR_ACCESS_FAULT_ERROR; break;
  350.     case WSAEHOSTUNREACH:  prError = PR_HOST_UNREACHABLE_ERROR; break;
  351.     case WSAEINVAL:  prError = PR_INVALID_ARGUMENT_ERROR; break;
  352.     case WSAEISCONN:  prError = PR_IS_CONNECTED_ERROR; break;
  353.     case WSAEMFILE:  prError = PR_PROC_DESC_TABLE_FULL_ERROR; break;
  354.     case WSAEMSGSIZE:  prError = PR_BUFFER_OVERFLOW_ERROR; break;
  355.     case WSAENETDOWN:  prError = PR_NETWORK_DOWN_ERROR; break;
  356.     case WSAENETRESET:  prError = PR_CONNECT_ABORTED_ERROR; break;
  357.     case WSAENETUNREACH:  prError = PR_NETWORK_UNREACHABLE_ERROR; break;
  358.     case WSAENOBUFS:  prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
  359.     case WSAENOPROTOOPT:  prError = PR_INVALID_ARGUMENT_ERROR; break;
  360.     case WSAENOTCONN:  prError = PR_NOT_CONNECTED_ERROR; break;
  361.     case WSAENOTSOCK:  prError = PR_NOT_SOCKET_ERROR; break;
  362.     case WSAEOPNOTSUPP:  prError = PR_OPERATION_NOT_SUPPORTED_ERROR; break;
  363.     case WSAEPROTONOSUPPORT:  prError = PR_PROTOCOL_NOT_SUPPORTED_ERROR; break;
  364.     case WSAEPROTOTYPE:  prError = PR_INVALID_ARGUMENT_ERROR; break;
  365.     case WSAESHUTDOWN:  prError = PR_SOCKET_SHUTDOWN_ERROR; break;
  366.     case WSAESOCKTNOSUPPORT:  prError = PR_INVALID_ARGUMENT_ERROR; break;
  367.     case WSAETIMEDOUT:  prError = PR_CONNECT_ABORTED_ERROR; break;
  368.     case WSAEWOULDBLOCK:  prError = PR_WOULD_BLOCK_ERROR; break;
  369.     default:  prError = PR_UNKNOWN_ERROR; break;
  370.     }
  371.     PR_SetError(prError, err);
  372. }