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

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

CA认证

开发平台：

WINDOWS

unix_err.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: unix_err.c,v 1.2 2000/09/18 19:53:59 nelsonb%netscape.com Exp $
  42.  */
  44. #if 0
  45. #include "primpl.h"
  46. #else
  47. #define _PR_POLL_AVAILABLE 1
  48. #include "prerror.h"
  49. #endif
  51. #if defined(_PR_POLL_AVAILABLE)
  52. #include <poll.h>
  53. #endif
  54. #include <errno.h>
  56. /* forward declarations. */
  57. void nss_MD_unix_map_default_error(int err);
  59. void nss_MD_unix_map_opendir_error(int err)
  60. {
  61.     nss_MD_unix_map_default_error(err);
  62. }
  64. void nss_MD_unix_map_closedir_error(int err)
  65. {
  66.     PRErrorCode prError;
  67.     switch (err) {
  68.     case EINVAL: prError = PR_BAD_DESCRIPTOR_ERROR; break;
  69.     default: nss_MD_unix_map_default_error(err); return;
  70.     }
  71.     PR_SetError(prError, err);
  72. }
  74. void nss_MD_unix_readdir_error(int err)
  75. {
  76.     PRErrorCode prError;
  78.     switch (err) {
  79.     case ENOENT: prError = PR_NO_MORE_FILES_ERROR; break;
  80. #ifdef EOVERFLOW
  81.     case EOVERFLOW: prError = PR_IO_ERROR; break;
  82. #endif
  83.     case EINVAL: prError = PR_IO_ERROR; break;
  84.     case ENXIO: prError = PR_IO_ERROR; break;
  85.     default: nss_MD_unix_map_default_error(err); return;
  86.     }
  87.     PR_SetError(prError, err);
  88. }
  90. void nss_MD_unix_map_unlink_error(int err)
  91. {
  92.     PRErrorCode prError;
  93.     switch (err) {
  94.     case EPERM: prError = PR_IS_DIRECTORY_ERROR; break;
  95.     default: nss_MD_unix_map_default_error(err); return;
  96.     }
  97.     PR_SetError(prError, err);
  98. }
  100. void nss_MD_unix_map_stat_error(int err)
  101. {
  102.     PRErrorCode prError;
  103.     switch (err) {
  104.     case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break;
  105.     default: nss_MD_unix_map_default_error(err); return;
  106.     }
  107.     PR_SetError(prError, err);
  108. }
  110. void nss_MD_unix_map_fstat_error(int err)
  111. {
  112.     PRErrorCode prError;
  113.     switch (err) {
  114.     case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break;
  115.     default: nss_MD_unix_map_default_error(err); return;
  116.     }
  117.     PR_SetError(prError, err);
  118. }
  120. void nss_MD_unix_map_rename_error(int err)
  121. {
  122.     PRErrorCode prError;
  123.     switch (err) {
  124.     case EEXIST: prError = PR_DIRECTORY_NOT_EMPTY_ERROR; break;
  125.     default: nss_MD_unix_map_default_error(err); return;
  126.     }
  127.     PR_SetError(prError, err);
  128. }
  130. void nss_MD_unix_map_access_error(int err)
  131. {
  132.     PRErrorCode prError;
  133.     switch (err) {
  134.     case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break;
  135.     default: nss_MD_unix_map_default_error(err); return;
  136.     }
  137.     PR_SetError(prError, err);
  138. }
  140. void nss_MD_unix_map_mkdir_error(int err)
  141. {
  142.     nss_MD_unix_map_default_error(err);
  143. }
  145. void nss_MD_unix_map_rmdir_error(int err)
  146. {
  147.     PRErrorCode prError;
  149.     switch (err) {
  150.     case EEXIST: prError = PR_DIRECTORY_NOT_EMPTY_ERROR; break;
  151.     case EINVAL: prError = PR_DIRECTORY_NOT_EMPTY_ERROR; break;
  152.     case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break;
  153.     default: nss_MD_unix_map_default_error(err); return;
  154.     }
  155.     PR_SetError(prError, err);
  156. }
  158. void nss_MD_unix_map_read_error(int err)
  159. {
  160.     PRErrorCode prError;
  161.     switch (err) {
  162.     case EINVAL: prError = PR_INVALID_METHOD_ERROR; break;
  163.     case ENXIO: prError = PR_INVALID_ARGUMENT_ERROR; break;
  164.     default: nss_MD_unix_map_default_error(err); return;
  165.     }
  166.     PR_SetError(prError, err);
  167. }
  169. void nss_MD_unix_map_write_error(int err)
  170. {
  171.     PRErrorCode prError;
  172.     switch (err) {
  173.     case EINVAL: prError = PR_INVALID_METHOD_ERROR; break;
  174.     case ENXIO: prError = PR_INVALID_METHOD_ERROR; break;
  175.     case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break;
  176.     default: nss_MD_unix_map_default_error(err); return;
  177.     }
  178.     PR_SetError(prError, err);
  179. }
  181. void nss_MD_unix_map_lseek_error(int err)
  182. {
  183.     nss_MD_unix_map_default_error(err);
  184. }
  186. void nss_MD_unix_map_fsync_error(int err)
  187. {
  188.     PRErrorCode prError;
  189.     switch (err) {
  190.     case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break;
  191.     case EINVAL: prError = PR_INVALID_METHOD_ERROR; break;
  192.     default: nss_MD_unix_map_default_error(err); return;
  193.     }
  194.     PR_SetError(prError, err);
  195. }
  197. void nss_MD_unix_map_close_error(int err)
  198. {
  199.     PRErrorCode prError;
  200.     switch (err) {
  201.     case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break;
  202.     default: nss_MD_unix_map_default_error(err); return;
  203.     }
  204.     PR_SetError(prError, err);
  205. }
  207. void nss_MD_unix_map_socket_error(int err)
  208. {
  209.     PRErrorCode prError;
  210.     switch (err) {
  211.     case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
  212.     default: nss_MD_unix_map_default_error(err); return;
  213.     }
  214.     PR_SetError(prError, err);
  215. }
  217. void nss_MD_unix_map_socketavailable_error(int err)
  218. {
  219.     PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
  220. }
  222. void nss_MD_unix_map_recv_error(int err)
  223. {
  224.     nss_MD_unix_map_default_error(err);
  225. }
  227. void nss_MD_unix_map_recvfrom_error(int err)
  228. {
  229.     nss_MD_unix_map_default_error(err);
  230. }
  232. void nss_MD_unix_map_send_error(int err)
  233. {
  234.     nss_MD_unix_map_default_error(err);
  235. }
  237. void nss_MD_unix_map_sendto_error(int err)
  238. {
  239.     nss_MD_unix_map_default_error(err);
  240. }
  242. void nss_MD_unix_map_writev_error(int err)
  243. {
  244.     nss_MD_unix_map_default_error(err);
  245. }
  247. void nss_MD_unix_map_accept_error(int err)
  248. {
  249.     PRErrorCode prError;
  250.     switch (err) {
  251.     case ENODEV: prError = PR_NOT_TCP_SOCKET_ERROR; break;
  252.     default: nss_MD_unix_map_default_error(err); return;
  253.     }
  254.     PR_SetError(prError, err);
  255. }
  257. void nss_MD_unix_map_connect_error(int err)
  258. {
  259.     PRErrorCode prError;
  260.     switch (err) {
  261.     case EACCES: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
  262. #if defined(UNIXWARE) || defined(SNI) || defined(NEC)
  263.     /*
  264.      * On some platforms, if we connect to a port on the local host 
  265.      * (the loopback address) that no process is listening on, we get 
  266.      * EIO instead of ECONNREFUSED.
  267.      */
  268.     case EIO: prError = PR_CONNECT_REFUSED_ERROR; break;
  269. #endif
  270.     case ELOOP: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
  271.     case ENOENT: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
  272.     case ENXIO: prError = PR_IO_ERROR; break;
  273.     default: nss_MD_unix_map_default_error(err); return;
  274.     }
  275.     PR_SetError(prError, err);
  276. }
  278. void nss_MD_unix_map_bind_error(int err)
  279. {
  280.     PRErrorCode prError;
  281.     switch (err) {
  282.     case EINVAL: prError = PR_SOCKET_ADDRESS_IS_BOUND_ERROR; break;
  283.         /*
  284.          * UNIX domain sockets are not supported in NSPR
  285.          */
  286.     case EIO: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
  287.     case EISDIR: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
  288.     case ELOOP: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
  289.     case ENOENT: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
  290.     case ENOTDIR: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
  291.     case EROFS: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
  292.     default: nss_MD_unix_map_default_error(err); return;
  293.     }
  294.     PR_SetError(prError, err);
  295. }
  297. void nss_MD_unix_map_listen_error(int err)
  298. {
  299.     nss_MD_unix_map_default_error(err);
  300. }
  302. void nss_MD_unix_map_shutdown_error(int err)
  303. {
  304.     nss_MD_unix_map_default_error(err);
  305. }
  307. void nss_MD_unix_map_socketpair_error(int err)
  308. {
  309.     PRErrorCode prError;
  310.     switch (err) {
  311.     case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
  312.     default: nss_MD_unix_map_default_error(err); return;
  313.     }
  314.     PR_SetError(prError, err);
  315. }
  317. void nss_MD_unix_map_getsockname_error(int err)
  318. {
  319.     PRErrorCode prError;
  320.     switch (err) {
  321.     case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
  322.     default: nss_MD_unix_map_default_error(err); return;
  323.     }
  324.     PR_SetError(prError, err);
  325. }
  327. void nss_MD_unix_map_getpeername_error(int err)
  328. {
  329.     PRErrorCode prError;
  331.     switch (err) {
  332.     case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
  333.     default: nss_MD_unix_map_default_error(err); return;
  334.     }
  335.     PR_SetError(prError, err);
  336. }
  338. void nss_MD_unix_map_getsockopt_error(int err)
  339. {
  340.     PRErrorCode prError;
  341.     switch (err) {
  342.     case EINVAL: prError = PR_BUFFER_OVERFLOW_ERROR; break;
  343.     case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
  344.     default: nss_MD_unix_map_default_error(err); return;
  345.     }
  346.     PR_SetError(prError, err);
  347. }
  349. void nss_MD_unix_map_setsockopt_error(int err)
  350. {
  351.     PRErrorCode prError;
  352.     switch (err) {
  353.     case EINVAL: prError = PR_BUFFER_OVERFLOW_ERROR; break;
  354.     case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
  355.     default: nss_MD_unix_map_default_error(err); return;
  356.     }
  357.     PR_SetError(prError, err);
  358. }
  360. void nss_MD_unix_map_open_error(int err)
  361. {
  362.     PRErrorCode prError;
  363.     switch (err) {
  364.     case EAGAIN: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
  365.     case EBUSY: prError = PR_IO_ERROR; break;
  366.     case ENODEV: prError = PR_FILE_NOT_FOUND_ERROR; break;
  367.     case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
  368.     case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break;
  369.     default: nss_MD_unix_map_default_error(err); return;
  370.     }
  371.     PR_SetError(prError, err);
  372. }
  374. void nss_MD_unix_map_mmap_error(int err)
  375. {
  376.     PRErrorCode prError;
  377.     switch (err) {
  378.     case EAGAIN: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
  379.     case EMFILE: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
  380.     case ENODEV: prError = PR_OPERATION_NOT_SUPPORTED_ERROR; break;
  381.     case ENXIO: prError = PR_INVALID_ARGUMENT_ERROR; break;
  382.     default: nss_MD_unix_map_default_error(err); return;
  383.     }
  384.     PR_SetError(prError, err);
  385. }
  387. void nss_MD_unix_map_gethostname_error(int err)
  388. {
  389.     nss_MD_unix_map_default_error(err);
  390. }
  392. void nss_MD_unix_map_select_error(int err)
  393. {
  394.     nss_MD_unix_map_default_error(err);
  395. }
  397. #ifdef _PR_POLL_AVAILABLE
  398. void nss_MD_unix_map_poll_error(int err)
  399. {
  400.     PRErrorCode prError;
  402.     switch (err) {
  403.     case EAGAIN: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
  404.     default: nss_MD_unix_map_default_error(err); return;
  405.     }
  406.     PR_SetError(prError, err);
  407. }
  409. void nss_MD_unix_map_poll_revents_error(int err)
  410. {
  411.     if (err & POLLNVAL)
  412.         PR_SetError(PR_BAD_DESCRIPTOR_ERROR, EBADF);
  413.     else if (err & POLLHUP)
  414.         PR_SetError(PR_CONNECT_RESET_ERROR, EPIPE);
  415.     else if (err & POLLERR)
  416.         PR_SetError(PR_IO_ERROR, EIO);
  417.     else
  418.         PR_SetError(PR_UNKNOWN_ERROR, err);
  419. }
  420. #endif /* _PR_POLL_AVAILABLE */
  423. void nss_MD_unix_map_flock_error(int err)
  424. {
  425.     PRErrorCode prError;
  426.     switch (err) {
  427.     case EINVAL: prError = PR_BAD_DESCRIPTOR_ERROR; break;
  428.     case EWOULDBLOCK: prError = PR_FILE_IS_LOCKED_ERROR; break;
  429.     default: nss_MD_unix_map_default_error(err); return;
  430.     }
  431.     PR_SetError(prError, err);
  432. }
  434. void nss_MD_unix_map_lockf_error(int err)
  435. {
  436.     PRErrorCode prError;
  437.     switch (err) {
  438.     case EACCES: prError = PR_FILE_IS_LOCKED_ERROR; break;
  439.     case EDEADLK: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
  440.     default: nss_MD_unix_map_default_error(err); return;
  441.     }
  442.     PR_SetError(prError, err);
  443. }
  445. #ifdef HPUX11
  446. void nss_MD_hpux_map_sendfile_error(int err)
  447. {
  448.     nss_MD_unix_map_default_error(err);
  449. }
  450. #endif /* HPUX11 */
  453. void nss_MD_unix_map_default_error(int err)
  454. {
  455.     PRErrorCode prError;
  456.     switch (err ) {
  457.     case EACCES: prError = PR_NO_ACCESS_RIGHTS_ERROR; break;
  458.     case EADDRINUSE: prError = PR_ADDRESS_IN_USE_ERROR; break;
  459.     case EADDRNOTAVAIL: prError = PR_ADDRESS_NOT_AVAILABLE_ERROR; break;
  460.     case EAFNOSUPPORT: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
  461.     case EAGAIN: prError = PR_WOULD_BLOCK_ERROR; break;
  462.     case EALREADY: prError = PR_ALREADY_INITIATED_ERROR; break;
  463.     case EBADF: prError = PR_BAD_DESCRIPTOR_ERROR; break;
  464. #ifdef EBADMSG
  465.     case EBADMSG: prError = PR_IO_ERROR; break;
  466. #endif
  467.     case EBUSY: prError = PR_FILESYSTEM_MOUNTED_ERROR; break;
  468.     case ECONNREFUSED: prError = PR_CONNECT_REFUSED_ERROR; break;
  469.     case ECONNRESET: prError = PR_CONNECT_RESET_ERROR; break;
  470.     case EDEADLK: prError = PR_DEADLOCK_ERROR; break;
  471. #ifdef EDIRCORRUPTED
  472.     case EDIRCORRUPTED: prError = PR_DIRECTORY_CORRUPTED_ERROR; break;
  473. #endif
  474. #ifdef EDQUOT
  475.     case EDQUOT: prError = PR_NO_DEVICE_SPACE_ERROR; break;
  476. #endif
  477.     case EEXIST: prError = PR_FILE_EXISTS_ERROR; break;
  478.     case EFAULT: prError = PR_ACCESS_FAULT_ERROR; break;
  479.     case EFBIG: prError = PR_FILE_TOO_BIG_ERROR; break;
  480.     case EINPROGRESS: prError = PR_IN_PROGRESS_ERROR; break;
  481.     case EINTR: prError = PR_PENDING_INTERRUPT_ERROR; break;
  482.     case EINVAL: prError = PR_INVALID_ARGUMENT_ERROR; break;
  483.     case EIO: prError = PR_IO_ERROR; break;
  484.     case EISCONN: prError = PR_IS_CONNECTED_ERROR; break;
  485.     case EISDIR: prError = PR_IS_DIRECTORY_ERROR; break;
  486.     case ELOOP: prError = PR_LOOP_ERROR; break;
  487.     case EMFILE: prError = PR_PROC_DESC_TABLE_FULL_ERROR; break;
  488.     case EMLINK: prError = PR_MAX_DIRECTORY_ENTRIES_ERROR; break;
  489.     case EMSGSIZE: prError = PR_INVALID_ARGUMENT_ERROR; break;
  490. #ifdef EMULTIHOP
  491.     case EMULTIHOP: prError = PR_REMOTE_FILE_ERROR; break;
  492. #endif
  493.     case ENAMETOOLONG: prError = PR_NAME_TOO_LONG_ERROR; break;
  494.     case ENETUNREACH: prError = PR_NETWORK_UNREACHABLE_ERROR; break;
  495.     case ENFILE: prError = PR_SYS_DESC_TABLE_FULL_ERROR; break;
  496. #if !defined(SCO)
  497.     case ENOBUFS: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
  498. #endif
  499.     case ENODEV: prError = PR_FILE_NOT_FOUND_ERROR; break;
  500.     case ENOENT: prError = PR_FILE_NOT_FOUND_ERROR; break;
  501.     case ENOLCK: prError = PR_FILE_IS_LOCKED_ERROR; break;
  502. #ifdef ENOLINK 
  503.     case ENOLINK: prError = PR_REMOTE_FILE_ERROR; break;
  504. #endif
  505.     case ENOMEM: prError = PR_OUT_OF_MEMORY_ERROR; break;
  506.     case ENOPROTOOPT: prError = PR_INVALID_ARGUMENT_ERROR; break;
  507.     case ENOSPC: prError = PR_NO_DEVICE_SPACE_ERROR; break;
  508. #ifdef ENOSR 
  509.     case ENOSR: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
  510. #endif
  511.     case ENOTCONN: prError = PR_NOT_CONNECTED_ERROR; break;
  512.     case ENOTDIR: prError = PR_NOT_DIRECTORY_ERROR; break;
  513.     case ENOTSOCK: prError = PR_NOT_SOCKET_ERROR; break;
  514.     case ENXIO: prError = PR_FILE_NOT_FOUND_ERROR; break;
  515.     case EOPNOTSUPP: prError = PR_NOT_TCP_SOCKET_ERROR; break;
  516. #ifdef EOVERFLOW
  517.     case EOVERFLOW: prError = PR_BUFFER_OVERFLOW_ERROR; break;
  518. #endif
  519.     case EPERM: prError = PR_NO_ACCESS_RIGHTS_ERROR; break;
  520.     case EPIPE: prError = PR_CONNECT_RESET_ERROR; break;
  521. #ifdef EPROTO
  522.     case EPROTO: prError = PR_IO_ERROR; break;
  523. #endif
  524.     case EPROTONOSUPPORT: prError = PR_PROTOCOL_NOT_SUPPORTED_ERROR; break;
  525.     case EPROTOTYPE: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
  526.     case ERANGE: prError = PR_INVALID_METHOD_ERROR; break;
  527.     case EROFS: prError = PR_READ_ONLY_FILESYSTEM_ERROR; break;
  528.     case ESPIPE: prError = PR_INVALID_METHOD_ERROR; break;
  529.     case ETIMEDOUT: prError = PR_IO_TIMEOUT_ERROR; break;
  530. #if EWOULDBLOCK != EAGAIN
  531.     case EWOULDBLOCK: prError = PR_WOULD_BLOCK_ERROR; break;
  532. #endif
  533.     case EXDEV: prError = PR_NOT_SAME_DEVICE_ERROR; break;
  535.     default: prError = PR_UNKNOWN_ERROR; break;
  536.     }
  537.     PR_SetError(prError, err);
  538. }