OLD | NEW |
| (Empty) |
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ | |
2 /* | |
3 * This file essentially replicates NSPR's source for the functions that | |
4 * map system-specific error codes to NSPR error codes. We would use | |
5 * NSPR's functions, instead of duplicating them, but they're private. | |
6 * As long as SSL's server session cache code must do platform native I/O | |
7 * to accomplish its job, and NSPR's error mapping functions remain private, | |
8 * this code will continue to need to be replicated. | |
9 * | |
10 * This Source Code Form is subject to the terms of the Mozilla Public | |
11 * License, v. 2.0. If a copy of the MPL was not distributed with this | |
12 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ | |
13 | |
14 #include "prerror.h" | |
15 #include "prlog.h" | |
16 #include <errno.h> | |
17 #include <windows.h> | |
18 | |
19 /* | |
20 * On Win32, we map three kinds of error codes: | |
21 * - GetLastError(): for Win32 functions | |
22 * - WSAGetLastError(): for Winsock functions | |
23 * - errno: for standard C library functions | |
24 * | |
25 * We do not check for WSAEINPROGRESS and WSAEINTR because we do not | |
26 * use blocking Winsock 1.1 calls. | |
27 * | |
28 * Except for the 'socket' call, we do not check for WSAEINITIALISED. | |
29 * It is assumed that if Winsock is not initialized, that fact will | |
30 * be detected at the time we create new sockets. | |
31 */ | |
32 | |
33 /* forward declaration. */ | |
34 void nss_MD_win32_map_default_error(PRInt32 err); | |
35 | |
36 void | |
37 nss_MD_win32_map_opendir_error(PRInt32 err) | |
38 { | |
39 nss_MD_win32_map_default_error(err); | |
40 } | |
41 | |
42 void | |
43 nss_MD_win32_map_closedir_error(PRInt32 err) | |
44 { | |
45 nss_MD_win32_map_default_error(err); | |
46 } | |
47 | |
48 void | |
49 nss_MD_win32_map_readdir_error(PRInt32 err) | |
50 { | |
51 nss_MD_win32_map_default_error(err); | |
52 } | |
53 | |
54 void | |
55 nss_MD_win32_map_delete_error(PRInt32 err) | |
56 { | |
57 nss_MD_win32_map_default_error(err); | |
58 } | |
59 | |
60 /* The error code for stat() is in errno. */ | |
61 void | |
62 nss_MD_win32_map_stat_error(PRInt32 err) | |
63 { | |
64 nss_MD_win32_map_default_error(err); | |
65 } | |
66 | |
67 void | |
68 nss_MD_win32_map_fstat_error(PRInt32 err) | |
69 { | |
70 nss_MD_win32_map_default_error(err); | |
71 } | |
72 | |
73 void | |
74 nss_MD_win32_map_rename_error(PRInt32 err) | |
75 { | |
76 nss_MD_win32_map_default_error(err); | |
77 } | |
78 | |
79 /* The error code for access() is in errno. */ | |
80 void | |
81 nss_MD_win32_map_access_error(PRInt32 err) | |
82 { | |
83 nss_MD_win32_map_default_error(err); | |
84 } | |
85 | |
86 void | |
87 nss_MD_win32_map_mkdir_error(PRInt32 err) | |
88 { | |
89 nss_MD_win32_map_default_error(err); | |
90 } | |
91 | |
92 void | |
93 nss_MD_win32_map_rmdir_error(PRInt32 err) | |
94 { | |
95 nss_MD_win32_map_default_error(err); | |
96 } | |
97 | |
98 void | |
99 nss_MD_win32_map_read_error(PRInt32 err) | |
100 { | |
101 nss_MD_win32_map_default_error(err); | |
102 } | |
103 | |
104 void | |
105 nss_MD_win32_map_transmitfile_error(PRInt32 err) | |
106 { | |
107 nss_MD_win32_map_default_error(err); | |
108 } | |
109 | |
110 void | |
111 nss_MD_win32_map_write_error(PRInt32 err) | |
112 { | |
113 nss_MD_win32_map_default_error(err); | |
114 } | |
115 | |
116 void | |
117 nss_MD_win32_map_lseek_error(PRInt32 err) | |
118 { | |
119 nss_MD_win32_map_default_error(err); | |
120 } | |
121 | |
122 void | |
123 nss_MD_win32_map_fsync_error(PRInt32 err) | |
124 { | |
125 nss_MD_win32_map_default_error(err); | |
126 } | |
127 | |
128 /* | |
129 * For both CloseHandle() and closesocket(). | |
130 */ | |
131 void | |
132 nss_MD_win32_map_close_error(PRInt32 err) | |
133 { | |
134 nss_MD_win32_map_default_error(err); | |
135 } | |
136 | |
137 void | |
138 nss_MD_win32_map_socket_error(PRInt32 err) | |
139 { | |
140 PR_ASSERT(err != WSANOTINITIALISED); | |
141 nss_MD_win32_map_default_error(err); | |
142 } | |
143 | |
144 void | |
145 nss_MD_win32_map_recv_error(PRInt32 err) | |
146 { | |
147 nss_MD_win32_map_default_error(err); | |
148 } | |
149 | |
150 void | |
151 nss_MD_win32_map_recvfrom_error(PRInt32 err) | |
152 { | |
153 nss_MD_win32_map_default_error(err); | |
154 } | |
155 | |
156 void | |
157 nss_MD_win32_map_send_error(PRInt32 err) | |
158 { | |
159 PRErrorCode prError; | |
160 switch (err) { | |
161 case WSAEMSGSIZE: | |
162 prError = PR_INVALID_ARGUMENT_ERROR; | |
163 break; | |
164 default: | |
165 nss_MD_win32_map_default_error(err); | |
166 return; | |
167 } | |
168 PR_SetError(prError, err); | |
169 } | |
170 | |
171 void | |
172 nss_MD_win32_map_sendto_error(PRInt32 err) | |
173 { | |
174 PRErrorCode prError; | |
175 switch (err) { | |
176 case WSAEMSGSIZE: | |
177 prError = PR_INVALID_ARGUMENT_ERROR; | |
178 break; | |
179 default: | |
180 nss_MD_win32_map_default_error(err); | |
181 return; | |
182 } | |
183 PR_SetError(prError, err); | |
184 } | |
185 | |
186 void | |
187 nss_MD_win32_map_accept_error(PRInt32 err) | |
188 { | |
189 PRErrorCode prError; | |
190 switch (err) { | |
191 case WSAEOPNOTSUPP: | |
192 prError = PR_NOT_TCP_SOCKET_ERROR; | |
193 break; | |
194 case WSAEINVAL: | |
195 prError = PR_INVALID_STATE_ERROR; | |
196 break; | |
197 default: | |
198 nss_MD_win32_map_default_error(err); | |
199 return; | |
200 } | |
201 PR_SetError(prError, err); | |
202 } | |
203 | |
204 void | |
205 nss_MD_win32_map_acceptex_error(PRInt32 err) | |
206 { | |
207 nss_MD_win32_map_default_error(err); | |
208 } | |
209 | |
210 void | |
211 nss_MD_win32_map_connect_error(PRInt32 err) | |
212 { | |
213 PRErrorCode prError; | |
214 switch (err) { | |
215 case WSAEWOULDBLOCK: | |
216 prError = PR_IN_PROGRESS_ERROR; | |
217 break; | |
218 case WSAEINVAL: | |
219 prError = PR_ALREADY_INITIATED_ERROR; | |
220 break; | |
221 case WSAETIMEDOUT: | |
222 prError = PR_IO_TIMEOUT_ERROR; | |
223 break; | |
224 default: | |
225 nss_MD_win32_map_default_error(err); | |
226 return; | |
227 } | |
228 PR_SetError(prError, err); | |
229 } | |
230 | |
231 void | |
232 nss_MD_win32_map_bind_error(PRInt32 err) | |
233 { | |
234 PRErrorCode prError; | |
235 switch (err) { | |
236 case WSAEINVAL: | |
237 prError = PR_SOCKET_ADDRESS_IS_BOUND_ERROR; | |
238 break; | |
239 default: | |
240 nss_MD_win32_map_default_error(err); | |
241 return; | |
242 } | |
243 PR_SetError(prError, err); | |
244 } | |
245 | |
246 void | |
247 nss_MD_win32_map_listen_error(PRInt32 err) | |
248 { | |
249 PRErrorCode prError; | |
250 switch (err) { | |
251 case WSAEOPNOTSUPP: | |
252 prError = PR_NOT_TCP_SOCKET_ERROR; | |
253 break; | |
254 case WSAEINVAL: | |
255 prError = PR_INVALID_STATE_ERROR; | |
256 break; | |
257 default: | |
258 nss_MD_win32_map_default_error(err); | |
259 return; | |
260 } | |
261 PR_SetError(prError, err); | |
262 } | |
263 | |
264 void | |
265 nss_MD_win32_map_shutdown_error(PRInt32 err) | |
266 { | |
267 nss_MD_win32_map_default_error(err); | |
268 } | |
269 | |
270 void | |
271 nss_MD_win32_map_getsockname_error(PRInt32 err) | |
272 { | |
273 PRErrorCode prError; | |
274 switch (err) { | |
275 case WSAEINVAL: | |
276 prError = PR_INVALID_STATE_ERROR; | |
277 break; | |
278 default: | |
279 nss_MD_win32_map_default_error(err); | |
280 return; | |
281 } | |
282 PR_SetError(prError, err); | |
283 } | |
284 | |
285 void | |
286 nss_MD_win32_map_getpeername_error(PRInt32 err) | |
287 { | |
288 nss_MD_win32_map_default_error(err); | |
289 } | |
290 | |
291 void | |
292 nss_MD_win32_map_getsockopt_error(PRInt32 err) | |
293 { | |
294 nss_MD_win32_map_default_error(err); | |
295 } | |
296 | |
297 void | |
298 nss_MD_win32_map_setsockopt_error(PRInt32 err) | |
299 { | |
300 nss_MD_win32_map_default_error(err); | |
301 } | |
302 | |
303 void | |
304 nss_MD_win32_map_open_error(PRInt32 err) | |
305 { | |
306 nss_MD_win32_map_default_error(err); | |
307 } | |
308 | |
309 void | |
310 nss_MD_win32_map_gethostname_error(PRInt32 err) | |
311 { | |
312 nss_MD_win32_map_default_error(err); | |
313 } | |
314 | |
315 /* Win32 select() only works on sockets. So in this | |
316 ** context, WSAENOTSOCK is equivalent to EBADF on Unix. | |
317 */ | |
318 void | |
319 nss_MD_win32_map_select_error(PRInt32 err) | |
320 { | |
321 PRErrorCode prError; | |
322 switch (err) { | |
323 case WSAENOTSOCK: | |
324 prError = PR_BAD_DESCRIPTOR_ERROR; | |
325 break; | |
326 default: | |
327 nss_MD_win32_map_default_error(err); | |
328 return; | |
329 } | |
330 PR_SetError(prError, err); | |
331 } | |
332 | |
333 void | |
334 nss_MD_win32_map_lockf_error(PRInt32 err) | |
335 { | |
336 nss_MD_win32_map_default_error(err); | |
337 } | |
338 | |
339 void | |
340 nss_MD_win32_map_default_error(PRInt32 err) | |
341 { | |
342 PRErrorCode prError; | |
343 | |
344 switch (err) { | |
345 case EACCES: | |
346 prError = PR_NO_ACCESS_RIGHTS_ERROR; | |
347 break; | |
348 case ENOENT: | |
349 prError = PR_FILE_NOT_FOUND_ERROR; | |
350 break; | |
351 case ERROR_ACCESS_DENIED: | |
352 prError = PR_NO_ACCESS_RIGHTS_ERROR; | |
353 break; | |
354 case ERROR_ALREADY_EXISTS: | |
355 prError = PR_FILE_EXISTS_ERROR; | |
356 break; | |
357 case ERROR_DISK_CORRUPT: | |
358 prError = PR_IO_ERROR; | |
359 break; | |
360 case ERROR_DISK_FULL: | |
361 prError = PR_NO_DEVICE_SPACE_ERROR; | |
362 break; | |
363 case ERROR_DISK_OPERATION_FAILED: | |
364 prError = PR_IO_ERROR; | |
365 break; | |
366 case ERROR_DRIVE_LOCKED: | |
367 prError = PR_FILE_IS_LOCKED_ERROR; | |
368 break; | |
369 case ERROR_FILENAME_EXCED_RANGE: | |
370 prError = PR_NAME_TOO_LONG_ERROR; | |
371 break; | |
372 case ERROR_FILE_CORRUPT: | |
373 prError = PR_IO_ERROR; | |
374 break; | |
375 case ERROR_FILE_EXISTS: | |
376 prError = PR_FILE_EXISTS_ERROR; | |
377 break; | |
378 case ERROR_FILE_INVALID: | |
379 prError = PR_BAD_DESCRIPTOR_ERROR; | |
380 break; | |
381 #if ERROR_FILE_NOT_FOUND != ENOENT | |
382 case ERROR_FILE_NOT_FOUND: | |
383 prError = PR_FILE_NOT_FOUND_ERROR; | |
384 break; | |
385 #endif | |
386 case ERROR_HANDLE_DISK_FULL: | |
387 prError = PR_NO_DEVICE_SPACE_ERROR; | |
388 break; | |
389 case ERROR_INVALID_ADDRESS: | |
390 prError = PR_ACCESS_FAULT_ERROR; | |
391 break; | |
392 case ERROR_INVALID_HANDLE: | |
393 prError = PR_BAD_DESCRIPTOR_ERROR; | |
394 break; | |
395 case ERROR_INVALID_NAME: | |
396 prError = PR_INVALID_ARGUMENT_ERROR; | |
397 break; | |
398 case ERROR_INVALID_PARAMETER: | |
399 prError = PR_INVALID_ARGUMENT_ERROR; | |
400 break; | |
401 case ERROR_INVALID_USER_BUFFER: | |
402 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
403 break; | |
404 case ERROR_LOCKED: | |
405 prError = PR_FILE_IS_LOCKED_ERROR; | |
406 break; | |
407 case ERROR_NETNAME_DELETED: | |
408 prError = PR_CONNECT_RESET_ERROR; | |
409 break; | |
410 case ERROR_NOACCESS: | |
411 prError = PR_ACCESS_FAULT_ERROR; | |
412 break; | |
413 case ERROR_NOT_ENOUGH_MEMORY: | |
414 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
415 break; | |
416 case ERROR_NOT_ENOUGH_QUOTA: | |
417 prError = PR_OUT_OF_MEMORY_ERROR; | |
418 break; | |
419 case ERROR_NOT_READY: | |
420 prError = PR_IO_ERROR; | |
421 break; | |
422 case ERROR_NO_MORE_FILES: | |
423 prError = PR_NO_MORE_FILES_ERROR; | |
424 break; | |
425 case ERROR_OPEN_FAILED: | |
426 prError = PR_IO_ERROR; | |
427 break; | |
428 case ERROR_OPEN_FILES: | |
429 prError = PR_IO_ERROR; | |
430 break; | |
431 case ERROR_OUTOFMEMORY: | |
432 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
433 break; | |
434 case ERROR_PATH_BUSY: | |
435 prError = PR_IO_ERROR; | |
436 break; | |
437 case ERROR_PATH_NOT_FOUND: | |
438 prError = PR_FILE_NOT_FOUND_ERROR; | |
439 break; | |
440 case ERROR_SEEK_ON_DEVICE: | |
441 prError = PR_IO_ERROR; | |
442 break; | |
443 case ERROR_SHARING_VIOLATION: | |
444 prError = PR_FILE_IS_BUSY_ERROR; | |
445 break; | |
446 case ERROR_STACK_OVERFLOW: | |
447 prError = PR_ACCESS_FAULT_ERROR; | |
448 break; | |
449 case ERROR_TOO_MANY_OPEN_FILES: | |
450 prError = PR_SYS_DESC_TABLE_FULL_ERROR; | |
451 break; | |
452 case ERROR_WRITE_PROTECT: | |
453 prError = PR_NO_ACCESS_RIGHTS_ERROR; | |
454 break; | |
455 case WSAEACCES: | |
456 prError = PR_NO_ACCESS_RIGHTS_ERROR; | |
457 break; | |
458 case WSAEADDRINUSE: | |
459 prError = PR_ADDRESS_IN_USE_ERROR; | |
460 break; | |
461 case WSAEADDRNOTAVAIL: | |
462 prError = PR_ADDRESS_NOT_AVAILABLE_ERROR; | |
463 break; | |
464 case WSAEAFNOSUPPORT: | |
465 prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; | |
466 break; | |
467 case WSAEALREADY: | |
468 prError = PR_ALREADY_INITIATED_ERROR; | |
469 break; | |
470 case WSAEBADF: | |
471 prError = PR_BAD_DESCRIPTOR_ERROR; | |
472 break; | |
473 case WSAECONNABORTED: | |
474 prError = PR_CONNECT_ABORTED_ERROR; | |
475 break; | |
476 case WSAECONNREFUSED: | |
477 prError = PR_CONNECT_REFUSED_ERROR; | |
478 break; | |
479 case WSAECONNRESET: | |
480 prError = PR_CONNECT_RESET_ERROR; | |
481 break; | |
482 case WSAEDESTADDRREQ: | |
483 prError = PR_INVALID_ARGUMENT_ERROR; | |
484 break; | |
485 case WSAEFAULT: | |
486 prError = PR_ACCESS_FAULT_ERROR; | |
487 break; | |
488 case WSAEHOSTUNREACH: | |
489 prError = PR_HOST_UNREACHABLE_ERROR; | |
490 break; | |
491 case WSAEINVAL: | |
492 prError = PR_INVALID_ARGUMENT_ERROR; | |
493 break; | |
494 case WSAEISCONN: | |
495 prError = PR_IS_CONNECTED_ERROR; | |
496 break; | |
497 case WSAEMFILE: | |
498 prError = PR_PROC_DESC_TABLE_FULL_ERROR; | |
499 break; | |
500 case WSAEMSGSIZE: | |
501 prError = PR_BUFFER_OVERFLOW_ERROR; | |
502 break; | |
503 case WSAENETDOWN: | |
504 prError = PR_NETWORK_DOWN_ERROR; | |
505 break; | |
506 case WSAENETRESET: | |
507 prError = PR_CONNECT_ABORTED_ERROR; | |
508 break; | |
509 case WSAENETUNREACH: | |
510 prError = PR_NETWORK_UNREACHABLE_ERROR; | |
511 break; | |
512 case WSAENOBUFS: | |
513 prError = PR_INSUFFICIENT_RESOURCES_ERROR; | |
514 break; | |
515 case WSAENOPROTOOPT: | |
516 prError = PR_INVALID_ARGUMENT_ERROR; | |
517 break; | |
518 case WSAENOTCONN: | |
519 prError = PR_NOT_CONNECTED_ERROR; | |
520 break; | |
521 case WSAENOTSOCK: | |
522 prError = PR_NOT_SOCKET_ERROR; | |
523 break; | |
524 case WSAEOPNOTSUPP: | |
525 prError = PR_OPERATION_NOT_SUPPORTED_ERROR; | |
526 break; | |
527 case WSAEPROTONOSUPPORT: | |
528 prError = PR_PROTOCOL_NOT_SUPPORTED_ERROR; | |
529 break; | |
530 case WSAEPROTOTYPE: | |
531 prError = PR_INVALID_ARGUMENT_ERROR; | |
532 break; | |
533 case WSAESHUTDOWN: | |
534 prError = PR_SOCKET_SHUTDOWN_ERROR; | |
535 break; | |
536 case WSAESOCKTNOSUPPORT: | |
537 prError = PR_INVALID_ARGUMENT_ERROR; | |
538 break; | |
539 case WSAETIMEDOUT: | |
540 prError = PR_CONNECT_ABORTED_ERROR; | |
541 break; | |
542 case WSAEWOULDBLOCK: | |
543 prError = PR_WOULD_BLOCK_ERROR; | |
544 break; | |
545 default: | |
546 prError = PR_UNKNOWN_ERROR; | |
547 break; | |
548 } | |
549 PR_SetError(prError, err); | |
550 } | |
OLD | NEW |