1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ 2 /* 3 * This file essentially replicates NSPR's source for the functions that 4 * map system-specific error codes to NSPR error codes. We would use 5 * NSPR's functions, instead of duplicating them, but they're private. 6 * As long as SSL's server session cache code must do platform native I/O 7 * to accomplish its job, and NSPR's error mapping functions remain private, 8 * this code will continue to need to be replicated. 9 * 10 * This Source Code Form is subject to the terms of the Mozilla Public 11 * License, v. 2.0. If a copy of the MPL was not distributed with this 12 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ 13 14 #if 0 15 #include "primpl.h" 16 #else 17 #define _PR_POLL_AVAILABLE 1 18 #include "prerror.h" 19 #endif 20 21 #if defined (__bsdi__) || defined(NTO) || defined(DARWIN) || defined(BEOS) 22 #undef _PR_POLL_AVAILABLE 23 #endif 24 25 #if defined(_PR_POLL_AVAILABLE) 26 #include <poll.h> 27 #endif 28 #include <errno.h> 29 30 /* forward declarations. */ 31 void nss_MD_unix_map_default_error(int err); 32 33 void nss_MD_unix_map_opendir_error(int err) 34 { 35 nss_MD_unix_map_default_error(err); 36 } 37 38 void nss_MD_unix_map_closedir_error(int err) 39 { 40 PRErrorCode prError; 41 switch (err) { 42 case EINVAL: prError = PR_BAD_DESCRIPTOR_ERROR; break; 43 default: nss_MD_unix_map_default_error(err); return; 44 } 45 PR_SetError(prError, err); 46 } 47 48 void nss_MD_unix_readdir_error(int err) 49 { 50 PRErrorCode prError; 51 52 switch (err) { 53 case ENOENT: prError = PR_NO_MORE_FILES_ERROR; break; 54 #ifdef EOVERFLOW 55 case EOVERFLOW: prError = PR_IO_ERROR; break; 56 #endif 57 case EINVAL: prError = PR_IO_ERROR; break; 58 case ENXIO: prError = PR_IO_ERROR; break; 59 default: nss_MD_unix_map_default_error(err); return; 60 } 61 PR_SetError(prError, err); 62 } 63 64 void nss_MD_unix_map_unlink_error(int err) 65 { 66 PRErrorCode prError; 67 switch (err) { 68 case EPERM: prError = PR_IS_DIRECTORY_ERROR; break; 69 default: nss_MD_unix_map_default_error(err); return; 70 } 71 PR_SetError(prError, err); 72 } 73 74 void nss_MD_unix_map_stat_error(int err) 75 { 76 PRErrorCode prError; 77 switch (err) { 78 case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break; 79 default: nss_MD_unix_map_default_error(err); return; 80 } 81 PR_SetError(prError, err); 82 } 83 84 void nss_MD_unix_map_fstat_error(int err) 85 { 86 PRErrorCode prError; 87 switch (err) { 88 case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break; 89 default: nss_MD_unix_map_default_error(err); return; 90 } 91 PR_SetError(prError, err); 92 } 93 94 void nss_MD_unix_map_rename_error(int err) 95 { 96 PRErrorCode prError; 97 switch (err) { 98 case EEXIST: prError = PR_DIRECTORY_NOT_EMPTY_ERROR; break; 99 default: nss_MD_unix_map_default_error(err); return; 100 } 101 PR_SetError(prError, err); 102 } 103 104 void nss_MD_unix_map_access_error(int err) 105 { 106 PRErrorCode prError; 107 switch (err) { 108 case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break; 109 default: nss_MD_unix_map_default_error(err); return; 110 } 111 PR_SetError(prError, err); 112 } 113 114 void nss_MD_unix_map_mkdir_error(int err) 115 { 116 nss_MD_unix_map_default_error(err); 117 } 118 119 void nss_MD_unix_map_rmdir_error(int err) 120 { 121 PRErrorCode prError; 122 123 switch (err) { 124 case EEXIST: prError = PR_DIRECTORY_NOT_EMPTY_ERROR; break; 125 case EINVAL: prError = PR_DIRECTORY_NOT_EMPTY_ERROR; break; 126 case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break; 127 default: nss_MD_unix_map_default_error(err); return; 128 } 129 PR_SetError(prError, err); 130 } 131 132 void nss_MD_unix_map_read_error(int err) 133 { 134 PRErrorCode prError; 135 switch (err) { 136 case EINVAL: prError = PR_INVALID_METHOD_ERROR; break; 137 case ENXIO: prError = PR_INVALID_ARGUMENT_ERROR; break; 138 default: nss_MD_unix_map_default_error(err); return; 139 } 140 PR_SetError(prError, err); 141 } 142 143 void nss_MD_unix_map_write_error(int err) 144 { 145 PRErrorCode prError; 146 switch (err) { 147 case EINVAL: prError = PR_INVALID_METHOD_ERROR; break; 148 case ENXIO: prError = PR_INVALID_METHOD_ERROR; break; 149 case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break; 150 default: nss_MD_unix_map_default_error(err); return; 151 } 152 PR_SetError(prError, err); 153 } 154 155 void nss_MD_unix_map_lseek_error(int err) 156 { 157 nss_MD_unix_map_default_error(err); 158 } 159 160 void nss_MD_unix_map_fsync_error(int err) 161 { 162 PRErrorCode prError; 163 switch (err) { 164 case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break; 165 case EINVAL: prError = PR_INVALID_METHOD_ERROR; break; 166 default: nss_MD_unix_map_default_error(err); return; 167 } 168 PR_SetError(prError, err); 169 } 170 171 void nss_MD_unix_map_close_error(int err) 172 { 173 PRErrorCode prError; 174 switch (err) { 175 case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break; 176 default: nss_MD_unix_map_default_error(err); return; 177 } 178 PR_SetError(prError, err); 179 } 180 181 void nss_MD_unix_map_socket_error(int err) 182 { 183 PRErrorCode prError; 184 switch (err) { 185 case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break; 186 default: nss_MD_unix_map_default_error(err); return; 187 } 188 PR_SetError(prError, err); 189 } 190 191 void nss_MD_unix_map_socketavailable_error(int err) 192 { 193 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err); 194 } 195 196 void nss_MD_unix_map_recv_error(int err) 197 { 198 nss_MD_unix_map_default_error(err); 199 } 200 201 void nss_MD_unix_map_recvfrom_error(int err) 202 { 203 nss_MD_unix_map_default_error(err); 204 } 205 206 void nss_MD_unix_map_send_error(int err) 207 { 208 nss_MD_unix_map_default_error(err); 209 } 210 211 void nss_MD_unix_map_sendto_error(int err) 212 { 213 nss_MD_unix_map_default_error(err); 214 } 215 216 void nss_MD_unix_map_writev_error(int err) 217 { 218 nss_MD_unix_map_default_error(err); 219 } 220 221 void nss_MD_unix_map_accept_error(int err) 222 { 223 PRErrorCode prError; 224 switch (err) { 225 case ENODEV: prError = PR_NOT_TCP_SOCKET_ERROR; break; 226 default: nss_MD_unix_map_default_error(err); return; 227 } 228 PR_SetError(prError, err); 229 } 230 231 void nss_MD_unix_map_connect_error(int err) 232 { 233 PRErrorCode prError; 234 switch (err) { 235 case EACCES: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break; 236 #if defined(UNIXWARE) || defined(SNI) || defined(NEC) 237 /* 238 * On some platforms, if we connect to a port on the local host 239 * (the loopback address) that no process is listening on, we get 240 * EIO instead of ECONNREFUSED. 241 */ 242 case EIO: prError = PR_CONNECT_REFUSED_ERROR; break; 243 #endif 244 case ELOOP: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break; 245 case ENOENT: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break; 246 case ENXIO: prError = PR_IO_ERROR; break; 247 default: nss_MD_unix_map_default_error(err); return; 248 } 249 PR_SetError(prError, err); 250 } 251 252 void nss_MD_unix_map_bind_error(int err) 253 { 254 PRErrorCode prError; 255 switch (err) { 256 case EINVAL: prError = PR_SOCKET_ADDRESS_IS_BOUND_ERROR; break; 257 /* 258 * UNIX domain sockets are not supported in NSPR 259 */ 260 case EIO: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break; 261 case EISDIR: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break; 262 case ELOOP: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break; 263 case ENOENT: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break; 264 case ENOTDIR: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break; 265 case EROFS: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break; 266 default: nss_MD_unix_map_default_error(err); return; 267 } 268 PR_SetError(prError, err); 269 } 270 271 void nss_MD_unix_map_listen_error(int err) 272 { 273 nss_MD_unix_map_default_error(err); 274 } 275 276 void nss_MD_unix_map_shutdown_error(int err) 277 { 278 nss_MD_unix_map_default_error(err); 279 } 280 281 void nss_MD_unix_map_socketpair_error(int err) 282 { 283 PRErrorCode prError; 284 switch (err) { 285 case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break; 286 default: nss_MD_unix_map_default_error(err); return; 287 } 288 PR_SetError(prError, err); 289 } 290 291 void nss_MD_unix_map_getsockname_error(int err) 292 { 293 PRErrorCode prError; 294 switch (err) { 295 case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break; 296 default: nss_MD_unix_map_default_error(err); return; 297 } 298 PR_SetError(prError, err); 299 } 300 301 void nss_MD_unix_map_getpeername_error(int err) 302 { 303 PRErrorCode prError; 304 305 switch (err) { 306 case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break; 307 default: nss_MD_unix_map_default_error(err); return; 308 } 309 PR_SetError(prError, err); 310 } 311 312 void nss_MD_unix_map_getsockopt_error(int err) 313 { 314 PRErrorCode prError; 315 switch (err) { 316 case EINVAL: prError = PR_BUFFER_OVERFLOW_ERROR; break; 317 case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break; 318 default: nss_MD_unix_map_default_error(err); return; 319 } 320 PR_SetError(prError, err); 321 } 322 323 void nss_MD_unix_map_setsockopt_error(int err) 324 { 325 PRErrorCode prError; 326 switch (err) { 327 case EINVAL: prError = PR_BUFFER_OVERFLOW_ERROR; break; 328 case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break; 329 default: nss_MD_unix_map_default_error(err); return; 330 } 331 PR_SetError(prError, err); 332 } 333 334 void nss_MD_unix_map_open_error(int err) 335 { 336 PRErrorCode prError; 337 switch (err) { 338 case EAGAIN: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break; 339 case EBUSY: prError = PR_IO_ERROR; break; 340 case ENODEV: prError = PR_FILE_NOT_FOUND_ERROR; break; 341 case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break; 342 case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break; 343 default: nss_MD_unix_map_default_error(err); return; 344 } 345 PR_SetError(prError, err); 346 } 347 348 void nss_MD_unix_map_mmap_error(int err) 349 { 350 PRErrorCode prError; 351 switch (err) { 352 case EAGAIN: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break; 353 case EMFILE: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break; 354 case ENODEV: prError = PR_OPERATION_NOT_SUPPORTED_ERROR; break; 355 case ENXIO: prError = PR_INVALID_ARGUMENT_ERROR; break; 356 default: nss_MD_unix_map_default_error(err); return; 357 } 358 PR_SetError(prError, err); 359 } 360 361 void nss_MD_unix_map_gethostname_error(int err) 362 { 363 nss_MD_unix_map_default_error(err); 364 } 365 366 void nss_MD_unix_map_select_error(int err) 367 { 368 nss_MD_unix_map_default_error(err); 369 } 370 371 #ifdef _PR_POLL_AVAILABLE 372 void nss_MD_unix_map_poll_error(int err) 373 { 374 PRErrorCode prError; 375 376 switch (err) { 377 case EAGAIN: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break; 378 default: nss_MD_unix_map_default_error(err); return; 379 } 380 PR_SetError(prError, err); 381 } 382 383 void nss_MD_unix_map_poll_revents_error(int err) 384 { 385 if (err & POLLNVAL) 386 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, EBADF); 387 else if (err & POLLHUP) 388 PR_SetError(PR_CONNECT_RESET_ERROR, EPIPE); 389 else if (err & POLLERR) 390 PR_SetError(PR_IO_ERROR, EIO); 391 else 392 PR_SetError(PR_UNKNOWN_ERROR, err); 393 } 394 #endif /* _PR_POLL_AVAILABLE */ 395 396 397 void nss_MD_unix_map_flock_error(int err) 398 { 399 PRErrorCode prError; 400 switch (err) { 401 case EINVAL: prError = PR_BAD_DESCRIPTOR_ERROR; break; 402 case EWOULDBLOCK: prError = PR_FILE_IS_LOCKED_ERROR; break; 403 default: nss_MD_unix_map_default_error(err); return; 404 } 405 PR_SetError(prError, err); 406 } 407 408 void nss_MD_unix_map_lockf_error(int err) 409 { 410 PRErrorCode prError; 411 switch (err) { 412 case EACCES: prError = PR_FILE_IS_LOCKED_ERROR; break; 413 case EDEADLK: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break; 414 default: nss_MD_unix_map_default_error(err); return; 415 } 416 PR_SetError(prError, err); 417 } 418 419 #ifdef HPUX11 420 void nss_MD_hpux_map_sendfile_error(int err) 421 { 422 nss_MD_unix_map_default_error(err); 423 } 424 #endif /* HPUX11 */ 425 426 427 void nss_MD_unix_map_default_error(int err) 428 { 429 PRErrorCode prError; 430 switch (err ) { 431 case EACCES: prError = PR_NO_ACCESS_RIGHTS_ERROR; break; 432 case EADDRINUSE: prError = PR_ADDRESS_IN_USE_ERROR; break; 433 case EADDRNOTAVAIL: prError = PR_ADDRESS_NOT_AVAILABLE_ERROR; break; 434 case EAFNOSUPPORT: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break; 435 case EAGAIN: prError = PR_WOULD_BLOCK_ERROR; break; 436 /* 437 * On QNX and Neutrino, EALREADY is defined as EBUSY. 438 */ 439 #if EALREADY != EBUSY 440 case EALREADY: prError = PR_ALREADY_INITIATED_ERROR; break; 441 #endif 442 case EBADF: prError = PR_BAD_DESCRIPTOR_ERROR; break; 443 #ifdef EBADMSG 444 case EBADMSG: prError = PR_IO_ERROR; break; 445 #endif 446 case EBUSY: prError = PR_FILESYSTEM_MOUNTED_ERROR; break; 447 case ECONNREFUSED: prError = PR_CONNECT_REFUSED_ERROR; break; 448 case ECONNRESET: prError = PR_CONNECT_RESET_ERROR; break; 449 case EDEADLK: prError = PR_DEADLOCK_ERROR; break; 450 #ifdef EDIRCORRUPTED 451 case EDIRCORRUPTED: prError = PR_DIRECTORY_CORRUPTED_ERROR; break; 452 #endif 453 #ifdef EDQUOT 454 case EDQUOT: prError = PR_NO_DEVICE_SPACE_ERROR; break; 455 #endif 456 case EEXIST: prError = PR_FILE_EXISTS_ERROR; break; 457 case EFAULT: prError = PR_ACCESS_FAULT_ERROR; break; 458 case EFBIG: prError = PR_FILE_TOO_BIG_ERROR; break; 459 case EINPROGRESS: prError = PR_IN_PROGRESS_ERROR; break; 460 case EINTR: prError = PR_PENDING_INTERRUPT_ERROR; break; 461 case EINVAL: prError = PR_INVALID_ARGUMENT_ERROR; break; 462 case EIO: prError = PR_IO_ERROR; break; 463 case EISCONN: prError = PR_IS_CONNECTED_ERROR; break; 464 case EISDIR: prError = PR_IS_DIRECTORY_ERROR; break; 465 case ELOOP: prError = PR_LOOP_ERROR; break; 466 case EMFILE: prError = PR_PROC_DESC_TABLE_FULL_ERROR; break; 467 case EMLINK: prError = PR_MAX_DIRECTORY_ENTRIES_ERROR; break; 468 case EMSGSIZE: prError = PR_INVALID_ARGUMENT_ERROR; break; 469 #ifdef EMULTIHOP 470 case EMULTIHOP: prError = PR_REMOTE_FILE_ERROR; break; 471 #endif 472 case ENAMETOOLONG: prError = PR_NAME_TOO_LONG_ERROR; break; 473 case ENETUNREACH: prError = PR_NETWORK_UNREACHABLE_ERROR; break; 474 case ENFILE: prError = PR_SYS_DESC_TABLE_FULL_ERROR; break; 475 #if !defined(SCO) 476 case ENOBUFS: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break; 477 #endif 478 case ENODEV: prError = PR_FILE_NOT_FOUND_ERROR; break; 479 case ENOENT: prError = PR_FILE_NOT_FOUND_ERROR; break; 480 case ENOLCK: prError = PR_FILE_IS_LOCKED_ERROR; break; 481 #ifdef ENOLINK 482 case ENOLINK: prError = PR_REMOTE_FILE_ERROR; break; 483 #endif 484 case ENOMEM: prError = PR_OUT_OF_MEMORY_ERROR; break; 485 case ENOPROTOOPT: prError = PR_INVALID_ARGUMENT_ERROR; break; 486 case ENOSPC: prError = PR_NO_DEVICE_SPACE_ERROR; break; 487 #ifdef ENOSR 488 case ENOSR: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break; 489 #endif 490 case ENOTCONN: prError = PR_NOT_CONNECTED_ERROR; break; 491 case ENOTDIR: prError = PR_NOT_DIRECTORY_ERROR; break; 492 case ENOTSOCK: prError = PR_NOT_SOCKET_ERROR; break; 493 case ENXIO: prError = PR_FILE_NOT_FOUND_ERROR; break; 494 case EOPNOTSUPP: prError = PR_NOT_TCP_SOCKET_ERROR; break; 495 #ifdef EOVERFLOW 496 case EOVERFLOW: prError = PR_BUFFER_OVERFLOW_ERROR; break; 497 #endif 498 case EPERM: prError = PR_NO_ACCESS_RIGHTS_ERROR; break; 499 case EPIPE: prError = PR_CONNECT_RESET_ERROR; break; 500 #ifdef EPROTO 501 case EPROTO: prError = PR_IO_ERROR; break; 502 #endif 503 case EPROTONOSUPPORT: prError = PR_PROTOCOL_NOT_SUPPORTED_ERROR; break; 504 case EPROTOTYPE: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break; 505 case ERANGE: prError = PR_INVALID_METHOD_ERROR; break; 506 case EROFS: prError = PR_READ_ONLY_FILESYSTEM_ERROR; break; 507 case ESPIPE: prError = PR_INVALID_METHOD_ERROR; break; 508 case ETIMEDOUT: prError = PR_IO_TIMEOUT_ERROR; break; 509 #if EWOULDBLOCK != EAGAIN 510 case EWOULDBLOCK: prError = PR_WOULD_BLOCK_ERROR; break; 511 #endif 512 case EXDEV: prError = PR_NOT_SAME_DEVICE_ERROR; break; 513 514 default: prError = PR_UNKNOWN_ERROR; break; 515 } 516 PR_SetError(prError, err); 517 } 518
