summaryrefslogtreecommitdiffstats
path: root/contrib/openbsm/libbsm/bsm_errno.c
blob: 8682fc784e73cbb8d41864fb4ef7f7a1aad4714f (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
/*-
 * Copyright (c) 2008 Apple Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1.  Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 * 2.  Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
 *     its contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE. 
 *
 * $P4: //depot/projects/trustedbsd/openbsm/libbsm/bsm_errno.c#22 $
 */

#include <sys/types.h>

#include <config/config.h>

#include <bsm/audit_errno.h>
#include <bsm/libbsm.h>

#include <errno.h>
#include <string.h>

/*
 * Different operating systems use different numeric constants for different
 * error numbers, and sometimes error numbers don't exist in more than one
 * operating system.  These routines convert between BSM and local error
 * number spaces, subject to the above realities.  BSM error numbers are
 * stored in a single 8-bit character, so don't have a byte order.
 *
 * Don't include string definitions when this code is compiled into a kernel.
 */
struct bsm_errno {
	int		 be_bsm_errno;
	int		 be_local_errno;
#if !defined(KERNEL) && !defined(_KERNEL)
	const char	*be_strerror;
#endif
};

#define	ERRNO_NO_LOCAL_MAPPING	-600

#if !defined(KERNEL) && !defined(_KERNEL)
#define	ES(x)	x
#else
#define	ES(x)
#endif

/*
 * Mapping table -- please maintain in numeric sorted order with respect to
 * the BSM constant.  Today we do a linear lookup, but could switch to a
 * binary search if it makes sense.  We only ifdef errors that aren't
 * generally available, but it does make the table a lot more ugly.
 *
 * XXXRW: It would be nice to have a similar ordered table mapping to BSM
 * constant from local constant, but the order of local constants varies by
 * OS.  Really we need to build that table at compile-time but don't do that
 * yet.
 *
 * XXXRW: We currently embed English-language error strings here, but should
 * support catalogues; these are only used if the OS doesn't have an error
 * string using strerror(3).
 */
static const struct bsm_errno bsm_errnos[] = {
	{ BSM_ERRNO_ESUCCESS, 0, ES("Success") },
	{ BSM_ERRNO_EPERM, EPERM, ES("Operation not permitted") },
	{ BSM_ERRNO_ENOENT, ENOENT, ES("No such file or directory") },
	{ BSM_ERRNO_ESRCH, ESRCH, ES("No such process") },
	{ BSM_ERRNO_EINTR, EINTR, ES("Interrupted system call") },
	{ BSM_ERRNO_EIO, EIO, ES("Input/output error") },
	{ BSM_ERRNO_ENXIO, ENXIO, ES("Device not configured") },
	{ BSM_ERRNO_E2BIG, E2BIG, ES("Argument list too long") },
	{ BSM_ERRNO_ENOEXEC, ENOEXEC, ES("Exec format error") },
	{ BSM_ERRNO_EBADF, EBADF, ES("Bad file descriptor") },
	{ BSM_ERRNO_ECHILD, ECHILD, ES("No child processes") },
	{ BSM_ERRNO_EAGAIN, EAGAIN, ES("Resource temporarily unavailable") },
	{ BSM_ERRNO_ENOMEM, ENOMEM, ES("Cannot allocate memory") },
	{ BSM_ERRNO_EACCES, EACCES, ES("Permission denied") },
	{ BSM_ERRNO_EFAULT, EFAULT, ES("Bad address") },
	{ BSM_ERRNO_ENOTBLK, ENOTBLK, ES("Block device required") },
	{ BSM_ERRNO_EBUSY, EBUSY, ES("Device busy") },
	{ BSM_ERRNO_EEXIST, EEXIST, ES("File exists") },
	{ BSM_ERRNO_EXDEV, EXDEV, ES("Cross-device link") },
	{ BSM_ERRNO_ENODEV, ENODEV, ES("Operation not supported by device") },
	{ BSM_ERRNO_ENOTDIR, ENOTDIR, ES("Not a directory") },
	{ BSM_ERRNO_EISDIR, EISDIR, ES("Is a directory") },
	{ BSM_ERRNO_EINVAL, EINVAL, ES("Invalid argument") },
	{ BSM_ERRNO_ENFILE, ENFILE, ES("Too many open files in system") },
	{ BSM_ERRNO_EMFILE, EMFILE, ES("Too many open files") },
	{ BSM_ERRNO_ENOTTY, ENOTTY, ES("Inappropriate ioctl for device") },
	{ BSM_ERRNO_ETXTBSY, ETXTBSY, ES("Text file busy") },
	{ BSM_ERRNO_EFBIG, EFBIG, ES("File too large") },
	{ BSM_ERRNO_ENOSPC, ENOSPC, ES("No space left on device") },
	{ BSM_ERRNO_ESPIPE, ESPIPE, ES("Illegal seek") },
	{ BSM_ERRNO_EROFS, EROFS, ES("Read-only file system") },
	{ BSM_ERRNO_EMLINK, EMLINK, ES("Too many links") },
	{ BSM_ERRNO_EPIPE, EPIPE, ES("Broken pipe") },
	{ BSM_ERRNO_EDOM, EDOM, ES("Numerical argument out of domain") },
	{ BSM_ERRNO_ERANGE, ERANGE, ES("Result too large") },
	{ BSM_ERRNO_ENOMSG, ENOMSG, ES("No message of desired type") },
	{ BSM_ERRNO_EIDRM, EIDRM, ES("Identifier removed") },
	{ BSM_ERRNO_ECHRNG,
#ifdef ECHRNG
	ECHRNG,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Channel number out of range") },
	{ BSM_ERRNO_EL2NSYNC,
#ifdef EL2NSYNC
	EL2NSYNC,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Level 2 not synchronized") },
	{ BSM_ERRNO_EL3HLT,
#ifdef EL3HLT
	EL3HLT,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Level 3 halted") },
	{ BSM_ERRNO_EL3RST,
#ifdef EL3RST
	EL3RST,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Level 3 reset") },
	{ BSM_ERRNO_ELNRNG,
#ifdef ELNRNG
	ELNRNG,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Link number out of range") },
	{ BSM_ERRNO_EUNATCH,
#ifdef EUNATCH
	EUNATCH,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Protocol driver not attached") },
	{ BSM_ERRNO_ENOCSI,
#ifdef ENOCSI
	ENOCSI,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("No CSI structure available") },
	{ BSM_ERRNO_EL2HLT,
#ifdef EL2HLT
	EL2HLT,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Level 2 halted") },
	{ BSM_ERRNO_EDEADLK, EDEADLK, ES("Resource deadlock avoided") },
	{ BSM_ERRNO_ENOLCK, ENOLCK, ES("No locks available") },
	{ BSM_ERRNO_ECANCELED, ECANCELED, ES("Operation canceled") },
	{ BSM_ERRNO_ENOTSUP, ENOTSUP, ES("Operation not supported") },
	{ BSM_ERRNO_EDQUOT, EDQUOT, ES("Disc quota exceeded") },
	{ BSM_ERRNO_EBADE,
#ifdef EBADE
	EBADE,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Invalid exchange") },
	{ BSM_ERRNO_EBADR,
#ifdef EBADR
	EBADR,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Invalid request descriptor") },
	{ BSM_ERRNO_EXFULL,
#ifdef EXFULL
	EXFULL,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Exchange full") },
	{ BSM_ERRNO_ENOANO,
#ifdef ENOANO
	ENOANO,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("No anode") },
	{ BSM_ERRNO_EBADRQC,
#ifdef EBADRQC
	EBADRQC,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Invalid request descriptor") },
	{ BSM_ERRNO_EBADSLT,
#ifdef EBADSLT
	EBADSLT,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Invalid slot") },
	{ BSM_ERRNO_EDEADLOCK,
#ifdef EDEADLOCK
	EDEADLOCK,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Resource deadlock avoided") },
	{ BSM_ERRNO_EBFONT,
#ifdef EBFONT
	EBFONT,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Bad font file format") },
	{ BSM_ERRNO_EOWNERDEAD,
#ifdef EOWNERDEAD
	EOWNERDEAD,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Process died with the lock") },
	{ BSM_ERRNO_ENOTRECOVERABLE,
#ifdef ENOTRECOVERABLE
	ENOTRECOVERABLE,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Lock is not recoverable") },
	{ BSM_ERRNO_ENOSTR,
#ifdef ENOSTR
	ENOSTR,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Device not a stream") },
	{ BSM_ERRNO_ENONET,
#ifdef ENONET
	ENONET,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Machine is not on the network") },
	{ BSM_ERRNO_ENOPKG,
#ifdef ENOPKG
	ENOPKG,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Package not installed") },
	{ BSM_ERRNO_EREMOTE, EREMOTE,
	    ES("Too many levels of remote in path") },
	{ BSM_ERRNO_ENOLINK,
#ifdef ENOLINK
	ENOLINK,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Link has been severed") },
	{ BSM_ERRNO_EADV,
#ifdef EADV
	EADV,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Advertise error") },
	{ BSM_ERRNO_ESRMNT,
#ifdef ESRMNT
	ESRMNT,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("srmount error") },
	{ BSM_ERRNO_ECOMM,
#ifdef ECOMM
	ECOMM,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Communication error on send") },
	{ BSM_ERRNO_EPROTO,
#ifdef EPROTO
	EPROTO,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Protocol error") },
	{ BSM_ERRNO_ELOCKUNMAPPED,
#ifdef ELOCKUNMAPPED
	ELOCKUNMAPPED,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Locked lock was unmapped") },
	{ BSM_ERRNO_ENOTACTIVE,
#ifdef ENOTACTIVE
	ENOTACTIVE,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Facility is not active") },
	{ BSM_ERRNO_EMULTIHOP,
#ifdef EMULTIHOP
	EMULTIHOP,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Multihop attempted") },
	{ BSM_ERRNO_EBADMSG,
#ifdef EBADMSG
	EBADMSG,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Bad message") },
	{ BSM_ERRNO_ENAMETOOLONG, ENAMETOOLONG, ES("File name too long") },
	{ BSM_ERRNO_EOVERFLOW, EOVERFLOW,
	    ES("Value too large to be stored in data type") },
	{ BSM_ERRNO_ENOTUNIQ,
#ifdef ENOTUNIQ
	ENOTUNIQ,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Given log name not unique") },
	{ BSM_ERRNO_EBADFD,
#ifdef EBADFD
	EBADFD,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Given f.d. invalid for this operation") },
	{ BSM_ERRNO_EREMCHG,
#ifdef EREMCHG
	EREMCHG,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Remote address changed") },
	{ BSM_ERRNO_ELIBACC,
#ifdef ELIBACC
	ELIBACC,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Can't access a needed shared lib") },
	{ BSM_ERRNO_ELIBBAD,
#ifdef ELIBBAD
	ELIBBAD,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Accessing a corrupted shared lib") },
	{ BSM_ERRNO_ELIBSCN,
#ifdef ELIBSCN
	ELIBSCN,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES(".lib section in a.out corrupted") },
	{ BSM_ERRNO_ELIBMAX,
#ifdef ELIBMAX
	ELIBMAX,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Attempting to link in too many libs") },
	{ BSM_ERRNO_ELIBEXEC,
#ifdef ELIBEXEC
	ELIBEXEC,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Attempting to exec a shared library") },
	{ BSM_ERRNO_EILSEQ, EILSEQ, ES("Illegal byte sequence") },
	{ BSM_ERRNO_ENOSYS, ENOSYS, ES("Function not implemented") },
	{ BSM_ERRNO_ELOOP, ELOOP, ES("Too many levels of symbolic links") },
	{ BSM_ERRNO_ERESTART,
#ifdef ERESTART
	ERESTART,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Restart syscall") },
	{ BSM_ERRNO_ESTRPIPE,
#ifdef ESTRPIPE
	ESTRPIPE,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("If pipe/FIFO, don't sleep in stream head") },
	{ BSM_ERRNO_ENOTEMPTY, ENOTEMPTY, ES("Directory not empty") },
	{ BSM_ERRNO_EUSERS, EUSERS, ES("Too many users") },
	{ BSM_ERRNO_ENOTSOCK, ENOTSOCK,
	    ES("Socket operation on non-socket") },
	{ BSM_ERRNO_EDESTADDRREQ, EDESTADDRREQ,
	    ES("Destination address required") },
	{ BSM_ERRNO_EMSGSIZE, EMSGSIZE, ES("Message too long") },
	{ BSM_ERRNO_EPROTOTYPE, EPROTOTYPE,
	    ES("Protocol wrong type for socket") },
	{ BSM_ERRNO_ENOPROTOOPT, ENOPROTOOPT, ES("Protocol not available") },
	{ BSM_ERRNO_EPROTONOSUPPORT, EPROTONOSUPPORT,
	    ES("Protocol not supported") },
	{ BSM_ERRNO_ESOCKTNOSUPPORT, ESOCKTNOSUPPORT,
	    ES("Socket type not supported") },
	{ BSM_ERRNO_EOPNOTSUPP, EOPNOTSUPP, ES("Operation not supported") },
	{ BSM_ERRNO_EPFNOSUPPORT, EPFNOSUPPORT,
	    ES("Protocol family not supported") },
	{ BSM_ERRNO_EAFNOSUPPORT, EAFNOSUPPORT,
	    ES("Address family not supported by protocol family") },
	{ BSM_ERRNO_EADDRINUSE, EADDRINUSE, ES("Address already in use") },
	{ BSM_ERRNO_EADDRNOTAVAIL, EADDRNOTAVAIL,
	    ES("Can't assign requested address") },
	{ BSM_ERRNO_ENETDOWN, ENETDOWN, ES("Network is down") },
	{ BSM_ERRNO_ENETRESET, ENETRESET,
	    ES("Network dropped connection on reset") },
	{ BSM_ERRNO_ECONNABORTED, ECONNABORTED,
	    ES("Software caused connection abort") },
	{ BSM_ERRNO_ECONNRESET, ECONNRESET, ES("Connection reset by peer") },
	{ BSM_ERRNO_ENOBUFS, ENOBUFS, ES("No buffer space available") },
	{ BSM_ERRNO_EISCONN, EISCONN, ES("Socket is already connected") },
	{ BSM_ERRNO_ENOTCONN, ENOTCONN, ES("Socket is not connected") },
	{ BSM_ERRNO_ESHUTDOWN, ESHUTDOWN,
	    ES("Can't send after socket shutdown") },
	{ BSM_ERRNO_ETOOMANYREFS, ETOOMANYREFS,
	    ES("Too many references: can't splice") },
	{ BSM_ERRNO_ETIMEDOUT, ETIMEDOUT, ES("Operation timed out") },
	{ BSM_ERRNO_ECONNREFUSED, ECONNREFUSED, ES("Connection refused") },
	{ BSM_ERRNO_EHOSTDOWN, EHOSTDOWN, ES("Host is down") },
	{ BSM_ERRNO_EHOSTUNREACH, EHOSTUNREACH, ES("No route to host") },
	{ BSM_ERRNO_EALREADY, EALREADY, ES("Operation already in progress") },
	{ BSM_ERRNO_EINPROGRESS, EINPROGRESS,
	    ES("Operation now in progress") },
	{ BSM_ERRNO_ESTALE, ESTALE, ES("Stale NFS file handle") },
	{ BSM_ERRNO_EPROCLIM,
#ifdef EPROCLIM
	EPROCLIM,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Too many processes") },
	{ BSM_ERRNO_EBADRPC,
#ifdef EBADRPC
	EBADRPC,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("RPC struct is bad") },
	{ BSM_ERRNO_ERPCMISMATCH,
#ifdef ERPCMISMATCH
	ERPCMISMATCH,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("RPC version wrong") },
	{ BSM_ERRNO_EPROGUNAVAIL,
#ifdef EPROGUNAVAIL
	EPROGUNAVAIL,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("RPC prog. not avail") },
	{ BSM_ERRNO_EPROGMISMATCH,
#ifdef EPROGMISMATCH
	EPROGMISMATCH,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("RPC version wrong") },
	{ BSM_ERRNO_EPROCUNAVAIL,
#ifdef EPROCUNAVAIL
	EPROCUNAVAIL,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Bad procedure for program") },
	{ BSM_ERRNO_EFTYPE,
#ifdef EFTYPE
	EFTYPE,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Inappropriate file type or format") },
	{ BSM_ERRNO_EAUTH,
#ifdef EAUTH
	EAUTH,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Authenticateion error") },
	{ BSM_ERRNO_ENEEDAUTH,
#ifdef ENEEDAUTH
	ENEEDAUTH,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Need authenticator") },
	{ BSM_ERRNO_ENOATTR,
#ifdef ENOATTR
	ENOATTR,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Attribute not found") },
	{ BSM_ERRNO_EDOOFUS,
#ifdef EDOOFUS
	EDOOFUS,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Programming error") },
	{ BSM_ERRNO_EJUSTRETURN,
#ifdef EJUSTRETURN
	EJUSTRETURN,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Just return") },
	{ BSM_ERRNO_ENOIOCTL,
#ifdef ENOIOCTL
	ENOIOCTL,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("ioctl not handled by this layer") },
	{ BSM_ERRNO_EDIRIOCTL,
#ifdef EDIRIOCTL
	EDIRIOCTL,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("do direct ioctl in GEOM") },
	{ BSM_ERRNO_EPWROFF,
#ifdef EPWROFF
	EPWROFF,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Device power is off") },
	{ BSM_ERRNO_EDEVERR,
#ifdef EDEVERR
	EDEVERR,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Device error") },
	{ BSM_ERRNO_EBADEXEC,
#ifdef EBADEXEC
	EBADEXEC,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Bad executable") },
	{ BSM_ERRNO_EBADARCH,
#ifdef EBADARCH
	EBADARCH,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Bad CPU type in executable") },
	{ BSM_ERRNO_ESHLIBVERS,
#ifdef ESHLIBVERS
	ESHLIBVERS,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Shared library version mismatch") },
	{ BSM_ERRNO_EBADMACHO,
#ifdef EBADMACHO
	EBADMACHO,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Malformed Macho file") },
	{ BSM_ERRNO_EPOLICY,
#ifdef EPOLICY
	EPOLICY,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Operation failed by policy") },
	{ BSM_ERRNO_EDOTDOT,
#ifdef EDOTDOT
	EDOTDOT,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("RFS specific error") },
	{ BSM_ERRNO_EUCLEAN,
#ifdef EUCLEAN
	EUCLEAN,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Structure needs cleaning") },
	{ BSM_ERRNO_ENOTNAM,
#ifdef ENOTNAM
	ENOTNAM,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Not a XENIX named type file") },
	{ BSM_ERRNO_ENAVAIL,
#ifdef ENAVAIL
	ENAVAIL,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("No XENIX semaphores available") },
	{ BSM_ERRNO_EISNAM,
#ifdef EISNAM
	EISNAM,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Is a named type file") },
	{ BSM_ERRNO_EREMOTEIO,
#ifdef EREMOTEIO
	EREMOTEIO,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Remote I/O error") },
	{ BSM_ERRNO_ENOMEDIUM,
#ifdef ENOMEDIUM
	ENOMEDIUM,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("No medium found") },
	{ BSM_ERRNO_EMEDIUMTYPE,
#ifdef EMEDIUMTYPE
	EMEDIUMTYPE,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Wrong medium type") },
	{ BSM_ERRNO_ENOKEY,
#ifdef ENOKEY
	ENOKEY,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Required key not available") },
	{ BSM_ERRNO_EKEYEXPIRED,
#ifdef EKEYEXPIRED
	EKEYEXPIRED,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Key has expired") },
	{ BSM_ERRNO_EKEYREVOKED,
#ifdef EKEYREVOKED
	EKEYREVOKED,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Key has been revoked") },
	{ BSM_ERRNO_EKEYREJECTED,
#ifdef EKEYREJECTED
	EKEYREJECTED,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Key was rejected by service") },
	{ BSM_ERRNO_ENOTCAPABLE,
#ifdef ENOTCAPABLE
	ENOTCAPABLE,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Capabilities insufficient") },
	{ BSM_ERRNO_ECAPMODE,
#ifdef ECAPMODE
	ECAPMODE,
#else
	ERRNO_NO_LOCAL_MAPPING,
#endif
	ES("Not permitted in capability mode") },
};
static const int bsm_errnos_count = sizeof(bsm_errnos) / sizeof(bsm_errnos[0]);

static const struct bsm_errno *
bsm_lookup_errno_local(int local_errno)
{
	int i;

	for (i = 0; i < bsm_errnos_count; i++) {
		if (bsm_errnos[i].be_local_errno == local_errno)
			return (&bsm_errnos[i]);
	}
	return (NULL);
}

/*
 * Conversion to the BSM errno space isn't allowed to fail; we simply map to
 * BSM_ERRNO_UNKNOWN and let the remote endpoint deal with it.
 */
u_char
au_errno_to_bsm(int local_errno)
{
	const struct bsm_errno *bsme;

	bsme = bsm_lookup_errno_local(local_errno);
	if (bsme == NULL)
		return (BSM_ERRNO_UNKNOWN);
	return (bsme->be_bsm_errno);
}

static const struct bsm_errno *
bsm_lookup_errno_bsm(u_char bsm_errno)
{
	int i;

	for (i = 0; i < bsm_errnos_count; i++) {
		if (bsm_errnos[i].be_bsm_errno == bsm_errno)
			return (&bsm_errnos[i]);
	}
	return (NULL);
}

/*
 * Converstion from a BSM error to a local error number may fail if either
 * OpenBSM doesn't recognize the error on the wire, or because there is no
 * appropriate local mapping.
 */
int
au_bsm_to_errno(u_char bsm_errno, int *errorp)
{
	const struct bsm_errno *bsme;

	bsme = bsm_lookup_errno_bsm(bsm_errno);
	if (bsme == NULL || bsme->be_local_errno == ERRNO_NO_LOCAL_MAPPING)
		return (-1);
	*errorp = bsme->be_local_errno;
	return (0);
}

#if !defined(KERNEL) && !defined(_KERNEL)
const char *
au_strerror(u_char bsm_errno)
{
	const struct bsm_errno *bsme;

	bsme = bsm_lookup_errno_bsm(bsm_errno);
	if (bsme == NULL)
		return ("Unrecognized BSM error");
	if (bsme->be_local_errno != ERRNO_NO_LOCAL_MAPPING)
		return (strerror(bsme->be_local_errno));
	return (bsme->be_strerror);
}
#endif
OpenPOWER on IntegriCloud