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