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 47 11.9 %
Date: 2012-06-02 Functions: 42 8 19.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           11901 : void _MD_unix_map_default_error(int err)
      45                 : {
      46                 :     PRErrorCode prError;
      47                 : 
      48           11901 :     switch (err ) {
      49                 :         case EACCES:
      50               0 :             prError = PR_NO_ACCESS_RIGHTS_ERROR;
      51               0 :             break;
      52                 :         case EADDRINUSE:
      53               1 :             prError = PR_ADDRESS_IN_USE_ERROR;
      54               1 :             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            6381 :             prError = PR_WOULD_BLOCK_ERROR;
      63            6381 :             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             136 :             prError = PR_CONNECT_REFUSED_ERROR;
      88             136 :             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            1531 :             prError = PR_FILE_EXISTS_ERROR;
     107            1531 :             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            3006 :             prError = PR_IN_PROGRESS_ERROR;
     119            3006 :             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             835 :             prError = PR_FILE_NOT_FOUND_ERROR;
     174             835 :             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               8 :             prError = PR_NOT_CONNECTED_ERROR;
     202               8 :             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               3 :             prError = PR_CONNECT_RESET_ERROR;
     225               3 :             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           11901 :     PR_SetError(prError, err);
     262           11901 : }
     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            6365 : void _MD_unix_map_recv_error(int err)
     518                 : {
     519            6365 :     _MD_unix_map_default_error(err);
     520            6365 : }
     521                 : 
     522               0 : void _MD_unix_map_recvfrom_error(int err)
     523                 : {
     524               0 :     _MD_unix_map_default_error(err);
     525               0 : }
     526                 : 
     527              19 : void _MD_unix_map_send_error(int err)
     528                 : {
     529              19 :     _MD_unix_map_default_error(err);
     530              19 : }
     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            3142 : void _MD_unix_map_connect_error(int err)
     558                 : {
     559                 :     PRErrorCode prError;
     560                 : 
     561            3142 :     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            3142 :             _MD_unix_map_default_error(err);
     586            3142 :             return;
     587                 :     }
     588               0 :     PR_SetError(prError, err);
     589                 : }
     590                 : 
     591               1 : void _MD_unix_map_bind_error(int err)
     592                 : {
     593                 :     PRErrorCode prError;
     594                 : 
     595               1 :     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               1 :             _MD_unix_map_default_error(err);
     612               1 :             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               8 : void _MD_unix_map_getpeername_error(int err)
     658                 : {
     659                 :     PRErrorCode prError;
     660                 : 
     661               8 :     switch (err) {
     662                 :         case ENOMEM:
     663               0 :             prError = PR_INSUFFICIENT_RESOURCES_ERROR;
     664                 :             break;
     665                 :         default:
     666               8 :             _MD_unix_map_default_error(err);
     667               8 :             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            2366 : void _MD_unix_map_open_error(int err)
     709                 : {
     710                 :     PRErrorCode prError;
     711                 : 
     712            2366 :     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            2366 :             _MD_unix_map_default_error(err);
     735            2366 :             return;
     736                 :     }
     737               0 :     PR_SetError(prError, err);
     738                 : }
     739                 : 
     740               1 : void _MD_unix_map_mmap_error(int err)
     741                 : {
     742                 :     PRErrorCode prError;
     743                 : 
     744               1 :     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               1 :             prError = PR_OPERATION_NOT_SUPPORTED_ERROR;
     753               1 :             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               1 :     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