The Tor Browser / file comparison

comparison: nsprpub/pr/src/md/os2/os2_errors.c

nsprpub/pr/src/md/os2/os2_errors.c

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:8ffe057db197
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 "prerror.h"
7 #include "primpl.h"
8
9 void _MD_os2_map_default_error(PRInt32 err)
10 {
11 switch (err) {
12 case EWOULDBLOCK:
13 PR_SetError(PR_WOULD_BLOCK_ERROR, err);
14 break;
15 case EBADF:
16 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
17 break;
18 case ENOTSOCK:
19 PR_SetError(PR_NOT_SOCKET_ERROR, err);
20 break;
21 case EMSGSIZE:
22 case EINVAL:
23 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
24 break;
25 case ENOBUFS:
26 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
27 break;
28 case ECONNREFUSED:
29 PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
30 break;
31 case EISCONN:
32 PR_SetError(PR_IS_CONNECTED_ERROR, err);
33 break;
34 #ifdef SOCEFAULT
35 case SOCEFAULT:
36 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
37 break;
38 #endif
39 case ERROR_NETNAME_DELETED:
40 PR_SetError(PR_CONNECT_RESET_ERROR, err);
41 break;
42 default:
43 PR_SetError(PR_UNKNOWN_ERROR, err);
44 break;
45 }
46 }
47 void _MD_os2_map_opendir_error(PRInt32 err)
48 {
49 switch (err) {
50 case ERROR_FILE_NOT_FOUND:
51 case ERROR_PATH_NOT_FOUND:
52 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
53 break;
54 case ERROR_ACCESS_DENIED:
55 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
56 break;
57 case ERROR_INVALID_ADDRESS:
58 case ERROR_INVALID_ACCESS:
59 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
60 break;
61 case ERROR_INVALID_NAME:
62 case ERROR_INVALID_PARAMETER:
63 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
64 break;
65 case ERROR_TOO_MANY_OPEN_FILES:
66 case ERROR_NOT_DOS_DISK:
67 case ERROR_NOT_READY:
68 case ERROR_OPEN_FAILED:
69 case ERROR_PATH_BUSY:
70 case ERROR_CANNOT_MAKE:
71 PR_SetError(PR_IO_ERROR, err);
72 break;
73 case ERROR_DRIVE_LOCKED:
74 case ERROR_DEVICE_IN_USE:
75 PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
76 break;
77 case ERROR_FILENAME_EXCED_RANGE:
78 PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
79 break;
80 case ERROR_NOT_ENOUGH_MEMORY:
81 case ERROR_SHARING_BUFFER_EXCEEDED:
82 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
83 break;
84 default:
85 PR_SetError(PR_UNKNOWN_ERROR, err);
86 break;
87 }
88 }
89
90 void _MD_os2_map_closedir_error(PRInt32 err)
91 {
92 switch (err) {
93 case ERROR_FILE_NOT_FOUND:
94 case ERROR_ACCESS_DENIED:
95 case ERROR_INVALID_HANDLE:
96 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
97 break;
98 default:
99 PR_SetError(PR_UNKNOWN_ERROR, err);
100 break;
101 }
102 }
103
104 void _MD_os2_readdir_error(PRInt32 err)
105 {
106
107 switch (err) {
108 case ERROR_NO_MORE_FILES:
109 PR_SetError(PR_NO_MORE_FILES_ERROR, err);
110 break;
111 case ERROR_FILE_NOT_FOUND:
112 case ERROR_INVALID_HANDLE:
113 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
114 break;
115 case ERROR_INVALID_ADDRESS:
116 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
117 break;
118 case ERROR_NOT_DOS_DISK:
119 case ERROR_LOCK_VIOLATION:
120 case ERROR_BROKEN_PIPE:
121 case ERROR_NOT_READY:
122 PR_SetError(PR_IO_ERROR, err);
123 break;
124 case ERROR_NOT_ENOUGH_MEMORY:
125 case ERROR_MORE_DATA:
126 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
127 break;
128 default:
129 PR_SetError(PR_UNKNOWN_ERROR, err);
130 break;
131 }
132 }
133
134 void _MD_os2_map_delete_error(PRInt32 err)
135 {
136 switch (err) {
137 case ERROR_FILE_NOT_FOUND:
138 case ERROR_PATH_NOT_FOUND:
139 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
140 break;
141 case ERROR_ACCESS_DENIED:
142 case ERROR_WRITE_PROTECT:
143 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
144 break;
145 case ERROR_INVALID_ADDRESS:
146 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
147 break;
148 case ERROR_DRIVE_LOCKED:
149 case ERROR_LOCKED:
150 case ERROR_SHARING_VIOLATION:
151 PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
152 break;
153 default:
154 PR_SetError(PR_UNKNOWN_ERROR, err);
155 break;
156 }
157 }
158
159 /* The error code for stat() is in errno. */
160 void _MD_os2_map_stat_error(PRInt32 err)
161 {
162 switch (err) {
163 case ENOENT:
164 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
165 break;
166 case EACCES:
167 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
168 break;
169 default:
170 PR_SetError(PR_UNKNOWN_ERROR, err);
171 }
172 }
173
174 void _MD_os2_map_fstat_error(PRInt32 err)
175 {
176 switch (err) {
177 case ERROR_ACCESS_DENIED:
178 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
179 break;
180 case ERROR_INVALID_HANDLE:
181 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
182 break;
183 case ERROR_INVALID_ADDRESS:
184 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
185 break;
186 case ERROR_NOT_READY:
187 case ERROR_PATH_BUSY:
188 PR_SetError(PR_IO_ERROR, err);
189 break;
190 case ERROR_NOT_ENOUGH_MEMORY:
191 case ERROR_MORE_DATA:
192 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
193 break;
194 case ERROR_DRIVE_LOCKED:
195 case ERROR_LOCKED:
196 PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
197 break;
198 default:
199 PR_SetError(PR_UNKNOWN_ERROR, err);
200 break;
201 }
202 }
203
204 void _MD_os2_map_rename_error(PRInt32 err)
205 {
206 switch (err) {
207 case ERROR_FILE_NOT_FOUND:
208 case ERROR_PATH_NOT_FOUND:
209 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
210 break;
211 case ERROR_ACCESS_DENIED:
212 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
213 break;
214 case ERROR_INVALID_ADDRESS:
215 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
216 break;
217 case ERROR_INVALID_NAME:
218 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
219 break;
220 case ERROR_NOT_READY:
221 case ERROR_PATH_BUSY:
222 PR_SetError(PR_IO_ERROR, err);
223 break;
224 case ERROR_DRIVE_LOCKED:
225 PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
226 break;
227 case ERROR_FILENAME_EXCED_RANGE:
228 PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
229 break;
230 case ERROR_NOT_ENOUGH_MEMORY:
231 case ERROR_MORE_DATA:
232 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
233 break;
234 case ERROR_ALREADY_EXISTS:
235 case ERROR_FILE_EXISTS:
236 PR_SetError(PR_FILE_EXISTS_ERROR, err);
237 break;
238 default:
239 PR_SetError(PR_UNKNOWN_ERROR, err);
240 break;
241 }
242 }
243
244 /* The error code for access() is in errno. */
245 void _MD_os2_map_access_error(PRInt32 err)
246 {
247 switch (err) {
248 case ENOENT:
249 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
250 break;
251 case EACCES:
252 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
253 break;
254 default:
255 PR_SetError(PR_UNKNOWN_ERROR, err);
256 }
257 }
258
259 void _MD_os2_map_mkdir_error(PRInt32 err)
260 {
261 switch (err) {
262 case ERROR_ALREADY_EXISTS:
263 case ERROR_FILE_EXISTS:
264 PR_SetError(PR_FILE_EXISTS_ERROR, err);
265 break;
266 case ERROR_FILE_NOT_FOUND:
267 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
268 break;
269 case ERROR_ACCESS_DENIED:
270 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
271 break;
272 case ERROR_INVALID_ADDRESS:
273 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
274 break;
275 case ERROR_INVALID_NAME:
276 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
277 break;
278 case ERROR_NOT_READY:
279 case ERROR_PATH_BUSY:
280 PR_SetError(PR_IO_ERROR, err);
281 break;
282 case ERROR_DRIVE_LOCKED:
283 PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
284 break;
285 case ERROR_FILENAME_EXCED_RANGE:
286 PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
287 break;
288 case ERROR_TOO_MANY_OPEN_FILES:
289 PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
290 break;
291 case ERROR_PATH_NOT_FOUND:
292 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
293 break;
294 case ERROR_NOT_ENOUGH_MEMORY:
295 case ERROR_MORE_DATA:
296 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
297 break;
298 case ERROR_DISK_FULL:
299 case ERROR_HANDLE_DISK_FULL:
300 PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
301 break;
302 case ERROR_WRITE_PROTECT:
303 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
304 break;
305 default:
306 PR_SetError(PR_UNKNOWN_ERROR, err);
307 break;
308 }
309 }
310
311 void _MD_os2_map_rmdir_error(PRInt32 err)
312 {
313
314 switch (err) {
315 case ERROR_FILE_NOT_FOUND:
316 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
317 break;
318 case ERROR_ACCESS_DENIED:
319 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
320 break;
321 case ERROR_INVALID_ADDRESS:
322 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
323 break;
324 case ERROR_INVALID_NAME:
325 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
326 break;
327 case ERROR_NOT_READY:
328 case ERROR_PATH_BUSY:
329 PR_SetError(PR_IO_ERROR, err);
330 break;
331 case ERROR_DRIVE_LOCKED:
332 PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
333 break;
334 case ERROR_FILENAME_EXCED_RANGE:
335 PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
336 break;
337 case ERROR_TOO_MANY_OPEN_FILES:
338 PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
339 break;
340 case ERROR_PATH_NOT_FOUND:
341 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
342 break;
343 case ERROR_NOT_ENOUGH_MEMORY:
344 case ERROR_MORE_DATA:
345 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
346 break;
347 case ERROR_WRITE_PROTECT:
348 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
349 break;
350 default:
351 PR_SetError(PR_UNKNOWN_ERROR, err);
352 break;
353 }
354 }
355
356 void _MD_os2_map_read_error(PRInt32 err)
357 {
358 switch (err) {
359 case ERROR_ACCESS_DENIED:
360 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
361 break;
362 case ERROR_INVALID_HANDLE:
363 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
364 break;
365 case ERROR_INVALID_ADDRESS:
366 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
367 break;
368 case ERROR_NOT_READY:
369 case ERROR_PATH_BUSY:
370 PR_SetError(PR_IO_ERROR, err);
371 break;
372 case ERROR_NOT_ENOUGH_MEMORY:
373 case ERROR_MORE_DATA:
374 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
375 break;
376 case ERROR_DRIVE_LOCKED:
377 case ERROR_LOCKED:
378 case ERROR_SHARING_VIOLATION:
379 PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
380 break;
381 case ERROR_NETNAME_DELETED:
382 PR_SetError(PR_CONNECT_RESET_ERROR, err);
383 break;
384 case EBADF:
385 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
386 break;
387 case ENOTSOCK:
388 PR_SetError(PR_NOT_SOCKET_ERROR, err);
389 break;
390 #ifdef SOCEFAULT
391 case SOCEFAULT:
392 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
393 break;
394 #endif
395 default:
396 PR_SetError(PR_UNKNOWN_ERROR, err);
397 break;
398 }
399 }
400
401 void _MD_os2_map_transmitfile_error(PRInt32 err)
402 {
403 switch (err) {
404 case ERROR_ACCESS_DENIED:
405 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
406 break;
407 case ERROR_INVALID_HANDLE:
408 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
409 break;
410 case ERROR_INVALID_ADDRESS:
411 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
412 break;
413 case ERROR_NOT_READY:
414 case ERROR_PATH_BUSY:
415 PR_SetError(PR_IO_ERROR, err);
416 break;
417 case ERROR_NOT_ENOUGH_MEMORY:
418 case ERROR_MORE_DATA:
419 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
420 break;
421 case ERROR_DRIVE_LOCKED:
422 case ERROR_LOCKED:
423 case ERROR_SHARING_VIOLATION:
424 PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
425 break;
426 case ERROR_FILENAME_EXCED_RANGE:
427 PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
428 break;
429 case ERROR_TOO_MANY_OPEN_FILES:
430 PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
431 break;
432 case ERROR_PATH_NOT_FOUND:
433 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
434 break;
435 case EBADF:
436 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
437 break;
438 case ENOTSOCK:
439 PR_SetError(PR_NOT_SOCKET_ERROR, err);
440 break;
441 #ifdef SOCEFAULT
442 case SOCEFAULT:
443 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
444 break;
445 #endif
446 default:
447 PR_SetError(PR_UNKNOWN_ERROR, err);
448 break;
449 }
450 }
451
452 void _MD_os2_map_write_error(PRInt32 err)
453 {
454 switch (err) {
455 case ERROR_ACCESS_DENIED:
456 case ERROR_WRITE_PROTECT:
457 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
458 break;
459 case ERROR_INVALID_HANDLE:
460 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
461 break;
462 case ERROR_INVALID_ADDRESS:
463 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
464 break;
465 case ERROR_NOT_READY:
466 case ERROR_PATH_BUSY:
467 PR_SetError(PR_IO_ERROR, err);
468 break;
469 case ERROR_DRIVE_LOCKED:
470 case ERROR_LOCKED:
471 case ERROR_SHARING_VIOLATION:
472 PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
473 break;
474 case ERROR_NOT_ENOUGH_MEMORY:
475 case ERROR_MORE_DATA:
476 case ERROR_DISK_FULL:
477 case ERROR_HANDLE_DISK_FULL:
478 case ENOSPC:
479 PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
480 break;
481 case ERROR_NETNAME_DELETED:
482 PR_SetError(PR_CONNECT_RESET_ERROR, err);
483 break;
484 case EBADF:
485 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
486 break;
487 case ENOTSOCK:
488 PR_SetError(PR_NOT_SOCKET_ERROR, err);
489 break;
490 case EMSGSIZE:
491 case EINVAL:
492 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
493 break;
494 case ENOBUFS:
495 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
496 break;
497 case ECONNREFUSED:
498 PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
499 break;
500 case EISCONN:
501 PR_SetError(PR_IS_CONNECTED_ERROR, err);
502 break;
503 #ifdef SOCEFAULT
504 case SOCEFAULT:
505 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
506 break;
507 #endif
508 default:
509 PR_SetError(PR_UNKNOWN_ERROR, err);
510 break;
511 }
512 }
513
514 void _MD_os2_map_lseek_error(PRInt32 err)
515 {
516 switch (err) {
517 case ERROR_INVALID_HANDLE:
518 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
519 break;
520 case ERROR_SEEK_ON_DEVICE:
521 PR_SetError(PR_IO_ERROR, err);
522 break;
523 default:
524 PR_SetError(PR_UNKNOWN_ERROR, err);
525 break;
526 }
527 }
528
529 void _MD_os2_map_fsync_error(PRInt32 err)
530 {
531 switch (err) {
532 case ERROR_ACCESS_DENIED:
533 case ERROR_WRITE_PROTECT:
534 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
535 break;
536 case ERROR_INVALID_HANDLE:
537 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
538 break;
539 case ERROR_NOT_ENOUGH_MEMORY:
540 case ERROR_MORE_DATA:
541 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
542 break;
543 case ERROR_DISK_FULL:
544 case ERROR_HANDLE_DISK_FULL:
545 PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
546 break;
547 default:
548 PR_SetError(PR_UNKNOWN_ERROR, err);
549 break;
550 }
551 }
552
553 void _MD_os2_map_close_error(PRInt32 err)
554 {
555 switch (err) {
556 case ERROR_INVALID_HANDLE:
557 case EBADF:
558 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
559 break;
560 case ERROR_NOT_READY:
561 case ERROR_PATH_BUSY:
562 PR_SetError(PR_IO_ERROR, err);
563 break;
564 default:
565 PR_SetError(PR_UNKNOWN_ERROR, err);
566 break;
567 }
568 }
569
570 void _MD_os2_map_socket_error(PRInt32 err)
571 {
572 switch (err) {
573 case EPROTONOSUPPORT:
574 PR_SetError(PR_PROTOCOL_NOT_SUPPORTED_ERROR, err);
575 break;
576 case EACCES:
577 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
578 break;
579 case ERROR_NOT_ENOUGH_MEMORY:
580 case ERROR_MORE_DATA:
581 case ENOBUFS:
582 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
583 break;
584 default:
585 PR_SetError(PR_UNKNOWN_ERROR, err);
586 break;
587 }
588 }
589
590 void _MD_os2_map_recv_error(PRInt32 err)
591 {
592 switch (err) {
593 case EWOULDBLOCK:
594 PR_SetError(PR_WOULD_BLOCK_ERROR, err);
595 break;
596 case EBADF:
597 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
598 break;
599 case ENOTSOCK:
600 PR_SetError(PR_NOT_SOCKET_ERROR, err);
601 break;
602 #ifdef SOCEFAULT
603 case SOCEFAULT:
604 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
605 break;
606 #endif
607 case ERROR_NETNAME_DELETED:
608 PR_SetError(PR_CONNECT_RESET_ERROR, err);
609 break;
610 default:
611 PR_SetError(PR_UNKNOWN_ERROR, err);
612 break;
613 }
614 }
615
616 void _MD_os2_map_recvfrom_error(PRInt32 err)
617 {
618 switch (err) {
619 case EWOULDBLOCK:
620 PR_SetError(PR_WOULD_BLOCK_ERROR, err);
621 break;
622 case EBADF:
623 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
624 break;
625 case ENOTSOCK:
626 PR_SetError(PR_NOT_SOCKET_ERROR, err);
627 break;
628 #ifdef SOCEFAULT
629 case SOCEFAULT:
630 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
631 break;
632 #endif
633 case ERROR_NETNAME_DELETED:
634 PR_SetError(PR_CONNECT_RESET_ERROR, err);
635 break;
636 default:
637 PR_SetError(PR_UNKNOWN_ERROR, err);
638 break;
639 }
640 }
641
642 void _MD_os2_map_send_error(PRInt32 err)
643 {
644 switch (err) {
645 case EWOULDBLOCK:
646 PR_SetError(PR_WOULD_BLOCK_ERROR, err);
647 break;
648 case EBADF:
649 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
650 break;
651 case ENOTSOCK:
652 PR_SetError(PR_NOT_SOCKET_ERROR, err);
653 break;
654 case EMSGSIZE:
655 case EINVAL:
656 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
657 break;
658 case ENOBUFS:
659 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
660 break;
661 case ECONNREFUSED:
662 PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
663 break;
664 case EISCONN:
665 PR_SetError(PR_IS_CONNECTED_ERROR, err);
666 break;
667 #ifdef SOCEFAULT
668 case SOCEFAULT:
669 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
670 break;
671 #endif
672 case ERROR_NETNAME_DELETED:
673 PR_SetError(PR_CONNECT_RESET_ERROR, err);
674 break;
675 default:
676 PR_SetError(PR_UNKNOWN_ERROR, err);
677 break;
678 }
679 }
680
681 void _MD_os2_map_sendto_error(PRInt32 err)
682 {
683 _MD_os2_map_default_error(err);
684 }
685
686 void _MD_os2_map_writev_error(int err)
687 {
688 _MD_os2_map_default_error(err);
689 }
690
691 void _MD_os2_map_accept_error(PRInt32 err)
692 {
693 _MD_os2_map_default_error(err);
694 }
695
696 void _MD_os2_map_acceptex_error(PRInt32 err)
697 {
698 switch (err) {
699 case ERROR_INVALID_HANDLE:
700 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
701 break;
702 case ERROR_INVALID_ADDRESS:
703 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
704 break;
705 case ERROR_NOT_ENOUGH_MEMORY:
706 case ERROR_MORE_DATA:
707 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
708 break;
709 default:
710 PR_SetError(PR_UNKNOWN_ERROR, err);
711 break;
712 }
713 }
714
715 /*
716 * An error code of 0 means that the nonblocking connect succeeded.
717 */
718
719 int _MD_os2_get_nonblocking_connect_error(int osfd)
720 {
721 int err;
722 int len = sizeof(err);
723 if (getsockopt(osfd, SOL_SOCKET, SO_ERROR, (char *) &err, &len) == -1) {
724 return sock_errno();
725 } else {
726 return err;
727 }
728 }
729
730 void _MD_os2_map_connect_error(PRInt32 err)
731 {
732 switch (err) {
733 case EWOULDBLOCK:
734 PR_SetError(PR_WOULD_BLOCK_ERROR, err);
735 break;
736 case EINPROGRESS:
737 PR_SetError(PR_IN_PROGRESS_ERROR, err);
738 break;
739 case EALREADY:
740 case EINVAL:
741 PR_SetError(PR_ALREADY_INITIATED_ERROR, err);
742 break;
743 case EBADF:
744 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
745 break;
746 case EADDRNOTAVAIL:
747 PR_SetError(PR_ADDRESS_NOT_AVAILABLE_ERROR, err);
748 break;
749 case ENOTSOCK:
750 PR_SetError(PR_NOT_SOCKET_ERROR, err);
751 break;
752 case EAFNOSUPPORT:
753 PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
754 break;
755 case ETIMEDOUT:
756 PR_SetError(PR_IO_TIMEOUT_ERROR, err);
757 break;
758 case ECONNREFUSED:
759 PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
760 break;
761 case ENETUNREACH:
762 PR_SetError(PR_NETWORK_UNREACHABLE_ERROR, err);
763 break;
764 case EADDRINUSE:
765 PR_SetError(PR_ADDRESS_IN_USE_ERROR, err);
766 break;
767 case EISCONN:
768 PR_SetError(PR_IS_CONNECTED_ERROR, err);
769 break;
770 #ifdef SOCEFAULT
771 case SOCEFAULT:
772 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
773 break;
774 #endif
775 default:
776 PR_SetError(PR_UNKNOWN_ERROR, err);
777 break;
778 }
779 }
780
781 void _MD_os2_map_bind_error(PRInt32 err)
782 {
783 switch (err) {
784 case EBADF:
785 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
786 break;
787 case ENOTSOCK:
788 PR_SetError(PR_NOT_SOCKET_ERROR, err);
789 break;
790 #ifdef SOCEFAULT
791 case SOCEFAULT:
792 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
793 break;
794 #endif
795 case EADDRNOTAVAIL:
796 PR_SetError(PR_ADDRESS_NOT_AVAILABLE_ERROR, err);
797 break;
798 case EADDRINUSE:
799 PR_SetError(PR_ADDRESS_IN_USE_ERROR, err);
800 break;
801 case EACCES:
802 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
803 break;
804 case EINVAL:
805 PR_SetError(PR_SOCKET_ADDRESS_IS_BOUND_ERROR, err);
806 break;
807 default:
808 PR_SetError(PR_UNKNOWN_ERROR, err);
809 break;
810 }
811 }
812
813 void _MD_os2_map_listen_error(PRInt32 err)
814 {
815 switch (err) {
816 case EBADF:
817 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
818 break;
819 case ENOTSOCK:
820 PR_SetError(PR_NOT_SOCKET_ERROR, err);
821 break;
822 case EOPNOTSUPP:
823 PR_SetError(PR_NOT_TCP_SOCKET_ERROR, err);
824 break;
825 default:
826 PR_SetError(PR_UNKNOWN_ERROR, err);
827 break;
828 }
829 }
830
831 void _MD_os2_map_shutdown_error(PRInt32 err)
832 {
833 switch (err) {
834 case EBADF:
835 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
836 break;
837 case ENOTSOCK:
838 PR_SetError(PR_NOT_SOCKET_ERROR, err);
839 break;
840 case ENOTCONN:
841 PR_SetError(PR_NOT_CONNECTED_ERROR, err);
842 break;
843 default:
844 PR_SetError(PR_UNKNOWN_ERROR, err);
845 break;
846 }
847 }
848
849 void _MD_os2_map_socketpair_error(PRInt32 err)
850 {
851 switch (err) {
852 case ENOMEM:
853 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
854 break;
855 case EAFNOSUPPORT:
856 PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
857 break;
858 case EPROTONOSUPPORT:
859 PR_SetError(PR_PROTOCOL_NOT_SUPPORTED_ERROR, err);
860 break;
861 case EOPNOTSUPP:
862 PR_SetError(PR_NOT_TCP_SOCKET_ERROR, err);
863 break;
864 case EPROTOTYPE:
865 PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
866 break;
867 default:
868 _MD_os2_map_default_error(err);
869 return;
870 }
871 }
872
873 void _MD_os2_map_getsockname_error(PRInt32 err)
874 {
875 switch (err) {
876 case EBADF:
877 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
878 break;
879 case ENOTSOCK:
880 PR_SetError(PR_NOT_SOCKET_ERROR, err);
881 break;
882 #ifdef SOCEFAULT
883 case SOCEFAULT:
884 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
885 break;
886 #endif
887 case ENOBUFS:
888 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
889 break;
890 default:
891 PR_SetError(PR_UNKNOWN_ERROR, err);
892 break;
893 }
894 }
895
896 void _MD_os2_map_getpeername_error(PRInt32 err)
897 {
898
899 switch (err) {
900 case EBADF:
901 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
902 break;
903 case ENOTSOCK:
904 PR_SetError(PR_NOT_SOCKET_ERROR, err);
905 break;
906 case ENOTCONN:
907 PR_SetError(PR_NOT_CONNECTED_ERROR, err);
908 break;
909 #ifdef SOCEFAULT
910 case SOCEFAULT:
911 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
912 break;
913 #endif
914 case ENOBUFS:
915 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
916 break;
917 default:
918 PR_SetError(PR_UNKNOWN_ERROR, err);
919 break;
920 }
921 }
922
923 void _MD_os2_map_getsockopt_error(PRInt32 err)
924 {
925 switch (err) {
926 case EBADF:
927 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
928 break;
929 case ENOTSOCK:
930 PR_SetError(PR_NOT_SOCKET_ERROR, err);
931 break;
932 case ENOPROTOOPT:
933 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
934 break;
935 #ifdef SOCEFAULT
936 case SOCEFAULT:
937 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
938 break;
939 #endif
940 case EINVAL:
941 PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
942 break;
943 default:
944 PR_SetError(PR_UNKNOWN_ERROR, err);
945 break;
946 }
947 }
948
949 void _MD_os2_map_setsockopt_error(PRInt32 err)
950 {
951 switch (err) {
952 case EBADF:
953 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
954 break;
955 case ENOTSOCK:
956 PR_SetError(PR_NOT_SOCKET_ERROR, err);
957 break;
958 case ENOPROTOOPT:
959 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
960 break;
961 #ifdef SOCEFAULT
962 case SOCEFAULT:
963 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
964 break;
965 #endif
966 case EINVAL:
967 PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
968 break;
969 default:
970 PR_SetError(PR_UNKNOWN_ERROR, err);
971 break;
972 }
973 }
974
975 void _MD_os2_map_open_error(PRInt32 err)
976 {
977 switch (err) {
978 case ERROR_ALREADY_EXISTS:
979 case ERROR_FILE_EXISTS:
980 PR_SetError(PR_FILE_EXISTS_ERROR, err);
981 break;
982 case ERROR_FILE_NOT_FOUND:
983 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
984 break;
985 case ERROR_ACCESS_DENIED:
986 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
987 break;
988 case ERROR_INVALID_ADDRESS:
989 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
990 break;
991 case ERROR_INVALID_NAME:
992 PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
993 break;
994 case ERROR_NOT_READY:
995 case ERROR_OPEN_FAILED:
996 case ERROR_PATH_BUSY:
997 PR_SetError(PR_IO_ERROR, err);
998 break;
999 case ERROR_DRIVE_LOCKED:
1000 PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
1001 break;
1002 case ERROR_FILENAME_EXCED_RANGE:
1003 PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
1004 break;
1005 case ERROR_TOO_MANY_OPEN_FILES:
1006 PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
1007 break;
1008 case ERROR_PATH_NOT_FOUND:
1009 PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
1010 break;
1011 case ERROR_NOT_ENOUGH_MEMORY:
1012 case ERROR_MORE_DATA:
1013 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
1014 break;
1015 case ERROR_DISK_FULL:
1016 case ERROR_HANDLE_DISK_FULL:
1017 PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
1018 break;
1019 case ERROR_WRITE_PROTECT:
1020 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
1021 break;
1022 default:
1023 PR_SetError(PR_UNKNOWN_ERROR, err);
1024 break;
1025 }
1026 }
1027
1028 void _MD_os2_map_gethostname_error(PRInt32 err)
1029 {
1030 switch (err) {
1031 #ifdef SOCEFAULT
1032 case SOCEFAULT:
1033 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
1034 break;
1035 #endif
1036 case ENETDOWN:
1037 case EINPROGRESS:
1038 default:
1039 PR_SetError(PR_UNKNOWN_ERROR, err);
1040 break;
1041 }
1042 }
1043
1044 void _MD_os2_map_select_error(PRInt32 err)
1045 {
1046 PRErrorCode prerror;
1047
1048 switch (err) {
1049 /*
1050 * OS/2 select() only works on sockets. So in this
1051 * context, ENOTSOCK is equivalent to EBADF on Unix.
1052 */
1053 case ENOTSOCK:
1054 prerror = PR_BAD_DESCRIPTOR_ERROR;
1055 break;
1056 case EINVAL:
1057 prerror = PR_INVALID_ARGUMENT_ERROR;
1058 break;
1059 #ifdef SOCEFAULT
1060 case SOCEFAULT:
1061 prerror = PR_ACCESS_FAULT_ERROR;
1062 break;
1063 #endif
1064 default:
1065 prerror = PR_UNKNOWN_ERROR;
1066 }
1067 PR_SetError(prerror, err);
1068 }
1069
1070 void _MD_os2_map_lockf_error(PRInt32 err)
1071 {
1072 switch (err) {
1073 case ERROR_ACCESS_DENIED:
1074 PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
1075 break;
1076 case ERROR_INVALID_HANDLE:
1077 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
1078 break;
1079 case ERROR_INVALID_ADDRESS:
1080 PR_SetError(PR_ACCESS_FAULT_ERROR, err);
1081 break;
1082 case ERROR_DRIVE_LOCKED:
1083 case ERROR_LOCKED:
1084 case ERROR_SHARING_VIOLATION:
1085 PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
1086 break;
1087 case ERROR_NOT_ENOUGH_MEMORY:
1088 case ERROR_MORE_DATA:
1089 PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
1090 break;
1091 default:
1092 PR_SetError(PR_UNKNOWN_ERROR, err);
1093 break;
1094 }
1095 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial