LCOV - app.info - nsprpub/pr/src/md/unix/unix_errors.c

LCOV - code coverage report
| Current view: | directory - nsprpub/pr/src/md/unix - unix_errors.c (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 394 | 0 | 0.0 %
| Date: | 2012-04-07 | Functions: | 42 | 0 | 0.0 %

           1                 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
           2                 : /* ***** BEGIN LICENSE BLOCK *****
           3                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
           4                 :  *
           5                 :  * The contents of this file are subject to the Mozilla Public License Version
           6                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           7                 :  * the License. You may obtain a copy of the License at
           8                 :  * http://www.mozilla.org/MPL/
           9                 :  *
          10                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          11                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          12                 :  * for the specific language governing rights and limitations under the
          13                 :  * License.
          14                 :  *
          15                 :  * The Original Code is the Netscape Portable Runtime (NSPR).
          16                 :  *
          17                 :  * The Initial Developer of the Original Code is
          18                 :  * Netscape Communications Corporation.
          19                 :  * Portions created by the Initial Developer are Copyright (C) 1998-2000
          20                 :  * the Initial Developer. All Rights Reserved.
          21                 :  *
          22                 :  * Contributor(s):
          23                 :  *
          24                 :  * Alternatively, the contents of this file may be used under the terms of
          25                 :  * either the GNU General Public License Version 2 or later (the "GPL"), or
          26                 :  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          27                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          28                 :  * of those above. If you wish to allow use of your version of this file only
          29                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          30                 :  * use your version of this file under the terms of the MPL, indicate your
          31                 :  * decision by deleting the provisions above and replace them with the notice
          32                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          33                 :  * the provisions above, a recipient may use your version of this file under
          34                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          35                 :  *
          36                 :  * ***** END LICENSE BLOCK ***** */
          37                 :
          38                 : #include "primpl.h"
          39                 : #if defined(_PR_POLL_AVAILABLE)
          40                 : #include <poll.h>
          41                 : #endif
          42                 : #include <errno.h>
          43                 :
          44               0 : void _MD_unix_map_default_error(int err)
          45                 : {
          46                 :     PRErrorCode prError;
          47                 :
          48               0 :     switch (err ) {
          49                 :         case EACCES:
          50               0 :             prError = PR_NO_ACCESS_RIGHTS_ERROR;
          51               0 :             break;
          52                 :         case EADDRINUSE:
          53               0 :             prError = PR_ADDRESS_IN_USE_ERROR;
          54               0 :             break;
          55                 :         case EADDRNOTAVAIL:
          56               0 :             prError = PR_ADDRESS_NOT_AVAILABLE_ERROR;
          57               0 :             break;
          58                 :         case EAFNOSUPPORT:
          59               0 :             prError = PR_ADDRESS_NOT_SUPPORTED_ERROR;
          60               0 :             break;
          61                 :         case EAGAIN:
          62               0 :             prError = PR_WOULD_BLOCK_ERROR;
          63               0 :             break;
          64                 :         /*
          65                 :          * On QNX and Neutrino, EALREADY is defined as EBUSY.
          66                 :          */
          67                 : #if EALREADY != EBUSY
          68                 :         case EALREADY:
          69               0 :             prError = PR_ALREADY_INITIATED_ERROR;
          70               0 :             break;
          71                 : #endif
          72                 :         case EBADF:
          73               0 :             prError = PR_BAD_DESCRIPTOR_ERROR;
          74               0 :             break;
          75                 : #ifdef EBADMSG
          76                 :         case EBADMSG:
          77               0 :             prError = PR_IO_ERROR;
          78               0 :             break;
          79                 : #endif
          80                 :         case EBUSY:
          81               0 :             prError = PR_FILESYSTEM_MOUNTED_ERROR;
          82               0 :             break;
          83                 :         case ECONNABORTED:
          84               0 :             prError = PR_CONNECT_ABORTED_ERROR;
          85               0 :             break;
          86                 :         case ECONNREFUSED:
          87               0 :             prError = PR_CONNECT_REFUSED_ERROR;
          88               0 :             break;
          89                 :         case ECONNRESET:
          90               0 :             prError = PR_CONNECT_RESET_ERROR;
          91               0 :             break;
          92                 :         case EDEADLK:
          93               0 :             prError = PR_DEADLOCK_ERROR;
          94               0 :             break;
          95                 : #ifdef EDIRCORRUPTED
          96                 :         case EDIRCORRUPTED:
          97                 :             prError = PR_DIRECTORY_CORRUPTED_ERROR;
          98                 :             break;
          99                 : #endif
         100                 : #ifdef EDQUOT
         101                 :         case EDQUOT:
         102               0 :             prError = PR_NO_DEVICE_SPACE_ERROR;
         103               0 :             break;
         104                 : #endif
         105                 :         case EEXIST:
         106               0 :             prError = PR_FILE_EXISTS_ERROR;
         107               0 :             break;
         108                 :         case EFAULT:
         109               0 :             prError = PR_ACCESS_FAULT_ERROR;
         110               0 :             break;
         111                 :         case EFBIG:
         112               0 :             prError = PR_FILE_TOO_BIG_ERROR;
         113               0 :             break;
         114                 :         case EHOSTUNREACH:
         115               0 :             prError = PR_HOST_UNREACHABLE_ERROR;
         116               0 :             break;
         117                 :         case EINPROGRESS:
         118               0 :             prError = PR_IN_PROGRESS_ERROR;
         119               0 :             break;
         120                 :         case EINTR:
         121               0 :             prError = PR_PENDING_INTERRUPT_ERROR;
         122               0 :             break;
         123                 :         case EINVAL:
         124               0 :             prError = PR_INVALID_ARGUMENT_ERROR;
         125               0 :             break;
         126                 :         case EIO:
         127               0 :             prError = PR_IO_ERROR;
         128               0 :             break;
         129                 :         case EISCONN:
         130               0 :             prError = PR_IS_CONNECTED_ERROR;
         131               0 :             break;
         132                 :         case EISDIR:
         133               0 :             prError = PR_IS_DIRECTORY_ERROR;
         134               0 :             break;
         135                 :         case ELOOP:
         136               0 :             prError = PR_LOOP_ERROR;
         137               0 :             break;
         138                 :         case EMFILE:
         139               0 :             prError = PR_PROC_DESC_TABLE_FULL_ERROR;
         140               0 :             break;
         141                 :         case EMLINK:
         142               0 :             prError = PR_MAX_DIRECTORY_ENTRIES_ERROR;
         143               0 :             break;
         144                 :         case EMSGSIZE:
         145               0 :             prError = PR_INVALID_ARGUMENT_ERROR;
         146               0 :             break;
         147                 : #ifdef EMULTIHOP
         148                 :         case EMULTIHOP:
         149               0 :             prError = PR_REMOTE_FILE_ERROR;
         150               0 :             break;
         151                 : #endif
         152                 :         case ENAMETOOLONG:
         153               0 :             prError = PR_NAME_TOO_LONG_ERROR;
         154               0 :             break;
         155                 :         case ENETUNREACH:
         156               0 :             prError = PR_NETWORK_UNREACHABLE_ERROR;
         157               0 :             break;
         158                 :         case ENFILE:
         159               0 :             prError = PR_SYS_DESC_TABLE_FULL_ERROR;
         160               0 :             break;
         161                 :         /*
         162                 :          * On SCO OpenServer 5, ENOBUFS is defined as ENOSR.
         163                 :          */
         164                 : #if defined(ENOBUFS) && (ENOBUFS != ENOSR)
         165                 :         case ENOBUFS:
         166               0 :             prError = PR_INSUFFICIENT_RESOURCES_ERROR;
         167               0 :             break;
         168                 : #endif
         169                 :         case ENODEV:
         170               0 :             prError = PR_FILE_NOT_FOUND_ERROR;
         171               0 :             break;
         172                 :         case ENOENT:
         173               0 :             prError = PR_FILE_NOT_FOUND_ERROR;
         174               0 :             break;
         175                 :         case ENOLCK:
         176               0 :             prError = PR_FILE_IS_LOCKED_ERROR;
         177               0 :             break;
         178                 : #ifdef ENOLINK
         179                 :         case ENOLINK:
         180               0 :             prError = PR_REMOTE_FILE_ERROR;
         181               0 :             break;
         182                 : #endif
         183                 :         case ENOMEM:
         184               0 :             prError = PR_OUT_OF_MEMORY_ERROR;
         185               0 :             break;
         186                 :         case ENOPROTOOPT:
         187               0 :             prError = PR_INVALID_ARGUMENT_ERROR;
         188               0 :             break;
         189                 :         case ENOSPC:
         190               0 :             prError = PR_NO_DEVICE_SPACE_ERROR;
         191               0 :             break;
         192                 : #ifdef ENOSR
         193                 :         case ENOSR:
         194               0 :             prError = PR_INSUFFICIENT_RESOURCES_ERROR;
         195               0 :             break;
         196                 : #endif
         197                 :         case ENOSYS:
         198               0 :             prError = PR_NOT_IMPLEMENTED_ERROR;
         199               0 :             break;
         200                 :         case ENOTCONN:
         201               0 :             prError = PR_NOT_CONNECTED_ERROR;
         202               0 :             break;
         203                 :         case ENOTDIR:
         204               0 :             prError = PR_NOT_DIRECTORY_ERROR;
         205               0 :             break;
         206                 :         case ENOTSOCK:
         207               0 :             prError = PR_NOT_SOCKET_ERROR;
         208               0 :             break;
         209                 :         case ENXIO:
         210               0 :             prError = PR_FILE_NOT_FOUND_ERROR;
         211               0 :             break;
         212                 :         case EOPNOTSUPP:
         213               0 :             prError = PR_NOT_TCP_SOCKET_ERROR;
         214               0 :             break;
         215                 : #ifdef EOVERFLOW
         216                 :         case EOVERFLOW:
         217               0 :             prError = PR_BUFFER_OVERFLOW_ERROR;
         218               0 :             break;
         219                 : #endif
         220                 :         case EPERM:
         221               0 :             prError = PR_NO_ACCESS_RIGHTS_ERROR;
         222               0 :             break;
         223                 :         case EPIPE:
         224               0 :             prError = PR_CONNECT_RESET_ERROR;
         225               0 :             break;
         226                 : #ifdef EPROTO
         227                 :         case EPROTO:
         228               0 :             prError = PR_IO_ERROR;
         229               0 :             break;
         230                 : #endif
         231                 :         case EPROTONOSUPPORT:
         232               0 :             prError = PR_PROTOCOL_NOT_SUPPORTED_ERROR;
         233               0 :             break;
         234                 :         case EPROTOTYPE:
         235               0 :             prError = PR_ADDRESS_NOT_SUPPORTED_ERROR;
         236               0 :             break;
         237                 :         case ERANGE:
         238               0 :             prError = PR_INVALID_METHOD_ERROR;
         239               0 :             break;
         240                 :         case EROFS:
         241               0 :             prError = PR_READ_ONLY_FILESYSTEM_ERROR;
         242               0 :             break;
         243                 :         case ESPIPE:
         244               0 :             prError = PR_INVALID_METHOD_ERROR;
         245               0 :             break;
         246                 :         case ETIMEDOUT:
         247               0 :             prError = PR_IO_TIMEOUT_ERROR;
         248               0 :             break;
         249                 : #if EWOULDBLOCK != EAGAIN
         250                 :         case EWOULDBLOCK:
         251                 :             prError = PR_WOULD_BLOCK_ERROR;
         252                 :             break;
         253                 : #endif
         254                 :         case EXDEV:
         255               0 :             prError = PR_NOT_SAME_DEVICE_ERROR;
         256               0 :             break;
         257                 :         default:
         258               0 :             prError = PR_UNKNOWN_ERROR;
         259               0 :             break;
         260                 :     }
         261               0 :     PR_SetError(prError, err);
         262               0 : }
         263                 :
         264               0 : void _MD_unix_map_opendir_error(int err)
         265                 : {
         266               0 :     _MD_unix_map_default_error(err);
         267               0 : }
         268                 :
         269               0 : void _MD_unix_map_closedir_error(int err)
         270                 : {
         271                 :     PRErrorCode prError;
         272                 :
         273               0 :     switch (err) {
         274                 :         case EINVAL:
         275               0 :             prError = PR_BAD_DESCRIPTOR_ERROR;
         276                 :             break;
         277                 :         default:
         278               0 :             _MD_unix_map_default_error(err);
         279               0 :             return;
         280                 :     }
         281               0 :     PR_SetError(prError, err);
         282                 : }
         283                 :
         284               0 : void _MD_unix_readdir_error(int err)
         285                 : {
         286                 :     PRErrorCode prError;
         287                 :
         288               0 :     switch (err) {
         289                 :         case 0:
         290                 :         case ENOENT:
         291               0 :             prError = PR_NO_MORE_FILES_ERROR;
         292               0 :             break;
         293                 : #ifdef EOVERFLOW
         294                 :         case EOVERFLOW:
         295               0 :             prError = PR_IO_ERROR;
         296               0 :             break;
         297                 : #endif
         298                 :         case EINVAL:
         299               0 :             prError = PR_IO_ERROR;
         300               0 :             break;
         301                 :         case ENXIO:
         302               0 :             prError = PR_IO_ERROR;
         303               0 :             break;
         304                 :         default:
         305               0 :             _MD_unix_map_default_error(err);
         306               0 :             return;
         307                 :     }
         308               0 :     PR_SetError(prError, err);
         309                 : }
         310                 :
         311               0 : void _MD_unix_map_unlink_error(int err)
         312                 : {
         313                 :     PRErrorCode prError;
         314                 :
         315               0 :     switch (err) {
         316                 :         case EPERM:
         317               0 :             prError = PR_IS_DIRECTORY_ERROR;
         318                 :             break;
         319                 :         default:
         320               0 :             _MD_unix_map_default_error(err);
         321               0 :             return;
         322                 :     }
         323               0 :     PR_SetError(prError, err);
         324                 : }
         325                 :
         326               0 : void _MD_unix_map_stat_error(int err)
         327                 : {
         328                 :     PRErrorCode prError;
         329                 :
         330               0 :     switch (err) {
         331                 :         case ETIMEDOUT:
         332               0 :             prError = PR_REMOTE_FILE_ERROR;
         333                 :             break;
         334                 :         default:
         335               0 :             _MD_unix_map_default_error(err);
         336               0 :             return;
         337                 :     }
         338               0 :     PR_SetError(prError, err);
         339                 : }
         340                 :
         341               0 : void _MD_unix_map_fstat_error(int err)
         342                 : {
         343                 :     PRErrorCode prError;
         344                 :
         345               0 :     switch (err) {
         346                 :         case ETIMEDOUT:
         347               0 :             prError = PR_REMOTE_FILE_ERROR;
         348                 :             break;
         349                 :         default:
         350               0 :             _MD_unix_map_default_error(err);
         351               0 :             return;
         352                 :     }
         353               0 :     PR_SetError(prError, err);
         354                 : }
         355                 :
         356               0 : void _MD_unix_map_rename_error(int err)
         357                 : {
         358                 :     PRErrorCode prError;
         359                 :
         360               0 :     switch (err) {
         361                 :         case EEXIST:
         362               0 :             prError = PR_DIRECTORY_NOT_EMPTY_ERROR;
         363                 :             break;
         364                 :         default:
         365               0 :             _MD_unix_map_default_error(err);
         366               0 :             return;
         367                 :     }
         368               0 :     PR_SetError(prError, err);
         369                 : }
         370                 :
         371               0 : void _MD_unix_map_access_error(int err)
         372                 : {
         373                 :     PRErrorCode prError;
         374                 :
         375               0 :     switch (err) {
         376                 :         case ETIMEDOUT:
         377               0 :             prError = PR_REMOTE_FILE_ERROR;
         378                 :             break;
         379                 :         default:
         380               0 :             _MD_unix_map_default_error(err);
         381               0 :             return;
         382                 :     }
         383               0 :     PR_SetError(prError, err);
         384                 : }
         385                 :
         386               0 : void _MD_unix_map_mkdir_error(int err)
         387                 : {
         388               0 :     _MD_unix_map_default_error(err);
         389               0 : }
         390                 :
         391               0 : void _MD_unix_map_rmdir_error(int err)
         392                 : {
         393                 :     PRErrorCode prError;
         394                 :
         395               0 :     switch (err) {
         396                 :         /*
         397                 :          * On AIX 4.3, ENOTEMPTY is defined as EEXIST.
         398                 :          */
         399                 : #if ENOTEMPTY != EEXIST
         400                 :         case ENOTEMPTY:
         401               0 :             prError = PR_DIRECTORY_NOT_EMPTY_ERROR;
         402               0 :             break;
         403                 : #endif
         404                 :         case EEXIST:
         405               0 :             prError = PR_DIRECTORY_NOT_EMPTY_ERROR;
         406               0 :             break;
         407                 :         case EINVAL:
         408               0 :             prError = PR_DIRECTORY_NOT_EMPTY_ERROR;
         409               0 :             break;
         410                 :         case ETIMEDOUT:
         411               0 :             prError = PR_REMOTE_FILE_ERROR;
         412               0 :             break;
         413                 :         default:
         414               0 :             _MD_unix_map_default_error(err);
         415               0 :             return;
         416                 :     }
         417               0 :     PR_SetError(prError, err);
         418                 : }
         419                 :
         420               0 : void _MD_unix_map_read_error(int err)
         421                 : {
         422                 :     PRErrorCode prError;
         423                 :
         424               0 :     switch (err) {
         425                 :         case EINVAL:
         426               0 :             prError = PR_INVALID_METHOD_ERROR;
         427               0 :             break;
         428                 :         case ENXIO:
         429               0 :             prError = PR_INVALID_ARGUMENT_ERROR;
         430               0 :             break;
         431                 :         default:
         432               0 :             _MD_unix_map_default_error(err);
         433               0 :             return;
         434                 :     }
         435               0 :     PR_SetError(prError, err);
         436                 : }
         437                 :
         438               0 : void _MD_unix_map_write_error(int err)
         439                 : {
         440                 :     PRErrorCode prError;
         441                 :
         442               0 :     switch (err) {
         443                 :         case EINVAL:
         444               0 :             prError = PR_INVALID_METHOD_ERROR;
         445               0 :             break;
         446                 :         case ENXIO:
         447               0 :             prError = PR_INVALID_METHOD_ERROR;
         448               0 :             break;
         449                 :         case ETIMEDOUT:
         450               0 :             prError = PR_REMOTE_FILE_ERROR;
         451               0 :             break;
         452                 :         default:
         453               0 :             _MD_unix_map_default_error(err);
         454               0 :             return;
         455                 :     }
         456               0 :     PR_SetError(prError, err);
         457                 : }
         458                 :
         459               0 : void _MD_unix_map_lseek_error(int err)
         460                 : {
         461               0 :     _MD_unix_map_default_error(err);
         462               0 : }
         463                 :
         464               0 : void _MD_unix_map_fsync_error(int err)
         465                 : {
         466                 :     PRErrorCode prError;
         467                 :
         468               0 :     switch (err) {
         469                 :         case ETIMEDOUT:
         470               0 :             prError = PR_REMOTE_FILE_ERROR;
         471               0 :             break;
         472                 :         case EINVAL:
         473               0 :             prError = PR_INVALID_METHOD_ERROR;
         474               0 :             break;
         475                 :         default:
         476               0 :             _MD_unix_map_default_error(err);
         477               0 :             return;
         478                 :     }
         479               0 :     PR_SetError(prError, err);
         480                 : }
         481                 :
         482               0 : void _MD_unix_map_close_error(int err)
         483                 : {
         484                 :     PRErrorCode prError;
         485                 :
         486               0 :     switch (err) {
         487                 :         case ETIMEDOUT:
         488               0 :             prError = PR_REMOTE_FILE_ERROR;
         489                 :             break;
         490                 :         default:
         491               0 :             _MD_unix_map_default_error(err);
         492               0 :             return;
         493                 :     }
         494               0 :     PR_SetError(prError, err);
         495                 : }
         496                 :
         497               0 : void _MD_unix_map_socket_error(int err)
         498                 : {
         499                 :     PRErrorCode prError;
         500                 :
         501               0 :     switch (err) {
         502                 :         case ENOMEM:
         503               0 :             prError = PR_INSUFFICIENT_RESOURCES_ERROR;
         504                 :             break;
         505                 :         default:
         506               0 :             _MD_unix_map_default_error(err);
         507               0 :             return;
         508                 :     }
         509               0 :     PR_SetError(prError, err);
         510                 : }
         511                 :
         512               0 : void _MD_unix_map_socketavailable_error(int err)
         513                 : {
         514               0 :     PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
         515               0 : }
         516                 :
         517               0 : void _MD_unix_map_recv_error(int err)
         518                 : {
         519               0 :     _MD_unix_map_default_error(err);
         520               0 : }
         521                 :
         522               0 : void _MD_unix_map_recvfrom_error(int err)
         523                 : {
         524               0 :     _MD_unix_map_default_error(err);
         525               0 : }
         526                 :
         527               0 : void _MD_unix_map_send_error(int err)
         528                 : {
         529               0 :     _MD_unix_map_default_error(err);
         530               0 : }
         531                 :
         532               0 : void _MD_unix_map_sendto_error(int err)
         533                 : {
         534               0 :     _MD_unix_map_default_error(err);
         535               0 : }
         536                 :
         537               0 : void _MD_unix_map_writev_error(int err)
         538                 : {
         539               0 :     _MD_unix_map_default_error(err);
         540               0 : }
         541                 :
         542               0 : void _MD_unix_map_accept_error(int err)
         543                 : {
         544                 :     PRErrorCode prError;
         545                 :
         546               0 :     switch (err) {
         547                 :         case ENODEV:
         548               0 :             prError = PR_NOT_TCP_SOCKET_ERROR;
         549                 :             break;
         550                 :         default:
         551               0 :             _MD_unix_map_default_error(err);
         552               0 :             return;
         553                 :     }
         554               0 :     PR_SetError(prError, err);
         555                 : }
         556                 :
         557               0 : void _MD_unix_map_connect_error(int err)
         558                 : {
         559                 :     PRErrorCode prError;
         560                 :
         561               0 :     switch (err) {
         562                 :         case EACCES:
         563               0 :             prError = PR_ADDRESS_NOT_SUPPORTED_ERROR;
         564               0 :             break;
         565                 : #if defined(UNIXWARE) || defined(SNI) || defined(NEC)
         566                 :         /*
         567                 :          * On some platforms, if we connect to a port on the local host
         568                 :          * (the loopback address) that no process is listening on, we get
         569                 :          * EIO instead of ECONNREFUSED.
         570                 :          */
         571                 :         case EIO:
         572                 :             prError = PR_CONNECT_REFUSED_ERROR;
         573                 :             break;
         574                 : #endif
         575                 :         case ELOOP:
         576               0 :             prError = PR_ADDRESS_NOT_SUPPORTED_ERROR;
         577               0 :             break;
         578                 :         case ENOENT:
         579               0 :             prError = PR_ADDRESS_NOT_SUPPORTED_ERROR;
         580               0 :             break;
         581                 :         case ENXIO:
         582               0 :             prError = PR_IO_ERROR;
         583               0 :             break;
         584                 :         default:
         585               0 :             _MD_unix_map_default_error(err);
         586               0 :             return;
         587                 :     }
         588               0 :     PR_SetError(prError, err);
         589                 : }
         590                 :
         591               0 : void _MD_unix_map_bind_error(int err)
         592                 : {
         593                 :     PRErrorCode prError;
         594                 :
         595               0 :     switch (err) {
         596                 :         case EINVAL:
         597               0 :             prError = PR_SOCKET_ADDRESS_IS_BOUND_ERROR;
         598               0 :             break;
         599                 :         /*
         600                 :          * UNIX domain sockets are not supported in NSPR
         601                 :          */
         602                 :         case EIO:
         603                 :         case EISDIR:
         604                 :         case ELOOP:
         605                 :         case ENOENT:
         606                 :         case ENOTDIR:
         607                 :         case EROFS:
         608               0 :             prError = PR_ADDRESS_NOT_SUPPORTED_ERROR;
         609               0 :             break;
         610                 :         default:
         611               0 :             _MD_unix_map_default_error(err);
         612               0 :             return;
         613                 :     }
         614               0 :     PR_SetError(prError, err);
         615                 : }
         616                 :
         617               0 : void _MD_unix_map_listen_error(int err)
         618                 : {
         619               0 :     _MD_unix_map_default_error(err);
         620               0 : }
         621                 :
         622               0 : void _MD_unix_map_shutdown_error(int err)
         623                 : {
         624               0 :     _MD_unix_map_default_error(err);
         625               0 : }
         626                 :
         627               0 : void _MD_unix_map_socketpair_error(int err)
         628                 : {
         629                 :     PRErrorCode prError;
         630                 :
         631               0 :     switch (err) {
         632                 :         case ENOMEM:
         633               0 :             prError = PR_INSUFFICIENT_RESOURCES_ERROR;
         634                 :             break;
         635                 :         default:
         636               0 :             _MD_unix_map_default_error(err);
         637               0 :             return;
         638                 :     }
         639               0 :     PR_SetError(prError, err);
         640                 : }
         641                 :
         642               0 : void _MD_unix_map_getsockname_error(int err)
         643                 : {
         644                 :     PRErrorCode prError;
         645                 :
         646               0 :     switch (err) {
         647                 :         case ENOMEM:
         648               0 :             prError = PR_INSUFFICIENT_RESOURCES_ERROR;
         649                 :             break;
         650                 :         default:
         651               0 :             _MD_unix_map_default_error(err);
         652               0 :             return;
         653                 :     }
         654               0 :     PR_SetError(prError, err);
         655                 : }
         656                 :
         657               0 : void _MD_unix_map_getpeername_error(int err)
         658                 : {
         659                 :     PRErrorCode prError;
         660                 :
         661               0 :     switch (err) {
         662                 :         case ENOMEM:
         663               0 :             prError = PR_INSUFFICIENT_RESOURCES_ERROR;
         664                 :             break;
         665                 :         default:
         666               0 :             _MD_unix_map_default_error(err);
         667               0 :             return;
         668                 :     }
         669               0 :     PR_SetError(prError, err);
         670                 : }
         671                 :
         672               0 : void _MD_unix_map_getsockopt_error(int err)
         673                 : {
         674                 :     PRErrorCode prError;
         675                 :
         676               0 :     switch (err) {
         677                 :         case EINVAL:
         678               0 :             prError = PR_BUFFER_OVERFLOW_ERROR;
         679               0 :             break;
         680                 :         case ENOMEM:
         681               0 :             prError = PR_INSUFFICIENT_RESOURCES_ERROR;
         682               0 :             break;
         683                 :         default:
         684               0 :             _MD_unix_map_default_error(err);
         685               0 :             return;
         686                 :     }
         687               0 :     PR_SetError(prError, err);
         688                 : }
         689                 :
         690               0 : void _MD_unix_map_setsockopt_error(int err)
         691                 : {
         692                 :     PRErrorCode prError;
         693                 :
         694               0 :     switch (err) {
         695                 :         case EINVAL:
         696               0 :             prError = PR_BUFFER_OVERFLOW_ERROR;
         697               0 :             break;
         698                 :         case ENOMEM:
         699               0 :             prError = PR_INSUFFICIENT_RESOURCES_ERROR;
         700               0 :             break;
         701                 :         default:
         702               0 :             _MD_unix_map_default_error(err);
         703               0 :             return;
         704                 :     }
         705               0 :     PR_SetError(prError, err);
         706                 : }
         707                 :
         708               0 : void _MD_unix_map_open_error(int err)
         709                 : {
         710                 :     PRErrorCode prError;
         711                 :
         712               0 :     switch (err) {
         713                 :         case EAGAIN:
         714               0 :             prError = PR_INSUFFICIENT_RESOURCES_ERROR;
         715               0 :             break;
         716                 :         case EBUSY:
         717               0 :             prError = PR_IO_ERROR;
         718               0 :             break;
         719                 :         case ENODEV:
         720               0 :             prError = PR_FILE_NOT_FOUND_ERROR;
         721               0 :             break;
         722                 :         case ENOMEM:
         723               0 :             prError = PR_INSUFFICIENT_RESOURCES_ERROR;
         724               0 :             break;
         725                 : #ifdef EOVERFLOW
         726                 :         case EOVERFLOW:
         727               0 :             prError = PR_FILE_TOO_BIG_ERROR;
         728               0 :             break;
         729                 : #endif
         730                 :         case ETIMEDOUT:
         731               0 :             prError = PR_REMOTE_FILE_ERROR;
         732               0 :             break;
         733                 :         default:
         734               0 :             _MD_unix_map_default_error(err);
         735               0 :             return;
         736                 :     }
         737               0 :     PR_SetError(prError, err);
         738                 : }
         739                 :
         740               0 : void _MD_unix_map_mmap_error(int err)
         741                 : {
         742                 :     PRErrorCode prError;
         743                 :
         744               0 :     switch (err) {
         745                 :         case EAGAIN:
         746               0 :             prError = PR_INSUFFICIENT_RESOURCES_ERROR;
         747               0 :             break;
         748                 :         case EMFILE:
         749               0 :             prError = PR_INSUFFICIENT_RESOURCES_ERROR;
         750               0 :             break;
         751                 :         case ENODEV:
         752               0 :             prError = PR_OPERATION_NOT_SUPPORTED_ERROR;
         753               0 :             break;
         754                 :         case ENXIO:
         755               0 :             prError = PR_INVALID_ARGUMENT_ERROR;
         756               0 :             break;
         757                 :         default:
         758               0 :             _MD_unix_map_default_error(err);
         759               0 :             return;
         760                 :     }
         761               0 :     PR_SetError(prError, err);
         762                 : }
         763                 :
         764               0 : void _MD_unix_map_gethostname_error(int err)
         765                 : {
         766               0 :     _MD_unix_map_default_error(err);
         767               0 : }
         768                 :
         769               0 : void _MD_unix_map_select_error(int err)
         770                 : {
         771               0 :     _MD_unix_map_default_error(err);
         772               0 : }
         773                 :
         774                 : #if defined(_PR_POLL_AVAILABLE) || defined(_PR_NEED_FAKE_POLL)
         775               0 : void _MD_unix_map_poll_error(int err)
         776                 : {
         777                 :     PRErrorCode prError;
         778                 :
         779               0 :     switch (err) {
         780                 :         case EAGAIN:
         781               0 :             prError = PR_INSUFFICIENT_RESOURCES_ERROR;
         782                 :             break;
         783                 :         default:
         784               0 :             _MD_unix_map_default_error(err);
         785               0 :             return;
         786                 :     }
         787               0 :     PR_SetError(prError, err);
         788                 : }
         789                 :
         790               0 : void _MD_unix_map_poll_revents_error(int err)
         791                 : {
         792               0 :     if (err & POLLNVAL)
         793               0 :         PR_SetError(PR_BAD_DESCRIPTOR_ERROR, EBADF);
         794               0 :     else if (err & POLLHUP)
         795               0 :         PR_SetError(PR_CONNECT_RESET_ERROR, EPIPE);
         796               0 :     else if (err & POLLERR)
         797               0 :         PR_SetError(PR_IO_ERROR, EIO);
         798                 :     else
         799               0 :         PR_SetError(PR_UNKNOWN_ERROR, err);
         800               0 : }
         801                 : #endif /* _PR_POLL_AVAILABLE || _PR_NEED_FAKE_POLL */
         802                 :
         803                 :
         804               0 : void _MD_unix_map_flock_error(int err)
         805                 : {
         806                 :     PRErrorCode prError;
         807                 :
         808               0 :     switch (err) {
         809                 :         case EINVAL:
         810               0 :             prError = PR_BAD_DESCRIPTOR_ERROR;
         811               0 :             break;
         812                 :         case EWOULDBLOCK:
         813               0 :             prError = PR_FILE_IS_LOCKED_ERROR;
         814               0 :             break;
         815                 :         default:
         816               0 :             _MD_unix_map_default_error(err);
         817               0 :             return;
         818                 :     }
         819               0 :     PR_SetError(prError, err);
         820                 : }
         821                 :
         822               0 : void _MD_unix_map_lockf_error(int err)
         823                 : {
         824                 :     PRErrorCode prError;
         825                 :
         826               0 :     switch (err) {
         827                 :         case EACCES:
         828               0 :             prError = PR_FILE_IS_LOCKED_ERROR;
         829               0 :             break;
         830                 :         case EDEADLK:
         831               0 :             prError = PR_INSUFFICIENT_RESOURCES_ERROR;
         832               0 :             break;
         833                 :         default:
         834               0 :             _MD_unix_map_default_error(err);
         835               0 :             return;
         836                 :     }
         837               0 :     PR_SetError(prError, err);
         838                 : }
         839                 :
         840                 : #ifdef AIX
         841                 : void _MD_aix_map_sendfile_error(int err)
         842                 : {
         843                 :     _MD_unix_map_default_error(err);
         844                 : }
         845                 : #endif /* AIX */
         846                 :
         847                 : #ifdef HPUX11
         848                 : void _MD_hpux_map_sendfile_error(int err)
         849                 : {
         850                 :     _MD_unix_map_default_error(err);
         851                 : }
         852                 : #endif /* HPUX11 */
         853                 :
         854                 : #ifdef SOLARIS
         855                 : void _MD_solaris_map_sendfile_error(int err)
         856                 : {
         857                 :     PRErrorCode prError;
         858                 :
         859                 :     switch (err) {
         860                 :         /*
         861                 :          * Solaris defines a 0 return value for sendfile to mean end-of-file.
         862                 :          */
         863                 :         case 0:
         864                 :             prError = PR_END_OF_FILE_ERROR;
         865                 :             break;
         866                 :
         867                 :         default:
         868                 :             _MD_unix_map_default_error(err) ;
         869                 :             return;
         870                 :     }
         871                 :     PR_SetError(prError, err);
         872                 : }
         873                 : #endif /* SOLARIS */
         874                 :
         875                 : #ifdef LINUX
         876               0 : void _MD_linux_map_sendfile_error(int err)
         877                 : {
         878               0 :     _MD_unix_map_default_error(err) ;
         879               0 : }
         880                 : #endif /* LINUX */

Generated by: LCOV version 1.7