| OLD | NEW |
|---|
| (Empty) |
| 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 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master