Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(45)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: net/third_party/nss/ssl/win32err.c

Issue 1844813002: Uprev NSS to 3.23 on iOS (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: One more GN fix Created 4 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « net/third_party/nss/ssl/win32err.h ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ 1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* 2 /*
3 * This file essentially replicates NSPR's source for the functions that 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 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. 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 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, 7 * to accomplish its job, and NSPR's error mapping functions remain private,
8 * this code will continue to need to be replicated. 8 * this code will continue to need to be replicated.
9 * 9 *
10 * This Source Code Form is subject to the terms of the Mozilla Public 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 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/. */ 12 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
13 13
14 #include "prerror.h" 14 #include "prerror.h"
15 #include "prlog.h" 15 #include "prlog.h"
16 #include <errno.h> 16 #include <errno.h>
17 #include <windows.h> 17 #include <windows.h>
18 18
19 /* 19 /*
20 * On Win32, we map three kinds of error codes: 20 * On Win32, we map three kinds of error codes:
21 * - GetLastError(): for Win32 functions 21 * - GetLastError(): for Win32 functions
22 * - WSAGetLastError(): for Winsock functions 22 * - WSAGetLastError(): for Winsock functions
23 * - errno: for standard C library functions 23 * - errno: for standard C library functions
24 * 24 *
25 * We do not check for WSAEINPROGRESS and WSAEINTR because we do not 25 * We do not check for WSAEINPROGRESS and WSAEINTR because we do not
26 * use blocking Winsock 1.1 calls. 26 * use blocking Winsock 1.1 calls.
27 * 27 *
28 * Except for the 'socket' call, we do not check for WSAEINITIALISED. 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 29 * It is assumed that if Winsock is not initialized, that fact will
30 * be detected at the time we create new sockets. 30 * be detected at the time we create new sockets.
31 */ 31 */
32 32
33 /* forward declaration. */ 33 /* forward declaration. */
34 void nss_MD_win32_map_default_error(PRInt32 err); 34 void nss_MD_win32_map_default_error(PRInt32 err);
35 35
36 void nss_MD_win32_map_opendir_error(PRInt32 err) 36 void
37 nss_MD_win32_map_opendir_error(PRInt32 err)
37 { 38 {
38 nss_MD_win32_map_default_error(err); 39 nss_MD_win32_map_default_error(err);
39 } 40 }
40 41
41 void nss_MD_win32_map_closedir_error(PRInt32 err) 42 void
43 nss_MD_win32_map_closedir_error(PRInt32 err)
42 { 44 {
43 nss_MD_win32_map_default_error(err); 45 nss_MD_win32_map_default_error(err);
44 } 46 }
45 47
46 void nss_MD_win32_map_readdir_error(PRInt32 err) 48 void
49 nss_MD_win32_map_readdir_error(PRInt32 err)
47 { 50 {
48 nss_MD_win32_map_default_error(err); 51 nss_MD_win32_map_default_error(err);
49 } 52 }
50 53
51 void nss_MD_win32_map_delete_error(PRInt32 err) 54 void
55 nss_MD_win32_map_delete_error(PRInt32 err)
52 { 56 {
53 nss_MD_win32_map_default_error(err); 57 nss_MD_win32_map_default_error(err);
54 } 58 }
55 59
56 /* The error code for stat() is in errno. */ 60 /* The error code for stat() is in errno. */
57 void nss_MD_win32_map_stat_error(PRInt32 err) 61 void
62 nss_MD_win32_map_stat_error(PRInt32 err)
58 { 63 {
59 nss_MD_win32_map_default_error(err); 64 nss_MD_win32_map_default_error(err);
60 } 65 }
61 66
62 void nss_MD_win32_map_fstat_error(PRInt32 err) 67 void
68 nss_MD_win32_map_fstat_error(PRInt32 err)
63 { 69 {
64 nss_MD_win32_map_default_error(err); 70 nss_MD_win32_map_default_error(err);
65 } 71 }
66 72
67 void nss_MD_win32_map_rename_error(PRInt32 err) 73 void
74 nss_MD_win32_map_rename_error(PRInt32 err)
68 { 75 {
69 nss_MD_win32_map_default_error(err); 76 nss_MD_win32_map_default_error(err);
70 } 77 }
71 78
72 /* The error code for access() is in errno. */ 79 /* The error code for access() is in errno. */
73 void nss_MD_win32_map_access_error(PRInt32 err) 80 void
81 nss_MD_win32_map_access_error(PRInt32 err)
74 { 82 {
75 nss_MD_win32_map_default_error(err); 83 nss_MD_win32_map_default_error(err);
76 } 84 }
77 85
78 void nss_MD_win32_map_mkdir_error(PRInt32 err) 86 void
87 nss_MD_win32_map_mkdir_error(PRInt32 err)
79 { 88 {
80 nss_MD_win32_map_default_error(err); 89 nss_MD_win32_map_default_error(err);
81 } 90 }
82 91
83 void nss_MD_win32_map_rmdir_error(PRInt32 err) 92 void
93 nss_MD_win32_map_rmdir_error(PRInt32 err)
84 { 94 {
85 nss_MD_win32_map_default_error(err); 95 nss_MD_win32_map_default_error(err);
86 } 96 }
87 97
88 void nss_MD_win32_map_read_error(PRInt32 err) 98 void
99 nss_MD_win32_map_read_error(PRInt32 err)
89 { 100 {
90 nss_MD_win32_map_default_error(err); 101 nss_MD_win32_map_default_error(err);
91 } 102 }
92 103
93 void nss_MD_win32_map_transmitfile_error(PRInt32 err) 104 void
105 nss_MD_win32_map_transmitfile_error(PRInt32 err)
94 { 106 {
95 nss_MD_win32_map_default_error(err); 107 nss_MD_win32_map_default_error(err);
96 } 108 }
97 109
98 void nss_MD_win32_map_write_error(PRInt32 err) 110 void
111 nss_MD_win32_map_write_error(PRInt32 err)
99 { 112 {
100 nss_MD_win32_map_default_error(err); 113 nss_MD_win32_map_default_error(err);
101 } 114 }
102 115
103 void nss_MD_win32_map_lseek_error(PRInt32 err) 116 void
117 nss_MD_win32_map_lseek_error(PRInt32 err)
104 { 118 {
105 nss_MD_win32_map_default_error(err); 119 nss_MD_win32_map_default_error(err);
106 } 120 }
107 121
108 void nss_MD_win32_map_fsync_error(PRInt32 err) 122 void
123 nss_MD_win32_map_fsync_error(PRInt32 err)
109 { 124 {
110 nss_MD_win32_map_default_error(err); 125 nss_MD_win32_map_default_error(err);
111 } 126 }
112 127
113 /* 128 /*
114 * For both CloseHandle() and closesocket(). 129 * For both CloseHandle() and closesocket().
115 */ 130 */
116 void nss_MD_win32_map_close_error(PRInt32 err) 131 void
117 { 132 nss_MD_win32_map_close_error(PRInt32 err)
118 nss_MD_win32_map_default_error(err); 133 {
119 } 134 nss_MD_win32_map_default_error(err);
120 135 }
121 void nss_MD_win32_map_socket_error(PRInt32 err) 136
137 void
138 nss_MD_win32_map_socket_error(PRInt32 err)
122 { 139 {
123 PR_ASSERT(err != WSANOTINITIALISED); 140 PR_ASSERT(err != WSANOTINITIALISED);
124 nss_MD_win32_map_default_error(err); 141 nss_MD_win32_map_default_error(err);
125 } 142 }
126 143
127 void nss_MD_win32_map_recv_error(PRInt32 err) 144 void
128 { 145 nss_MD_win32_map_recv_error(PRInt32 err)
129 nss_MD_win32_map_default_error(err); 146 {
130 } 147 nss_MD_win32_map_default_error(err);
131 148 }
132 void nss_MD_win32_map_recvfrom_error(PRInt32 err) 149
133 { 150 void
134 nss_MD_win32_map_default_error(err); 151 nss_MD_win32_map_recvfrom_error(PRInt32 err)
135 } 152 {
136 153 nss_MD_win32_map_default_error(err);
137 void nss_MD_win32_map_send_error(PRInt32 err) 154 }
138 { 155
139 PRErrorCode prError; 156 void
140 switch (err) { 157 nss_MD_win32_map_send_error(PRInt32 err)
141 case WSAEMSGSIZE: » prError = PR_INVALID_ARGUMENT_ERROR; break; 158 {
142 default:» » nss_MD_win32_map_default_error(err); return; 159 PRErrorCode prError;
143 } 160 switch (err) {
144 PR_SetError(prError, err); 161 case WSAEMSGSIZE:
145 } 162 prError = PR_INVALID_ARGUMENT_ERROR;
146 163 break;
147 void nss_MD_win32_map_sendto_error(PRInt32 err) 164 default:
148 { 165 nss_MD_win32_map_default_error(err);
149 PRErrorCode prError; 166 return;
150 switch (err) { 167 }
151 case WSAEMSGSIZE: » prError = PR_INVALID_ARGUMENT_ERROR; break; 168 PR_SetError(prError, err);
152 default:» » nss_MD_win32_map_default_error(err); return; 169 }
153 } 170
154 PR_SetError(prError, err); 171 void
155 } 172 nss_MD_win32_map_sendto_error(PRInt32 err)
156 173 {
157 void nss_MD_win32_map_accept_error(PRInt32 err) 174 PRErrorCode prError;
158 { 175 switch (err) {
159 PRErrorCode prError; 176 case WSAEMSGSIZE:
160 switch (err) { 177 prError = PR_INVALID_ARGUMENT_ERROR;
161 case WSAEOPNOTSUPP: prError = PR_NOT_TCP_SOCKET_ERROR; break; 178 break;
162 case WSAEINVAL: » prError = PR_INVALID_STATE_ERROR; break; 179 default:
163 default:» » nss_MD_win32_map_default_error(err); return; 180 nss_MD_win32_map_default_error(err);
164 } 181 return;
165 PR_SetError(prError, err); 182 }
166 } 183 PR_SetError(prError, err);
167 184 }
168 void nss_MD_win32_map_acceptex_error(PRInt32 err) 185
169 { 186 void
170 nss_MD_win32_map_default_error(err); 187 nss_MD_win32_map_accept_error(PRInt32 err)
171 } 188 {
172 189 PRErrorCode prError;
173 void nss_MD_win32_map_connect_error(PRInt32 err) 190 switch (err) {
174 { 191 case WSAEOPNOTSUPP:
175 PRErrorCode prError; 192 prError = PR_NOT_TCP_SOCKET_ERROR;
176 switch (err) { 193 break;
177 case WSAEWOULDBLOCK: prError = PR_IN_PROGRESS_ERROR; break; 194 case WSAEINVAL:
178 case WSAEINVAL: » prError = PR_ALREADY_INITIATED_ERROR; break; 195 prError = PR_INVALID_STATE_ERROR;
179 case WSAETIMEDOUT: »prError = PR_IO_TIMEOUT_ERROR; break; 196 break;
180 default:» » nss_MD_win32_map_default_error(err); return; 197 default:
181 } 198 nss_MD_win32_map_default_error(err);
182 PR_SetError(prError, err); 199 return;
183 } 200 }
184 201 PR_SetError(prError, err);
185 void nss_MD_win32_map_bind_error(PRInt32 err) 202 }
186 { 203
187 PRErrorCode prError; 204 void
188 switch (err) { 205 nss_MD_win32_map_acceptex_error(PRInt32 err)
189 case WSAEINVAL: » prError = PR_SOCKET_ADDRESS_IS_BOUND_ERROR; break; 206 {
190 default:» » nss_MD_win32_map_default_error(err); return; 207 nss_MD_win32_map_default_error(err);
191 } 208 }
192 PR_SetError(prError, err); 209
193 } 210 void
194 211 nss_MD_win32_map_connect_error(PRInt32 err)
195 void nss_MD_win32_map_listen_error(PRInt32 err) 212 {
196 { 213 PRErrorCode prError;
197 PRErrorCode prError; 214 switch (err) {
198 switch (err) { 215 case WSAEWOULDBLOCK:
199 case WSAEOPNOTSUPP: prError = PR_NOT_TCP_SOCKET_ERROR; break; 216 prError = PR_IN_PROGRESS_ERROR;
200 case WSAEINVAL: » prError = PR_INVALID_STATE_ERROR; break; 217 break;
201 default:» » nss_MD_win32_map_default_error(err); return; 218 case WSAEINVAL:
202 } 219 prError = PR_ALREADY_INITIATED_ERROR;
203 PR_SetError(prError, err); 220 break;
204 } 221 case WSAETIMEDOUT:
205 222 prError = PR_IO_TIMEOUT_ERROR;
206 void nss_MD_win32_map_shutdown_error(PRInt32 err) 223 break;
207 { 224 default:
208 nss_MD_win32_map_default_error(err); 225 nss_MD_win32_map_default_error(err);
209 } 226 return;
210 227 }
211 void nss_MD_win32_map_getsockname_error(PRInt32 err) 228 PR_SetError(prError, err);
212 { 229 }
213 PRErrorCode prError; 230
214 switch (err) { 231 void
215 case WSAEINVAL: » prError = PR_INVALID_STATE_ERROR; break; 232 nss_MD_win32_map_bind_error(PRInt32 err)
216 default:» » nss_MD_win32_map_default_error(err); return; 233 {
217 } 234 PRErrorCode prError;
218 PR_SetError(prError, err); 235 switch (err) {
219 } 236 case WSAEINVAL:
220 237 prError = PR_SOCKET_ADDRESS_IS_BOUND_ERROR;
221 void nss_MD_win32_map_getpeername_error(PRInt32 err) 238 break;
222 { 239 default:
223 nss_MD_win32_map_default_error(err); 240 nss_MD_win32_map_default_error(err);
224 } 241 return;
225 242 }
226 void nss_MD_win32_map_getsockopt_error(PRInt32 err) 243 PR_SetError(prError, err);
227 { 244 }
228 nss_MD_win32_map_default_error(err); 245
229 } 246 void
230 247 nss_MD_win32_map_listen_error(PRInt32 err)
231 void nss_MD_win32_map_setsockopt_error(PRInt32 err) 248 {
232 { 249 PRErrorCode prError;
233 nss_MD_win32_map_default_error(err); 250 switch (err) {
234 } 251 case WSAEOPNOTSUPP:
235 252 prError = PR_NOT_TCP_SOCKET_ERROR;
236 void nss_MD_win32_map_open_error(PRInt32 err) 253 break;
237 { 254 case WSAEINVAL:
238 nss_MD_win32_map_default_error(err); 255 prError = PR_INVALID_STATE_ERROR;
239 } 256 break;
240 257 default:
241 void nss_MD_win32_map_gethostname_error(PRInt32 err) 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)
242 { 311 {
243 nss_MD_win32_map_default_error(err); 312 nss_MD_win32_map_default_error(err);
244 } 313 }
245 314
246 /* Win32 select() only works on sockets. So in this 315 /* Win32 select() only works on sockets. So in this
247 ** context, WSAENOTSOCK is equivalent to EBADF on Unix. 316 ** context, WSAENOTSOCK is equivalent to EBADF on Unix.
248 */ 317 */
249 void nss_MD_win32_map_select_error(PRInt32 err) 318 void
250 { 319 nss_MD_win32_map_select_error(PRInt32 err)
251 PRErrorCode prError; 320 {
252 switch (err) { 321 PRErrorCode prError;
253 case WSAENOTSOCK:» prError = PR_BAD_DESCRIPTOR_ERROR; break; 322 switch (err) {
254 default:» » nss_MD_win32_map_default_error(err); return; 323 case WSAENOTSOCK:
255 } 324 prError = PR_BAD_DESCRIPTOR_ERROR;
256 PR_SetError(prError, err); 325 break;
257 } 326 default:
258 327 nss_MD_win32_map_default_error(err);
259 void nss_MD_win32_map_lockf_error(PRInt32 err) 328 return;
260 { 329 }
261 nss_MD_win32_map_default_error(err); 330 PR_SetError(prError, err);
262 } 331 }
263 332
264 333 void
265 334 nss_MD_win32_map_lockf_error(PRInt32 err)
266 void nss_MD_win32_map_default_error(PRInt32 err) 335 {
267 { 336 nss_MD_win32_map_default_error(err);
268 PRErrorCode prError; 337 }
269 338
270 switch (err) { 339 void
271 case EACCES: » » prError = PR_NO_ACCESS_RIGHTS_ERROR; break; 340 nss_MD_win32_map_default_error(PRInt32 err)
272 case ENOENT: » » prError = PR_FILE_NOT_FOUND_ERROR; break; 341 {
273 case ERROR_ACCESS_DENIED: » prError = PR_NO_ACCESS_RIGHTS_ERROR; break; 342 PRErrorCode prError;
274 case ERROR_ALREADY_EXISTS: »prError = PR_FILE_EXISTS_ERROR; break; 343
275 case ERROR_DISK_CORRUPT: » prError = PR_IO_ERROR; break; 344 switch (err) {
276 case ERROR_DISK_FULL: » prError = PR_NO_DEVICE_SPACE_ERROR; break; 345 case EACCES:
277 case ERROR_DISK_OPERATION_FAILED: prError = PR_IO_ERROR; break; 346 prError = PR_NO_ACCESS_RIGHTS_ERROR;
278 case ERROR_DRIVE_LOCKED: » prError = PR_FILE_IS_LOCKED_ERROR; break; 347 break;
279 case ERROR_FILENAME_EXCED_RANGE: prError = PR_NAME_TOO_LONG_ERROR; break; 348 case ENOENT:
280 case ERROR_FILE_CORRUPT: » prError = PR_IO_ERROR; break; 349 prError = PR_FILE_NOT_FOUND_ERROR;
281 case ERROR_FILE_EXISTS: » prError = PR_FILE_EXISTS_ERROR; break; 350 break;
282 case ERROR_FILE_INVALID: » prError = PR_BAD_DESCRIPTOR_ERROR; 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;
283 #if ERROR_FILE_NOT_FOUND != ENOENT 381 #if ERROR_FILE_NOT_FOUND != ENOENT
284 case ERROR_FILE_NOT_FOUND: »prError = PR_FILE_NOT_FOUND_ERROR; break; 382 case ERROR_FILE_NOT_FOUND:
383 prError = PR_FILE_NOT_FOUND_ERROR;
384 break;
285 #endif 385 #endif
286 case ERROR_HANDLE_DISK_FULL: prError = PR_NO_DEVICE_SPACE_ERROR; break; 386 case ERROR_HANDLE_DISK_FULL:
287 case ERROR_INVALID_ADDRESS: prError = PR_ACCESS_FAULT_ERROR; break; 387 prError = PR_NO_DEVICE_SPACE_ERROR;
288 case ERROR_INVALID_HANDLE: »prError = PR_BAD_DESCRIPTOR_ERROR; break; 388 break;
289 case ERROR_INVALID_NAME: » prError = PR_INVALID_ARGUMENT_ERROR; break; 389 case ERROR_INVALID_ADDRESS:
290 case ERROR_INVALID_PARAMETER: prError = PR_INVALID_ARGUMENT_ERROR; break; 390 prError = PR_ACCESS_FAULT_ERROR;
291 case ERROR_INVALID_USER_BUFFER: prError = PR_INSUFFICIENT_RESOURCES_ERROR; b reak; 391 break;
292 case ERROR_LOCKED:» » prError = PR_FILE_IS_LOCKED_ERROR; break; 392 case ERROR_INVALID_HANDLE:
293 case ERROR_NETNAME_DELETED: prError = PR_CONNECT_RESET_ERROR; break; 393 prError = PR_BAD_DESCRIPTOR_ERROR;
294 case ERROR_NOACCESS: » prError = PR_ACCESS_FAULT_ERROR; break; 394 break;
295 case ERROR_NOT_ENOUGH_MEMORY: prError = PR_INSUFFICIENT_RESOURCES_ERROR; bre ak; 395 case ERROR_INVALID_NAME:
296 case ERROR_NOT_ENOUGH_QUOTA: prError = PR_OUT_OF_MEMORY_ERROR; break; 396 prError = PR_INVALID_ARGUMENT_ERROR;
297 case ERROR_NOT_READY: » prError = PR_IO_ERROR; break; 397 break;
298 case ERROR_NO_MORE_FILES: » prError = PR_NO_MORE_FILES_ERROR; break; 398 case ERROR_INVALID_PARAMETER:
299 case ERROR_OPEN_FAILED: » prError = PR_IO_ERROR; break; 399 prError = PR_INVALID_ARGUMENT_ERROR;
300 case ERROR_OPEN_FILES: » prError = PR_IO_ERROR; break; 400 break;
301 case ERROR_OUTOFMEMORY: » prError = PR_INSUFFICIENT_RESOURCES_ERROR; break ; 401 case ERROR_INVALID_USER_BUFFER:
302 case ERROR_PATH_BUSY: » prError = PR_IO_ERROR; break; 402 prError = PR_INSUFFICIENT_RESOURCES_ERROR;
303 case ERROR_PATH_NOT_FOUND: »prError = PR_FILE_NOT_FOUND_ERROR; break; 403 break;
304 case ERROR_SEEK_ON_DEVICE: »prError = PR_IO_ERROR; break; 404 case ERROR_LOCKED:
305 case ERROR_SHARING_VIOLATION: prError = PR_FILE_IS_BUSY_ERROR; break; 405 prError = PR_FILE_IS_LOCKED_ERROR;
306 case ERROR_STACK_OVERFLOW: »prError = PR_ACCESS_FAULT_ERROR; break; 406 break;
307 case ERROR_TOO_MANY_OPEN_FILES: prError = PR_SYS_DESC_TABLE_FULL_ERROR; brea k; 407 case ERROR_NETNAME_DELETED:
308 case ERROR_WRITE_PROTECT: » prError = PR_NO_ACCESS_RIGHTS_ERROR; break; 408 prError = PR_CONNECT_RESET_ERROR;
309 case WSAEACCES: » » prError = PR_NO_ACCESS_RIGHTS_ERROR; break; 409 break;
310 case WSAEADDRINUSE: » prError = PR_ADDRESS_IN_USE_ERROR; break; 410 case ERROR_NOACCESS:
311 case WSAEADDRNOTAVAIL: » prError = PR_ADDRESS_NOT_AVAILABLE_ERROR; break; 411 prError = PR_ACCESS_FAULT_ERROR;
312 case WSAEAFNOSUPPORT: » prError = PR_ADDRESS_NOT_SUPPORTED_ERROR; break; 412 break;
313 case WSAEALREADY: » » prError = PR_ALREADY_INITIATED_ERROR; break; 413 case ERROR_NOT_ENOUGH_MEMORY:
314 case WSAEBADF: » » prError = PR_BAD_DESCRIPTOR_ERROR; break; 414 prError = PR_INSUFFICIENT_RESOURCES_ERROR;
315 case WSAECONNABORTED: » prError = PR_CONNECT_ABORTED_ERROR; break; 415 break;
316 case WSAECONNREFUSED: » prError = PR_CONNECT_REFUSED_ERROR; break; 416 case ERROR_NOT_ENOUGH_QUOTA:
317 case WSAECONNRESET: » prError = PR_CONNECT_RESET_ERROR; break; 417 prError = PR_OUT_OF_MEMORY_ERROR;
318 case WSAEDESTADDRREQ: » prError = PR_INVALID_ARGUMENT_ERROR; break; 418 break;
319 case WSAEFAULT: » » prError = PR_ACCESS_FAULT_ERROR; break; 419 case ERROR_NOT_READY:
320 case WSAEHOSTUNREACH: » prError = PR_HOST_UNREACHABLE_ERROR; break; 420 prError = PR_IO_ERROR;
321 case WSAEINVAL: » » prError = PR_INVALID_ARGUMENT_ERROR; break; 421 break;
322 case WSAEISCONN: » » prError = PR_IS_CONNECTED_ERROR; break; 422 case ERROR_NO_MORE_FILES:
323 case WSAEMFILE: » » prError = PR_PROC_DESC_TABLE_FULL_ERROR; break; 423 prError = PR_NO_MORE_FILES_ERROR;
324 case WSAEMSGSIZE: » » prError = PR_BUFFER_OVERFLOW_ERROR; break; 424 break;
325 case WSAENETDOWN: » » prError = PR_NETWORK_DOWN_ERROR; break; 425 case ERROR_OPEN_FAILED:
326 case WSAENETRESET: »» prError = PR_CONNECT_ABORTED_ERROR; break; 426 prError = PR_IO_ERROR;
327 case WSAENETUNREACH: » prError = PR_NETWORK_UNREACHABLE_ERROR; break; 427 break;
328 case WSAENOBUFS: » » prError = PR_INSUFFICIENT_RESOURCES_ERROR; break ; 428 case ERROR_OPEN_FILES:
329 case WSAENOPROTOOPT: » prError = PR_INVALID_ARGUMENT_ERROR; break; 429 prError = PR_IO_ERROR;
330 case WSAENOTCONN: » » prError = PR_NOT_CONNECTED_ERROR; break; 430 break;
331 case WSAENOTSOCK: » » prError = PR_NOT_SOCKET_ERROR; break; 431 case ERROR_OUTOFMEMORY:
332 case WSAEOPNOTSUPP: » prError = PR_OPERATION_NOT_SUPPORTED_ERROR; brea k; 432 prError = PR_INSUFFICIENT_RESOURCES_ERROR;
333 case WSAEPROTONOSUPPORT: » prError = PR_PROTOCOL_NOT_SUPPORTED_ERROR; break ; 433 break;
334 case WSAEPROTOTYPE: » prError = PR_INVALID_ARGUMENT_ERROR; break; 434 case ERROR_PATH_BUSY:
335 case WSAESHUTDOWN: »» prError = PR_SOCKET_SHUTDOWN_ERROR; break; 435 prError = PR_IO_ERROR;
336 case WSAESOCKTNOSUPPORT: » prError = PR_INVALID_ARGUMENT_ERROR; break; 436 break;
337 case WSAETIMEDOUT: »» prError = PR_CONNECT_ABORTED_ERROR; break; 437 case ERROR_PATH_NOT_FOUND:
338 case WSAEWOULDBLOCK: » prError = PR_WOULD_BLOCK_ERROR; break; 438 prError = PR_FILE_NOT_FOUND_ERROR;
339 default: » » » prError = PR_UNKNOWN_ERROR; break; 439 break;
340 } 440 case ERROR_SEEK_ON_DEVICE:
341 PR_SetError(prError, err); 441 prError = PR_IO_ERROR;
342 } 442 break;
343 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 }
OLDNEW
« no previous file with comments | « net/third_party/nss/ssl/win32err.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698