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 | |
34 nss_MD_unix_map_opendir_error(int err) | |
35 { | |
36 nss_MD_unix_map_default_error(err); | |
37 } | |
38 | |
39 void | |
40 nss_MD_unix_map_closedir_error(int err) | |
41 { | |
42 PRErrorCode prError; | |
43 switch (err) { | |
44 case EINVAL: | |
45 prError = PR_BAD_DESCRIPTOR_ERROR; | |
46 break; | |
47 default: | |
48 nss_MD_unix_map_default_error(err); | |
49 return; | |
50 } | |
51 PR_SetError(prError, err); | |
52 } | |
53 | |
54 void | |
55 nss_MD_unix_readdir_error(int err) | |
56 { | |
57 PRErrorCode prError; | |
58 | |
59 switch (err) { | |
60 case ENOENT: | |
61 prError = PR_NO_MORE_FILES_ERROR; | |
62 break; | |
63 #ifdef EOVERFLOW | |
64 case EOVERFLOW: | |
65 prError = PR_IO_ERROR; | |
66 break; | |
67 #endif | |
68 case EINVAL: | |
69 prError = PR_IO_ERROR; | |
70 break; | |
71 case ENXIO: | |
72 prError = PR_IO_ERROR; | |
73 break; | |
74 default: | |
75 nss_MD_unix_map_default_error(err); | |
76 return; | |
77 } | |
78 PR_SetError(prError, err); | |
79 } | |
80 | |
81 void | |
82 nss_MD_unix_map_unlink_error(int err) | |
83 { | |
84 PRErrorCode prError; | |
85 switch (err) { | |
86 case EPERM: | |
87 prError = PR_IS_DIRECTORY_ERROR; | |
88 break; | |
89 default: | |
90 nss_MD_unix_map_default_error(err); | |
91 return; | |
92 } | |
93 PR_SetError(prError, err); | |
94 } | |
95 | |
96 void | |
97 nss_MD_unix_map_stat_error(int err) | |
98 { | |
99 PRErrorCode prError; | |
100 switch (err) { | |
101 case ETIMEDOUT: | |
102 prError = PR_REMOTE_FILE_ERROR; | |
103 break; | |
104 default: | |
105 nss_MD_unix_map_default_error(err); | |
106 return; | |
107 } | |
108 PR_SetError(prError, err); | |
109 } | |
110 | |
111 void | |
112 nss_MD_unix_map_fstat_error(int err) | |
113 { | |
114 PRErrorCode prError; | |
115 switch (err) { | |
116 case ETIMEDOUT: | |
117 prError = PR_REMOTE_FILE_ERROR; | |
118 break; | |
119 default: | |
120 nss_MD_unix_map_default_error(err); | |
121 return; | |
122 } | |
123 PR_SetError(prError, err); | |
124 } | |
125 | |
126 void | |
127 nss_MD_unix_map_rename_error(int err) | |
128 { | |
129 PRErrorCode prError; | |
130 switch (err) { | |
131 case EEXIST: | |
132 prError = PR_DIRECTORY_NOT_EMPTY_ERROR; | |
133 break; | |
134 default: | |
135 nss_MD_unix_map_default_error(err); | |
136 return; | |
137 } | |
138 PR_SetError(prError, err); | |
139 } | |
140 | |
141 void | |
142 nss_MD_unix_map_access_error(int err) | |
143 { | |
144 PRErrorCode prError; | |
145 switch (err) { | |
146 case ETIMEDOUT: | |
147 prError = PR_REMOTE_FILE_ERROR; | |
148 break; | |
149 default: | |
150 nss_MD_unix_map_default_error(err); | |
151 return; | |
152 } | |
153 PR_SetError(prError, err); | |
154 } | |
155 | |
156 void | |
157 nss_MD_unix_map_mkdir_error(int err) | |
158 { | |
159 nss_MD_unix_map_default_error(err); | |
160 } | |
161 | |
162 void | |
163 nss_MD_unix_map_rmdir_error(int err) | |
164 { | |
165 PRErrorCode prError; | |
166 | |
167 switch (err) { | |
168 case EEXIST: | |
169 prError = PR_DIRECTORY_NOT_EMPTY_ERROR; | |
170 break; | |
171 case EINVAL: | |
172 prError = PR_DIRECTORY_NOT_EMPTY_ERROR; | |
173 break; | |
174 case ETIMEDOUT: | |
175 prError = PR_REMOTE_FILE_ERROR; | |
176 break; | |
177 default: | |
178 nss_MD_unix_map_default_error(err); | |
179 return; | |
180 } | |
181 PR_SetError(prError, err); | |
182 } | |
183 | |
184 void | |
185 nss_MD_unix_map_read_error(int err) | |
186 { | |
187 PRErrorCode prError; | |
188 switch (err) { | |
189 case EINVAL: | |
190 prError = PR_INVALID_METHOD_ERROR; | |
191 break; | |
192 case ENXIO: | |
193 prError = PR_INVALID_ARGUMENT_ERROR; | |
194 break; | |
195 default: | |
196 nss_MD_unix_map_default_error(err); | |
197 return; | |
198 } | |
199 PR_SetError(prError, err); | |
200 } | |
201 | |
202 void | |
203 nss_MD_unix_map_write_error(int err) | |
204 { | |
205 PRErrorCode prError; | |
206 switch (err) { | |
207 case EINVAL: | |
208 prError = PR_INVALID_METHOD_ERROR; | |
209 break; | |
210 case ENXIO: | |
211 prError = PR_INVALID_METHOD_ERROR; | |
212 break; | |
213 case ETIMEDOUT: | |
214 prError = PR_REMOTE_FILE_ERROR; | |
215 break; | |
216 default: | |
217 nss_MD_unix_map_default_error(err); | |
218 return; | |
219 } | |
220 PR_SetError(prError, err); | |
221 } | |
222 | |
223 void | |
224 nss_MD_unix_map_lseek_error(int err) | |
225 { | |
226 nss_MD_unix_map_default_error(err); | |
227 } | |
228 | |
229 void | |
230 nss_MD_unix_map_fsync_error(int err) | |
231 { | |
232 PRErrorCode prError; | |
233 switch (err) { | |
234 case ETIMEDOUT: | |
235 prError = PR_REMOTE_FILE_ERROR; | |
236 break; | |
237 case EINVAL: | |
238 prError = PR_INVALID_METHOD_ERROR; | |
239 break; | |
240 default: | |
241 nss_MD_unix_map_default_error(err); | |
242 return; | |
243 } | |
244 PR_SetError(prError, err); | |
245 } | |
246 | |
247 void | |
248 nss_MD_unix_map_close_error(int err) | |
249 { | |
250 PRErrorCode prError; | |
251 switch (err) { | |
252 case ETIMEDOUT: | |
253 prError = PR_REMOTE_FILE_ERROR; | |
254 break; | |
255 default: | |
256 nss_MD_unix_map_default_error(err); | |
257 return; | |
258 } | |
259 PR_SetError(prError, err); | |
260 } | |
261 | |
262 void | |
263 nss_MD_unix_map_socket_error(int err) | |
264 { | |
265 PRErrorCode prError; | |
266 switch (err) { | |
267 case ENOMEM: | |
268 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
269 break; | |
270 default: | |
271 nss_MD_unix_map_default_error(err); | |
272 return; | |
273 } | |
274 PR_SetError(prError, err); | |
275 } | |
276 | |
277 void | |
278 nss_MD_unix_map_socketavailable_error(int err) | |
279 { | |
280 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err); | |
281 } | |
282 | |
283 void | |
284 nss_MD_unix_map_recv_error(int err) | |
285 { | |
286 nss_MD_unix_map_default_error(err); | |
287 } | |
288 | |
289 void | |
290 nss_MD_unix_map_recvfrom_error(int err) | |
291 { | |
292 nss_MD_unix_map_default_error(err); | |
293 } | |
294 | |
295 void | |
296 nss_MD_unix_map_send_error(int err) | |
297 { | |
298 nss_MD_unix_map_default_error(err); | |
299 } | |
300 | |
301 void | |
302 nss_MD_unix_map_sendto_error(int err) | |
303 { | |
304 nss_MD_unix_map_default_error(err); | |
305 } | |
306 | |
307 void | |
308 nss_MD_unix_map_writev_error(int err) | |
309 { | |
310 nss_MD_unix_map_default_error(err); | |
311 } | |
312 | |
313 void | |
314 nss_MD_unix_map_accept_error(int err) | |
315 { | |
316 PRErrorCode prError; | |
317 switch (err) { | |
318 case ENODEV: | |
319 prError = PR_NOT_TCP_SOCKET_ERROR; | |
320 break; | |
321 default: | |
322 nss_MD_unix_map_default_error(err); | |
323 return; | |
324 } | |
325 PR_SetError(prError, err); | |
326 } | |
327 | |
328 void | |
329 nss_MD_unix_map_connect_error(int err) | |
330 { | |
331 PRErrorCode prError; | |
332 switch (err) { | |
333 case EACCES: | |
334 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
335 break; | |
336 #if defined(UNIXWARE) || defined(SNI) || defined(NEC) | |
337 /* | |
338 * On some platforms, if we connect to a port on the local host | |
339 * (the loopback address) that no process is listening on, we get | |
340 * EIO instead of ECONNREFUSED. | |
341 */ | |
342 case EIO: | |
343 prError = PR_CONNECT_REFUSED_ERROR; | |
344 break; | |
345 #endif | |
346 case ELOOP: | |
347 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
348 break; | |
349 case ENOENT: | |
350 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
351 break; | |
352 case ENXIO: | |
353 prError = PR_IO_ERROR; | |
354 break; | |
355 default: | |
356 nss_MD_unix_map_default_error(err); | |
357 return; | |
358 } | |
359 PR_SetError(prError, err); | |
360 } | |
361 | |
362 void | |
363 nss_MD_unix_map_bind_error(int err) | |
364 { | |
365 PRErrorCode prError; | |
366 switch (err) { | |
367 case EINVAL: | |
368 prError = PR_SOCKET_ADDRESS_IS_BOUND_ERROR; | |
369 break; | |
370 /* | |
371 * UNIX domain sockets are not supported in NSPR | |
372 */ | |
373 case EIO: | |
374 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
375 break; | |
376 case EISDIR: | |
377 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
378 break; | |
379 case ELOOP: | |
380 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
381 break; | |
382 case ENOENT: | |
383 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
384 break; | |
385 case ENOTDIR: | |
386 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
387 break; | |
388 case EROFS: | |
389 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
390 break; | |
391 default: | |
392 nss_MD_unix_map_default_error(err); | |
393 return; | |
394 } | |
395 PR_SetError(prError, err); | |
396 } | |
397 | |
398 void | |
399 nss_MD_unix_map_listen_error(int err) | |
400 { | |
401 nss_MD_unix_map_default_error(err); | |
402 } | |
403 | |
404 void | |
405 nss_MD_unix_map_shutdown_error(int err) | |
406 { | |
407 nss_MD_unix_map_default_error(err); | |
408 } | |
409 | |
410 void | |
411 nss_MD_unix_map_socketpair_error(int err) | |
412 { | |
413 PRErrorCode prError; | |
414 switch (err) { | |
415 case ENOMEM: | |
416 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
417 break; | |
418 default: | |
419 nss_MD_unix_map_default_error(err); | |
420 return; | |
421 } | |
422 PR_SetError(prError, err); | |
423 } | |
424 | |
425 void | |
426 nss_MD_unix_map_getsockname_error(int err) | |
427 { | |
428 PRErrorCode prError; | |
429 switch (err) { | |
430 case ENOMEM: | |
431 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
432 break; | |
433 default: | |
434 nss_MD_unix_map_default_error(err); | |
435 return; | |
436 } | |
437 PR_SetError(prError, err); | |
438 } | |
439 | |
440 void | |
441 nss_MD_unix_map_getpeername_error(int err) | |
442 { | |
443 PRErrorCode prError; | |
444 | |
445 switch (err) { | |
446 case ENOMEM: | |
447 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
448 break; | |
449 default: | |
450 nss_MD_unix_map_default_error(err); | |
451 return; | |
452 } | |
453 PR_SetError(prError, err); | |
454 } | |
455 | |
456 void | |
457 nss_MD_unix_map_getsockopt_error(int err) | |
458 { | |
459 PRErrorCode prError; | |
460 switch (err) { | |
461 case EINVAL: | |
462 prError = PR_BUFFER_OVERFLOW_ERROR; | |
463 break; | |
464 case ENOMEM: | |
465 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
466 break; | |
467 default: | |
468 nss_MD_unix_map_default_error(err); | |
469 return; | |
470 } | |
471 PR_SetError(prError, err); | |
472 } | |
473 | |
474 void | |
475 nss_MD_unix_map_setsockopt_error(int err) | |
476 { | |
477 PRErrorCode prError; | |
478 switch (err) { | |
479 case EINVAL: | |
480 prError = PR_BUFFER_OVERFLOW_ERROR; | |
481 break; | |
482 case ENOMEM: | |
483 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
484 break; | |
485 default: | |
486 nss_MD_unix_map_default_error(err); | |
487 return; | |
488 } | |
489 PR_SetError(prError, err); | |
490 } | |
491 | |
492 void | |
493 nss_MD_unix_map_open_error(int err) | |
494 { | |
495 PRErrorCode prError; | |
496 switch (err) { | |
497 case EAGAIN: | |
498 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
499 break; | |
500 case EBUSY: | |
501 prError = PR_IO_ERROR; | |
502 break; | |
503 case ENODEV: | |
504 prError = PR_FILE_NOT_FOUND_ERROR; | |
505 break; | |
506 case ENOMEM: | |
507 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
508 break; | |
509 case ETIMEDOUT: | |
510 prError = PR_REMOTE_FILE_ERROR; | |
511 break; | |
512 default: | |
513 nss_MD_unix_map_default_error(err); | |
514 return; | |
515 } | |
516 PR_SetError(prError, err); | |
517 } | |
518 | |
519 void | |
520 nss_MD_unix_map_mmap_error(int err) | |
521 { | |
522 PRErrorCode prError; | |
523 switch (err) { | |
524 case EAGAIN: | |
525 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
526 break; | |
527 case EMFILE: | |
528 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
529 break; | |
530 case ENODEV: | |
531 prError = PR_OPERATION_NOT_SUPPORTED_ERROR; | |
532 break; | |
533 case ENXIO: | |
534 prError = PR_INVALID_ARGUMENT_ERROR; | |
535 break; | |
536 default: | |
537 nss_MD_unix_map_default_error(err); | |
538 return; | |
539 } | |
540 PR_SetError(prError, err); | |
541 } | |
542 | |
543 void | |
544 nss_MD_unix_map_gethostname_error(int err) | |
545 { | |
546 nss_MD_unix_map_default_error(err); | |
547 } | |
548 | |
549 void | |
550 nss_MD_unix_map_select_error(int err) | |
551 { | |
552 nss_MD_unix_map_default_error(err); | |
553 } | |
554 | |
555 #ifdef _PR_POLL_AVAILABLE | |
556 void | |
557 nss_MD_unix_map_poll_error(int err) | |
558 { | |
559 PRErrorCode prError; | |
560 | |
561 switch (err) { | |
562 case EAGAIN: | |
563 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
564 break; | |
565 default: | |
566 nss_MD_unix_map_default_error(err); | |
567 return; | |
568 } | |
569 PR_SetError(prError, err); | |
570 } | |
571 | |
572 void | |
573 nss_MD_unix_map_poll_revents_error(int err) | |
574 { | |
575 if (err & POLLNVAL) | |
576 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, EBADF); | |
577 else if (err & POLLHUP) | |
578 PR_SetError(PR_CONNECT_RESET_ERROR, EPIPE); | |
579 else if (err & POLLERR) | |
580 PR_SetError(PR_IO_ERROR, EIO); | |
581 else | |
582 PR_SetError(PR_UNKNOWN_ERROR, err); | |
583 } | |
584 #endif /* _PR_POLL_AVAILABLE */ | |
585 | |
586 void | |
587 nss_MD_unix_map_flock_error(int err) | |
588 { | |
589 PRErrorCode prError; | |
590 switch (err) { | |
591 case EINVAL: | |
592 prError = PR_BAD_DESCRIPTOR_ERROR; | |
593 break; | |
594 case EWOULDBLOCK: | |
595 prError = PR_FILE_IS_LOCKED_ERROR; | |
596 break; | |
597 default: | |
598 nss_MD_unix_map_default_error(err); | |
599 return; | |
600 } | |
601 PR_SetError(prError, err); | |
602 } | |
603 | |
604 void | |
605 nss_MD_unix_map_lockf_error(int err) | |
606 { | |
607 PRErrorCode prError; | |
608 switch (err) { | |
609 case EACCES: | |
610 prError = PR_FILE_IS_LOCKED_ERROR; | |
611 break; | |
612 case EDEADLK: | |
613 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
614 break; | |
615 default: | |
616 nss_MD_unix_map_default_error(err); | |
617 return; | |
618 } | |
619 PR_SetError(prError, err); | |
620 } | |
621 | |
622 #ifdef HPUX11 | |
623 void | |
624 nss_MD_hpux_map_sendfile_error(int err) | |
625 { | |
626 nss_MD_unix_map_default_error(err); | |
627 } | |
628 #endif /* HPUX11 */ | |
629 | |
630 void | |
631 nss_MD_unix_map_default_error(int err) | |
632 { | |
633 PRErrorCode prError; | |
634 switch (err) { | |
635 case EACCES: | |
636 prError = PR_NO_ACCESS_RIGHTS_ERROR; | |
637 break; | |
638 case EADDRINUSE: | |
639 prError = PR_ADDRESS_IN_USE_ERROR; | |
640 break; | |
641 case EADDRNOTAVAIL: | |
642 prError = PR_ADDRESS_NOT_AVAILABLE_ERROR; | |
643 break; | |
644 case EAFNOSUPPORT: | |
645 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
646 break; | |
647 case EAGAIN: | |
648 prError = PR_WOULD_BLOCK_ERROR; | |
649 break; | |
650 /* | |
651 * On QNX and Neutrino, EALREADY is defined as EBUSY. | |
652 */ | |
653 #if EALREADY != EBUSY | |
654 case EALREADY: | |
655 prError = PR_ALREADY_INITIATED_ERROR; | |
656 break; | |
657 #endif | |
658 case EBADF: | |
659 prError = PR_BAD_DESCRIPTOR_ERROR; | |
660 break; | |
661 #ifdef EBADMSG | |
662 case EBADMSG: | |
663 prError = PR_IO_ERROR; | |
664 break; | |
665 #endif | |
666 case EBUSY: | |
667 prError = PR_FILESYSTEM_MOUNTED_ERROR; | |
668 break; | |
669 case ECONNREFUSED: | |
670 prError = PR_CONNECT_REFUSED_ERROR; | |
671 break; | |
672 case ECONNRESET: | |
673 prError = PR_CONNECT_RESET_ERROR; | |
674 break; | |
675 case EDEADLK: | |
676 prError = PR_DEADLOCK_ERROR; | |
677 break; | |
678 #ifdef EDIRCORRUPTED | |
679 case EDIRCORRUPTED: | |
680 prError = PR_DIRECTORY_CORRUPTED_ERROR; | |
681 break; | |
682 #endif | |
683 #ifdef EDQUOT | |
684 case EDQUOT: | |
685 prError = PR_NO_DEVICE_SPACE_ERROR; | |
686 break; | |
687 #endif | |
688 case EEXIST: | |
689 prError = PR_FILE_EXISTS_ERROR; | |
690 break; | |
691 case EFAULT: | |
692 prError = PR_ACCESS_FAULT_ERROR; | |
693 break; | |
694 case EFBIG: | |
695 prError = PR_FILE_TOO_BIG_ERROR; | |
696 break; | |
697 case EINPROGRESS: | |
698 prError = PR_IN_PROGRESS_ERROR; | |
699 break; | |
700 case EINTR: | |
701 prError = PR_PENDING_INTERRUPT_ERROR; | |
702 break; | |
703 case EINVAL: | |
704 prError = PR_INVALID_ARGUMENT_ERROR; | |
705 break; | |
706 case EIO: | |
707 prError = PR_IO_ERROR; | |
708 break; | |
709 case EISCONN: | |
710 prError = PR_IS_CONNECTED_ERROR; | |
711 break; | |
712 case EISDIR: | |
713 prError = PR_IS_DIRECTORY_ERROR; | |
714 break; | |
715 case ELOOP: | |
716 prError = PR_LOOP_ERROR; | |
717 break; | |
718 case EMFILE: | |
719 prError = PR_PROC_DESC_TABLE_FULL_ERROR; | |
720 break; | |
721 case EMLINK: | |
722 prError = PR_MAX_DIRECTORY_ENTRIES_ERROR; | |
723 break; | |
724 case EMSGSIZE: | |
725 prError = PR_INVALID_ARGUMENT_ERROR; | |
726 break; | |
727 #ifdef EMULTIHOP | |
728 case EMULTIHOP: | |
729 prError = PR_REMOTE_FILE_ERROR; | |
730 break; | |
731 #endif | |
732 case ENAMETOOLONG: | |
733 prError = PR_NAME_TOO_LONG_ERROR; | |
734 break; | |
735 case ENETUNREACH: | |
736 prError = PR_NETWORK_UNREACHABLE_ERROR; | |
737 break; | |
738 case ENFILE: | |
739 prError = PR_SYS_DESC_TABLE_FULL_ERROR; | |
740 break; | |
741 #if !defined(SCO) | |
742 case ENOBUFS: | |
743 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
744 break; | |
745 #endif | |
746 case ENODEV: | |
747 prError = PR_FILE_NOT_FOUND_ERROR; | |
748 break; | |
749 case ENOENT: | |
750 prError = PR_FILE_NOT_FOUND_ERROR; | |
751 break; | |
752 case ENOLCK: | |
753 prError = PR_FILE_IS_LOCKED_ERROR; | |
754 break; | |
755 #ifdef ENOLINK | |
756 case ENOLINK: | |
757 prError = PR_REMOTE_FILE_ERROR; | |
758 break; | |
759 #endif | |
760 case ENOMEM: | |
761 prError = PR_OUT_OF_MEMORY_ERROR; | |
762 break; | |
763 case ENOPROTOOPT: | |
764 prError = PR_INVALID_ARGUMENT_ERROR; | |
765 break; | |
766 case ENOSPC: | |
767 prError = PR_NO_DEVICE_SPACE_ERROR; | |
768 break; | |
769 #ifdef ENOSR | |
770 case ENOSR: | |
771 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
772 break; | |
773 #endif | |
774 case ENOTCONN: | |
775 prError = PR_NOT_CONNECTED_ERROR; | |
776 break; | |
777 case ENOTDIR: | |
778 prError = PR_NOT_DIRECTORY_ERROR; | |
779 break; | |
780 case ENOTSOCK: | |
781 prError = PR_NOT_SOCKET_ERROR; | |
782 break; | |
783 case ENXIO: | |
784 prError = PR_FILE_NOT_FOUND_ERROR; | |
785 break; | |
786 case EOPNOTSUPP: | |
787 prError = PR_NOT_TCP_SOCKET_ERROR; | |
788 break; | |
789 #ifdef EOVERFLOW | |
790 case EOVERFLOW: | |
791 prError = PR_BUFFER_OVERFLOW_ERROR; | |
792 break; | |
793 #endif | |
794 case EPERM: | |
795 prError = PR_NO_ACCESS_RIGHTS_ERROR; | |
796 break; | |
797 case EPIPE: | |
798 prError = PR_CONNECT_RESET_ERROR; | |
799 break; | |
800 #ifdef EPROTO | |
801 case EPROTO: | |
802 prError = PR_IO_ERROR; | |
803 break; | |
804 #endif | |
805 case EPROTONOSUPPORT: | |
806 prError = PR_PROTOCOL_NOT_SUPPORTED_ERROR; | |
807 break; | |
808 case EPROTOTYPE: | |
809 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
810 break; | |
811 case ERANGE: | |
812 prError = PR_INVALID_METHOD_ERROR; | |
813 break; | |
814 case EROFS: | |
815 prError = PR_READ_ONLY_FILESYSTEM_ERROR; | |
816 break; | |
817 case ESPIPE: | |
818 prError = PR_INVALID_METHOD_ERROR; | |
819 break; | |
820 case ETIMEDOUT: | |
821 prError = PR_IO_TIMEOUT_ERROR; | |
822 break; | |
823 #if EWOULDBLOCK != EAGAIN | |
824 case EWOULDBLOCK: | |
825 prError = PR_WOULD_BLOCK_ERROR; | |
826 break; | |
827 #endif | |
828 case EXDEV: | |
829 prError = PR_NOT_SAME_DEVICE_ERROR; | |
830 break; | |
831 | |
832 default: | |
833 prError = PR_UNKNOWN_ERROR; | |
834 break; | |
835 } | |
836 PR_SetError(prError, err); | |
837 } | |
OLD | NEW |