1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 : /* ***** BEGIN LICENSE BLOCK *****
3 : * Version: MPL 1.1/GPL 2.0/LGPL 2.1
4 : *
5 : * The contents of this file are subject to the Mozilla Public License Version
6 : * 1.1 (the "License"); you may not use this file except in compliance with
7 : * the License. You may obtain a copy of the License at
8 : * http://www.mozilla.org/MPL/
9 : *
10 : * Software distributed under the License is distributed on an "AS IS" basis,
11 : * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
12 : * for the specific language governing rights and limitations under the
13 : * License.
14 : *
15 : * The Original Code is the Netscape Portable Runtime (NSPR).
16 : *
17 : * The Initial Developer of the Original Code is
18 : * Netscape Communications Corporation.
19 : * Portions created by the Initial Developer are Copyright (C) 1998-2000
20 : * the Initial Developer. All Rights Reserved.
21 : *
22 : * Contributor(s):
23 : *
24 : * Alternatively, the contents of this file may be used under the terms of
25 : * either the GNU General Public License Version 2 or later (the "GPL"), or
26 : * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
27 : * in which case the provisions of the GPL or the LGPL are applicable instead
28 : * of those above. If you wish to allow use of your version of this file only
29 : * under the terms of either the GPL or the LGPL, and not to allow others to
30 : * use your version of this file under the terms of the MPL, indicate your
31 : * decision by deleting the provisions above and replace them with the notice
32 : * and other provisions required by the GPL or the LGPL. If you do not delete
33 : * the provisions above, a recipient may use your version of this file under
34 : * the terms of any one of the MPL, the GPL or the LGPL.
35 : *
36 : * ***** END LICENSE BLOCK ***** */
37 :
38 : #include "primpl.h"
39 : #if defined(_PR_POLL_AVAILABLE)
40 : #include <poll.h>
41 : #endif
42 : #include <errno.h>
43 :
44 11901 : void _MD_unix_map_default_error(int err)
45 : {
46 : PRErrorCode prError;
47 :
48 11901 : switch (err ) {
49 : case EACCES:
50 0 : prError = PR_NO_ACCESS_RIGHTS_ERROR;
51 0 : break;
52 : case EADDRINUSE:
53 1 : prError = PR_ADDRESS_IN_USE_ERROR;
54 1 : break;
55 : case EADDRNOTAVAIL:
56 0 : prError = PR_ADDRESS_NOT_AVAILABLE_ERROR;
57 0 : break;
58 : case EAFNOSUPPORT:
59 0 : prError = PR_ADDRESS_NOT_SUPPORTED_ERROR;
60 0 : break;
61 : case EAGAIN:
62 6381 : prError = PR_WOULD_BLOCK_ERROR;
63 6381 : break;
64 : /*
65 : * On QNX and Neutrino, EALREADY is defined as EBUSY.
66 : */
67 : #if EALREADY != EBUSY
68 : case EALREADY:
69 0 : prError = PR_ALREADY_INITIATED_ERROR;
70 0 : break;
71 : #endif
72 : case EBADF:
73 0 : prError = PR_BAD_DESCRIPTOR_ERROR;
74 0 : break;
75 : #ifdef EBADMSG
76 : case EBADMSG:
77 0 : prError = PR_IO_ERROR;
78 0 : break;
79 : #endif
80 : case EBUSY:
81 0 : prError = PR_FILESYSTEM_MOUNTED_ERROR;
82 0 : break;
83 : case ECONNABORTED:
84 0 : prError = PR_CONNECT_ABORTED_ERROR;
85 0 : break;
86 : case ECONNREFUSED:
87 136 : prError = PR_CONNECT_REFUSED_ERROR;
88 136 : break;
89 : case ECONNRESET:
90 0 : prError = PR_CONNECT_RESET_ERROR;
91 0 : break;
92 : case EDEADLK:
93 0 : prError = PR_DEADLOCK_ERROR;
94 0 : break;
95 : #ifdef EDIRCORRUPTED
96 : case EDIRCORRUPTED:
97 : prError = PR_DIRECTORY_CORRUPTED_ERROR;
98 : break;
99 : #endif
100 : #ifdef EDQUOT
101 : case EDQUOT:
102 0 : prError = PR_NO_DEVICE_SPACE_ERROR;
103 0 : break;
104 : #endif
105 : case EEXIST:
106 1531 : prError = PR_FILE_EXISTS_ERROR;
107 1531 : break;
108 : case EFAULT:
109 0 : prError = PR_ACCESS_FAULT_ERROR;
110 0 : break;
111 : case EFBIG:
112 0 : prError = PR_FILE_TOO_BIG_ERROR;
113 0 : break;
114 : case EHOSTUNREACH:
115 0 : prError = PR_HOST_UNREACHABLE_ERROR;
116 0 : break;
117 : case EINPROGRESS:
118 3006 : prError = PR_IN_PROGRESS_ERROR;
119 3006 : break;
120 : case EINTR:
121 0 : prError = PR_PENDING_INTERRUPT_ERROR;
122 0 : break;
123 : case EINVAL:
124 0 : prError = PR_INVALID_ARGUMENT_ERROR;
125 0 : break;
126 : case EIO:
127 0 : prError = PR_IO_ERROR;
128 0 : break;
129 : case EISCONN:
130 0 : prError = PR_IS_CONNECTED_ERROR;
131 0 : break;
132 : case EISDIR:
133 0 : prError = PR_IS_DIRECTORY_ERROR;
134 0 : break;
135 : case ELOOP:
136 0 : prError = PR_LOOP_ERROR;
137 0 : break;
138 : case EMFILE:
139 0 : prError = PR_PROC_DESC_TABLE_FULL_ERROR;
140 0 : break;
141 : case EMLINK:
142 0 : prError = PR_MAX_DIRECTORY_ENTRIES_ERROR;
143 0 : break;
144 : case EMSGSIZE:
145 0 : prError = PR_INVALID_ARGUMENT_ERROR;
146 0 : break;
147 : #ifdef EMULTIHOP
148 : case EMULTIHOP:
149 0 : prError = PR_REMOTE_FILE_ERROR;
150 0 : break;
151 : #endif
152 : case ENAMETOOLONG:
153 0 : prError = PR_NAME_TOO_LONG_ERROR;
154 0 : break;
155 : case ENETUNREACH:
156 0 : prError = PR_NETWORK_UNREACHABLE_ERROR;
157 0 : break;
158 : case ENFILE:
159 0 : prError = PR_SYS_DESC_TABLE_FULL_ERROR;
160 0 : break;
161 : /*
162 : * On SCO OpenServer 5, ENOBUFS is defined as ENOSR.
163 : */
164 : #if defined(ENOBUFS) && (ENOBUFS != ENOSR)
165 : case ENOBUFS:
166 0 : prError = PR_INSUFFICIENT_RESOURCES_ERROR;
167 0 : break;
168 : #endif
169 : case ENODEV:
170 0 : prError = PR_FILE_NOT_FOUND_ERROR;
171 0 : break;
172 : case ENOENT:
173 835 : prError = PR_FILE_NOT_FOUND_ERROR;
174 835 : break;
175 : case ENOLCK:
176 0 : prError = PR_FILE_IS_LOCKED_ERROR;
177 0 : break;
178 : #ifdef ENOLINK
179 : case ENOLINK:
180 0 : prError = PR_REMOTE_FILE_ERROR;
181 0 : break;
182 : #endif
183 : case ENOMEM:
184 0 : prError = PR_OUT_OF_MEMORY_ERROR;
185 0 : break;
186 : case ENOPROTOOPT:
187 0 : prError = PR_INVALID_ARGUMENT_ERROR;
188 0 : break;
189 : case ENOSPC:
190 0 : prError = PR_NO_DEVICE_SPACE_ERROR;
191 0 : break;
192 : #ifdef ENOSR
193 : case ENOSR:
194 0 : prError = PR_INSUFFICIENT_RESOURCES_ERROR;
195 0 : break;
196 : #endif
197 : case ENOSYS:
198 0 : prError = PR_NOT_IMPLEMENTED_ERROR;
199 0 : break;
200 : case ENOTCONN:
201 8 : prError = PR_NOT_CONNECTED_ERROR;
202 8 : break;
203 : case ENOTDIR:
204 0 : prError = PR_NOT_DIRECTORY_ERROR;
205 0 : break;
206 : case ENOTSOCK:
207 0 : prError = PR_NOT_SOCKET_ERROR;
208 0 : break;
209 : case ENXIO:
210 0 : prError = PR_FILE_NOT_FOUND_ERROR;
211 0 : break;
212 : case EOPNOTSUPP:
213 0 : prError = PR_NOT_TCP_SOCKET_ERROR;
214 0 : break;
215 : #ifdef EOVERFLOW
216 : case EOVERFLOW:
217 0 : prError = PR_BUFFER_OVERFLOW_ERROR;
218 0 : break;
219 : #endif
220 : case EPERM:
221 0 : prError = PR_NO_ACCESS_RIGHTS_ERROR;
222 0 : break;
223 : case EPIPE:
224 3 : prError = PR_CONNECT_RESET_ERROR;
225 3 : break;
226 : #ifdef EPROTO
227 : case EPROTO:
228 0 : prError = PR_IO_ERROR;
229 0 : break;
230 : #endif
231 : case EPROTONOSUPPORT:
232 0 : prError = PR_PROTOCOL_NOT_SUPPORTED_ERROR;
233 0 : break;
234 : case EPROTOTYPE:
235 0 : prError = PR_ADDRESS_NOT_SUPPORTED_ERROR;
236 0 : break;
237 : case ERANGE:
238 0 : prError = PR_INVALID_METHOD_ERROR;
239 0 : break;
240 : case EROFS:
241 0 : prError = PR_READ_ONLY_FILESYSTEM_ERROR;
242 0 : break;
243 : case ESPIPE:
244 0 : prError = PR_INVALID_METHOD_ERROR;
245 0 : break;
246 : case ETIMEDOUT:
247 0 : prError = PR_IO_TIMEOUT_ERROR;
248 0 : break;
249 : #if EWOULDBLOCK != EAGAIN
250 : case EWOULDBLOCK:
251 : prError = PR_WOULD_BLOCK_ERROR;
252 : break;
253 : #endif
254 : case EXDEV:
255 0 : prError = PR_NOT_SAME_DEVICE_ERROR;
256 0 : break;
257 : default:
258 0 : prError = PR_UNKNOWN_ERROR;
259 0 : break;
260 : }
261 11901 : PR_SetError(prError, err);
262 11901 : }
263 :
264 0 : void _MD_unix_map_opendir_error(int err)
265 : {
266 0 : _MD_unix_map_default_error(err);
267 0 : }
268 :
269 0 : void _MD_unix_map_closedir_error(int err)
270 : {
271 : PRErrorCode prError;
272 :
273 0 : switch (err) {
274 : case EINVAL:
275 0 : prError = PR_BAD_DESCRIPTOR_ERROR;
276 : break;
277 : default:
278 0 : _MD_unix_map_default_error(err);
279 0 : return;
280 : }
281 0 : PR_SetError(prError, err);
282 : }
283 :
284 0 : void _MD_unix_readdir_error(int err)
285 : {
286 : PRErrorCode prError;
287 :
288 0 : switch (err) {
289 : case 0:
290 : case ENOENT:
291 0 : prError = PR_NO_MORE_FILES_ERROR;
292 0 : break;
293 : #ifdef EOVERFLOW
294 : case EOVERFLOW:
295 0 : prError = PR_IO_ERROR;
296 0 : break;
297 : #endif
298 : case EINVAL:
299 0 : prError = PR_IO_ERROR;
300 0 : break;
301 : case ENXIO:
302 0 : prError = PR_IO_ERROR;
303 0 : break;
304 : default:
305 0 : _MD_unix_map_default_error(err);
306 0 : return;
307 : }
308 0 : PR_SetError(prError, err);
309 : }
310 :
311 0 : void _MD_unix_map_unlink_error(int err)
312 : {
313 : PRErrorCode prError;
314 :
315 0 : switch (err) {
316 : case EPERM:
317 0 : prError = PR_IS_DIRECTORY_ERROR;
318 : break;
319 : default:
320 0 : _MD_unix_map_default_error(err);
321 0 : return;
322 : }
323 0 : PR_SetError(prError, err);
324 : }
325 :
326 0 : void _MD_unix_map_stat_error(int err)
327 : {
328 : PRErrorCode prError;
329 :
330 0 : switch (err) {
331 : case ETIMEDOUT:
332 0 : prError = PR_REMOTE_FILE_ERROR;
333 : break;
334 : default:
335 0 : _MD_unix_map_default_error(err);
336 0 : return;
337 : }
338 0 : PR_SetError(prError, err);
339 : }
340 :
341 0 : void _MD_unix_map_fstat_error(int err)
342 : {
343 : PRErrorCode prError;
344 :
345 0 : switch (err) {
346 : case ETIMEDOUT:
347 0 : prError = PR_REMOTE_FILE_ERROR;
348 : break;
349 : default:
350 0 : _MD_unix_map_default_error(err);
351 0 : return;
352 : }
353 0 : PR_SetError(prError, err);
354 : }
355 :
356 0 : void _MD_unix_map_rename_error(int err)
357 : {
358 : PRErrorCode prError;
359 :
360 0 : switch (err) {
361 : case EEXIST:
362 0 : prError = PR_DIRECTORY_NOT_EMPTY_ERROR;
363 : break;
364 : default:
365 0 : _MD_unix_map_default_error(err);
366 0 : return;
367 : }
368 0 : PR_SetError(prError, err);
369 : }
370 :
371 0 : void _MD_unix_map_access_error(int err)
372 : {
373 : PRErrorCode prError;
374 :
375 0 : switch (err) {
376 : case ETIMEDOUT:
377 0 : prError = PR_REMOTE_FILE_ERROR;
378 : break;
379 : default:
380 0 : _MD_unix_map_default_error(err);
381 0 : return;
382 : }
383 0 : PR_SetError(prError, err);
384 : }
385 :
386 0 : void _MD_unix_map_mkdir_error(int err)
387 : {
388 0 : _MD_unix_map_default_error(err);
389 0 : }
390 :
391 0 : void _MD_unix_map_rmdir_error(int err)
392 : {
393 : PRErrorCode prError;
394 :
395 0 : switch (err) {
396 : /*
397 : * On AIX 4.3, ENOTEMPTY is defined as EEXIST.
398 : */
399 : #if ENOTEMPTY != EEXIST
400 : case ENOTEMPTY:
401 0 : prError = PR_DIRECTORY_NOT_EMPTY_ERROR;
402 0 : break;
403 : #endif
404 : case EEXIST:
405 0 : prError = PR_DIRECTORY_NOT_EMPTY_ERROR;
406 0 : break;
407 : case EINVAL:
408 0 : prError = PR_DIRECTORY_NOT_EMPTY_ERROR;
409 0 : break;
410 : case ETIMEDOUT:
411 0 : prError = PR_REMOTE_FILE_ERROR;
412 0 : break;
413 : default:
414 0 : _MD_unix_map_default_error(err);
415 0 : return;
416 : }
417 0 : PR_SetError(prError, err);
418 : }
419 :
420 0 : void _MD_unix_map_read_error(int err)
421 : {
422 : PRErrorCode prError;
423 :
424 0 : switch (err) {
425 : case EINVAL:
426 0 : prError = PR_INVALID_METHOD_ERROR;
427 0 : break;
428 : case ENXIO:
429 0 : prError = PR_INVALID_ARGUMENT_ERROR;
430 0 : break;
431 : default:
432 0 : _MD_unix_map_default_error(err);
433 0 : return;
434 : }
435 0 : PR_SetError(prError, err);
436 : }
437 :
438 0 : void _MD_unix_map_write_error(int err)
439 : {
440 : PRErrorCode prError;
441 :
442 0 : switch (err) {
443 : case EINVAL:
444 0 : prError = PR_INVALID_METHOD_ERROR;
445 0 : break;
446 : case ENXIO:
447 0 : prError = PR_INVALID_METHOD_ERROR;
448 0 : break;
449 : case ETIMEDOUT:
450 0 : prError = PR_REMOTE_FILE_ERROR;
451 0 : break;
452 : default:
453 0 : _MD_unix_map_default_error(err);
454 0 : return;
455 : }
456 0 : PR_SetError(prError, err);
457 : }
458 :
459 0 : void _MD_unix_map_lseek_error(int err)
460 : {
461 0 : _MD_unix_map_default_error(err);
462 0 : }
463 :
464 0 : void _MD_unix_map_fsync_error(int err)
465 : {
466 : PRErrorCode prError;
467 :
468 0 : switch (err) {
469 : case ETIMEDOUT:
470 0 : prError = PR_REMOTE_FILE_ERROR;
471 0 : break;
472 : case EINVAL:
473 0 : prError = PR_INVALID_METHOD_ERROR;
474 0 : break;
475 : default:
476 0 : _MD_unix_map_default_error(err);
477 0 : return;
478 : }
479 0 : PR_SetError(prError, err);
480 : }
481 :
482 0 : void _MD_unix_map_close_error(int err)
483 : {
484 : PRErrorCode prError;
485 :
486 0 : switch (err) {
487 : case ETIMEDOUT:
488 0 : prError = PR_REMOTE_FILE_ERROR;
489 : break;
490 : default:
491 0 : _MD_unix_map_default_error(err);
492 0 : return;
493 : }
494 0 : PR_SetError(prError, err);
495 : }
496 :
497 0 : void _MD_unix_map_socket_error(int err)
498 : {
499 : PRErrorCode prError;
500 :
501 0 : switch (err) {
502 : case ENOMEM:
503 0 : prError = PR_INSUFFICIENT_RESOURCES_ERROR;
504 : break;
505 : default:
506 0 : _MD_unix_map_default_error(err);
507 0 : return;
508 : }
509 0 : PR_SetError(prError, err);
510 : }
511 :
512 0 : void _MD_unix_map_socketavailable_error(int err)
513 : {
514 0 : PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
515 0 : }
516 :
517 6365 : void _MD_unix_map_recv_error(int err)
518 : {
519 6365 : _MD_unix_map_default_error(err);
520 6365 : }
521 :
522 0 : void _MD_unix_map_recvfrom_error(int err)
523 : {
524 0 : _MD_unix_map_default_error(err);
525 0 : }
526 :
527 19 : void _MD_unix_map_send_error(int err)
528 : {
529 19 : _MD_unix_map_default_error(err);
530 19 : }
531 :
532 0 : void _MD_unix_map_sendto_error(int err)
533 : {
534 0 : _MD_unix_map_default_error(err);
535 0 : }
536 :
537 0 : void _MD_unix_map_writev_error(int err)
538 : {
539 0 : _MD_unix_map_default_error(err);
540 0 : }
541 :
542 0 : void _MD_unix_map_accept_error(int err)
543 : {
544 : PRErrorCode prError;
545 :
546 0 : switch (err) {
547 : case ENODEV:
548 0 : prError = PR_NOT_TCP_SOCKET_ERROR;
549 : break;
550 : default:
551 0 : _MD_unix_map_default_error(err);
552 0 : return;
553 : }
554 0 : PR_SetError(prError, err);
555 : }
556 :
557 3142 : void _MD_unix_map_connect_error(int err)
558 : {
559 : PRErrorCode prError;
560 :
561 3142 : switch (err) {
562 : case EACCES:
563 0 : prError = PR_ADDRESS_NOT_SUPPORTED_ERROR;
564 0 : break;
565 : #if defined(UNIXWARE) || defined(SNI) || defined(NEC)
566 : /*
567 : * On some platforms, if we connect to a port on the local host
568 : * (the loopback address) that no process is listening on, we get
569 : * EIO instead of ECONNREFUSED.
570 : */
571 : case EIO:
572 : prError = PR_CONNECT_REFUSED_ERROR;
573 : break;
574 : #endif
575 : case ELOOP:
576 0 : prError = PR_ADDRESS_NOT_SUPPORTED_ERROR;
577 0 : break;
578 : case ENOENT:
579 0 : prError = PR_ADDRESS_NOT_SUPPORTED_ERROR;
580 0 : break;
581 : case ENXIO:
582 0 : prError = PR_IO_ERROR;
583 0 : break;
584 : default:
585 3142 : _MD_unix_map_default_error(err);
586 3142 : return;
587 : }
588 0 : PR_SetError(prError, err);
589 : }
590 :
591 1 : void _MD_unix_map_bind_error(int err)
592 : {
593 : PRErrorCode prError;
594 :
595 1 : switch (err) {
596 : case EINVAL:
597 0 : prError = PR_SOCKET_ADDRESS_IS_BOUND_ERROR;
598 0 : break;
599 : /*
600 : * UNIX domain sockets are not supported in NSPR
601 : */
602 : case EIO:
603 : case EISDIR:
604 : case ELOOP:
605 : case ENOENT:
606 : case ENOTDIR:
607 : case EROFS:
608 0 : prError = PR_ADDRESS_NOT_SUPPORTED_ERROR;
609 0 : break;
610 : default:
611 1 : _MD_unix_map_default_error(err);
612 1 : return;
613 : }
614 0 : PR_SetError(prError, err);
615 : }
616 :
617 0 : void _MD_unix_map_listen_error(int err)
618 : {
619 0 : _MD_unix_map_default_error(err);
620 0 : }
621 :
622 0 : void _MD_unix_map_shutdown_error(int err)
623 : {
624 0 : _MD_unix_map_default_error(err);
625 0 : }
626 :
627 0 : void _MD_unix_map_socketpair_error(int err)
628 : {
629 : PRErrorCode prError;
630 :
631 0 : switch (err) {
632 : case ENOMEM:
633 0 : prError = PR_INSUFFICIENT_RESOURCES_ERROR;
634 : break;
635 : default:
636 0 : _MD_unix_map_default_error(err);
637 0 : return;
638 : }
639 0 : PR_SetError(prError, err);
640 : }
641 :
642 0 : void _MD_unix_map_getsockname_error(int err)
643 : {
644 : PRErrorCode prError;
645 :
646 0 : switch (err) {
647 : case ENOMEM:
648 0 : prError = PR_INSUFFICIENT_RESOURCES_ERROR;
649 : break;
650 : default:
651 0 : _MD_unix_map_default_error(err);
652 0 : return;
653 : }
654 0 : PR_SetError(prError, err);
655 : }
656 :
657 8 : void _MD_unix_map_getpeername_error(int err)
658 : {
659 : PRErrorCode prError;
660 :
661 8 : switch (err) {
662 : case ENOMEM:
663 0 : prError = PR_INSUFFICIENT_RESOURCES_ERROR;
664 : break;
665 : default:
666 8 : _MD_unix_map_default_error(err);
667 8 : return;
668 : }
669 0 : PR_SetError(prError, err);
670 : }
671 :
672 0 : void _MD_unix_map_getsockopt_error(int err)
673 : {
674 : PRErrorCode prError;
675 :
676 0 : switch (err) {
677 : case EINVAL:
678 0 : prError = PR_BUFFER_OVERFLOW_ERROR;
679 0 : break;
680 : case ENOMEM:
681 0 : prError = PR_INSUFFICIENT_RESOURCES_ERROR;
682 0 : break;
683 : default:
684 0 : _MD_unix_map_default_error(err);
685 0 : return;
686 : }
687 0 : PR_SetError(prError, err);
688 : }
689 :
690 0 : void _MD_unix_map_setsockopt_error(int err)
691 : {
692 : PRErrorCode prError;
693 :
694 0 : switch (err) {
695 : case EINVAL:
696 0 : prError = PR_BUFFER_OVERFLOW_ERROR;
697 0 : break;
698 : case ENOMEM:
699 0 : prError = PR_INSUFFICIENT_RESOURCES_ERROR;
700 0 : break;
701 : default:
702 0 : _MD_unix_map_default_error(err);
703 0 : return;
704 : }
705 0 : PR_SetError(prError, err);
706 : }
707 :
708 2366 : void _MD_unix_map_open_error(int err)
709 : {
710 : PRErrorCode prError;
711 :
712 2366 : switch (err) {
713 : case EAGAIN:
714 0 : prError = PR_INSUFFICIENT_RESOURCES_ERROR;
715 0 : break;
716 : case EBUSY:
717 0 : prError = PR_IO_ERROR;
718 0 : break;
719 : case ENODEV:
720 0 : prError = PR_FILE_NOT_FOUND_ERROR;
721 0 : break;
722 : case ENOMEM:
723 0 : prError = PR_INSUFFICIENT_RESOURCES_ERROR;
724 0 : break;
725 : #ifdef EOVERFLOW
726 : case EOVERFLOW:
727 0 : prError = PR_FILE_TOO_BIG_ERROR;
728 0 : break;
729 : #endif
730 : case ETIMEDOUT:
731 0 : prError = PR_REMOTE_FILE_ERROR;
732 0 : break;
733 : default:
734 2366 : _MD_unix_map_default_error(err);
735 2366 : return;
736 : }
737 0 : PR_SetError(prError, err);
738 : }
739 :
740 1 : void _MD_unix_map_mmap_error(int err)
741 : {
742 : PRErrorCode prError;
743 :
744 1 : switch (err) {
745 : case EAGAIN:
746 0 : prError = PR_INSUFFICIENT_RESOURCES_ERROR;
747 0 : break;
748 : case EMFILE:
749 0 : prError = PR_INSUFFICIENT_RESOURCES_ERROR;
750 0 : break;
751 : case ENODEV:
752 1 : prError = PR_OPERATION_NOT_SUPPORTED_ERROR;
753 1 : break;
754 : case ENXIO:
755 0 : prError = PR_INVALID_ARGUMENT_ERROR;
756 0 : break;
757 : default:
758 0 : _MD_unix_map_default_error(err);
759 0 : return;
760 : }
761 1 : PR_SetError(prError, err);
762 : }
763 :
764 0 : void _MD_unix_map_gethostname_error(int err)
765 : {
766 0 : _MD_unix_map_default_error(err);
767 0 : }
768 :
769 0 : void _MD_unix_map_select_error(int err)
770 : {
771 0 : _MD_unix_map_default_error(err);
772 0 : }
773 :
774 : #if defined(_PR_POLL_AVAILABLE) || defined(_PR_NEED_FAKE_POLL)
775 0 : void _MD_unix_map_poll_error(int err)
776 : {
777 : PRErrorCode prError;
778 :
779 0 : switch (err) {
780 : case EAGAIN:
781 0 : prError = PR_INSUFFICIENT_RESOURCES_ERROR;
782 : break;
783 : default:
784 0 : _MD_unix_map_default_error(err);
785 0 : return;
786 : }
787 0 : PR_SetError(prError, err);
788 : }
789 :
790 0 : void _MD_unix_map_poll_revents_error(int err)
791 : {
792 0 : if (err & POLLNVAL)
793 0 : PR_SetError(PR_BAD_DESCRIPTOR_ERROR, EBADF);
794 0 : else if (err & POLLHUP)
795 0 : PR_SetError(PR_CONNECT_RESET_ERROR, EPIPE);
796 0 : else if (err & POLLERR)
797 0 : PR_SetError(PR_IO_ERROR, EIO);
798 : else
799 0 : PR_SetError(PR_UNKNOWN_ERROR, err);
800 0 : }
801 : #endif /* _PR_POLL_AVAILABLE || _PR_NEED_FAKE_POLL */
802 :
803 :
804 0 : void _MD_unix_map_flock_error(int err)
805 : {
806 : PRErrorCode prError;
807 :
808 0 : switch (err) {
809 : case EINVAL:
810 0 : prError = PR_BAD_DESCRIPTOR_ERROR;
811 0 : break;
812 : case EWOULDBLOCK:
813 0 : prError = PR_FILE_IS_LOCKED_ERROR;
814 0 : break;
815 : default:
816 0 : _MD_unix_map_default_error(err);
817 0 : return;
818 : }
819 0 : PR_SetError(prError, err);
820 : }
821 :
822 0 : void _MD_unix_map_lockf_error(int err)
823 : {
824 : PRErrorCode prError;
825 :
826 0 : switch (err) {
827 : case EACCES:
828 0 : prError = PR_FILE_IS_LOCKED_ERROR;
829 0 : break;
830 : case EDEADLK:
831 0 : prError = PR_INSUFFICIENT_RESOURCES_ERROR;
832 0 : break;
833 : default:
834 0 : _MD_unix_map_default_error(err);
835 0 : return;
836 : }
837 0 : PR_SetError(prError, err);
838 : }
839 :
840 : #ifdef AIX
841 : void _MD_aix_map_sendfile_error(int err)
842 : {
843 : _MD_unix_map_default_error(err);
844 : }
845 : #endif /* AIX */
846 :
847 : #ifdef HPUX11
848 : void _MD_hpux_map_sendfile_error(int err)
849 : {
850 : _MD_unix_map_default_error(err);
851 : }
852 : #endif /* HPUX11 */
853 :
854 : #ifdef SOLARIS
855 : void _MD_solaris_map_sendfile_error(int err)
856 : {
857 : PRErrorCode prError;
858 :
859 : switch (err) {
860 : /*
861 : * Solaris defines a 0 return value for sendfile to mean end-of-file.
862 : */
863 : case 0:
864 : prError = PR_END_OF_FILE_ERROR;
865 : break;
866 :
867 : default:
868 : _MD_unix_map_default_error(err) ;
869 : return;
870 : }
871 : PR_SetError(prError, err);
872 : }
873 : #endif /* SOLARIS */
874 :
875 : #ifdef LINUX
876 0 : void _MD_linux_map_sendfile_error(int err)
877 : {
878 0 : _MD_unix_map_default_error(err) ;
879 0 : }
880 : #endif /* LINUX */
|