← Back to branch summary

~ubuntu-branches/ubuntu/precise/kompozer/precise

« back to all changes in this revision

Viewing changes to mozilla/nsprpub/pr/src/md/os2/os2_errors.c

  • Committer: Bazaar Package Importer
  • Author(s): Anthony Yarusso
  • Date: 2007-08-27 01:11:03 UTC
  • Revision ID: james.westby@ubuntu.com-20070827011103-2jgf4s6532gqu2ka
Tags: upstream-0.7.10
Import upstream version 0.7.10

Show diffs side-by-side

added added

removed removed

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