The Tor Browser / file comparison

comparison: nsprpub/pr/src/md/beos/beos_errors.c

nsprpub/pr/src/md/beos/beos_errors.c

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:22d423a49a86
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 #include "prtypes.h"
7 #include "md/_unix_errors.h"
8 #include "prerror.h"
9 #include <errno.h>
10
11 void _MD_unix_map_opendir_error(int err)
12 {
13 switch (err) {
14 case ENOTDIR:
15 PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
16 break;
17 case EACCES:
18 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
19 break;
20 case EMFILE:
21 PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
22 break;
23 case ENFILE:
24 PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
25 break;
26 case EFAULT:
27 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
28 break;
29 case ELOOP:
30 PR_SetError(PR_LOOP_ERROR, err);
31 break;
32 case ENAMETOOLONG:
33 PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
34 break;
35 case ENOENT:
36 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
37 break;
38 default:
39 PR_SetError(PR_UNKNOWN_ERROR, err);
40 break;
41 }
42 }
43
44 void _MD_unix_map_closedir_error(int err)
45 {
46 switch (err) {
47 case EINVAL:
48 case EBADF:
49 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
50 break;
51 default:
52 PR_SetError(PR_UNKNOWN_ERROR, err);
53 break;
54 }
55 }
56
57 void _MD_unix_readdir_error(int err)
58 {
59
60 switch (err) {
61 case 0:
62 case ENOENT:
63 PR_SetError(PR_NO_MORE_FILES_ERROR, err);
64 break;
65 case EBADF:
66 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
67 break;
68 #ifdef IRIX
69 #ifdef IRIX5_3
70 #else
71 case EDIRCORRUPTED:
72 PR_SetError(PR_DIRECTORY_CORRUPTED_ERROR, err);
73 break;
74 #endif
75 #endif
76 #ifdef EOVERFLOW
77 case EOVERFLOW:
78 PR_SetError(PR_IO_ERROR, err);
79 break;
80 #endif
81 case EINVAL:
82 PR_SetError(PR_IO_ERROR, err);
83 break;
84 #ifdef EBADMSG
85 case EBADMSG:
86 PR_SetError(PR_IO_ERROR, err);
87 break;
88 #endif
89 case EDEADLK:
90 PR_SetError(PR_DEADLOCK_ERROR, err);
91 break;
92 case EFAULT:
93 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
94 break;
95 case EINTR:
96 PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
97 break;
98 case EIO:
99 PR_SetError(PR_IO_ERROR, err);
100 break;
101 case ENOLCK:
102 PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
103 break;
104 #ifdef ENOLINK
105 case ENOLINK:
106 PR_SetError(PR_REMOTE_FILE_ERROR, err);
107 break;
108 #endif
109 case ENXIO:
110 PR_SetError(PR_IO_ERROR, err);
111 break;
112 default:
113 PR_SetError(PR_UNKNOWN_ERROR, err);
114 break;
115 }
116 }
117
118 void _MD_unix_map_unlink_error(int err)
119 {
120 switch (err) {
121 case EACCES:
122 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
123 break;
124 case EBUSY:
125 PR_SetError(PR_FILESYSTEM_MOUNTED_ERROR, err);
126 break;
127 case EFAULT:
128 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
129 break;
130 case EINTR:
131 PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
132 break;
133 case ELOOP:
134 PR_SetError(PR_LOOP_ERROR, err);
135 break;
136 case ENAMETOOLONG:
137 PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
138 break;
139 case ENOENT:
140 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
141 break;
142 case ENOTDIR:
143 PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
144 break;
145 case EPERM:
146 PR_SetError(PR_IS_DIRECTORY_ERROR, err);
147 break;
148 case EROFS:
149 PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
150 break;
151 default:
152 PR_SetError(PR_UNKNOWN_ERROR, err);
153 break;
154 }
155 }
156
157 void _MD_unix_map_stat_error(int err)
158 {
159 switch (err) {
160 case EACCES:
161 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
162 break;
163 case EFAULT:
164 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
165 break;
166 case EINTR:
167 PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
168 break;
169 case ETIMEDOUT:
170 PR_SetError(PR_REMOTE_FILE_ERROR, err);
171 break;
172 case ELOOP:
173 PR_SetError(PR_LOOP_ERROR, err);
174 break;
175 case ENAMETOOLONG:
176 PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
177 break;
178 case ENOENT:
179 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
180 break;
181 case ENOTDIR:
182 PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
183 break;
184 #ifdef EOVERFLOW
185 case EOVERFLOW:
186 PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
187 break;
188 #endif
189 default:
190 PR_SetError(PR_UNKNOWN_ERROR, err);
191 break;
192 }
193 }
194
195 void _MD_unix_map_fstat_error(int err)
196 {
197 switch (err) {
198 case EBADF:
199 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
200 break;
201 case EFAULT:
202 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
203 break;
204 case EINTR:
205 PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
206 break;
207 case ETIMEDOUT:
208 #ifdef ENOLINK
209 case ENOLINK:
210 #endif
211 PR_SetError(PR_REMOTE_FILE_ERROR, err);
212 break;
213 #ifdef EOVERFLOW
214 case EOVERFLOW:
215 PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
216 break;
217 #endif
218 default:
219 PR_SetError(PR_UNKNOWN_ERROR, err);
220 break;
221 }
222 }
223
224 void _MD_unix_map_rename_error(int err)
225 {
226 switch (err) {
227 case EACCES:
228 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
229 break;
230 case EBUSY:
231 PR_SetError(PR_FILESYSTEM_MOUNTED_ERROR, err);
232 break;
233 #ifdef EDQUOT
234 case EDQUOT:
235 PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
236 break;
237 #endif
238 case EEXIST:
239 PR_SetError(PR_DIRECTORY_NOT_EMPTY_ERROR, err);
240 break;
241 case EFAULT:
242 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
243 break;
244 case EINTR:
245 PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
246 break;
247 case EINVAL:
248 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
249 break;
250 case EIO:
251 PR_SetError(PR_IO_ERROR, err);
252 break;
253 case EISDIR:
254 PR_SetError(PR_IS_DIRECTORY_ERROR, err);
255 break;
256 case ELOOP:
257 PR_SetError(PR_LOOP_ERROR, err);
258 break;
259 case ENAMETOOLONG:
260 PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
261 break;
262 case ENOENT:
263 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
264 break;
265 case ENOSPC:
266 PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
267 break;
268 case ENOTDIR:
269 PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
270 break;
271 case EROFS:
272 PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
273 break;
274 case EXDEV:
275 PR_SetError(PR_NOT_SAME_DEVICE_ERROR, err);
276 break;
277 case EMLINK:
278 PR_SetError(PR_MAX_DIRECTORY_ENTRIES_ERROR, err);
279 break;
280 default:
281 PR_SetError(PR_UNKNOWN_ERROR, err);
282 break;
283 }
284 }
285
286 void _MD_unix_map_access_error(int err)
287 {
288 switch (err) {
289 case EACCES:
290 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
291 break;
292 case EFAULT:
293 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
294 break;
295 case EINTR:
296 PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
297 break;
298 case EINVAL:
299 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
300 break;
301 case ELOOP:
302 PR_SetError(PR_LOOP_ERROR, err);
303 break;
304 case ETIMEDOUT:
305 PR_SetError(PR_REMOTE_FILE_ERROR, err);
306 break;
307 case ENAMETOOLONG:
308 PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
309 break;
310 case ENOENT:
311 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
312 break;
313 case ENOTDIR:
314 PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
315 break;
316 case EROFS:
317 PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
318 break;
319 default:
320 PR_SetError(PR_UNKNOWN_ERROR, err);
321 break;
322 }
323 }
324
325 void _MD_unix_map_mkdir_error(int err)
326 {
327 switch (err) {
328 case ENOTDIR:
329 PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
330 break;
331 case ENOENT:
332 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
333 break;
334 case ENAMETOOLONG:
335 PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
336 break;
337 case EACCES:
338 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
339 break;
340 case EEXIST:
341 PR_SetError(PR_FILE_EXISTS_ERROR, err);
342 break;
343 case EROFS:
344 PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
345 break;
346 case EFAULT:
347 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
348 break;
349 case ELOOP:
350 PR_SetError(PR_LOOP_ERROR, err);
351 break;
352 case EMLINK:
353 PR_SetError(PR_MAX_DIRECTORY_ENTRIES_ERROR, err);
354 break;
355 case ENOSPC:
356 PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
357 break;
358 #ifdef EDQUOT
359 case EDQUOT:
360 PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
361 break;
362 #endif
363 case EIO:
364 PR_SetError(PR_IO_ERROR, err);
365 break;
366 default:
367 PR_SetError(PR_UNKNOWN_ERROR, err);
368 break;
369 }
370 }
371
372 void _MD_unix_map_rmdir_error(int err)
373 {
374
375 switch (err) {
376 case EACCES:
377 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
378 break;
379 case EBUSY:
380 PR_SetError(PR_FILESYSTEM_MOUNTED_ERROR, err);
381 break;
382 case EEXIST:
383 PR_SetError(PR_DIRECTORY_NOT_EMPTY_ERROR, err);
384 break;
385 case EFAULT:
386 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
387 break;
388 case EINVAL:
389 PR_SetError(PR_DIRECTORY_NOT_EMPTY_ERROR, err);
390 break;
391 case EIO:
392 PR_SetError(PR_IO_ERROR, err);
393 break;
394 case ELOOP:
395 PR_SetError(PR_LOOP_ERROR, err);
396 break;
397 case ETIMEDOUT:
398 PR_SetError(PR_REMOTE_FILE_ERROR, err);
399 break;
400 case ENAMETOOLONG:
401 PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
402 break;
403 case ENOENT:
404 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
405 break;
406 case ENOTDIR:
407 PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
408 break;
409 case EROFS:
410 PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
411 break;
412 default:
413 PR_SetError(PR_UNKNOWN_ERROR, err);
414 break;
415 }
416 }
417
418 void _MD_unix_map_read_error(int err)
419 {
420 switch (err) {
421 case EACCES:
422 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
423 break;
424 case EAGAIN:
425 #if EWOULDBLOCK != EAGAIN
426 case EWOULDBLOCK:
427 #endif
428 PR_SetError(PR_WOULD_BLOCK_ERROR, err);
429 break;
430 case EBADF:
431 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
432 break;
433 #ifdef EBADMSG
434 case EBADMSG:
435 PR_SetError(PR_IO_ERROR, err);
436 break;
437 #endif
438 case EDEADLK:
439 PR_SetError(PR_DEADLOCK_ERROR, err);
440 break;
441 case EFAULT:
442 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
443 break;
444 case EINTR:
445 PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
446 break;
447 case EINVAL:
448 PR_SetError(PR_INVALID_METHOD_ERROR, err);
449 break;
450 case EIO:
451 PR_SetError(PR_IO_ERROR, err);
452 break;
453 case ENOLCK:
454 PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
455 break;
456 case ENXIO:
457 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
458 break;
459 case EISDIR:
460 PR_SetError(PR_IS_DIRECTORY_ERROR, err);
461 break;
462 case ECONNRESET:
463 case EPIPE:
464 PR_SetError(PR_CONNECT_RESET_ERROR, err);
465 break;
466 #ifdef ENOLINK
467 case ENOLINK:
468 PR_SetError(PR_REMOTE_FILE_ERROR, err);
469 break;
470 #endif
471 default:
472 PR_SetError(PR_UNKNOWN_ERROR, err);
473 break;
474 }
475 }
476
477 void _MD_unix_map_write_error(int err)
478 {
479 switch (err) {
480 case EAGAIN:
481 #if EWOULDBLOCK != EAGAIN
482 case EWOULDBLOCK:
483 #endif
484 PR_SetError(PR_WOULD_BLOCK_ERROR, err);
485 break;
486 case EBADF:
487 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
488 break;
489 case EDEADLK:
490 PR_SetError(PR_DEADLOCK_ERROR, err);
491 break;
492 case EFAULT:
493 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
494 break;
495 case EFBIG:
496 PR_SetError(PR_FILE_TOO_BIG_ERROR, err);
497 break;
498 case EINTR:
499 PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
500 break;
501 case EINVAL:
502 PR_SetError(PR_INVALID_METHOD_ERROR, err);
503 break;
504 case EIO:
505 PR_SetError(PR_IO_ERROR, err);
506 break;
507 case ENOLCK:
508 PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
509 break;
510 #ifdef ENOSR
511 case ENOSR:
512 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
513 break;
514 #endif
515 case ENOSPC:
516 PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
517 break;
518 case ENXIO:
519 PR_SetError(PR_INVALID_METHOD_ERROR, err);
520 break;
521 case ERANGE:
522 PR_SetError(PR_INVALID_METHOD_ERROR, err);
523 break;
524 case ETIMEDOUT:
525 PR_SetError(PR_REMOTE_FILE_ERROR, err);
526 break;
527 case ECONNRESET:
528 case EPIPE:
529 PR_SetError(PR_CONNECT_RESET_ERROR, err);
530 break;
531 #ifdef EDQUOT
532 case EDQUOT:
533 PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
534 break;
535 #endif
536 #ifdef ENOLINK
537 case ENOLINK:
538 PR_SetError(PR_REMOTE_FILE_ERROR, err);
539 break;
540 #endif
541 default:
542 PR_SetError(PR_UNKNOWN_ERROR, err);
543 break;
544 }
545 }
546
547 void _MD_unix_map_lseek_error(int err)
548 {
549 switch (err) {
550 case EBADF:
551 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
552 break;
553 case ESPIPE:
554 PR_SetError(PR_INVALID_METHOD_ERROR, err);
555 break;
556 case EINVAL:
557 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
558 break;
559 default:
560 PR_SetError(PR_UNKNOWN_ERROR, err);
561 break;
562 }
563 }
564
565 void _MD_unix_map_fsync_error(int err)
566 {
567 switch (err) {
568 case EBADF:
569 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
570 break;
571 #ifdef ENOLINK
572 case ENOLINK:
573 #endif
574 case ETIMEDOUT:
575 PR_SetError(PR_REMOTE_FILE_ERROR, err);
576 break;
577 case EINTR:
578 PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
579 break;
580 case EIO:
581 PR_SetError(PR_IO_ERROR, err);
582 break;
583 case EINVAL:
584 PR_SetError(PR_INVALID_METHOD_ERROR, err);
585 break;
586 default:
587 PR_SetError(PR_UNKNOWN_ERROR, err);
588 break;
589 }
590 }
591
592 void _MD_unix_map_close_error(int err)
593 {
594 switch (err) {
595 case EBADF:
596 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
597 break;
598 case EINTR:
599 PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
600 break;
601 #ifdef ENOLINK
602 case ENOLINK:
603 #endif
604 case ETIMEDOUT:
605 PR_SetError(PR_REMOTE_FILE_ERROR, err);
606 break;
607 case EIO:
608 PR_SetError(PR_IO_ERROR, err);
609 break;
610 default:
611 PR_SetError(PR_UNKNOWN_ERROR, err);
612 break;
613 }
614 }
615
616 void _MD_unix_map_socket_error(int err)
617 {
618 switch (err) {
619 case EPROTONOSUPPORT:
620 PR_SetError(PR_PROTOCOL_NOT_SUPPORTED_ERROR, err);
621 break;
622 case EMFILE:
623 PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
624 break;
625 case ENFILE:
626 PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
627 break;
628 case EACCES:
629 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
630 break;
631 #if !defined(SCO)
632 case ENOBUFS:
633 #endif /* !defined(SCO) */
634 case ENOMEM:
635 #ifdef ENOSR
636 case ENOSR:
637 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
638 break;
639 #endif
640 default:
641 PR_SetError(PR_UNKNOWN_ERROR, err);
642 break;
643 }
644 }
645
646 void _MD_unix_map_socketavailable_error(int err)
647 {
648 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
649 }
650
651 void _MD_unix_map_recv_error(int err)
652 {
653 switch (err) {
654 case EAGAIN:
655 #if EWOULDBLOCK != EAGAIN
656 case EWOULDBLOCK:
657 #endif
658 PR_SetError(PR_WOULD_BLOCK_ERROR, err);
659 break;
660 case EBADF:
661 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
662 break;
663 #if !defined(BEOS)
664 case ENOTSOCK:
665 PR_SetError(PR_NOT_SOCKET_ERROR, err);
666 break;
667 #endif
668 case EINTR:
669 PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
670 break;
671 case EFAULT:
672 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
673 break;
674 case ENOMEM:
675 PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
676 break;
677 case ECONNRESET:
678 case EPIPE:
679 PR_SetError(PR_CONNECT_RESET_ERROR, err);
680 break;
681 #ifdef ENOSR
682 case ENOSR:
683 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
684 break;
685 #endif
686 default:
687 PR_SetError(PR_UNKNOWN_ERROR, err);
688 break;
689 }
690 }
691
692 void _MD_unix_map_recvfrom_error(int err)
693 {
694 switch (err) {
695 case EAGAIN:
696 #if EWOULDBLOCK != EAGAIN
697 case EWOULDBLOCK:
698 #endif
699 PR_SetError(PR_WOULD_BLOCK_ERROR, err);
700 break;
701 case EBADF:
702 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
703 break;
704 #if !defined(BEOS)
705 case ENOTSOCK:
706 PR_SetError(PR_NOT_SOCKET_ERROR, err);
707 break;
708 #endif
709 case EINTR:
710 PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
711 break;
712 case EFAULT:
713 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
714 break;
715 case ENOMEM:
716 PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
717 break;
718 #ifdef ENOSR
719 case ENOSR:
720 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
721 break;
722 #endif
723 case ECONNRESET:
724 PR_SetError(PR_CONNECT_RESET_ERROR, err);
725 break;
726 default:
727 PR_SetError(PR_UNKNOWN_ERROR, err);
728 break;
729 }
730 }
731
732 void _MD_unix_map_send_error(int err)
733 {
734 switch (err) {
735 case EAGAIN:
736 #if EWOULDBLOCK != EAGAIN
737 case EWOULDBLOCK:
738 #endif
739 PR_SetError(PR_WOULD_BLOCK_ERROR, err);
740 break;
741 case EBADF:
742 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
743 break;
744 #if !defined(BEOS)
745 case ENOTSOCK:
746 PR_SetError(PR_NOT_SOCKET_ERROR, err);
747 break;
748 #endif
749 #if !defined(BEOS)
750 case EMSGSIZE:
751 #endif
752 case EINVAL:
753 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
754 break;
755 #if !defined(SCO)
756 case ENOBUFS:
757 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
758 break;
759 #endif /* !defined(SCO) */
760 case ECONNREFUSED:
761 PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
762 break;
763 case EISCONN:
764 PR_SetError(PR_IS_CONNECTED_ERROR, err);
765 break;
766 case EFAULT:
767 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
768 break;
769 case EINTR:
770 PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
771 break;
772 case ENOMEM:
773 PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
774 break;
775 #ifdef ENOSR
776 case ENOSR:
777 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
778 break;
779 #endif
780 case ECONNRESET:
781 case EPIPE:
782 PR_SetError(PR_CONNECT_RESET_ERROR, err);
783 break;
784 default:
785 PR_SetError(PR_UNKNOWN_ERROR, err);
786 break;
787 }
788 }
789
790 void _MD_unix_map_sendto_error(int err)
791 {
792 switch (err) {
793 case EAGAIN:
794 #if EWOULDBLOCK != EAGAIN
795 case EWOULDBLOCK:
796 #endif
797 PR_SetError(PR_WOULD_BLOCK_ERROR, err);
798 break;
799 case EBADF:
800 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
801 break;
802 #if !defined(BEOS)
803 case ENOTSOCK:
804 PR_SetError(PR_NOT_SOCKET_ERROR, err);
805 break;
806 #endif
807 #if !defined(BEOS)
808 case EMSGSIZE:
809 #endif
810 case EINVAL:
811 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
812 break;
813 #if !defined(SCO)
814 case ENOBUFS:
815 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
816 break;
817 #endif /* !defined(SCO) */
818 case ECONNREFUSED:
819 PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
820 break;
821 case EISCONN:
822 PR_SetError(PR_IS_CONNECTED_ERROR, err);
823 break;
824 case EFAULT:
825 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
826 break;
827 case EINTR:
828 PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
829 break;
830 case ENOMEM:
831 PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
832 break;
833 #ifdef ENOSR
834 case ENOSR:
835 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
836 break;
837 #endif
838 case ECONNRESET:
839 case EPIPE:
840 PR_SetError(PR_CONNECT_RESET_ERROR, err);
841 break;
842 default:
843 PR_SetError(PR_UNKNOWN_ERROR, err);
844 break;
845 }
846 }
847
848 void _MD_unix_map_writev_error(int err)
849 {
850 switch (err) {
851 case EAGAIN:
852 #if EWOULDBLOCK != EAGAIN
853 case EWOULDBLOCK:
854 #endif
855 PR_SetError(PR_WOULD_BLOCK_ERROR, err);
856 break;
857 case EBADF:
858 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
859 break;
860 case EFAULT:
861 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
862 break;
863 case EINTR:
864 PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
865 break;
866 #ifdef ENOSR
867 case ENOSR:
868 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
869 break;
870 #endif
871 case EINVAL:
872 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
873 break;
874 case ECONNRESET:
875 case EPIPE:
876 PR_SetError(PR_CONNECT_RESET_ERROR, err);
877 break;
878 default:
879 PR_SetError(PR_UNKNOWN_ERROR, err);
880 break;
881 }
882 }
883
884 void _MD_unix_map_accept_error(int err)
885 {
886 switch (err) {
887 case EAGAIN:
888 #if EWOULDBLOCK != EAGAIN
889 case EWOULDBLOCK:
890 #endif
891 PR_SetError(PR_WOULD_BLOCK_ERROR, err);
892 break;
893 case EBADF:
894 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
895 break;
896 #if !defined(BEOS)
897 case ENOTSOCK:
898 PR_SetError(PR_NOT_SOCKET_ERROR, err);
899 break;
900 #endif
901 #if !defined(BEOS)
902 case EOPNOTSUPP:
903 #endif
904 case ENODEV:
905 PR_SetError(PR_NOT_TCP_SOCKET_ERROR, err);
906 break;
907 case EFAULT:
908 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
909 break;
910 case EMFILE:
911 PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
912 break;
913 case ENFILE:
914 PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
915 break;
916 case EINTR:
917 PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
918 break;
919 case ENOMEM:
920 PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
921 break;
922 #ifdef ENOSR
923 case ENOSR:
924 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
925 break;
926 #endif
927 #ifdef EPROTO
928 case EPROTO:
929 PR_SetError(PR_IO_ERROR, err);
930 break;
931 #endif
932 default:
933 PR_SetError(PR_UNKNOWN_ERROR, err);
934 break;
935 }
936 }
937
938 void _MD_unix_map_connect_error(int err)
939 {
940 switch (err) {
941 case EBADF:
942 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
943 break;
944 case EADDRNOTAVAIL:
945 PR_SetError(PR_ADDRESS_NOT_AVAILABLE_ERROR, err);
946 break;
947 case EINPROGRESS:
948 PR_SetError(PR_IN_PROGRESS_ERROR, err);
949 break;
950 case EALREADY:
951 PR_SetError(PR_ALREADY_INITIATED_ERROR, err);
952 break;
953 #if !defined(BEOS)
954 case ENOTSOCK:
955 PR_SetError(PR_NOT_SOCKET_ERROR, err);
956 break;
957 #endif
958 case EAFNOSUPPORT:
959 PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
960 break;
961 case EISCONN:
962 PR_SetError(PR_IS_CONNECTED_ERROR, err);
963 break;
964 case ETIMEDOUT:
965 PR_SetError(PR_IO_TIMEOUT_ERROR, err);
966 break;
967 case ECONNREFUSED:
968 PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
969 break;
970 case ENETUNREACH:
971 PR_SetError(PR_NETWORK_UNREACHABLE_ERROR, err);
972 break;
973 case EADDRINUSE:
974 PR_SetError(PR_ADDRESS_IN_USE_ERROR, err);
975 break;
976 case EFAULT:
977 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
978 break;
979 /*
980 * UNIX domain sockets are not supported in NSPR
981 */
982 case EACCES:
983 PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
984 break;
985 case EINTR:
986 PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
987 break;
988 case EINVAL:
989 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
990 break;
991 case EIO:
992 #if defined(UNIXWARE)
993 /*
994 * On some platforms, if we connect to a port on
995 * the local host (the loopback address) that no
996 * process is listening on, we get EIO instead
997 * of ECONNREFUSED.
998 */
999 PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
1000 #else
1001 PR_SetError(PR_IO_ERROR, err);
1002 #endif
1003 break;
1004 case ELOOP:
1005 PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
1006 break;
1007 case ENOENT:
1008 PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
1009 break;
1010 #ifdef ENOSR
1011 case ENOSR:
1012 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
1013 break;
1014 #endif
1015 case ENXIO:
1016 PR_SetError(PR_IO_ERROR, err);
1017 break;
1018 case EPROTOTYPE:
1019 PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
1020 break;
1021 default:
1022 PR_SetError(PR_UNKNOWN_ERROR, err);
1023 break;
1024 }
1025 }
1026
1027 void _MD_unix_map_bind_error(int err)
1028 {
1029 switch (err) {
1030 case EBADF:
1031 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
1032 break;
1033 #if !defined(BEOS)
1034 case ENOTSOCK:
1035 PR_SetError(PR_NOT_SOCKET_ERROR, err);
1036 break;
1037 #endif
1038 case EFAULT:
1039 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
1040 break;
1041 case EADDRNOTAVAIL:
1042 PR_SetError(PR_ADDRESS_NOT_AVAILABLE_ERROR, err);
1043 break;
1044 case EADDRINUSE:
1045 PR_SetError(PR_ADDRESS_IN_USE_ERROR, err);
1046 break;
1047 case EACCES:
1048 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
1049 break;
1050 case EINVAL:
1051 PR_SetError(PR_SOCKET_ADDRESS_IS_BOUND_ERROR, err);
1052 break;
1053 #ifdef ENOSR
1054 case ENOSR:
1055 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
1056 break;
1057 #endif
1058 /*
1059 * UNIX domain sockets are not supported in NSPR
1060 */
1061 case EIO:
1062 case EISDIR:
1063 case ELOOP:
1064 case ENOENT:
1065 case ENOTDIR:
1066 case EROFS:
1067 PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
1068 break;
1069 default:
1070 PR_SetError(PR_UNKNOWN_ERROR, err);
1071 break;
1072 }
1073 }
1074
1075 void _MD_unix_map_listen_error(int err)
1076 {
1077 switch (err) {
1078 case EBADF:
1079 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
1080 break;
1081 #if !defined(BEOS)
1082 case ENOTSOCK:
1083 PR_SetError(PR_NOT_SOCKET_ERROR, err);
1084 break;
1085 #endif
1086 #if !defined(BEOS)
1087 case EOPNOTSUPP:
1088 PR_SetError(PR_NOT_TCP_SOCKET_ERROR, err);
1089 break;
1090 #endif
1091 default:
1092 PR_SetError(PR_UNKNOWN_ERROR, err);
1093 break;
1094 }
1095 }
1096
1097 void _MD_unix_map_shutdown_error(int err)
1098 {
1099 switch (err) {
1100 case EBADF:
1101 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
1102 break;
1103 #if !defined(BEOS)
1104 case ENOTSOCK:
1105 PR_SetError(PR_NOT_SOCKET_ERROR, err);
1106 break;
1107 #endif
1108 case ENOTCONN:
1109 PR_SetError(PR_NOT_CONNECTED_ERROR, err);
1110 break;
1111 case ENOMEM:
1112 PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
1113 break;
1114 #ifdef ENOSR
1115 case ENOSR:
1116 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
1117 break;
1118 #endif
1119 default:
1120 PR_SetError(PR_UNKNOWN_ERROR, err);
1121 break;
1122 }
1123 }
1124
1125 void _MD_unix_map_socketpair_error(int err)
1126 {
1127 switch (err) {
1128 case EMFILE:
1129 PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
1130 break;
1131 case EFAULT:
1132 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
1133 break;
1134 case ENOMEM:
1135 #ifdef ENOSR
1136 case ENOSR:
1137 #endif
1138 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
1139 break;
1140 case EAFNOSUPPORT:
1141 case EPROTONOSUPPORT:
1142 #if !defined(BEOS)
1143 case EOPNOTSUPP:
1144 #endif
1145 default:
1146 PR_SetError(PR_UNKNOWN_ERROR, err);
1147 break;
1148 }
1149 }
1150
1151 void _MD_unix_map_getsockname_error(int err)
1152 {
1153 switch (err) {
1154 case EBADF:
1155 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
1156 break;
1157 #if !defined(BEOS)
1158 case ENOTSOCK:
1159 PR_SetError(PR_NOT_SOCKET_ERROR, err);
1160 break;
1161 #endif
1162 case EFAULT:
1163 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
1164 break;
1165 #if !defined(SCO)
1166 case ENOBUFS:
1167 #endif /* !defined(SCO) */
1168 case ENOMEM:
1169 #ifdef ENOSR
1170 case ENOSR:
1171 #endif
1172 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
1173 break;
1174 default:
1175 PR_SetError(PR_UNKNOWN_ERROR, err);
1176 break;
1177 }
1178 }
1179
1180 void _MD_unix_map_getpeername_error(int err)
1181 {
1182
1183 switch (err) {
1184 case EBADF:
1185 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
1186 break;
1187 #if !defined(BEOS)
1188 case ENOTSOCK:
1189 PR_SetError(PR_NOT_SOCKET_ERROR, err);
1190 break;
1191 #endif
1192 case ENOTCONN:
1193 PR_SetError(PR_NOT_CONNECTED_ERROR, err);
1194 break;
1195 case EFAULT:
1196 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
1197 break;
1198 #if !defined(SCO)
1199 case ENOBUFS:
1200 #endif /* !defined(SCO) */
1201 case ENOMEM:
1202 #ifdef ENOSR
1203 case ENOSR:
1204 #endif
1205 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
1206 break;
1207 default:
1208 PR_SetError(PR_UNKNOWN_ERROR, err);
1209 break;
1210 }
1211 }
1212
1213 void _MD_unix_map_getsockopt_error(int err)
1214 {
1215 switch (err) {
1216 case EBADF:
1217 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
1218 break;
1219 #if !defined(BEOS)
1220 case ENOTSOCK:
1221 PR_SetError(PR_NOT_SOCKET_ERROR, err);
1222 break;
1223 #endif
1224 case ENOPROTOOPT:
1225 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
1226 break;
1227 case EFAULT:
1228 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
1229 break;
1230 case EINVAL:
1231 PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
1232 break;
1233 case ENOMEM:
1234 #ifdef ENOSR
1235 case ENOSR:
1236 #endif
1237 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
1238 break;
1239 default:
1240 PR_SetError(PR_UNKNOWN_ERROR, err);
1241 break;
1242 }
1243 }
1244
1245 void _MD_unix_map_setsockopt_error(int err)
1246 {
1247 switch (err) {
1248 case EBADF:
1249 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
1250 break;
1251 #if !defined(BEOS)
1252 case ENOTSOCK:
1253 PR_SetError(PR_NOT_SOCKET_ERROR, err);
1254 break;
1255 #endif
1256 case ENOPROTOOPT:
1257 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
1258 break;
1259 case EFAULT:
1260 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
1261 break;
1262 case EINVAL:
1263 PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
1264 break;
1265 case ENOMEM:
1266 #ifdef ENOSR
1267 case ENOSR:
1268 #endif
1269 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
1270 break;
1271 default:
1272 PR_SetError(PR_UNKNOWN_ERROR, err);
1273 break;
1274 }
1275 }
1276
1277 void _MD_unix_map_open_error(int err)
1278 {
1279 switch (err) {
1280 case EACCES:
1281 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
1282 break;
1283 case EAGAIN:
1284 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
1285 break;
1286 case EBUSY:
1287 PR_SetError(PR_IO_ERROR, err);
1288 break;
1289 case EEXIST:
1290 PR_SetError(PR_FILE_EXISTS_ERROR, err);
1291 break;
1292 case EFAULT:
1293 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
1294 break;
1295 case EINTR:
1296 PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
1297 break;
1298 case EINVAL:
1299 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
1300 break;
1301 case EIO:
1302 PR_SetError(PR_IO_ERROR, err);
1303 break;
1304 case EISDIR:
1305 PR_SetError(PR_IS_DIRECTORY_ERROR, err);
1306 break;
1307 case ELOOP:
1308 PR_SetError(PR_LOOP_ERROR, err);
1309 break;
1310 case EMFILE:
1311 PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
1312 break;
1313 case ENAMETOOLONG:
1314 PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
1315 break;
1316 case ENFILE:
1317 PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
1318 break;
1319 case ENODEV:
1320 case ENOENT:
1321 case ENXIO:
1322 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
1323 break;
1324 case ENOMEM:
1325 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
1326 break;
1327 case ENOSPC:
1328 PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
1329 break;
1330 #ifdef ENOSR
1331 case ENOSR:
1332 #endif
1333 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
1334 break;
1335 case ENOTDIR:
1336 PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
1337 break;
1338 case EPERM:
1339 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
1340 break;
1341 case ETIMEDOUT:
1342 PR_SetError(PR_REMOTE_FILE_ERROR, err);
1343 break;
1344 case EROFS:
1345 PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
1346 break;
1347 default:
1348 PR_SetError(PR_UNKNOWN_ERROR, err);
1349 break;
1350 }
1351 }
1352
1353 void _MD_unix_map_mmap_error(int err)
1354 {
1355
1356 switch (err) {
1357 case EBADF:
1358 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
1359 break;
1360 case EAGAIN:
1361 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
1362 break;
1363 case EACCES:
1364 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
1365 break;
1366 case ENOMEM:
1367 PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
1368 break;
1369 default:
1370 PR_SetError(PR_UNKNOWN_ERROR, err);
1371 break;
1372 }
1373 }
1374
1375 void _MD_unix_map_gethostname_error(int err)
1376 {
1377 switch (err) {
1378 case EFAULT:
1379 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
1380 break;
1381 default:
1382 PR_SetError(PR_UNKNOWN_ERROR, err);
1383 break;
1384 }
1385 }
1386
1387 void _MD_unix_map_select_error(int err)
1388 {
1389 switch (err) {
1390 case EBADF:
1391 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
1392 break;
1393 case EINTR:
1394 PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
1395 break;
1396 case EINVAL:
1397 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
1398 break;
1399 default:
1400 PR_SetError(PR_UNKNOWN_ERROR, err);
1401 break;
1402 }
1403 }
1404
1405 void _MD_unix_map_poll_error(int err)
1406 {
1407 PRErrorCode prerror;
1408 switch (err) {
1409 case EAGAIN:
1410 prerror = PR_INSUFFICIENT_RESOURCES_ERROR;
1411 break;
1412 case EINVAL:
1413 prerror = PR_INVALID_ARGUMENT_ERROR;
1414 break;
1415 case EFAULT:
1416 prerror = PR_ACCESS_FAULT_ERROR;
1417 break;
1418 default:
1419 prerror = PR_UNKNOWN_ERROR;
1420 break;
1421 }
1422 PR_SetError(prerror, err);
1423 }
1424
1425 void _MD_unix_map_flock_error(int err)
1426 {
1427 switch (err) {
1428 case EBADF:
1429 case EINVAL:
1430 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
1431 break;
1432 case EWOULDBLOCK:
1433 PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
1434 break;
1435 default:
1436 PR_SetError(PR_UNKNOWN_ERROR, err);
1437 break;
1438 }
1439 }
1440
1441 void _MD_unix_map_lockf_error(int err)
1442 {
1443 switch (err) {
1444 case EBADF:
1445 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
1446 break;
1447 case EACCES:
1448 PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
1449 break;
1450 case EDEADLK:
1451 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
1452 break;
1453 default:
1454 PR_SetError(PR_UNKNOWN_ERROR, err);
1455 break;
1456 }
1457 }
1458
1459 #ifdef HPUX11
1460 void _MD_hpux_map_sendfile_error(int oserror)
1461 {
1462 PRErrorCode prerror;
1463
1464 switch (oserror) {
1465 case ENOTSOCK:
1466 prerror = PR_NOT_SOCKET_ERROR;
1467 break;
1468 case EFAULT:
1469 prerror = PR_ACCESS_FAULT_ERROR;
1470 break;
1471 case ENOBUFS:
1472 prerror = PR_INSUFFICIENT_RESOURCES_ERROR;
1473 break;
1474 case EINVAL:
1475 prerror = PR_INVALID_ARGUMENT_ERROR;
1476 break;
1477 case ENOTCONN:
1478 prerror = PR_NOT_CONNECTED_ERROR;
1479 break;
1480 case EPIPE:
1481 prerror = PR_CONNECT_RESET_ERROR;
1482 break;
1483 case ENOMEM:
1484 prerror = PR_OUT_OF_MEMORY_ERROR;
1485 break;
1486 case EOPNOTSUPP:
1487 prerror = PR_NOT_TCP_SOCKET_ERROR;
1488 break;
1489 default:
1490 prerror = PR_UNKNOWN_ERROR;
1491 }
1492 PR_SetError(prerror, oserror);
1493 }
1494 #endif /* HPUX11 */

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial