The Tor Browser / file comparison

comparison: security/nss/lib/ssl/unix_err.c

security/nss/lib/ssl/unix_err.c

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:df2eb0c6cb7b
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 #if 0
15 #include "primpl.h"
16 #else
17 #define _PR_POLL_AVAILABLE 1
18 #include "prerror.h"
19 #endif
20
21 #if defined (__bsdi__) || defined(NTO) || defined(DARWIN) || defined(BEOS)
22 #undef _PR_POLL_AVAILABLE
23 #endif
24
25 #if defined(_PR_POLL_AVAILABLE)
26 #include <poll.h>
27 #endif
28 #include <errno.h>
29
30 /* forward declarations. */
31 void nss_MD_unix_map_default_error(int err);
32
33 void nss_MD_unix_map_opendir_error(int err)
34 {
35 nss_MD_unix_map_default_error(err);
36 }
37
38 void nss_MD_unix_map_closedir_error(int err)
39 {
40 PRErrorCode prError;
41 switch (err) {
42 case EINVAL: prError = PR_BAD_DESCRIPTOR_ERROR; break;
43 default: nss_MD_unix_map_default_error(err); return;
44 }
45 PR_SetError(prError, err);
46 }
47
48 void nss_MD_unix_readdir_error(int err)
49 {
50 PRErrorCode prError;
51
52 switch (err) {
53 case ENOENT: prError = PR_NO_MORE_FILES_ERROR; break;
54 #ifdef EOVERFLOW
55 case EOVERFLOW: prError = PR_IO_ERROR; break;
56 #endif
57 case EINVAL: prError = PR_IO_ERROR; break;
58 case ENXIO: prError = PR_IO_ERROR; break;
59 default: nss_MD_unix_map_default_error(err); return;
60 }
61 PR_SetError(prError, err);
62 }
63
64 void nss_MD_unix_map_unlink_error(int err)
65 {
66 PRErrorCode prError;
67 switch (err) {
68 case EPERM: prError = PR_IS_DIRECTORY_ERROR; break;
69 default: nss_MD_unix_map_default_error(err); return;
70 }
71 PR_SetError(prError, err);
72 }
73
74 void nss_MD_unix_map_stat_error(int err)
75 {
76 PRErrorCode prError;
77 switch (err) {
78 case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break;
79 default: nss_MD_unix_map_default_error(err); return;
80 }
81 PR_SetError(prError, err);
82 }
83
84 void nss_MD_unix_map_fstat_error(int err)
85 {
86 PRErrorCode prError;
87 switch (err) {
88 case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break;
89 default: nss_MD_unix_map_default_error(err); return;
90 }
91 PR_SetError(prError, err);
92 }
93
94 void nss_MD_unix_map_rename_error(int err)
95 {
96 PRErrorCode prError;
97 switch (err) {
98 case EEXIST: prError = PR_DIRECTORY_NOT_EMPTY_ERROR; break;
99 default: nss_MD_unix_map_default_error(err); return;
100 }
101 PR_SetError(prError, err);
102 }
103
104 void nss_MD_unix_map_access_error(int err)
105 {
106 PRErrorCode prError;
107 switch (err) {
108 case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break;
109 default: nss_MD_unix_map_default_error(err); return;
110 }
111 PR_SetError(prError, err);
112 }
113
114 void nss_MD_unix_map_mkdir_error(int err)
115 {
116 nss_MD_unix_map_default_error(err);
117 }
118
119 void nss_MD_unix_map_rmdir_error(int err)
120 {
121 PRErrorCode prError;
122
123 switch (err) {
124 case EEXIST: prError = PR_DIRECTORY_NOT_EMPTY_ERROR; break;
125 case EINVAL: prError = PR_DIRECTORY_NOT_EMPTY_ERROR; break;
126 case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break;
127 default: nss_MD_unix_map_default_error(err); return;
128 }
129 PR_SetError(prError, err);
130 }
131
132 void nss_MD_unix_map_read_error(int err)
133 {
134 PRErrorCode prError;
135 switch (err) {
136 case EINVAL: prError = PR_INVALID_METHOD_ERROR; break;
137 case ENXIO: prError = PR_INVALID_ARGUMENT_ERROR; break;
138 default: nss_MD_unix_map_default_error(err); return;
139 }
140 PR_SetError(prError, err);
141 }
142
143 void nss_MD_unix_map_write_error(int err)
144 {
145 PRErrorCode prError;
146 switch (err) {
147 case EINVAL: prError = PR_INVALID_METHOD_ERROR; break;
148 case ENXIO: prError = PR_INVALID_METHOD_ERROR; break;
149 case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break;
150 default: nss_MD_unix_map_default_error(err); return;
151 }
152 PR_SetError(prError, err);
153 }
154
155 void nss_MD_unix_map_lseek_error(int err)
156 {
157 nss_MD_unix_map_default_error(err);
158 }
159
160 void nss_MD_unix_map_fsync_error(int err)
161 {
162 PRErrorCode prError;
163 switch (err) {
164 case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break;
165 case EINVAL: prError = PR_INVALID_METHOD_ERROR; break;
166 default: nss_MD_unix_map_default_error(err); return;
167 }
168 PR_SetError(prError, err);
169 }
170
171 void nss_MD_unix_map_close_error(int err)
172 {
173 PRErrorCode prError;
174 switch (err) {
175 case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break;
176 default: nss_MD_unix_map_default_error(err); return;
177 }
178 PR_SetError(prError, err);
179 }
180
181 void nss_MD_unix_map_socket_error(int err)
182 {
183 PRErrorCode prError;
184 switch (err) {
185 case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
186 default: nss_MD_unix_map_default_error(err); return;
187 }
188 PR_SetError(prError, err);
189 }
190
191 void nss_MD_unix_map_socketavailable_error(int err)
192 {
193 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
194 }
195
196 void nss_MD_unix_map_recv_error(int err)
197 {
198 nss_MD_unix_map_default_error(err);
199 }
200
201 void nss_MD_unix_map_recvfrom_error(int err)
202 {
203 nss_MD_unix_map_default_error(err);
204 }
205
206 void nss_MD_unix_map_send_error(int err)
207 {
208 nss_MD_unix_map_default_error(err);
209 }
210
211 void nss_MD_unix_map_sendto_error(int err)
212 {
213 nss_MD_unix_map_default_error(err);
214 }
215
216 void nss_MD_unix_map_writev_error(int err)
217 {
218 nss_MD_unix_map_default_error(err);
219 }
220
221 void nss_MD_unix_map_accept_error(int err)
222 {
223 PRErrorCode prError;
224 switch (err) {
225 case ENODEV: prError = PR_NOT_TCP_SOCKET_ERROR; break;
226 default: nss_MD_unix_map_default_error(err); return;
227 }
228 PR_SetError(prError, err);
229 }
230
231 void nss_MD_unix_map_connect_error(int err)
232 {
233 PRErrorCode prError;
234 switch (err) {
235 case EACCES: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
236 #if defined(UNIXWARE) || defined(SNI) || defined(NEC)
237 /*
238 * On some platforms, if we connect to a port on the local host
239 * (the loopback address) that no process is listening on, we get
240 * EIO instead of ECONNREFUSED.
241 */
242 case EIO: prError = PR_CONNECT_REFUSED_ERROR; break;
243 #endif
244 case ELOOP: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
245 case ENOENT: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
246 case ENXIO: prError = PR_IO_ERROR; break;
247 default: nss_MD_unix_map_default_error(err); return;
248 }
249 PR_SetError(prError, err);
250 }
251
252 void nss_MD_unix_map_bind_error(int err)
253 {
254 PRErrorCode prError;
255 switch (err) {
256 case EINVAL: prError = PR_SOCKET_ADDRESS_IS_BOUND_ERROR; break;
257 /*
258 * UNIX domain sockets are not supported in NSPR
259 */
260 case EIO: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
261 case EISDIR: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
262 case ELOOP: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
263 case ENOENT: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
264 case ENOTDIR: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
265 case EROFS: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
266 default: nss_MD_unix_map_default_error(err); return;
267 }
268 PR_SetError(prError, err);
269 }
270
271 void nss_MD_unix_map_listen_error(int err)
272 {
273 nss_MD_unix_map_default_error(err);
274 }
275
276 void nss_MD_unix_map_shutdown_error(int err)
277 {
278 nss_MD_unix_map_default_error(err);
279 }
280
281 void nss_MD_unix_map_socketpair_error(int err)
282 {
283 PRErrorCode prError;
284 switch (err) {
285 case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
286 default: nss_MD_unix_map_default_error(err); return;
287 }
288 PR_SetError(prError, err);
289 }
290
291 void nss_MD_unix_map_getsockname_error(int err)
292 {
293 PRErrorCode prError;
294 switch (err) {
295 case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
296 default: nss_MD_unix_map_default_error(err); return;
297 }
298 PR_SetError(prError, err);
299 }
300
301 void nss_MD_unix_map_getpeername_error(int err)
302 {
303 PRErrorCode prError;
304
305 switch (err) {
306 case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
307 default: nss_MD_unix_map_default_error(err); return;
308 }
309 PR_SetError(prError, err);
310 }
311
312 void nss_MD_unix_map_getsockopt_error(int err)
313 {
314 PRErrorCode prError;
315 switch (err) {
316 case EINVAL: prError = PR_BUFFER_OVERFLOW_ERROR; break;
317 case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
318 default: nss_MD_unix_map_default_error(err); return;
319 }
320 PR_SetError(prError, err);
321 }
322
323 void nss_MD_unix_map_setsockopt_error(int err)
324 {
325 PRErrorCode prError;
326 switch (err) {
327 case EINVAL: prError = PR_BUFFER_OVERFLOW_ERROR; break;
328 case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
329 default: nss_MD_unix_map_default_error(err); return;
330 }
331 PR_SetError(prError, err);
332 }
333
334 void nss_MD_unix_map_open_error(int err)
335 {
336 PRErrorCode prError;
337 switch (err) {
338 case EAGAIN: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
339 case EBUSY: prError = PR_IO_ERROR; break;
340 case ENODEV: prError = PR_FILE_NOT_FOUND_ERROR; break;
341 case ENOMEM: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
342 case ETIMEDOUT: prError = PR_REMOTE_FILE_ERROR; break;
343 default: nss_MD_unix_map_default_error(err); return;
344 }
345 PR_SetError(prError, err);
346 }
347
348 void nss_MD_unix_map_mmap_error(int err)
349 {
350 PRErrorCode prError;
351 switch (err) {
352 case EAGAIN: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
353 case EMFILE: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
354 case ENODEV: prError = PR_OPERATION_NOT_SUPPORTED_ERROR; break;
355 case ENXIO: prError = PR_INVALID_ARGUMENT_ERROR; break;
356 default: nss_MD_unix_map_default_error(err); return;
357 }
358 PR_SetError(prError, err);
359 }
360
361 void nss_MD_unix_map_gethostname_error(int err)
362 {
363 nss_MD_unix_map_default_error(err);
364 }
365
366 void nss_MD_unix_map_select_error(int err)
367 {
368 nss_MD_unix_map_default_error(err);
369 }
370
371 #ifdef _PR_POLL_AVAILABLE
372 void nss_MD_unix_map_poll_error(int err)
373 {
374 PRErrorCode prError;
375
376 switch (err) {
377 case EAGAIN: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
378 default: nss_MD_unix_map_default_error(err); return;
379 }
380 PR_SetError(prError, err);
381 }
382
383 void nss_MD_unix_map_poll_revents_error(int err)
384 {
385 if (err & POLLNVAL)
386 PR_SetError(PR_BAD_DESCRIPTOR_ERROR, EBADF);
387 else if (err & POLLHUP)
388 PR_SetError(PR_CONNECT_RESET_ERROR, EPIPE);
389 else if (err & POLLERR)
390 PR_SetError(PR_IO_ERROR, EIO);
391 else
392 PR_SetError(PR_UNKNOWN_ERROR, err);
393 }
394 #endif /* _PR_POLL_AVAILABLE */
395
396
397 void nss_MD_unix_map_flock_error(int err)
398 {
399 PRErrorCode prError;
400 switch (err) {
401 case EINVAL: prError = PR_BAD_DESCRIPTOR_ERROR; break;
402 case EWOULDBLOCK: prError = PR_FILE_IS_LOCKED_ERROR; break;
403 default: nss_MD_unix_map_default_error(err); return;
404 }
405 PR_SetError(prError, err);
406 }
407
408 void nss_MD_unix_map_lockf_error(int err)
409 {
410 PRErrorCode prError;
411 switch (err) {
412 case EACCES: prError = PR_FILE_IS_LOCKED_ERROR; break;
413 case EDEADLK: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
414 default: nss_MD_unix_map_default_error(err); return;
415 }
416 PR_SetError(prError, err);
417 }
418
419 #ifdef HPUX11
420 void nss_MD_hpux_map_sendfile_error(int err)
421 {
422 nss_MD_unix_map_default_error(err);
423 }
424 #endif /* HPUX11 */
425
426
427 void nss_MD_unix_map_default_error(int err)
428 {
429 PRErrorCode prError;
430 switch (err ) {
431 case EACCES: prError = PR_NO_ACCESS_RIGHTS_ERROR; break;
432 case EADDRINUSE: prError = PR_ADDRESS_IN_USE_ERROR; break;
433 case EADDRNOTAVAIL: prError = PR_ADDRESS_NOT_AVAILABLE_ERROR; break;
434 case EAFNOSUPPORT: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
435 case EAGAIN: prError = PR_WOULD_BLOCK_ERROR; break;
436 /*
437 * On QNX and Neutrino, EALREADY is defined as EBUSY.
438 */
439 #if EALREADY != EBUSY
440 case EALREADY: prError = PR_ALREADY_INITIATED_ERROR; break;
441 #endif
442 case EBADF: prError = PR_BAD_DESCRIPTOR_ERROR; break;
443 #ifdef EBADMSG
444 case EBADMSG: prError = PR_IO_ERROR; break;
445 #endif
446 case EBUSY: prError = PR_FILESYSTEM_MOUNTED_ERROR; break;
447 case ECONNREFUSED: prError = PR_CONNECT_REFUSED_ERROR; break;
448 case ECONNRESET: prError = PR_CONNECT_RESET_ERROR; break;
449 case EDEADLK: prError = PR_DEADLOCK_ERROR; break;
450 #ifdef EDIRCORRUPTED
451 case EDIRCORRUPTED: prError = PR_DIRECTORY_CORRUPTED_ERROR; break;
452 #endif
453 #ifdef EDQUOT
454 case EDQUOT: prError = PR_NO_DEVICE_SPACE_ERROR; break;
455 #endif
456 case EEXIST: prError = PR_FILE_EXISTS_ERROR; break;
457 case EFAULT: prError = PR_ACCESS_FAULT_ERROR; break;
458 case EFBIG: prError = PR_FILE_TOO_BIG_ERROR; break;
459 case EINPROGRESS: prError = PR_IN_PROGRESS_ERROR; break;
460 case EINTR: prError = PR_PENDING_INTERRUPT_ERROR; break;
461 case EINVAL: prError = PR_INVALID_ARGUMENT_ERROR; break;
462 case EIO: prError = PR_IO_ERROR; break;
463 case EISCONN: prError = PR_IS_CONNECTED_ERROR; break;
464 case EISDIR: prError = PR_IS_DIRECTORY_ERROR; break;
465 case ELOOP: prError = PR_LOOP_ERROR; break;
466 case EMFILE: prError = PR_PROC_DESC_TABLE_FULL_ERROR; break;
467 case EMLINK: prError = PR_MAX_DIRECTORY_ENTRIES_ERROR; break;
468 case EMSGSIZE: prError = PR_INVALID_ARGUMENT_ERROR; break;
469 #ifdef EMULTIHOP
470 case EMULTIHOP: prError = PR_REMOTE_FILE_ERROR; break;
471 #endif
472 case ENAMETOOLONG: prError = PR_NAME_TOO_LONG_ERROR; break;
473 case ENETUNREACH: prError = PR_NETWORK_UNREACHABLE_ERROR; break;
474 case ENFILE: prError = PR_SYS_DESC_TABLE_FULL_ERROR; break;
475 #if !defined(SCO)
476 case ENOBUFS: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
477 #endif
478 case ENODEV: prError = PR_FILE_NOT_FOUND_ERROR; break;
479 case ENOENT: prError = PR_FILE_NOT_FOUND_ERROR; break;
480 case ENOLCK: prError = PR_FILE_IS_LOCKED_ERROR; break;
481 #ifdef ENOLINK
482 case ENOLINK: prError = PR_REMOTE_FILE_ERROR; break;
483 #endif
484 case ENOMEM: prError = PR_OUT_OF_MEMORY_ERROR; break;
485 case ENOPROTOOPT: prError = PR_INVALID_ARGUMENT_ERROR; break;
486 case ENOSPC: prError = PR_NO_DEVICE_SPACE_ERROR; break;
487 #ifdef ENOSR
488 case ENOSR: prError = PR_INSUFFICIENT_RESOURCES_ERROR; break;
489 #endif
490 case ENOTCONN: prError = PR_NOT_CONNECTED_ERROR; break;
491 case ENOTDIR: prError = PR_NOT_DIRECTORY_ERROR; break;
492 case ENOTSOCK: prError = PR_NOT_SOCKET_ERROR; break;
493 case ENXIO: prError = PR_FILE_NOT_FOUND_ERROR; break;
494 case EOPNOTSUPP: prError = PR_NOT_TCP_SOCKET_ERROR; break;
495 #ifdef EOVERFLOW
496 case EOVERFLOW: prError = PR_BUFFER_OVERFLOW_ERROR; break;
497 #endif
498 case EPERM: prError = PR_NO_ACCESS_RIGHTS_ERROR; break;
499 case EPIPE: prError = PR_CONNECT_RESET_ERROR; break;
500 #ifdef EPROTO
501 case EPROTO: prError = PR_IO_ERROR; break;
502 #endif
503 case EPROTONOSUPPORT: prError = PR_PROTOCOL_NOT_SUPPORTED_ERROR; break;
504 case EPROTOTYPE: prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break;
505 case ERANGE: prError = PR_INVALID_METHOD_ERROR; break;
506 case EROFS: prError = PR_READ_ONLY_FILESYSTEM_ERROR; break;
507 case ESPIPE: prError = PR_INVALID_METHOD_ERROR; break;
508 case ETIMEDOUT: prError = PR_IO_TIMEOUT_ERROR; break;
509 #if EWOULDBLOCK != EAGAIN
510 case EWOULDBLOCK: prError = PR_WOULD_BLOCK_ERROR; break;
511 #endif
512 case EXDEV: prError = PR_NOT_SAME_DEVICE_ERROR; break;
513
514 default: prError = PR_UNKNOWN_ERROR; break;
515 }
516 PR_SetError(prError, err);
517 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial