Back to index

lightning-sunbird  0.9+nobinonly
beos_errors.c
Go to the documentation of this file.
00001 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
00002 /* ***** BEGIN LICENSE BLOCK *****
00003  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
00004  *
00005  * The contents of this file are subject to the Mozilla Public License Version
00006  * 1.1 (the "License"); you may not use this file except in compliance with
00007  * the License. You may obtain a copy of the License at
00008  * http://www.mozilla.org/MPL/
00009  *
00010  * Software distributed under the License is distributed on an "AS IS" basis,
00011  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
00012  * for the specific language governing rights and limitations under the
00013  * License.
00014  *
00015  * The Original Code is the Netscape Portable Runtime (NSPR).
00016  *
00017  * The Initial Developer of the Original Code is
00018  * Netscape Communications Corporation.
00019  * Portions created by the Initial Developer are Copyright (C) 1998-2000
00020  * the Initial Developer. All Rights Reserved.
00021  *
00022  * Contributor(s):
00023  *
00024  * Alternatively, the contents of this file may be used under the terms of
00025  * either the GNU General Public License Version 2 or later (the "GPL"), or
00026  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
00027  * in which case the provisions of the GPL or the LGPL are applicable instead
00028  * of those above. If you wish to allow use of your version of this file only
00029  * under the terms of either the GPL or the LGPL, and not to allow others to
00030  * use your version of this file under the terms of the MPL, indicate your
00031  * decision by deleting the provisions above and replace them with the notice
00032  * and other provisions required by the GPL or the LGPL. If you do not delete
00033  * the provisions above, a recipient may use your version of this file under
00034  * the terms of any one of the MPL, the GPL or the LGPL.
00035  *
00036  * ***** END LICENSE BLOCK ***** */
00037 
00038 #include "prtypes.h"
00039 #include "md/_unix_errors.h"
00040 #include "prerror.h"
00041 #include <errno.h>
00042 
00043 void _MD_unix_map_opendir_error(int err)
00044 {
00045        switch (err) {
00046               case ENOTDIR:
00047                      PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
00048                      break;
00049               case EACCES:
00050                      PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
00051                      break;
00052               case EMFILE:
00053                      PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
00054                      break;
00055               case ENFILE:
00056                      PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
00057                      break;
00058               case EFAULT:
00059                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
00060                      break;
00061               case ELOOP:
00062                      PR_SetError(PR_LOOP_ERROR, err);
00063                      break;
00064               case ENAMETOOLONG:
00065                      PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
00066                      break;
00067               case ENOENT:
00068                      PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
00069                      break;
00070               default:
00071                      PR_SetError(PR_UNKNOWN_ERROR, err);
00072                      break;
00073        }
00074 }
00075 
00076 void _MD_unix_map_closedir_error(int err)
00077 {
00078        switch (err) {
00079               case EINVAL:
00080               case EBADF:
00081                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
00082                      break;
00083               default:
00084                      PR_SetError(PR_UNKNOWN_ERROR, err);
00085                      break;
00086        }
00087 }
00088 
00089 void _MD_unix_readdir_error(int err)
00090 {
00091 
00092        switch (err) {
00093               case 0:
00094               case ENOENT:
00095                      PR_SetError(PR_NO_MORE_FILES_ERROR, err);
00096                      break;
00097               case EBADF:
00098                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
00099                      break;
00100 #ifdef IRIX
00101 #ifdef IRIX5_3
00102 #else
00103               case EDIRCORRUPTED:
00104                      PR_SetError(PR_DIRECTORY_CORRUPTED_ERROR, err);
00105                      break;
00106 #endif
00107 #endif
00108 #ifdef EOVERFLOW
00109               case EOVERFLOW:
00110                      PR_SetError(PR_IO_ERROR, err);
00111                      break;
00112 #endif
00113               case EINVAL:
00114                      PR_SetError(PR_IO_ERROR, err);
00115                      break;
00116 #ifdef EBADMSG
00117               case EBADMSG:
00118                      PR_SetError(PR_IO_ERROR, err);
00119                      break;
00120 #endif
00121               case EDEADLK:
00122                      PR_SetError(PR_DEADLOCK_ERROR, err);
00123                      break;
00124               case EFAULT:
00125                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
00126                      break;
00127               case EINTR:
00128                      PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
00129                      break;
00130               case EIO:
00131                      PR_SetError(PR_IO_ERROR, err);
00132                      break;
00133               case ENOLCK:
00134                      PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
00135                      break;
00136 #ifdef ENOLINK
00137               case ENOLINK:
00138                      PR_SetError(PR_REMOTE_FILE_ERROR, err);
00139                      break;
00140 #endif
00141               case ENXIO:
00142                      PR_SetError(PR_IO_ERROR, err);
00143                      break;
00144               default:
00145                      PR_SetError(PR_UNKNOWN_ERROR, err);
00146                      break;
00147        }
00148 }
00149 
00150 void _MD_unix_map_unlink_error(int err)
00151 {
00152        switch (err) {
00153               case EACCES:
00154                      PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
00155                      break;
00156               case EBUSY:
00157                      PR_SetError(PR_FILESYSTEM_MOUNTED_ERROR, err);
00158                      break;
00159               case EFAULT:
00160                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
00161                      break;
00162               case EINTR:
00163                      PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
00164                      break;
00165               case ELOOP:
00166                      PR_SetError(PR_LOOP_ERROR, err);
00167                      break;
00168               case ENAMETOOLONG:
00169                      PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
00170                      break;
00171               case ENOENT:
00172                      PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
00173                      break;
00174               case ENOTDIR:
00175                      PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
00176                      break;
00177               case EPERM:
00178                      PR_SetError(PR_IS_DIRECTORY_ERROR, err);
00179                      break;
00180               case EROFS:
00181                      PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
00182                      break;
00183               default:
00184                      PR_SetError(PR_UNKNOWN_ERROR, err);
00185                      break;
00186        }
00187 }
00188 
00189 void _MD_unix_map_stat_error(int err)
00190 {
00191        switch (err) {
00192               case EACCES:
00193                      PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
00194                      break;
00195               case EFAULT:
00196                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
00197                      break;
00198               case EINTR:
00199                      PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
00200                      break;
00201               case ETIMEDOUT:
00202                      PR_SetError(PR_REMOTE_FILE_ERROR, err);
00203                      break;
00204               case ELOOP:
00205                      PR_SetError(PR_LOOP_ERROR, err);
00206                      break;
00207               case ENAMETOOLONG:
00208                      PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
00209                      break;
00210               case ENOENT:
00211                      PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
00212                      break;
00213               case ENOTDIR:
00214                      PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
00215                      break;
00216 #ifdef EOVERFLOW
00217               case EOVERFLOW:
00218                      PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
00219                      break;
00220 #endif
00221               default:
00222                      PR_SetError(PR_UNKNOWN_ERROR, err);
00223                      break;
00224        }
00225 }
00226 
00227 void _MD_unix_map_fstat_error(int err)
00228 {
00229        switch (err) {
00230               case EBADF:
00231                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
00232                      break;
00233               case EFAULT:
00234                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
00235                      break;
00236               case EINTR:
00237                      PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
00238                      break;
00239               case ETIMEDOUT:
00240 #ifdef ENOLINK
00241               case ENOLINK:
00242 #endif
00243                      PR_SetError(PR_REMOTE_FILE_ERROR, err);
00244                      break;
00245 #ifdef EOVERFLOW
00246               case EOVERFLOW:
00247                      PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
00248                      break;
00249 #endif
00250               default:
00251                      PR_SetError(PR_UNKNOWN_ERROR, err);
00252                      break;
00253        }
00254 }
00255 
00256 void _MD_unix_map_rename_error(int err)
00257 {
00258        switch (err) {
00259               case EACCES:
00260                      PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
00261                      break;
00262               case EBUSY:
00263                      PR_SetError(PR_FILESYSTEM_MOUNTED_ERROR, err);
00264                      break;
00265 #ifdef EDQUOT
00266               case EDQUOT:
00267                      PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
00268                      break;
00269 #endif
00270               case EEXIST:
00271                      PR_SetError(PR_DIRECTORY_NOT_EMPTY_ERROR, err);
00272                      break;
00273               case EFAULT:
00274                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
00275                      break;
00276               case EINTR:
00277                      PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
00278                      break;
00279               case EINVAL:
00280                      PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
00281                      break;
00282               case EIO:
00283                      PR_SetError(PR_IO_ERROR, err);
00284                      break;
00285               case EISDIR:
00286                      PR_SetError(PR_IS_DIRECTORY_ERROR, err);
00287                      break;
00288               case ELOOP:
00289                      PR_SetError(PR_LOOP_ERROR, err);
00290                      break;
00291               case ENAMETOOLONG:
00292                      PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
00293                      break;
00294               case ENOENT:
00295                      PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
00296                      break;
00297               case ENOSPC:
00298                      PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
00299                      break;
00300               case ENOTDIR:
00301                      PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
00302                      break;
00303               case EROFS:
00304                      PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
00305                      break;
00306               case EXDEV:
00307                      PR_SetError(PR_NOT_SAME_DEVICE_ERROR, err);
00308                      break;
00309               case EMLINK:
00310                      PR_SetError(PR_MAX_DIRECTORY_ENTRIES_ERROR, err);
00311                      break;
00312               default:
00313                      PR_SetError(PR_UNKNOWN_ERROR, err);
00314                      break;
00315        }
00316 }
00317 
00318 void _MD_unix_map_access_error(int err)
00319 {
00320        switch (err) {
00321               case EACCES:
00322                      PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
00323                      break;
00324               case EFAULT:
00325                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
00326                      break;
00327               case EINTR:
00328                      PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
00329                      break;
00330               case EINVAL:
00331                      PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
00332                      break;
00333               case ELOOP:
00334                      PR_SetError(PR_LOOP_ERROR, err);
00335                      break;
00336               case ETIMEDOUT:
00337                      PR_SetError(PR_REMOTE_FILE_ERROR, err);
00338                      break;
00339               case ENAMETOOLONG:
00340                      PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
00341                      break;
00342               case ENOENT:
00343                      PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
00344                      break;
00345               case ENOTDIR:
00346                      PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
00347                      break;
00348               case EROFS:
00349                      PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
00350                      break;
00351               default:
00352                      PR_SetError(PR_UNKNOWN_ERROR, err);
00353                      break;
00354        }
00355 }
00356 
00357 void _MD_unix_map_mkdir_error(int err)
00358 {
00359        switch (err) {
00360               case ENOTDIR:
00361                      PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
00362                      break;
00363               case ENOENT:
00364                      PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
00365                      break;
00366               case ENAMETOOLONG:
00367                      PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
00368                      break;
00369               case EACCES:
00370                      PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
00371                      break;
00372               case EEXIST:
00373                      PR_SetError(PR_FILE_EXISTS_ERROR, err);
00374                      break;
00375               case EROFS:
00376                      PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
00377                      break;
00378               case EFAULT:
00379                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
00380                      break;
00381               case ELOOP:
00382                      PR_SetError(PR_LOOP_ERROR, err);
00383                      break;
00384               case EMLINK:
00385                      PR_SetError(PR_MAX_DIRECTORY_ENTRIES_ERROR, err);
00386                      break;
00387               case ENOSPC:
00388                      PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
00389                      break;
00390 #ifdef EDQUOT
00391               case EDQUOT:
00392                      PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
00393                      break;
00394 #endif
00395               case EIO:
00396                      PR_SetError(PR_IO_ERROR, err);
00397                      break;
00398               default:
00399                      PR_SetError(PR_UNKNOWN_ERROR, err);
00400                      break;
00401        }
00402 }
00403 
00404 void _MD_unix_map_rmdir_error(int err)
00405 {
00406 
00407        switch (err) {
00408               case EACCES:
00409                      PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
00410                      break;
00411               case EBUSY:
00412                      PR_SetError(PR_FILESYSTEM_MOUNTED_ERROR, err);
00413                      break;
00414               case EEXIST:
00415                      PR_SetError(PR_DIRECTORY_NOT_EMPTY_ERROR, err);
00416                      break;
00417               case EFAULT:
00418                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
00419                      break;
00420               case EINVAL:
00421                      PR_SetError(PR_DIRECTORY_NOT_EMPTY_ERROR, err);
00422                      break;
00423               case EIO:
00424                      PR_SetError(PR_IO_ERROR, err);
00425                      break;
00426               case ELOOP:
00427                      PR_SetError(PR_LOOP_ERROR, err);
00428                      break;
00429               case ETIMEDOUT:
00430                      PR_SetError(PR_REMOTE_FILE_ERROR, err);
00431                      break;
00432               case ENAMETOOLONG:
00433                      PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
00434                      break;
00435               case ENOENT:
00436                      PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
00437                      break;
00438               case ENOTDIR:
00439                      PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
00440                      break;
00441               case EROFS:
00442                      PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
00443                      break;
00444               default:
00445                      PR_SetError(PR_UNKNOWN_ERROR, err);
00446                      break;
00447        }
00448 }
00449 
00450 void _MD_unix_map_read_error(int err)
00451 {
00452        switch (err) {
00453               case EACCES:
00454                      PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
00455                      break;
00456               case EAGAIN:
00457 #if EWOULDBLOCK != EAGAIN
00458               case EWOULDBLOCK:
00459 #endif
00460                      PR_SetError(PR_WOULD_BLOCK_ERROR, err);
00461                      break;
00462               case EBADF:
00463                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
00464                      break;
00465 #ifdef EBADMSG
00466               case EBADMSG:
00467                      PR_SetError(PR_IO_ERROR, err);
00468                      break;
00469 #endif
00470               case EDEADLK:
00471                      PR_SetError(PR_DEADLOCK_ERROR, err);
00472                      break;
00473               case EFAULT:
00474                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
00475                      break;
00476               case EINTR:
00477                      PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
00478                      break;
00479               case EINVAL:
00480                      PR_SetError(PR_INVALID_METHOD_ERROR, err);
00481                      break;
00482               case EIO:
00483                      PR_SetError(PR_IO_ERROR, err);
00484                      break;
00485               case ENOLCK:
00486                      PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
00487                      break;
00488               case ENXIO:
00489                      PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
00490                      break;
00491               case EISDIR:
00492                      PR_SetError(PR_IS_DIRECTORY_ERROR, err);
00493                      break;
00494               case ECONNRESET:
00495               case EPIPE:
00496                      PR_SetError(PR_CONNECT_RESET_ERROR, err);
00497                      break;
00498 #ifdef ENOLINK
00499               case ENOLINK:
00500                      PR_SetError(PR_REMOTE_FILE_ERROR, err);
00501                      break;
00502 #endif
00503               default:
00504                      PR_SetError(PR_UNKNOWN_ERROR, err);
00505                      break;
00506        }
00507 }
00508 
00509 void _MD_unix_map_write_error(int err)
00510 {
00511        switch (err) {
00512               case EAGAIN:
00513 #if EWOULDBLOCK != EAGAIN
00514               case EWOULDBLOCK:
00515 #endif
00516                      PR_SetError(PR_WOULD_BLOCK_ERROR, err);
00517                      break;
00518               case EBADF:
00519                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
00520                      break;
00521               case EDEADLK:
00522                      PR_SetError(PR_DEADLOCK_ERROR, err);
00523                      break;
00524               case EFAULT:
00525                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
00526                      break;
00527               case EFBIG:
00528                      PR_SetError(PR_FILE_TOO_BIG_ERROR, err);
00529                      break;
00530               case EINTR:
00531                      PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
00532                      break;
00533               case EINVAL:
00534                      PR_SetError(PR_INVALID_METHOD_ERROR, err);
00535                      break;
00536               case EIO:
00537                      PR_SetError(PR_IO_ERROR, err);
00538                      break;
00539               case ENOLCK:
00540                      PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
00541                      break;
00542 #ifdef ENOSR
00543               case ENOSR:
00544                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
00545                      break;
00546 #endif
00547               case ENOSPC:
00548                      PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
00549                      break;
00550               case ENXIO:
00551                      PR_SetError(PR_INVALID_METHOD_ERROR, err);
00552                      break;
00553               case ERANGE:
00554                      PR_SetError(PR_INVALID_METHOD_ERROR, err);
00555                      break;
00556               case ETIMEDOUT:
00557                      PR_SetError(PR_REMOTE_FILE_ERROR, err);
00558                      break;
00559               case ECONNRESET:
00560               case EPIPE:
00561                      PR_SetError(PR_CONNECT_RESET_ERROR, err);
00562                      break;
00563 #ifdef EDQUOT
00564               case EDQUOT:
00565                      PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
00566                      break;
00567 #endif
00568 #ifdef ENOLINK
00569               case ENOLINK:
00570                      PR_SetError(PR_REMOTE_FILE_ERROR, err);
00571                      break;
00572 #endif
00573               default:
00574                      PR_SetError(PR_UNKNOWN_ERROR, err);
00575                      break;
00576        }
00577 }
00578 
00579 void _MD_unix_map_lseek_error(int err)
00580 {
00581        switch (err) {
00582               case EBADF:
00583                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
00584                      break;
00585               case ESPIPE:
00586                      PR_SetError(PR_INVALID_METHOD_ERROR, err);
00587                      break;
00588               case EINVAL:
00589                      PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
00590                      break;
00591               default:
00592                      PR_SetError(PR_UNKNOWN_ERROR, err);
00593                      break;
00594        }
00595 }
00596 
00597 void _MD_unix_map_fsync_error(int err)
00598 {
00599        switch (err) {
00600               case EBADF:
00601                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
00602                      break;
00603 #ifdef ENOLINK
00604               case ENOLINK:
00605 #endif
00606               case ETIMEDOUT:
00607                      PR_SetError(PR_REMOTE_FILE_ERROR, err);
00608                      break;
00609               case EINTR:
00610                      PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
00611                      break;
00612               case EIO:
00613                      PR_SetError(PR_IO_ERROR, err);
00614                      break;
00615               case EINVAL:
00616                      PR_SetError(PR_INVALID_METHOD_ERROR, err);
00617                      break;
00618               default:
00619                      PR_SetError(PR_UNKNOWN_ERROR, err);
00620                      break;
00621        }
00622 }
00623 
00624 void _MD_unix_map_close_error(int err)
00625 {
00626        switch (err) {
00627               case EBADF:
00628                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
00629                      break;
00630               case EINTR:
00631                      PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
00632                      break;
00633 #ifdef ENOLINK
00634               case ENOLINK:
00635 #endif
00636               case ETIMEDOUT:
00637                      PR_SetError(PR_REMOTE_FILE_ERROR, err);
00638                      break;
00639               case EIO:
00640                      PR_SetError(PR_IO_ERROR, err);
00641                      break;
00642               default:
00643                      PR_SetError(PR_UNKNOWN_ERROR, err);
00644                      break;
00645        }
00646 }
00647 
00648 void _MD_unix_map_socket_error(int err)
00649 {
00650        switch (err) {
00651               case EPROTONOSUPPORT:
00652                      PR_SetError(PR_PROTOCOL_NOT_SUPPORTED_ERROR, err);
00653                      break;
00654               case EMFILE:
00655                      PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
00656                      break;
00657               case ENFILE:
00658                      PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
00659                      break;
00660               case EACCES:
00661                      PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
00662                      break;
00663 #if !defined(SCO)
00664               case ENOBUFS:
00665 #endif /* !defined(SCO) */
00666               case ENOMEM:
00667 #ifdef ENOSR
00668               case ENOSR:
00669                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
00670                      break;
00671 #endif
00672               default:
00673                      PR_SetError(PR_UNKNOWN_ERROR, err);
00674                      break;
00675        }
00676 }
00677 
00678 void _MD_unix_map_socketavailable_error(int err)
00679 {
00680        PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
00681 }
00682 
00683 void _MD_unix_map_recv_error(int err)
00684 {
00685        switch (err) {
00686               case EAGAIN:
00687 #if EWOULDBLOCK != EAGAIN
00688               case EWOULDBLOCK:
00689 #endif
00690                      PR_SetError(PR_WOULD_BLOCK_ERROR, err);
00691                      break;
00692               case EBADF:
00693                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
00694                      break;
00695 #if !defined(BEOS)
00696               case ENOTSOCK:
00697                      PR_SetError(PR_NOT_SOCKET_ERROR, err);
00698                      break;
00699 #endif
00700               case EINTR:
00701                      PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
00702                      break;
00703               case EFAULT:
00704                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
00705                      break;
00706               case ENOMEM:
00707                      PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
00708                      break;
00709               case ECONNRESET:
00710               case EPIPE:
00711                      PR_SetError(PR_CONNECT_RESET_ERROR, err);
00712                      break;
00713 #ifdef ENOSR
00714               case ENOSR:
00715                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
00716                      break;
00717 #endif
00718               default:
00719                      PR_SetError(PR_UNKNOWN_ERROR, err);
00720                      break;
00721        }
00722 }
00723 
00724 void _MD_unix_map_recvfrom_error(int err)
00725 {
00726        switch (err) {
00727               case EAGAIN:
00728 #if EWOULDBLOCK != EAGAIN
00729               case EWOULDBLOCK:
00730 #endif
00731                      PR_SetError(PR_WOULD_BLOCK_ERROR, err);
00732                      break;
00733               case EBADF:
00734                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
00735                      break;
00736 #if !defined(BEOS)
00737               case ENOTSOCK:
00738                      PR_SetError(PR_NOT_SOCKET_ERROR, err);
00739                      break;
00740 #endif
00741               case EINTR:
00742                      PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
00743                      break;
00744               case EFAULT:
00745                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
00746                      break;
00747               case ENOMEM:
00748                      PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
00749                      break;
00750 #ifdef ENOSR
00751               case ENOSR:
00752                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
00753                      break;
00754 #endif
00755               case ECONNRESET:
00756                      PR_SetError(PR_CONNECT_RESET_ERROR, err);
00757                      break;
00758               default:
00759                      PR_SetError(PR_UNKNOWN_ERROR, err);
00760                      break;
00761        }
00762 }
00763 
00764 void _MD_unix_map_send_error(int err)
00765 {
00766        switch (err) {
00767               case EAGAIN:
00768 #if EWOULDBLOCK != EAGAIN
00769               case EWOULDBLOCK:
00770 #endif
00771                      PR_SetError(PR_WOULD_BLOCK_ERROR, err);
00772                      break;
00773               case EBADF:
00774                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
00775                      break;
00776 #if !defined(BEOS)
00777               case ENOTSOCK:
00778                      PR_SetError(PR_NOT_SOCKET_ERROR, err);
00779                      break;
00780 #endif
00781 #if !defined(BEOS)
00782               case EMSGSIZE:
00783 #endif
00784               case EINVAL:
00785                      PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
00786                      break;
00787 #if !defined(SCO)
00788               case ENOBUFS:
00789                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
00790                      break;
00791 #endif /* !defined(SCO) */
00792               case ECONNREFUSED:
00793                      PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
00794                      break;
00795               case EISCONN:
00796                      PR_SetError(PR_IS_CONNECTED_ERROR, err);
00797                      break;
00798               case EFAULT:
00799                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
00800                      break;
00801               case EINTR:
00802                      PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
00803                      break;
00804               case ENOMEM:
00805                      PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
00806                      break;
00807 #ifdef ENOSR
00808               case ENOSR:
00809                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
00810                      break;
00811 #endif
00812               case ECONNRESET:
00813               case EPIPE:
00814                      PR_SetError(PR_CONNECT_RESET_ERROR, err);
00815                      break;
00816               default:
00817                      PR_SetError(PR_UNKNOWN_ERROR, err);
00818                      break;
00819        }
00820 }
00821 
00822 void _MD_unix_map_sendto_error(int err)
00823 {
00824        switch (err) {
00825               case EAGAIN:
00826 #if EWOULDBLOCK != EAGAIN
00827               case EWOULDBLOCK:
00828 #endif
00829                      PR_SetError(PR_WOULD_BLOCK_ERROR, err);
00830                      break;
00831               case EBADF:
00832                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
00833                      break;
00834 #if !defined(BEOS)
00835               case ENOTSOCK:
00836                      PR_SetError(PR_NOT_SOCKET_ERROR, err);
00837                      break;
00838 #endif
00839 #if !defined(BEOS)
00840               case EMSGSIZE:
00841 #endif
00842               case EINVAL:
00843                      PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
00844                      break;
00845 #if !defined(SCO)
00846               case ENOBUFS:
00847                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
00848                      break;
00849 #endif /* !defined(SCO) */
00850               case ECONNREFUSED:
00851                      PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
00852                      break;
00853               case EISCONN:
00854                      PR_SetError(PR_IS_CONNECTED_ERROR, err);
00855                      break;
00856               case EFAULT:
00857                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
00858                      break;
00859               case EINTR:
00860                      PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
00861                      break;
00862               case ENOMEM:
00863                      PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
00864                      break;
00865 #ifdef ENOSR
00866               case ENOSR:
00867                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
00868                      break;
00869 #endif
00870               case ECONNRESET:
00871               case EPIPE:
00872                      PR_SetError(PR_CONNECT_RESET_ERROR, err);
00873                      break;
00874               default:
00875                      PR_SetError(PR_UNKNOWN_ERROR, err);
00876                      break;
00877        }
00878 }
00879 
00880 void _MD_unix_map_writev_error(int err)
00881 {
00882        switch (err) {
00883               case EAGAIN:
00884 #if EWOULDBLOCK != EAGAIN
00885               case EWOULDBLOCK:
00886 #endif
00887                      PR_SetError(PR_WOULD_BLOCK_ERROR, err);
00888                      break;
00889               case EBADF:
00890                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
00891                      break;
00892               case EFAULT:
00893                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
00894                      break;
00895               case EINTR:
00896                      PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
00897                      break;
00898 #ifdef ENOSR
00899               case ENOSR:
00900                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
00901                      break;
00902 #endif
00903               case EINVAL:
00904                      PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
00905                      break;
00906               case ECONNRESET:
00907               case EPIPE:
00908                      PR_SetError(PR_CONNECT_RESET_ERROR, err);
00909                      break;
00910               default:
00911                      PR_SetError(PR_UNKNOWN_ERROR, err);
00912                      break;
00913        }
00914 }
00915 
00916 void _MD_unix_map_accept_error(int err)
00917 {
00918        switch (err) {
00919               case EAGAIN:
00920 #if EWOULDBLOCK != EAGAIN
00921               case EWOULDBLOCK:
00922 #endif
00923                      PR_SetError(PR_WOULD_BLOCK_ERROR, err);
00924                      break;
00925               case EBADF:
00926                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
00927                      break;
00928 #if !defined(BEOS)
00929               case ENOTSOCK:
00930                      PR_SetError(PR_NOT_SOCKET_ERROR, err);
00931                      break;
00932 #endif
00933 #if !defined(BEOS)
00934               case EOPNOTSUPP:
00935 #endif
00936               case ENODEV:
00937                      PR_SetError(PR_NOT_TCP_SOCKET_ERROR, err);
00938                      break;
00939               case EFAULT:
00940                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
00941                      break;
00942               case EMFILE:
00943                      PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
00944                      break;
00945               case ENFILE:
00946                      PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
00947                      break;
00948               case EINTR:
00949                      PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
00950                      break;
00951               case ENOMEM:
00952                      PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
00953                      break;
00954 #ifdef ENOSR
00955               case ENOSR:
00956                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
00957                      break;
00958 #endif
00959 #ifdef EPROTO
00960               case EPROTO:
00961                      PR_SetError(PR_IO_ERROR, err);
00962                      break;
00963 #endif
00964               default:
00965                      PR_SetError(PR_UNKNOWN_ERROR, err);
00966                      break;
00967        }
00968 }
00969 
00970 void _MD_unix_map_connect_error(int err)
00971 {
00972        switch (err) {
00973               case EBADF:
00974                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
00975                      break;
00976               case EADDRNOTAVAIL:
00977                      PR_SetError(PR_ADDRESS_NOT_AVAILABLE_ERROR, err);
00978                      break;
00979               case EINPROGRESS:
00980                      PR_SetError(PR_IN_PROGRESS_ERROR, err);
00981                      break;
00982               case EALREADY:
00983                      PR_SetError(PR_ALREADY_INITIATED_ERROR, err);
00984                      break;
00985 #if !defined(BEOS)
00986               case ENOTSOCK:
00987                      PR_SetError(PR_NOT_SOCKET_ERROR, err);
00988                      break;
00989 #endif
00990               case EAFNOSUPPORT:
00991                      PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
00992                      break;
00993               case EISCONN:
00994                      PR_SetError(PR_IS_CONNECTED_ERROR, err);
00995                      break;
00996               case ETIMEDOUT:
00997                      PR_SetError(PR_IO_TIMEOUT_ERROR, err);
00998                      break;
00999               case ECONNREFUSED:
01000                      PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
01001                      break;
01002               case ENETUNREACH:
01003                      PR_SetError(PR_NETWORK_UNREACHABLE_ERROR, err);
01004                      break;
01005               case EADDRINUSE:
01006                      PR_SetError(PR_ADDRESS_IN_USE_ERROR, err);
01007                      break;
01008               case EFAULT:
01009                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
01010                      break;
01011               /*
01012                * UNIX domain sockets are not supported in NSPR
01013                */
01014               case EACCES:
01015                      PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
01016                      break;
01017               case EINTR:
01018                      PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
01019                      break;
01020               case EINVAL:
01021                      PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
01022                      break;
01023               case EIO:
01024 #if defined(UNIXWARE) || defined(SNI) || defined(NEC)
01025                      /*
01026                       * On some platforms, if we connect to a port on
01027                       * the local host (the loopback address) that no
01028                       * process is listening on, we get EIO instead
01029                       * of ECONNREFUSED.
01030                       */
01031                      PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
01032 #else
01033                      PR_SetError(PR_IO_ERROR, err);
01034 #endif
01035                      break;
01036               case ELOOP:
01037                      PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
01038                      break;
01039               case ENOENT:
01040                      PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
01041                      break;
01042 #ifdef ENOSR
01043               case ENOSR:
01044                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
01045                      break;
01046 #endif
01047               case ENXIO:
01048                      PR_SetError(PR_IO_ERROR, err);
01049                      break;
01050               case EPROTOTYPE:
01051                      PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
01052                      break;
01053               default:
01054                      PR_SetError(PR_UNKNOWN_ERROR, err);
01055                      break;
01056        }
01057 }
01058 
01059 void _MD_unix_map_bind_error(int err)
01060 {
01061        switch (err) {
01062               case EBADF:
01063                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
01064                      break;
01065 #if !defined(BEOS)
01066               case ENOTSOCK:
01067                      PR_SetError(PR_NOT_SOCKET_ERROR, err);
01068                      break;
01069 #endif
01070               case EFAULT:
01071                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
01072                      break;
01073               case EADDRNOTAVAIL:
01074                      PR_SetError(PR_ADDRESS_NOT_AVAILABLE_ERROR, err);
01075                      break;
01076               case EADDRINUSE:
01077                      PR_SetError(PR_ADDRESS_IN_USE_ERROR, err);
01078                      break;
01079               case EACCES:
01080                      PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
01081                      break;
01082               case EINVAL:
01083                      PR_SetError(PR_SOCKET_ADDRESS_IS_BOUND_ERROR, err);
01084                      break;
01085 #ifdef ENOSR
01086               case ENOSR:
01087                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
01088                      break;
01089 #endif
01090               /*
01091                * UNIX domain sockets are not supported in NSPR
01092                */
01093               case EIO:
01094               case EISDIR:
01095               case ELOOP:
01096               case ENOENT:
01097               case ENOTDIR:
01098               case EROFS:
01099                      PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
01100                      break;
01101               default:
01102                      PR_SetError(PR_UNKNOWN_ERROR, err);
01103                      break;
01104        }
01105 }
01106 
01107 void _MD_unix_map_listen_error(int err)
01108 {
01109        switch (err) {
01110               case EBADF:
01111                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
01112                      break;
01113 #if !defined(BEOS)
01114               case ENOTSOCK:
01115                      PR_SetError(PR_NOT_SOCKET_ERROR, err);
01116                      break;
01117 #endif
01118 #if !defined(BEOS)
01119               case EOPNOTSUPP:
01120                      PR_SetError(PR_NOT_TCP_SOCKET_ERROR, err);
01121                      break;
01122 #endif
01123               default:
01124                      PR_SetError(PR_UNKNOWN_ERROR, err);
01125                      break;
01126        }
01127 }
01128 
01129 void _MD_unix_map_shutdown_error(int err)
01130 {
01131        switch (err) {
01132               case EBADF:
01133                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
01134                      break;
01135 #if !defined(BEOS)
01136               case ENOTSOCK:
01137                      PR_SetError(PR_NOT_SOCKET_ERROR, err);
01138                      break;
01139 #endif
01140               case ENOTCONN:
01141                      PR_SetError(PR_NOT_CONNECTED_ERROR, err);
01142                      break;
01143               case ENOMEM:
01144                      PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
01145                      break;
01146 #ifdef ENOSR
01147               case ENOSR:
01148                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
01149                      break;
01150 #endif
01151               default:
01152                      PR_SetError(PR_UNKNOWN_ERROR, err);
01153                      break;
01154        }
01155 }
01156 
01157 void _MD_unix_map_socketpair_error(int err)
01158 {
01159        switch (err) {
01160               case EMFILE:
01161                      PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
01162                      break;
01163               case EFAULT:
01164                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
01165                      break;
01166               case ENOMEM:
01167 #ifdef ENOSR
01168               case ENOSR:
01169 #endif
01170                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
01171                      break;
01172               case EAFNOSUPPORT:
01173               case EPROTONOSUPPORT:
01174 #if !defined(BEOS)
01175               case EOPNOTSUPP:
01176 #endif
01177               default:
01178                      PR_SetError(PR_UNKNOWN_ERROR, err);
01179                      break;
01180        }
01181 }
01182 
01183 void _MD_unix_map_getsockname_error(int err)
01184 {
01185        switch (err) {
01186               case EBADF:
01187                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
01188                      break;
01189 #if !defined(BEOS)
01190               case ENOTSOCK:
01191                      PR_SetError(PR_NOT_SOCKET_ERROR, err);
01192                      break;
01193 #endif
01194               case EFAULT:
01195                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
01196                      break;
01197 #if !defined(SCO)
01198               case ENOBUFS:
01199 #endif /* !defined(SCO) */
01200               case ENOMEM:
01201 #ifdef ENOSR
01202               case ENOSR:
01203 #endif
01204                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
01205                      break;
01206               default:
01207                      PR_SetError(PR_UNKNOWN_ERROR, err);
01208                      break;
01209        }
01210 }
01211 
01212 void _MD_unix_map_getpeername_error(int err)
01213 {
01214 
01215        switch (err) {
01216               case EBADF:
01217                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
01218                      break;
01219 #if !defined(BEOS)
01220               case ENOTSOCK:
01221                      PR_SetError(PR_NOT_SOCKET_ERROR, err);
01222                      break;
01223 #endif
01224               case ENOTCONN:
01225                      PR_SetError(PR_NOT_CONNECTED_ERROR, err);
01226                      break;
01227               case EFAULT:
01228                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
01229                      break;
01230 #if !defined(SCO)
01231               case ENOBUFS:
01232 #endif /* !defined(SCO) */
01233               case ENOMEM:
01234 #ifdef ENOSR
01235               case ENOSR:
01236 #endif
01237                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
01238                      break;
01239               default:
01240                      PR_SetError(PR_UNKNOWN_ERROR, err);
01241                      break;
01242        }
01243 }
01244 
01245 void _MD_unix_map_getsockopt_error(int err)
01246 {
01247        switch (err) {
01248               case EBADF:
01249                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
01250                      break;
01251 #if !defined(BEOS)
01252               case ENOTSOCK:
01253                      PR_SetError(PR_NOT_SOCKET_ERROR, err);
01254                      break;
01255 #endif
01256               case ENOPROTOOPT:
01257                      PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
01258                      break;
01259               case EFAULT:
01260                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
01261                      break;
01262               case EINVAL:
01263                      PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
01264                      break;
01265               case ENOMEM:
01266 #ifdef ENOSR
01267               case ENOSR:
01268 #endif
01269                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
01270                      break;
01271               default:
01272                      PR_SetError(PR_UNKNOWN_ERROR, err);
01273                      break;
01274        }
01275 }
01276 
01277 void _MD_unix_map_setsockopt_error(int err)
01278 {
01279        switch (err) {
01280               case EBADF:
01281                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
01282                      break;
01283 #if !defined(BEOS)
01284               case ENOTSOCK:
01285                      PR_SetError(PR_NOT_SOCKET_ERROR, err);
01286                      break;
01287 #endif
01288               case ENOPROTOOPT:
01289                      PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
01290                      break;
01291               case EFAULT:
01292                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
01293                      break;
01294               case EINVAL:
01295                      PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
01296                      break;
01297               case ENOMEM:
01298 #ifdef ENOSR
01299               case ENOSR:
01300 #endif
01301                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
01302                      break;
01303               default:
01304                      PR_SetError(PR_UNKNOWN_ERROR, err);
01305                      break;
01306        }
01307 }
01308 
01309 void _MD_unix_map_open_error(int err)
01310 {
01311        switch (err) {
01312               case EACCES:
01313                      PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
01314                      break;
01315               case EAGAIN:
01316                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
01317                      break;
01318               case EBUSY:
01319                      PR_SetError(PR_IO_ERROR, err);
01320                      break;
01321               case EEXIST:
01322                      PR_SetError(PR_FILE_EXISTS_ERROR, err);
01323                      break;
01324               case EFAULT:
01325                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
01326                      break;
01327               case EINTR:
01328                      PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
01329                      break;
01330               case EINVAL:
01331                      PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
01332                      break;
01333               case EIO:
01334                      PR_SetError(PR_IO_ERROR, err);
01335                      break;
01336               case EISDIR:
01337                      PR_SetError(PR_IS_DIRECTORY_ERROR, err);
01338                      break;
01339               case ELOOP:
01340                      PR_SetError(PR_LOOP_ERROR, err);
01341                      break;
01342               case EMFILE:
01343                      PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
01344                      break;
01345               case ENAMETOOLONG:
01346                      PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
01347                      break;
01348               case ENFILE:
01349                      PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
01350                      break;
01351               case ENODEV:
01352               case ENOENT:
01353               case ENXIO:
01354                      PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
01355                      break;
01356               case ENOMEM:
01357                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
01358                      break;
01359               case ENOSPC:
01360                      PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
01361                      break;
01362 #ifdef ENOSR
01363               case ENOSR:
01364 #endif
01365                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
01366                      break;
01367               case ENOTDIR:
01368                      PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
01369                      break;
01370               case EPERM:
01371                      PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
01372                      break;
01373               case ETIMEDOUT:
01374                      PR_SetError(PR_REMOTE_FILE_ERROR, err);
01375                      break;
01376               case EROFS:
01377                      PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
01378                      break;
01379               default:
01380                      PR_SetError(PR_UNKNOWN_ERROR, err);
01381                      break;
01382        }
01383 }
01384 
01385 void _MD_unix_map_mmap_error(int err)
01386 {
01387 
01388        switch (err) {
01389               case EBADF:
01390                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
01391                      break;
01392               case EAGAIN:
01393                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
01394                      break;
01395               case EACCES:
01396                      PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
01397                      break;
01398               case ENOMEM:
01399                      PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
01400                      break;
01401               default:
01402                      PR_SetError(PR_UNKNOWN_ERROR, err);
01403                      break;
01404        }
01405 }
01406 
01407 void _MD_unix_map_gethostname_error(int err)
01408 {
01409     switch (err) {
01410               case EFAULT:
01411                      PR_SetError(PR_ACCESS_FAULT_ERROR, err);
01412                      break;
01413               default:
01414                      PR_SetError(PR_UNKNOWN_ERROR, err);
01415                      break;
01416     }
01417 }
01418 
01419 void _MD_unix_map_select_error(int err)
01420 {
01421     switch (err) {
01422               case EBADF:
01423                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
01424                      break;
01425               case EINTR:
01426                      PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
01427                      break;
01428               case EINVAL:
01429                      PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
01430                      break;
01431               default:
01432                      PR_SetError(PR_UNKNOWN_ERROR, err);
01433                      break;
01434     }
01435 }
01436 
01437 void _MD_unix_map_poll_error(int err)
01438 {
01439     PRErrorCode prerror;
01440     switch (err) {
01441         case EAGAIN:
01442             prerror = PR_INSUFFICIENT_RESOURCES_ERROR;
01443             break;
01444         case EINVAL:
01445             prerror = PR_INVALID_ARGUMENT_ERROR;
01446             break;
01447         case EFAULT:
01448             prerror = PR_ACCESS_FAULT_ERROR;
01449             break;
01450         default:
01451             prerror = PR_UNKNOWN_ERROR;
01452             break;
01453     }
01454     PR_SetError(prerror, err);
01455 }
01456 
01457 void _MD_unix_map_flock_error(int err)
01458 {
01459     switch (err) {
01460               case EBADF:
01461               case EINVAL:
01462                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
01463                      break;
01464               case EWOULDBLOCK:
01465                      PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
01466                      break;
01467               default:
01468                      PR_SetError(PR_UNKNOWN_ERROR, err);
01469                      break;
01470     }
01471 }
01472 
01473 void _MD_unix_map_lockf_error(int err)
01474 {
01475     switch (err) {
01476               case EBADF:
01477                      PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
01478                      break;
01479               case EACCES:
01480                      PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
01481                      break;
01482               case EDEADLK:
01483                      PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
01484                      break;
01485               default:
01486                      PR_SetError(PR_UNKNOWN_ERROR, err);
01487                      break;
01488     }
01489 }
01490 
01491 #ifdef HPUX11
01492 void _MD_hpux_map_sendfile_error(int oserror)
01493 {
01494     PRErrorCode prerror;
01495 
01496     switch (oserror) {
01497         case ENOTSOCK:
01498             prerror = PR_NOT_SOCKET_ERROR;
01499             break;
01500         case EFAULT:
01501             prerror = PR_ACCESS_FAULT_ERROR;
01502             break;
01503         case ENOBUFS:
01504             prerror = PR_INSUFFICIENT_RESOURCES_ERROR;
01505             break;
01506         case EINVAL:
01507             prerror = PR_INVALID_ARGUMENT_ERROR;
01508             break;
01509         case ENOTCONN:
01510             prerror = PR_NOT_CONNECTED_ERROR;
01511             break;
01512         case EPIPE:
01513             prerror = PR_CONNECT_RESET_ERROR;
01514             break;
01515         case ENOMEM:
01516             prerror = PR_OUT_OF_MEMORY_ERROR;
01517             break;
01518         case EOPNOTSUPP:
01519             prerror = PR_NOT_TCP_SOCKET_ERROR;
01520             break;
01521         default:
01522             prerror = PR_UNKNOWN_ERROR;
01523     }
01524     PR_SetError(prerror, oserror); 
01525 }
01526 #endif /* HPUX11 */