1 /*
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1999-2009 Apple Inc.
5 * Copyright (c) 2016-2017 Robert N. M. Watson
6 * All rights reserved.
7 *
8 * Portions of this software were developed by BAE Systems, the University of
9 * Cambridge Computer Laboratory, and Memorial University under DARPA/AFRL
10 * contract FA8650-15-C-7558 ("CADETS"), as part of the DARPA Transparent
11 * Computing (TC) research program.
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
15 * are met:
16 * 1. Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution.
21 * 3. Neither the name of Apple Inc. ("Apple") nor the names of
22 * its contributors may be used to endorse or promote products derived
23 * from this software without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND
26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 * ARE DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR
29 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
33 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
34 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35 * POSSIBILITY OF SUCH DAMAGE.
36 */
37
38 #include <sys/cdefs.h>
39 #include <sys/param.h>
40 #include <sys/vnode.h>
41 #include <sys/ipc.h>
42 #include <sys/lock.h>
43 #include <sys/malloc.h>
44 #include <sys/mutex.h>
45 #include <sys/socket.h>
46 #include <sys/extattr.h>
47 #include <sys/fcntl.h>
48 #include <sys/user.h>
49 #include <sys/systm.h>
50
51 #include <bsm/audit.h>
52 #include <bsm/audit_internal.h>
53 #include <bsm/audit_record.h>
54 #include <bsm/audit_kevents.h>
55
56 #include <security/audit/audit.h>
57 #include <security/audit/audit_private.h>
58
59 #include <netinet/in_systm.h>
60 #include <netinet/in.h>
61 #include <netinet/ip.h>
62
63 MALLOC_DEFINE(M_AUDITBSM, "audit_bsm", "Audit BSM data");
64
65 static void audit_sys_auditon(struct audit_record *ar,
66 struct au_record *rec);
67
68 /*
69 * Initialize the BSM auditing subsystem.
70 */
71 void
kau_init(void)72 kau_init(void)
73 {
74
75 au_evclassmap_init();
76 au_evnamemap_init();
77 }
78
79 /*
80 * This call reserves memory for the audit record. Memory must be guaranteed
81 * before any auditable event can be generated. The au_record structure
82 * maintains a reference to the memory allocated above and also the list of
83 * tokens associated with this record.
84 */
85 static struct au_record *
kau_open(void)86 kau_open(void)
87 {
88 struct au_record *rec;
89
90 rec = malloc(sizeof(*rec), M_AUDITBSM, M_WAITOK);
91 rec->data = NULL;
92 TAILQ_INIT(&rec->token_q);
93 rec->len = 0;
94 rec->used = 1;
95
96 return (rec);
97 }
98
99 /*
100 * Store the token with the record descriptor.
101 */
102 static void
kau_write(struct au_record * rec,struct au_token * tok)103 kau_write(struct au_record *rec, struct au_token *tok)
104 {
105
106 KASSERT(tok != NULL, ("kau_write: tok == NULL"));
107
108 TAILQ_INSERT_TAIL(&rec->token_q, tok, tokens);
109 rec->len += tok->len;
110 }
111
112 /*
113 * Close out the audit record by adding the header token, identifying any
114 * missing tokens. Write out the tokens to the record memory.
115 */
116 static void
kau_close(struct au_record * rec,struct timespec * ctime,short event)117 kau_close(struct au_record *rec, struct timespec *ctime, short event)
118 {
119 u_char *dptr;
120 size_t tot_rec_size;
121 token_t *cur, *hdr, *trail;
122 struct timeval tm;
123 size_t hdrsize;
124 struct auditinfo_addr ak;
125 struct in6_addr *ap;
126
127 audit_get_kinfo(&ak);
128 hdrsize = 0;
129 switch (ak.ai_termid.at_type) {
130 case AU_IPv4:
131 hdrsize = (ak.ai_termid.at_addr[0] == INADDR_ANY) ?
132 AUDIT_HEADER_SIZE : AUDIT_HEADER_EX_SIZE(&ak);
133 break;
134 case AU_IPv6:
135 ap = (struct in6_addr *)&ak.ai_termid.at_addr[0];
136 hdrsize = (IN6_IS_ADDR_UNSPECIFIED(ap)) ? AUDIT_HEADER_SIZE :
137 AUDIT_HEADER_EX_SIZE(&ak);
138 break;
139 default:
140 panic("kau_close: invalid address family");
141 }
142 tot_rec_size = rec->len + hdrsize + AUDIT_TRAILER_SIZE;
143 rec->data = malloc(tot_rec_size, M_AUDITBSM, M_WAITOK | M_ZERO);
144
145 tm.tv_usec = ctime->tv_nsec / 1000;
146 tm.tv_sec = ctime->tv_sec;
147 if (hdrsize != AUDIT_HEADER_SIZE)
148 hdr = au_to_header32_ex_tm(tot_rec_size, event, 0, tm, &ak);
149 else
150 hdr = au_to_header32_tm(tot_rec_size, event, 0, tm);
151 TAILQ_INSERT_HEAD(&rec->token_q, hdr, tokens);
152
153 trail = au_to_trailer(tot_rec_size);
154 TAILQ_INSERT_TAIL(&rec->token_q, trail, tokens);
155
156 rec->len = tot_rec_size;
157 dptr = rec->data;
158 TAILQ_FOREACH(cur, &rec->token_q, tokens) {
159 memcpy(dptr, cur->t_data, cur->len);
160 dptr += cur->len;
161 }
162 }
163
164 /*
165 * Free a BSM audit record by releasing all the tokens and clearing the audit
166 * record information.
167 */
168 void
kau_free(struct au_record * rec)169 kau_free(struct au_record *rec)
170 {
171 struct au_token *tok;
172
173 /* Free the token list. */
174 while ((tok = TAILQ_FIRST(&rec->token_q))) {
175 TAILQ_REMOVE(&rec->token_q, tok, tokens);
176 free(tok->t_data, M_AUDITBSM);
177 free(tok, M_AUDITBSM);
178 }
179
180 rec->used = 0;
181 rec->len = 0;
182 free(rec->data, M_AUDITBSM);
183 free(rec, M_AUDITBSM);
184 }
185
186 /*
187 * XXX: May want turn some (or all) of these macros into functions in order
188 * to reduce the generated code size.
189 *
190 * XXXAUDIT: These macros assume that 'kar', 'ar', 'rec', and 'tok' in the
191 * caller are OK with this.
192 */
193 #define ATFD1_TOKENS(argnum) do { \
194 if (ARG_IS_VALID(kar, ARG_ATFD1)) { \
195 tok = au_to_arg32(argnum, "at fd 1", ar->ar_arg_atfd1); \
196 kau_write(rec, tok); \
197 } \
198 } while (0)
199
200 #define ATFD2_TOKENS(argnum) do { \
201 if (ARG_IS_VALID(kar, ARG_ATFD2)) { \
202 tok = au_to_arg32(argnum, "at fd 2", ar->ar_arg_atfd2); \
203 kau_write(rec, tok); \
204 } \
205 } while (0)
206
207 #define UPATH1_TOKENS do { \
208 if (ARG_IS_VALID(kar, ARG_UPATH1)) { \
209 tok = au_to_path(ar->ar_arg_upath1); \
210 kau_write(rec, tok); \
211 } \
212 } while (0)
213
214 #define UPATH2_TOKENS do { \
215 if (ARG_IS_VALID(kar, ARG_UPATH2)) { \
216 tok = au_to_path(ar->ar_arg_upath2); \
217 kau_write(rec, tok); \
218 } \
219 } while (0)
220
221 #define VNODE1_TOKENS do { \
222 if (ARG_IS_VALID(kar, ARG_ATFD)) { \
223 tok = au_to_arg32(1, "at fd", ar->ar_arg_atfd); \
224 kau_write(rec, tok); \
225 } \
226 if (ARG_IS_VALID(kar, ARG_VNODE1)) { \
227 tok = au_to_attr32(&ar->ar_arg_vnode1); \
228 kau_write(rec, tok); \
229 } \
230 } while (0)
231
232 #define UPATH1_VNODE1_TOKENS do { \
233 UPATH1_TOKENS; \
234 if (ARG_IS_VALID(kar, ARG_VNODE1)) { \
235 tok = au_to_attr32(&ar->ar_arg_vnode1); \
236 kau_write(rec, tok); \
237 } \
238 } while (0)
239
240 #define VNODE2_TOKENS do { \
241 if (ARG_IS_VALID(kar, ARG_VNODE2)) { \
242 tok = au_to_attr32(&ar->ar_arg_vnode2); \
243 kau_write(rec, tok); \
244 } \
245 } while (0)
246
247 #define FD_VNODE1_TOKENS do { \
248 if (ARG_IS_VALID(kar, ARG_VNODE1)) { \
249 if (ARG_IS_VALID(kar, ARG_FD)) { \
250 tok = au_to_arg32(1, "fd", ar->ar_arg_fd); \
251 kau_write(rec, tok); \
252 } \
253 tok = au_to_attr32(&ar->ar_arg_vnode1); \
254 kau_write(rec, tok); \
255 } else { \
256 if (ARG_IS_VALID(kar, ARG_FD)) { \
257 tok = au_to_arg32(1, "non-file: fd", \
258 ar->ar_arg_fd); \
259 kau_write(rec, tok); \
260 } \
261 } \
262 } while (0)
263
264 #define PROCESS_PID_TOKENS(argn) do { \
265 if ((ar->ar_arg_pid > 0) /* Reference a single process */ \
266 && (ARG_IS_VALID(kar, ARG_PROCESS))) { \
267 tok = au_to_process32_ex(ar->ar_arg_auid, \
268 ar->ar_arg_euid, ar->ar_arg_egid, \
269 ar->ar_arg_ruid, ar->ar_arg_rgid, \
270 ar->ar_arg_pid, ar->ar_arg_asid, \
271 &ar->ar_arg_termid_addr); \
272 kau_write(rec, tok); \
273 } else if (ARG_IS_VALID(kar, ARG_PID)) { \
274 tok = au_to_arg32(argn, "process", ar->ar_arg_pid); \
275 kau_write(rec, tok); \
276 } \
277 } while (0)
278
279 #define EXTATTR_TOKENS(namespace_argnum) do { \
280 if (ARG_IS_VALID(kar, ARG_VALUE)) { \
281 switch (ar->ar_arg_value) { \
282 case EXTATTR_NAMESPACE_USER: \
283 tok = au_to_text(EXTATTR_NAMESPACE_USER_STRING);\
284 break; \
285 case EXTATTR_NAMESPACE_SYSTEM: \
286 tok = au_to_text(EXTATTR_NAMESPACE_SYSTEM_STRING);\
287 break; \
288 default: \
289 tok = au_to_arg32((namespace_argnum), \
290 "attrnamespace", ar->ar_arg_value); \
291 break; \
292 } \
293 kau_write(rec, tok); \
294 } \
295 /* attrname is in the text field */ \
296 if (ARG_IS_VALID(kar, ARG_TEXT)) { \
297 tok = au_to_text(ar->ar_arg_text); \
298 kau_write(rec, tok); \
299 } \
300 } while (0)
301
302 /*
303 * Not all pointer arguments to system calls are of interest, but in some
304 * cases they reflect delegation of rights, such as mmap(2) followed by
305 * minherit(2) before execve(2), so do the best we can.
306 */
307 #define ADDR_TOKEN(argnum, argname) do { \
308 if (ARG_IS_VALID(kar, ARG_ADDR)) { \
309 if (sizeof(void *) == sizeof(uint32_t)) \
310 tok = au_to_arg32((argnum), (argname), \
311 (uint32_t)(uintptr_t)ar->ar_arg_addr); \
312 else \
313 tok = au_to_arg64((argnum), (argname), \
314 (uint64_t)(uintptr_t)ar->ar_arg_addr); \
315 kau_write(rec, tok); \
316 } \
317 } while (0)
318
319 /*
320 * Implement auditing for the auditon() system call. The audit tokens that
321 * are generated depend on the command that was sent into the auditon()
322 * system call.
323 */
324 static void
audit_sys_auditon(struct audit_record * ar,struct au_record * rec)325 audit_sys_auditon(struct audit_record *ar, struct au_record *rec)
326 {
327 struct au_token *tok;
328
329 tok = au_to_arg32(3, "length", ar->ar_arg_len);
330 kau_write(rec, tok);
331 switch (ar->ar_arg_cmd) {
332 case A_OLDSETPOLICY:
333 if ((size_t)ar->ar_arg_len == sizeof(int64_t)) {
334 tok = au_to_arg64(2, "policy",
335 ar->ar_arg_auditon.au_policy64);
336 kau_write(rec, tok);
337 break;
338 }
339 /* FALLTHROUGH */
340
341 case A_SETPOLICY:
342 tok = au_to_arg32(2, "policy", ar->ar_arg_auditon.au_policy);
343 kau_write(rec, tok);
344 break;
345
346 case A_SETKMASK:
347 tok = au_to_arg32(2, "setkmask:as_success",
348 ar->ar_arg_auditon.au_mask.am_success);
349 kau_write(rec, tok);
350 tok = au_to_arg32(2, "setkmask:as_failure",
351 ar->ar_arg_auditon.au_mask.am_failure);
352 kau_write(rec, tok);
353 break;
354
355 case A_OLDSETQCTRL:
356 if ((size_t)ar->ar_arg_len == sizeof(au_qctrl64_t)) {
357 tok = au_to_arg64(2, "setqctrl:aq_hiwater",
358 ar->ar_arg_auditon.au_qctrl64.aq64_hiwater);
359 kau_write(rec, tok);
360 tok = au_to_arg64(2, "setqctrl:aq_lowater",
361 ar->ar_arg_auditon.au_qctrl64.aq64_lowater);
362 kau_write(rec, tok);
363 tok = au_to_arg64(2, "setqctrl:aq_bufsz",
364 ar->ar_arg_auditon.au_qctrl64.aq64_bufsz);
365 kau_write(rec, tok);
366 tok = au_to_arg64(2, "setqctrl:aq_delay",
367 ar->ar_arg_auditon.au_qctrl64.aq64_delay);
368 kau_write(rec, tok);
369 tok = au_to_arg64(2, "setqctrl:aq_minfree",
370 ar->ar_arg_auditon.au_qctrl64.aq64_minfree);
371 kau_write(rec, tok);
372 break;
373 }
374 /* FALLTHROUGH */
375
376 case A_SETQCTRL:
377 tok = au_to_arg32(2, "setqctrl:aq_hiwater",
378 ar->ar_arg_auditon.au_qctrl.aq_hiwater);
379 kau_write(rec, tok);
380 tok = au_to_arg32(2, "setqctrl:aq_lowater",
381 ar->ar_arg_auditon.au_qctrl.aq_lowater);
382 kau_write(rec, tok);
383 tok = au_to_arg32(2, "setqctrl:aq_bufsz",
384 ar->ar_arg_auditon.au_qctrl.aq_bufsz);
385 kau_write(rec, tok);
386 tok = au_to_arg32(2, "setqctrl:aq_delay",
387 ar->ar_arg_auditon.au_qctrl.aq_delay);
388 kau_write(rec, tok);
389 tok = au_to_arg32(2, "setqctrl:aq_minfree",
390 ar->ar_arg_auditon.au_qctrl.aq_minfree);
391 kau_write(rec, tok);
392 break;
393
394 case A_SETUMASK:
395 tok = au_to_arg32(2, "setumask:as_success",
396 ar->ar_arg_auditon.au_auinfo.ai_mask.am_success);
397 kau_write(rec, tok);
398 tok = au_to_arg32(2, "setumask:as_failure",
399 ar->ar_arg_auditon.au_auinfo.ai_mask.am_failure);
400 kau_write(rec, tok);
401 break;
402
403 case A_SETSMASK:
404 tok = au_to_arg32(2, "setsmask:as_success",
405 ar->ar_arg_auditon.au_auinfo.ai_mask.am_success);
406 kau_write(rec, tok);
407 tok = au_to_arg32(2, "setsmask:as_failure",
408 ar->ar_arg_auditon.au_auinfo.ai_mask.am_failure);
409 kau_write(rec, tok);
410 break;
411
412 case A_OLDSETCOND:
413 if ((size_t)ar->ar_arg_len == sizeof(int64_t)) {
414 tok = au_to_arg64(2, "setcond",
415 ar->ar_arg_auditon.au_cond64);
416 kau_write(rec, tok);
417 break;
418 }
419 /* FALLTHROUGH */
420
421 case A_SETCOND:
422 tok = au_to_arg32(2, "setcond", ar->ar_arg_auditon.au_cond);
423 kau_write(rec, tok);
424 break;
425
426 case A_SETCLASS:
427 tok = au_to_arg32(2, "setclass:ec_event",
428 ar->ar_arg_auditon.au_evclass.ec_number);
429 kau_write(rec, tok);
430 tok = au_to_arg32(2, "setclass:ec_class",
431 ar->ar_arg_auditon.au_evclass.ec_class);
432 kau_write(rec, tok);
433 break;
434
435 case A_SETPMASK:
436 tok = au_to_arg32(2, "setpmask:as_success",
437 ar->ar_arg_auditon.au_aupinfo.ap_mask.am_success);
438 kau_write(rec, tok);
439 tok = au_to_arg32(2, "setpmask:as_failure",
440 ar->ar_arg_auditon.au_aupinfo.ap_mask.am_failure);
441 kau_write(rec, tok);
442 break;
443
444 case A_SETFSIZE:
445 tok = au_to_arg32(2, "setfsize:filesize",
446 ar->ar_arg_auditon.au_fstat.af_filesz);
447 kau_write(rec, tok);
448 break;
449
450 default:
451 break;
452 }
453 }
454
455 /*
456 * Convert an internal kernel audit record to a BSM record and return a
457 * success/failure indicator. The BSM record is passed as an out parameter to
458 * this function.
459 *
460 * Return conditions:
461 * BSM_SUCCESS: The BSM record is valid
462 * BSM_FAILURE: Failure; the BSM record is NULL.
463 * BSM_NOAUDIT: The event is not auditable for BSM; the BSM record is NULL.
464 */
465 int
kaudit_to_bsm(struct kaudit_record * kar,struct au_record ** pau)466 kaudit_to_bsm(struct kaudit_record *kar, struct au_record **pau)
467 {
468 struct au_token *tok, *subj_tok, *jail_tok;
469 struct au_record *rec;
470 au_tid_t tid;
471 struct audit_record *ar;
472 int ctr;
473
474 KASSERT(kar != NULL, ("kaudit_to_bsm: kar == NULL"));
475
476 *pau = NULL;
477 ar = &kar->k_ar;
478 rec = kau_open();
479
480 /*
481 * Create the subject token. If this credential was jailed be sure to
482 * generate a zonename token.
483 */
484 if (ar->ar_jailname[0] != '\0')
485 jail_tok = au_to_zonename(ar->ar_jailname);
486 else
487 jail_tok = NULL;
488 switch (ar->ar_subj_term_addr.at_type) {
489 case AU_IPv4:
490 tid.port = ar->ar_subj_term_addr.at_port;
491 tid.machine = ar->ar_subj_term_addr.at_addr[0];
492 subj_tok = au_to_subject32(ar->ar_subj_auid, /* audit ID */
493 ar->ar_subj_cred.cr_uid, /* eff uid */
494 ar->ar_subj_egid, /* eff group id */
495 ar->ar_subj_ruid, /* real uid */
496 ar->ar_subj_rgid, /* real group id */
497 ar->ar_subj_pid, /* process id */
498 ar->ar_subj_asid, /* session ID */
499 &tid);
500 break;
501 case AU_IPv6:
502 subj_tok = au_to_subject32_ex(ar->ar_subj_auid,
503 ar->ar_subj_cred.cr_uid,
504 ar->ar_subj_egid,
505 ar->ar_subj_ruid,
506 ar->ar_subj_rgid,
507 ar->ar_subj_pid,
508 ar->ar_subj_asid,
509 &ar->ar_subj_term_addr);
510 break;
511 default:
512 bzero(&tid, sizeof(tid));
513 subj_tok = au_to_subject32(ar->ar_subj_auid,
514 ar->ar_subj_cred.cr_uid,
515 ar->ar_subj_egid,
516 ar->ar_subj_ruid,
517 ar->ar_subj_rgid,
518 ar->ar_subj_pid,
519 ar->ar_subj_asid,
520 &tid);
521 }
522
523 /*
524 * The logic inside each case fills in the tokens required for the
525 * event, except for the header, trailer, and return tokens. The
526 * header and trailer tokens are added by the kau_close() function.
527 * The return token is added outside of the switch statement.
528 */
529 switch(ar->ar_event) {
530 case AUE_ACCEPT:
531 if (ARG_IS_VALID(kar, ARG_FD)) {
532 tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
533 kau_write(rec, tok);
534 }
535 if (ARG_IS_VALID(kar, ARG_SADDRINET)) {
536 tok = au_to_sock_inet((struct sockaddr_in *)
537 &ar->ar_arg_sockaddr);
538 kau_write(rec, tok);
539 }
540 if (ARG_IS_VALID(kar, ARG_SADDRUNIX)) {
541 tok = au_to_sock_unix((struct sockaddr_un *)
542 &ar->ar_arg_sockaddr);
543 kau_write(rec, tok);
544 UPATH1_TOKENS;
545 }
546 break;
547
548 case AUE_BIND:
549 case AUE_LISTEN:
550 case AUE_CONNECT:
551 case AUE_RECV:
552 case AUE_RECVFROM:
553 case AUE_RECVMSG:
554 case AUE_SEND:
555 case AUE_SENDMSG:
556 case AUE_SENDTO:
557 /*
558 * Socket-related events.
559 */
560 if (ARG_IS_VALID(kar, ARG_FD)) {
561 tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
562 kau_write(rec, tok);
563 }
564 if (ARG_IS_VALID(kar, ARG_SADDRINET)) {
565 tok = au_to_sock_inet((struct sockaddr_in *)
566 &ar->ar_arg_sockaddr);
567 kau_write(rec, tok);
568 }
569 if (ARG_IS_VALID(kar, ARG_SADDRUNIX)) {
570 tok = au_to_sock_unix((struct sockaddr_un *)
571 &ar->ar_arg_sockaddr);
572 kau_write(rec, tok);
573 UPATH1_TOKENS;
574 }
575 /* XXX Need to handle ARG_SADDRINET6 */
576 break;
577
578 case AUE_BINDAT:
579 case AUE_CONNECTAT:
580 ATFD1_TOKENS(1);
581 if (ARG_IS_VALID(kar, ARG_FD)) {
582 tok = au_to_arg32(2, "fd", ar->ar_arg_fd);
583 kau_write(rec, tok);
584 }
585 if (ARG_IS_VALID(kar, ARG_SADDRUNIX)) {
586 tok = au_to_sock_unix((struct sockaddr_un *)
587 &ar->ar_arg_sockaddr);
588 kau_write(rec, tok);
589 UPATH1_TOKENS;
590 }
591 break;
592
593 case AUE_SENDFILE:
594 FD_VNODE1_TOKENS;
595 if (ARG_IS_VALID(kar, ARG_SADDRINET)) {
596 tok = au_to_sock_inet((struct sockaddr_in *)
597 &ar->ar_arg_sockaddr);
598 kau_write(rec, tok);
599 }
600 if (ARG_IS_VALID(kar, ARG_SADDRUNIX)) {
601 tok = au_to_sock_unix((struct sockaddr_un *)
602 &ar->ar_arg_sockaddr);
603 kau_write(rec, tok);
604 UPATH1_TOKENS;
605 }
606 /* XXX Need to handle ARG_SADDRINET6 */
607 break;
608
609 case AUE_SOCKET:
610 case AUE_SOCKETPAIR:
611 if (ARG_IS_VALID(kar, ARG_SOCKINFO)) {
612 tok = au_to_arg32(1, "domain",
613 ar->ar_arg_sockinfo.so_domain);
614 kau_write(rec, tok);
615 tok = au_to_arg32(2, "type",
616 ar->ar_arg_sockinfo.so_type);
617 kau_write(rec, tok);
618 tok = au_to_arg32(3, "protocol",
619 ar->ar_arg_sockinfo.so_protocol);
620 kau_write(rec, tok);
621 }
622 break;
623
624 case AUE_SETSOCKOPT:
625 case AUE_SHUTDOWN:
626 if (ARG_IS_VALID(kar, ARG_FD)) {
627 tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
628 kau_write(rec, tok);
629 }
630 break;
631
632 case AUE_ACCT:
633 if (ARG_IS_VALID(kar, ARG_UPATH1)) {
634 UPATH1_VNODE1_TOKENS;
635 } else {
636 tok = au_to_arg32(1, "accounting off", 0);
637 kau_write(rec, tok);
638 }
639 break;
640
641 case AUE_SETAUID:
642 if (ARG_IS_VALID(kar, ARG_AUID)) {
643 tok = au_to_arg32(2, "setauid", ar->ar_arg_auid);
644 kau_write(rec, tok);
645 }
646 break;
647
648 case AUE_SETAUDIT:
649 if (ARG_IS_VALID(kar, ARG_AUID) &&
650 ARG_IS_VALID(kar, ARG_ASID) &&
651 ARG_IS_VALID(kar, ARG_AMASK) &&
652 ARG_IS_VALID(kar, ARG_TERMID)) {
653 tok = au_to_arg32(1, "setaudit:auid",
654 ar->ar_arg_auid);
655 kau_write(rec, tok);
656 tok = au_to_arg32(1, "setaudit:port",
657 ar->ar_arg_termid.port);
658 kau_write(rec, tok);
659 tok = au_to_arg32(1, "setaudit:machine",
660 ar->ar_arg_termid.machine);
661 kau_write(rec, tok);
662 tok = au_to_arg32(1, "setaudit:as_success",
663 ar->ar_arg_amask.am_success);
664 kau_write(rec, tok);
665 tok = au_to_arg32(1, "setaudit:as_failure",
666 ar->ar_arg_amask.am_failure);
667 kau_write(rec, tok);
668 tok = au_to_arg32(1, "setaudit:asid",
669 ar->ar_arg_asid);
670 kau_write(rec, tok);
671 }
672 break;
673
674 case AUE_SETAUDIT_ADDR:
675 if (ARG_IS_VALID(kar, ARG_AUID) &&
676 ARG_IS_VALID(kar, ARG_ASID) &&
677 ARG_IS_VALID(kar, ARG_AMASK) &&
678 ARG_IS_VALID(kar, ARG_TERMID_ADDR)) {
679 tok = au_to_arg32(1, "setaudit_addr:auid",
680 ar->ar_arg_auid);
681 kau_write(rec, tok);
682 tok = au_to_arg32(1, "setaudit_addr:as_success",
683 ar->ar_arg_amask.am_success);
684 kau_write(rec, tok);
685 tok = au_to_arg32(1, "setaudit_addr:as_failure",
686 ar->ar_arg_amask.am_failure);
687 kau_write(rec, tok);
688 tok = au_to_arg32(1, "setaudit_addr:asid",
689 ar->ar_arg_asid);
690 kau_write(rec, tok);
691 tok = au_to_arg32(1, "setaudit_addr:type",
692 ar->ar_arg_termid_addr.at_type);
693 kau_write(rec, tok);
694 tok = au_to_arg32(1, "setaudit_addr:port",
695 ar->ar_arg_termid_addr.at_port);
696 kau_write(rec, tok);
697 if (ar->ar_arg_termid_addr.at_type == AU_IPv6)
698 tok = au_to_in_addr_ex((struct in6_addr *)
699 &ar->ar_arg_termid_addr.at_addr[0]);
700 if (ar->ar_arg_termid_addr.at_type == AU_IPv4)
701 tok = au_to_in_addr((struct in_addr *)
702 &ar->ar_arg_termid_addr.at_addr[0]);
703 kau_write(rec, tok);
704 }
705 break;
706
707 case AUE_AUDITON:
708 /*
709 * For AUDITON commands without own event, audit the cmd.
710 */
711 if (ARG_IS_VALID(kar, ARG_CMD)) {
712 tok = au_to_arg32(1, "cmd", ar->ar_arg_cmd);
713 kau_write(rec, tok);
714 }
715 /* FALLTHROUGH */
716
717 case AUE_AUDITON_GETCAR:
718 case AUE_AUDITON_GETCLASS:
719 case AUE_AUDITON_GETCOND:
720 case AUE_AUDITON_GETCWD:
721 case AUE_AUDITON_GETKMASK:
722 case AUE_AUDITON_GETSTAT:
723 case AUE_AUDITON_GPOLICY:
724 case AUE_AUDITON_GQCTRL:
725 case AUE_AUDITON_SETCLASS:
726 case AUE_AUDITON_SETCOND:
727 case AUE_AUDITON_SETKMASK:
728 case AUE_AUDITON_SETSMASK:
729 case AUE_AUDITON_SETSTAT:
730 case AUE_AUDITON_SETUMASK:
731 case AUE_AUDITON_SPOLICY:
732 case AUE_AUDITON_SQCTRL:
733 if (ARG_IS_VALID(kar, ARG_AUDITON))
734 audit_sys_auditon(ar, rec);
735 break;
736
737 case AUE_AUDITCTL:
738 UPATH1_VNODE1_TOKENS;
739 break;
740
741 case AUE_EXIT:
742 if (ARG_IS_VALID(kar, ARG_EXIT)) {
743 tok = au_to_exit(ar->ar_arg_exitretval,
744 ar->ar_arg_exitstatus);
745 kau_write(rec, tok);
746 }
747 break;
748
749 case AUE_ADJTIME:
750 case AUE_CLOCK_SETTIME:
751 case AUE_AUDIT:
752 case AUE_DUP2:
753 case AUE_GETAUDIT:
754 case AUE_GETAUDIT_ADDR:
755 case AUE_GETAUID:
756 case AUE_GETCWD:
757 case AUE_GETFSSTAT:
758 case AUE_GETRESUID:
759 case AUE_GETRESGID:
760 case AUE_KQUEUE:
761 case AUE_MODLOAD:
762 case AUE_MODUNLOAD:
763 case AUE_MSGSYS:
764 case AUE_NTP_ADJTIME:
765 case AUE_PIPE:
766 case AUE_POSIX_OPENPT:
767 case AUE_PROFILE:
768 case AUE_RTPRIO:
769 case AUE_SEMSYS:
770 case AUE_SETFIB:
771 case AUE_SHMSYS:
772 case AUE_SETPGRP:
773 case AUE_SETRLIMIT:
774 case AUE_SETSID:
775 case AUE_SETTIMEOFDAY:
776 case AUE_SYSARCH:
777
778 /*
779 * Header, subject, and return tokens added at end.
780 */
781 break;
782
783 case AUE_ACL_DELETE_FD:
784 case AUE_ACL_DELETE_FILE:
785 case AUE_ACL_CHECK_FD:
786 case AUE_ACL_CHECK_FILE:
787 case AUE_ACL_CHECK_LINK:
788 case AUE_ACL_DELETE_LINK:
789 case AUE_ACL_GET_FD:
790 case AUE_ACL_GET_FILE:
791 case AUE_ACL_GET_LINK:
792 case AUE_ACL_SET_FD:
793 case AUE_ACL_SET_FILE:
794 case AUE_ACL_SET_LINK:
795 if (ARG_IS_VALID(kar, ARG_VALUE)) {
796 tok = au_to_arg32(1, "type", ar->ar_arg_value);
797 kau_write(rec, tok);
798 }
799 ATFD1_TOKENS(1);
800 UPATH1_VNODE1_TOKENS;
801 break;
802
803 /*
804 * NB: We may want to verify that the appropriate
805 * audit args are being processed here, but I think
806 * a bit analysis is required.
807 *
808 * Process AUE_JAIL_SET in the next block so we can pickup any path
809 * related tokens that might exist.
810 */
811 case AUE_JAIL_GET:
812 case AUE_JAIL_ATTACH:
813 case AUE_JAIL_REMOVE:
814 break;
815
816 case AUE_JAIL_SET:
817 case AUE_CHDIR:
818 case AUE_CHROOT:
819 case AUE_FSTATAT:
820 case AUE_FUTIMESAT:
821 case AUE_GETATTRLIST:
822 case AUE_JAIL:
823 case AUE_LUTIMES:
824 case AUE_NFS_GETFH:
825 case AUE_LGETFH:
826 case AUE_LSTAT:
827 case AUE_LPATHCONF:
828 case AUE_PATHCONF:
829 case AUE_READLINK:
830 case AUE_READLINKAT:
831 case AUE_REVOKE:
832 case AUE_RMDIR:
833 case AUE_SEARCHFS:
834 case AUE_SETATTRLIST:
835 case AUE_STAT:
836 case AUE_STATFS:
837 case AUE_SWAPON:
838 case AUE_SWAPOFF:
839 case AUE_TRUNCATE:
840 case AUE_UNDELETE:
841 case AUE_UNLINK:
842 case AUE_UNLINKAT:
843 case AUE_UTIMES:
844 case AUE_REALPATHAT:
845 ATFD1_TOKENS(1);
846 UPATH1_VNODE1_TOKENS;
847 break;
848
849 case AUE_ACCESS:
850 case AUE_EACCESS:
851 case AUE_FACCESSAT:
852 ATFD1_TOKENS(1);
853 UPATH1_VNODE1_TOKENS;
854 if (ARG_IS_VALID(kar, ARG_VALUE)) {
855 tok = au_to_arg32(2, "mode", ar->ar_arg_value);
856 kau_write(rec, tok);
857 }
858 break;
859
860 case AUE_FHSTATFS:
861 case AUE_FHOPEN:
862 case AUE_FHSTAT:
863 /* XXXRW: Need to audit vnode argument. */
864 break;
865
866 case AUE_CHFLAGS:
867 case AUE_LCHFLAGS:
868 case AUE_CHFLAGSAT:
869 if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
870 tok = au_to_arg32(2, "flags", ar->ar_arg_fflags);
871 kau_write(rec, tok);
872 }
873 UPATH1_VNODE1_TOKENS;
874 break;
875
876 case AUE_CHMOD:
877 case AUE_LCHMOD:
878 if (ARG_IS_VALID(kar, ARG_MODE)) {
879 tok = au_to_arg32(2, "new file mode",
880 ar->ar_arg_mode);
881 kau_write(rec, tok);
882 }
883 UPATH1_VNODE1_TOKENS;
884 break;
885
886 case AUE_FCHMODAT:
887 ATFD1_TOKENS(1);
888 if (ARG_IS_VALID(kar, ARG_MODE)) {
889 tok = au_to_arg32(3, "new file mode",
890 ar->ar_arg_mode);
891 kau_write(rec, tok);
892 }
893 UPATH1_VNODE1_TOKENS;
894 break;
895
896 case AUE_CHOWN:
897 case AUE_LCHOWN:
898 if (ARG_IS_VALID(kar, ARG_UID)) {
899 tok = au_to_arg32(2, "new file uid", ar->ar_arg_uid);
900 kau_write(rec, tok);
901 }
902 if (ARG_IS_VALID(kar, ARG_GID)) {
903 tok = au_to_arg32(3, "new file gid", ar->ar_arg_gid);
904 kau_write(rec, tok);
905 }
906 UPATH1_VNODE1_TOKENS;
907 break;
908
909 case AUE_FCHOWNAT:
910 ATFD1_TOKENS(1);
911 if (ARG_IS_VALID(kar, ARG_UID)) {
912 tok = au_to_arg32(3, "new file uid", ar->ar_arg_uid);
913 kau_write(rec, tok);
914 }
915 if (ARG_IS_VALID(kar, ARG_GID)) {
916 tok = au_to_arg32(4, "new file gid", ar->ar_arg_gid);
917 kau_write(rec, tok);
918 }
919 UPATH1_VNODE1_TOKENS;
920 break;
921
922 case AUE_EXCHANGEDATA:
923 UPATH1_VNODE1_TOKENS;
924 UPATH2_TOKENS;
925 break;
926
927 case AUE_CLOSE:
928 if (ARG_IS_VALID(kar, ARG_FD)) {
929 tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
930 kau_write(rec, tok);
931 }
932 UPATH1_VNODE1_TOKENS;
933 break;
934
935 case AUE_CLOSEFROM:
936 if (ARG_IS_VALID(kar, ARG_FD)) {
937 tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
938 kau_write(rec, tok);
939 }
940 break;
941
942 case AUE_CLOSERANGE:
943 if (ARG_IS_VALID(kar, ARG_FD)) {
944 tok = au_to_arg32(1, "lowfd", ar->ar_arg_fd);
945 kau_write(rec, tok);
946 }
947 if (ARG_IS_VALID(kar, ARG_CMD)) {
948 tok = au_to_arg32(2, "highfd", ar->ar_arg_cmd);
949 kau_write(rec, tok);
950 }
951 if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
952 tok = au_to_arg32(3, "flags", ar->ar_arg_fflags);
953 kau_write(rec, tok);
954 }
955 break;
956
957 case AUE_CORE:
958 if (ARG_IS_VALID(kar, ARG_SIGNUM)) {
959 tok = au_to_arg32(1, "signal", ar->ar_arg_signum);
960 kau_write(rec, tok);
961 }
962 UPATH1_VNODE1_TOKENS;
963 break;
964
965 case AUE_EXTATTRCTL:
966 UPATH1_VNODE1_TOKENS;
967 if (ARG_IS_VALID(kar, ARG_CMD)) {
968 tok = au_to_arg32(2, "cmd", ar->ar_arg_cmd);
969 kau_write(rec, tok);
970 }
971 /* extattrctl(2) filename parameter is in upath2/vnode2 */
972 UPATH2_TOKENS;
973 VNODE2_TOKENS;
974 EXTATTR_TOKENS(4);
975 break;
976
977 case AUE_EXTATTR_GET_FILE:
978 case AUE_EXTATTR_SET_FILE:
979 case AUE_EXTATTR_LIST_FILE:
980 case AUE_EXTATTR_DELETE_FILE:
981 case AUE_EXTATTR_GET_LINK:
982 case AUE_EXTATTR_SET_LINK:
983 case AUE_EXTATTR_LIST_LINK:
984 case AUE_EXTATTR_DELETE_LINK:
985 UPATH1_VNODE1_TOKENS;
986 EXTATTR_TOKENS(2);
987 break;
988
989 case AUE_EXTATTR_GET_FD:
990 case AUE_EXTATTR_SET_FD:
991 case AUE_EXTATTR_LIST_FD:
992 case AUE_EXTATTR_DELETE_FD:
993 if (ARG_IS_VALID(kar, ARG_FD)) {
994 tok = au_to_arg32(2, "fd", ar->ar_arg_fd);
995 kau_write(rec, tok);
996 }
997 EXTATTR_TOKENS(2);
998 break;
999
1000 case AUE_FEXECVE:
1001 if (ARG_IS_VALID(kar, ARG_FD)) {
1002 tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
1003 kau_write(rec, tok);
1004 }
1005 /* FALLTHROUGH */
1006
1007 case AUE_EXECVE:
1008 case AUE_MAC_EXECVE:
1009 if (ARG_IS_VALID(kar, ARG_ARGV)) {
1010 tok = au_to_exec_args(ar->ar_arg_argv,
1011 ar->ar_arg_argc);
1012 kau_write(rec, tok);
1013 }
1014 if (ARG_IS_VALID(kar, ARG_ENVV)) {
1015 tok = au_to_exec_env(ar->ar_arg_envv,
1016 ar->ar_arg_envc);
1017 kau_write(rec, tok);
1018 }
1019 UPATH1_VNODE1_TOKENS;
1020 break;
1021
1022 case AUE_FCHMOD:
1023 if (ARG_IS_VALID(kar, ARG_MODE)) {
1024 tok = au_to_arg32(2, "new file mode",
1025 ar->ar_arg_mode);
1026 kau_write(rec, tok);
1027 }
1028 FD_VNODE1_TOKENS;
1029 break;
1030
1031 /*
1032 * XXXRW: Some of these need to handle non-vnode cases as well.
1033 */
1034 case AUE_FCHDIR:
1035 case AUE_FPATHCONF:
1036 case AUE_FSTAT:
1037 case AUE_FSTATFS:
1038 case AUE_FSYNC:
1039 case AUE_FTRUNCATE:
1040 case AUE_FUTIMES:
1041 case AUE_GETDIRENTRIES:
1042 case AUE_GETDIRENTRIESATTR:
1043 case AUE_LSEEK:
1044 case AUE_POLL:
1045 case AUE_POSIX_FALLOCATE:
1046 case AUE_PREAD:
1047 case AUE_PWRITE:
1048 case AUE_READ:
1049 case AUE_READV:
1050 case AUE_WRITE:
1051 case AUE_WRITEV:
1052 FD_VNODE1_TOKENS;
1053 break;
1054
1055 case AUE_FCHOWN:
1056 if (ARG_IS_VALID(kar, ARG_UID)) {
1057 tok = au_to_arg32(2, "new file uid", ar->ar_arg_uid);
1058 kau_write(rec, tok);
1059 }
1060 if (ARG_IS_VALID(kar, ARG_GID)) {
1061 tok = au_to_arg32(3, "new file gid", ar->ar_arg_gid);
1062 kau_write(rec, tok);
1063 }
1064 FD_VNODE1_TOKENS;
1065 break;
1066
1067 case AUE_FCNTL:
1068 if (ARG_IS_VALID(kar, ARG_CMD)) {
1069 tok = au_to_arg32(2, "cmd",
1070 au_fcntl_cmd_to_bsm(ar->ar_arg_cmd));
1071 kau_write(rec, tok);
1072 }
1073 FD_VNODE1_TOKENS;
1074 break;
1075
1076 case AUE_FCHFLAGS:
1077 if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
1078 tok = au_to_arg32(2, "flags", ar->ar_arg_fflags);
1079 kau_write(rec, tok);
1080 }
1081 FD_VNODE1_TOKENS;
1082 break;
1083
1084 case AUE_FLOCK:
1085 if (ARG_IS_VALID(kar, ARG_CMD)) {
1086 tok = au_to_arg32(2, "operation", ar->ar_arg_cmd);
1087 kau_write(rec, tok);
1088 }
1089 FD_VNODE1_TOKENS;
1090 break;
1091
1092 case AUE_RFORK:
1093 if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
1094 tok = au_to_arg32(1, "flags", ar->ar_arg_fflags);
1095 kau_write(rec, tok);
1096 }
1097 /* FALLTHROUGH */
1098
1099 case AUE_FORK:
1100 case AUE_VFORK:
1101 if (ARG_IS_VALID(kar, ARG_PID)) {
1102 tok = au_to_arg32(0, "child PID", ar->ar_arg_pid);
1103 kau_write(rec, tok);
1104 }
1105 break;
1106
1107 case AUE_IOCTL:
1108 if (ARG_IS_VALID(kar, ARG_CMD)) {
1109 tok = au_to_arg32(2, "cmd", ar->ar_arg_cmd);
1110 kau_write(rec, tok);
1111 }
1112 if (ARG_IS_VALID(kar, ARG_VNODE1))
1113 FD_VNODE1_TOKENS;
1114 else {
1115 if (ARG_IS_VALID(kar, ARG_SOCKINFO)) {
1116 tok = kau_to_socket(&ar->ar_arg_sockinfo);
1117 kau_write(rec, tok);
1118 } else {
1119 if (ARG_IS_VALID(kar, ARG_FD)) {
1120 tok = au_to_arg32(1, "fd",
1121 ar->ar_arg_fd);
1122 kau_write(rec, tok);
1123 }
1124 }
1125 }
1126 break;
1127
1128 case AUE_KILL:
1129 case AUE_KILLPG:
1130 if (ARG_IS_VALID(kar, ARG_SIGNUM)) {
1131 tok = au_to_arg32(2, "signal", ar->ar_arg_signum);
1132 kau_write(rec, tok);
1133 }
1134 PROCESS_PID_TOKENS(1);
1135 break;
1136
1137 case AUE_KTRACE:
1138 if (ARG_IS_VALID(kar, ARG_CMD)) {
1139 tok = au_to_arg32(2, "ops", ar->ar_arg_cmd);
1140 kau_write(rec, tok);
1141 }
1142 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1143 tok = au_to_arg32(3, "trpoints", ar->ar_arg_value);
1144 kau_write(rec, tok);
1145 }
1146 PROCESS_PID_TOKENS(4);
1147 UPATH1_VNODE1_TOKENS;
1148 break;
1149
1150 case AUE_LINK:
1151 case AUE_LINKAT:
1152 case AUE_RENAME:
1153 case AUE_RENAMEAT:
1154 ATFD1_TOKENS(1);
1155 UPATH1_VNODE1_TOKENS;
1156 ATFD2_TOKENS(3);
1157 UPATH2_TOKENS;
1158 break;
1159
1160 case AUE_LOADSHFILE:
1161 ADDR_TOKEN(4, "base addr");
1162 UPATH1_VNODE1_TOKENS;
1163 break;
1164
1165 case AUE_MKDIR:
1166 case AUE_MKDIRAT:
1167 case AUE_MKFIFO:
1168 case AUE_MKFIFOAT:
1169 ATFD1_TOKENS(1);
1170 if (ARG_IS_VALID(kar, ARG_MODE)) {
1171 tok = au_to_arg32(2, "mode", ar->ar_arg_mode);
1172 kau_write(rec, tok);
1173 }
1174 UPATH1_VNODE1_TOKENS;
1175 break;
1176
1177 case AUE_MKNOD:
1178 case AUE_MKNODAT:
1179 ATFD1_TOKENS(1);
1180 if (ARG_IS_VALID(kar, ARG_MODE)) {
1181 tok = au_to_arg32(2, "mode", ar->ar_arg_mode);
1182 kau_write(rec, tok);
1183 }
1184 if (ARG_IS_VALID(kar, ARG_DEV)) {
1185 tok = au_to_arg32(3, "dev", ar->ar_arg_dev);
1186 kau_write(rec, tok);
1187 }
1188 UPATH1_VNODE1_TOKENS;
1189 break;
1190
1191 case AUE_MMAP:
1192 case AUE_MUNMAP:
1193 case AUE_MPROTECT:
1194 case AUE_MLOCK:
1195 case AUE_MUNLOCK:
1196 case AUE_MINHERIT:
1197 ADDR_TOKEN(1, "addr");
1198 if (ARG_IS_VALID(kar, ARG_LEN)) {
1199 tok = au_to_arg32(2, "len", ar->ar_arg_len);
1200 kau_write(rec, tok);
1201 }
1202 if (ar->ar_event == AUE_MMAP)
1203 FD_VNODE1_TOKENS;
1204 if (ar->ar_event == AUE_MPROTECT) {
1205 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1206 tok = au_to_arg32(3, "protection",
1207 ar->ar_arg_value);
1208 kau_write(rec, tok);
1209 }
1210 }
1211 if (ar->ar_event == AUE_MINHERIT) {
1212 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1213 tok = au_to_arg32(3, "inherit",
1214 ar->ar_arg_value);
1215 kau_write(rec, tok);
1216 }
1217 }
1218 break;
1219
1220 case AUE_MOUNT:
1221 case AUE_NMOUNT:
1222 /* XXX Need to handle NFS mounts */
1223 if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
1224 tok = au_to_arg32(3, "flags", ar->ar_arg_fflags);
1225 kau_write(rec, tok);
1226 }
1227 if (ARG_IS_VALID(kar, ARG_TEXT)) {
1228 tok = au_to_text(ar->ar_arg_text);
1229 kau_write(rec, tok);
1230 }
1231 /* FALLTHROUGH */
1232
1233 case AUE_NFS_SVC:
1234 if (ARG_IS_VALID(kar, ARG_CMD)) {
1235 tok = au_to_arg32(1, "flags", ar->ar_arg_cmd);
1236 kau_write(rec, tok);
1237 }
1238 break;
1239
1240 case AUE_UMOUNT:
1241 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1242 tok = au_to_arg32(2, "flags", ar->ar_arg_value);
1243 kau_write(rec, tok);
1244 }
1245 UPATH1_VNODE1_TOKENS;
1246 if (ARG_IS_VALID(kar, ARG_TEXT)) {
1247 tok = au_to_text(ar->ar_arg_text);
1248 kau_write(rec, tok);
1249 }
1250 break;
1251
1252 case AUE_MSGCTL:
1253 ar->ar_event = audit_msgctl_to_event(ar->ar_arg_svipc_cmd);
1254 /* Fall through */
1255
1256 case AUE_MSGRCV:
1257 case AUE_MSGSND:
1258 tok = au_to_arg32(1, "msg ID", ar->ar_arg_svipc_id);
1259 kau_write(rec, tok);
1260 if (ar->ar_errno != EINVAL) {
1261 tok = au_to_ipc(AT_IPC_MSG, ar->ar_arg_svipc_id);
1262 kau_write(rec, tok);
1263 }
1264 break;
1265
1266 case AUE_MSGGET:
1267 if (ar->ar_errno == 0) {
1268 if (ARG_IS_VALID(kar, ARG_SVIPC_ID)) {
1269 tok = au_to_ipc(AT_IPC_MSG,
1270 ar->ar_arg_svipc_id);
1271 kau_write(rec, tok);
1272 }
1273 }
1274 break;
1275
1276 case AUE_RESETSHFILE:
1277 ADDR_TOKEN(1, "base addr");
1278 break;
1279
1280 case AUE_OPEN_RC:
1281 case AUE_OPEN_RTC:
1282 case AUE_OPEN_RWC:
1283 case AUE_OPEN_RWTC:
1284 case AUE_OPEN_WC:
1285 case AUE_OPEN_WTC:
1286 case AUE_CREAT:
1287 if (ARG_IS_VALID(kar, ARG_MODE)) {
1288 tok = au_to_arg32(3, "mode", ar->ar_arg_mode);
1289 kau_write(rec, tok);
1290 }
1291 /* FALLTHROUGH */
1292
1293 case AUE_OPEN_R:
1294 case AUE_OPEN_RT:
1295 case AUE_OPEN_RW:
1296 case AUE_OPEN_RWT:
1297 case AUE_OPEN_W:
1298 case AUE_OPEN_WT:
1299 if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
1300 tok = au_to_arg32(2, "flags", ar->ar_arg_fflags);
1301 kau_write(rec, tok);
1302 }
1303 UPATH1_VNODE1_TOKENS;
1304 break;
1305
1306 case AUE_OPENAT_RC:
1307 case AUE_OPENAT_RTC:
1308 case AUE_OPENAT_RWC:
1309 case AUE_OPENAT_RWTC:
1310 case AUE_OPENAT_WC:
1311 case AUE_OPENAT_WTC:
1312 if (ARG_IS_VALID(kar, ARG_MODE)) {
1313 tok = au_to_arg32(3, "mode", ar->ar_arg_mode);
1314 kau_write(rec, tok);
1315 }
1316 /* FALLTHROUGH */
1317
1318 case AUE_OPENAT_R:
1319 case AUE_OPENAT_RT:
1320 case AUE_OPENAT_RW:
1321 case AUE_OPENAT_RWT:
1322 case AUE_OPENAT_W:
1323 case AUE_OPENAT_WT:
1324 if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
1325 tok = au_to_arg32(2, "flags", ar->ar_arg_fflags);
1326 kau_write(rec, tok);
1327 }
1328 ATFD1_TOKENS(1);
1329 UPATH1_VNODE1_TOKENS;
1330 break;
1331
1332 case AUE_PDKILL:
1333 if (ARG_IS_VALID(kar, ARG_FD)) {
1334 tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
1335 kau_write(rec, tok);
1336 }
1337 if (ARG_IS_VALID(kar, ARG_SIGNUM)) {
1338 tok = au_to_arg32(2, "signal", ar->ar_arg_signum);
1339 kau_write(rec, tok);
1340 }
1341 PROCESS_PID_TOKENS(1);
1342 break;
1343 case AUE_PDFORK:
1344 if (ARG_IS_VALID(kar, ARG_PID)) {
1345 tok = au_to_arg32(0, "child PID", ar->ar_arg_pid);
1346 kau_write(rec, tok);
1347 }
1348 if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
1349 tok = au_to_arg32(2, "flags", ar->ar_arg_fflags);
1350 kau_write(rec, tok);
1351 }
1352 if (ARG_IS_VALID(kar, ARG_FD)) {
1353 tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
1354 kau_write(rec, tok);
1355 }
1356 break;
1357 case AUE_PDGETPID:
1358 if (ARG_IS_VALID(kar, ARG_FD)) {
1359 tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
1360 kau_write(rec, tok);
1361 }
1362 break;
1363
1364 case AUE_PROCCTL:
1365 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1366 tok = au_to_arg32(1, "idtype", ar->ar_arg_value);
1367 kau_write(rec, tok);
1368 }
1369 if (ARG_IS_VALID(kar, ARG_CMD)) {
1370 tok = au_to_arg32(2, "com", ar->ar_arg_cmd);
1371 kau_write(rec, tok);
1372 }
1373 PROCESS_PID_TOKENS(3);
1374 break;
1375
1376 case AUE_PTRACE:
1377 if (ARG_IS_VALID(kar, ARG_CMD)) {
1378 tok = au_to_arg32(1, "request", ar->ar_arg_cmd);
1379 kau_write(rec, tok);
1380 }
1381 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1382 tok = au_to_arg32(4, "data", ar->ar_arg_value);
1383 kau_write(rec, tok);
1384 }
1385 PROCESS_PID_TOKENS(2);
1386 break;
1387
1388 case AUE_QUOTACTL:
1389 if (ARG_IS_VALID(kar, ARG_CMD)) {
1390 tok = au_to_arg32(2, "command", ar->ar_arg_cmd);
1391 kau_write(rec, tok);
1392 }
1393 if (ARG_IS_VALID(kar, ARG_UID)) {
1394 tok = au_to_arg32(3, "uid", ar->ar_arg_uid);
1395 kau_write(rec, tok);
1396 }
1397 if (ARG_IS_VALID(kar, ARG_GID)) {
1398 tok = au_to_arg32(3, "gid", ar->ar_arg_gid);
1399 kau_write(rec, tok);
1400 }
1401 UPATH1_VNODE1_TOKENS;
1402 break;
1403
1404 case AUE_REBOOT:
1405 if (ARG_IS_VALID(kar, ARG_CMD)) {
1406 tok = au_to_arg32(1, "howto", ar->ar_arg_cmd);
1407 kau_write(rec, tok);
1408 }
1409 break;
1410
1411 case AUE_SEMCTL:
1412 ar->ar_event = audit_semctl_to_event(ar->ar_arg_svipc_cmd);
1413 /* Fall through */
1414
1415 case AUE_SEMOP:
1416 if (ARG_IS_VALID(kar, ARG_SVIPC_ID)) {
1417 tok = au_to_arg32(1, "sem ID", ar->ar_arg_svipc_id);
1418 kau_write(rec, tok);
1419 if (ar->ar_errno != EINVAL) {
1420 tok = au_to_ipc(AT_IPC_SEM,
1421 ar->ar_arg_svipc_id);
1422 kau_write(rec, tok);
1423 }
1424 }
1425 break;
1426
1427 case AUE_SEMGET:
1428 if (ar->ar_errno == 0) {
1429 if (ARG_IS_VALID(kar, ARG_SVIPC_ID)) {
1430 tok = au_to_ipc(AT_IPC_SEM,
1431 ar->ar_arg_svipc_id);
1432 kau_write(rec, tok);
1433 }
1434 }
1435 break;
1436
1437 case AUE_SETEGID:
1438 if (ARG_IS_VALID(kar, ARG_EGID)) {
1439 tok = au_to_arg32(1, "egid", ar->ar_arg_egid);
1440 kau_write(rec, tok);
1441 }
1442 break;
1443
1444 case AUE_SETEUID:
1445 if (ARG_IS_VALID(kar, ARG_EUID)) {
1446 tok = au_to_arg32(1, "euid", ar->ar_arg_euid);
1447 kau_write(rec, tok);
1448 }
1449 break;
1450
1451 case AUE_SETREGID:
1452 if (ARG_IS_VALID(kar, ARG_RGID)) {
1453 tok = au_to_arg32(1, "rgid", ar->ar_arg_rgid);
1454 kau_write(rec, tok);
1455 }
1456 if (ARG_IS_VALID(kar, ARG_EGID)) {
1457 tok = au_to_arg32(2, "egid", ar->ar_arg_egid);
1458 kau_write(rec, tok);
1459 }
1460 break;
1461
1462 case AUE_SETREUID:
1463 if (ARG_IS_VALID(kar, ARG_RUID)) {
1464 tok = au_to_arg32(1, "ruid", ar->ar_arg_ruid);
1465 kau_write(rec, tok);
1466 }
1467 if (ARG_IS_VALID(kar, ARG_EUID)) {
1468 tok = au_to_arg32(2, "euid", ar->ar_arg_euid);
1469 kau_write(rec, tok);
1470 }
1471 break;
1472
1473 case AUE_SETRESGID:
1474 if (ARG_IS_VALID(kar, ARG_RGID)) {
1475 tok = au_to_arg32(1, "rgid", ar->ar_arg_rgid);
1476 kau_write(rec, tok);
1477 }
1478 if (ARG_IS_VALID(kar, ARG_EGID)) {
1479 tok = au_to_arg32(2, "egid", ar->ar_arg_egid);
1480 kau_write(rec, tok);
1481 }
1482 if (ARG_IS_VALID(kar, ARG_SGID)) {
1483 tok = au_to_arg32(3, "sgid", ar->ar_arg_sgid);
1484 kau_write(rec, tok);
1485 }
1486 break;
1487
1488 case AUE_SETRESUID:
1489 if (ARG_IS_VALID(kar, ARG_RUID)) {
1490 tok = au_to_arg32(1, "ruid", ar->ar_arg_ruid);
1491 kau_write(rec, tok);
1492 }
1493 if (ARG_IS_VALID(kar, ARG_EUID)) {
1494 tok = au_to_arg32(2, "euid", ar->ar_arg_euid);
1495 kau_write(rec, tok);
1496 }
1497 if (ARG_IS_VALID(kar, ARG_SUID)) {
1498 tok = au_to_arg32(3, "suid", ar->ar_arg_suid);
1499 kau_write(rec, tok);
1500 }
1501 break;
1502
1503 case AUE_SETGID:
1504 if (ARG_IS_VALID(kar, ARG_GID)) {
1505 tok = au_to_arg32(1, "gid", ar->ar_arg_gid);
1506 kau_write(rec, tok);
1507 }
1508 break;
1509
1510 case AUE_SETUID:
1511 if (ARG_IS_VALID(kar, ARG_UID)) {
1512 tok = au_to_arg32(1, "uid", ar->ar_arg_uid);
1513 kau_write(rec, tok);
1514 }
1515 break;
1516
1517 case AUE_SETGROUPS:
1518 if (ARG_IS_VALID(kar, ARG_GROUPSET)) {
1519 for(ctr = 0; ctr < ar->ar_arg_groups.gidset_size; ctr++)
1520 {
1521 tok = au_to_arg32(1, "setgroups",
1522 ar->ar_arg_groups.gidset[ctr]);
1523 kau_write(rec, tok);
1524 }
1525 }
1526 break;
1527
1528 case AUE_SETLOGIN:
1529 if (ARG_IS_VALID(kar, ARG_LOGIN)) {
1530 tok = au_to_text(ar->ar_arg_login);
1531 kau_write(rec, tok);
1532 }
1533 break;
1534
1535 case AUE_SETLOGINCLASS:
1536 break;
1537
1538 case AUE_SETPRIORITY:
1539 if (ARG_IS_VALID(kar, ARG_CMD)) {
1540 tok = au_to_arg32(1, "which", ar->ar_arg_cmd);
1541 kau_write(rec, tok);
1542 }
1543 if (ARG_IS_VALID(kar, ARG_UID)) {
1544 tok = au_to_arg32(2, "who", ar->ar_arg_uid);
1545 kau_write(rec, tok);
1546 }
1547 PROCESS_PID_TOKENS(2);
1548 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1549 tok = au_to_arg32(3, "priority", ar->ar_arg_value);
1550 kau_write(rec, tok);
1551 }
1552 break;
1553
1554 case AUE_SETPRIVEXEC:
1555 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1556 tok = au_to_arg32(1, "flag", ar->ar_arg_value);
1557 kau_write(rec, tok);
1558 }
1559 break;
1560
1561 /* AUE_SHMAT, AUE_SHMCTL, AUE_SHMDT and AUE_SHMGET are SysV IPC */
1562 case AUE_SHMAT:
1563 if (ARG_IS_VALID(kar, ARG_SVIPC_ID)) {
1564 tok = au_to_arg32(1, "shmid", ar->ar_arg_svipc_id);
1565 kau_write(rec, tok);
1566 /* XXXAUDIT: Does having the ipc token make sense? */
1567 tok = au_to_ipc(AT_IPC_SHM, ar->ar_arg_svipc_id);
1568 kau_write(rec, tok);
1569 }
1570 if (ARG_IS_VALID(kar, ARG_SVIPC_ADDR)) {
1571 tok = au_to_arg32(2, "shmaddr",
1572 (int)(uintptr_t)ar->ar_arg_svipc_addr);
1573 kau_write(rec, tok);
1574 }
1575 if (ARG_IS_VALID(kar, ARG_SVIPC_PERM)) {
1576 tok = au_to_ipc_perm(&ar->ar_arg_svipc_perm);
1577 kau_write(rec, tok);
1578 }
1579 break;
1580
1581 case AUE_SHMCTL:
1582 if (ARG_IS_VALID(kar, ARG_SVIPC_ID)) {
1583 tok = au_to_arg32(1, "shmid", ar->ar_arg_svipc_id);
1584 kau_write(rec, tok);
1585 /* XXXAUDIT: Does having the ipc token make sense? */
1586 tok = au_to_ipc(AT_IPC_SHM, ar->ar_arg_svipc_id);
1587 kau_write(rec, tok);
1588 }
1589 switch (ar->ar_arg_svipc_cmd) {
1590 case IPC_STAT:
1591 ar->ar_event = AUE_SHMCTL_STAT;
1592 break;
1593 case IPC_RMID:
1594 ar->ar_event = AUE_SHMCTL_RMID;
1595 break;
1596 case IPC_SET:
1597 ar->ar_event = AUE_SHMCTL_SET;
1598 if (ARG_IS_VALID(kar, ARG_SVIPC_PERM)) {
1599 tok = au_to_ipc_perm(&ar->ar_arg_svipc_perm);
1600 kau_write(rec, tok);
1601 }
1602 break;
1603 default:
1604 break; /* We will audit a bad command */
1605 }
1606 break;
1607
1608 case AUE_SHMDT:
1609 if (ARG_IS_VALID(kar, ARG_SVIPC_ADDR)) {
1610 tok = au_to_arg32(1, "shmaddr",
1611 (int)(uintptr_t)ar->ar_arg_svipc_addr);
1612 kau_write(rec, tok);
1613 }
1614 break;
1615
1616 case AUE_SHMGET:
1617 /* This is unusual; the return value is in an argument token */
1618 if (ARG_IS_VALID(kar, ARG_SVIPC_ID)) {
1619 tok = au_to_arg32(0, "shmid", ar->ar_arg_svipc_id);
1620 kau_write(rec, tok);
1621 tok = au_to_ipc(AT_IPC_SHM, ar->ar_arg_svipc_id);
1622 kau_write(rec, tok);
1623 }
1624 if (ARG_IS_VALID(kar, ARG_SVIPC_PERM)) {
1625 tok = au_to_ipc_perm(&ar->ar_arg_svipc_perm);
1626 kau_write(rec, tok);
1627 }
1628 break;
1629
1630 /* shm_rename is a non-Posix extension to the Posix shm implementation */
1631 case AUE_SHMRENAME:
1632 UPATH1_TOKENS;
1633 UPATH2_TOKENS;
1634 if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
1635 tok = au_to_arg32(2, "flags", ar->ar_arg_fflags);
1636 kau_write(rec, tok);
1637 }
1638 break;
1639
1640 /* AUE_SHMOPEN, AUE_SHMUNLINK, AUE_SEMOPEN, AUE_SEMCLOSE
1641 * and AUE_SEMUNLINK are Posix IPC */
1642 case AUE_SHMOPEN:
1643 if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
1644 tok = au_to_arg32(2, "flags", ar->ar_arg_fflags);
1645 kau_write(rec, tok);
1646 }
1647 if (ARG_IS_VALID(kar, ARG_MODE)) {
1648 tok = au_to_arg32(3, "mode", ar->ar_arg_mode);
1649 kau_write(rec, tok);
1650 }
1651 /* FALLTHROUGH */
1652
1653 case AUE_SHMUNLINK:
1654 UPATH1_TOKENS;
1655 if (ARG_IS_VALID(kar, ARG_POSIX_IPC_PERM)) {
1656 struct ipc_perm perm;
1657
1658 perm.uid = ar->ar_arg_pipc_perm.pipc_uid;
1659 perm.gid = ar->ar_arg_pipc_perm.pipc_gid;
1660 perm.cuid = ar->ar_arg_pipc_perm.pipc_uid;
1661 perm.cgid = ar->ar_arg_pipc_perm.pipc_gid;
1662 perm.mode = ar->ar_arg_pipc_perm.pipc_mode;
1663 perm.seq = 0;
1664 perm.key = 0;
1665 tok = au_to_ipc_perm(&perm);
1666 kau_write(rec, tok);
1667 }
1668 break;
1669
1670 case AUE_SEMOPEN:
1671 if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
1672 tok = au_to_arg32(2, "flags", ar->ar_arg_fflags);
1673 kau_write(rec, tok);
1674 }
1675 if (ARG_IS_VALID(kar, ARG_MODE)) {
1676 tok = au_to_arg32(3, "mode", ar->ar_arg_mode);
1677 kau_write(rec, tok);
1678 }
1679 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1680 tok = au_to_arg32(4, "value", ar->ar_arg_value);
1681 kau_write(rec, tok);
1682 }
1683 /* FALLTHROUGH */
1684
1685 case AUE_SEMUNLINK:
1686 if (ARG_IS_VALID(kar, ARG_TEXT)) {
1687 tok = au_to_text(ar->ar_arg_text);
1688 kau_write(rec, tok);
1689 }
1690 if (ARG_IS_VALID(kar, ARG_POSIX_IPC_PERM)) {
1691 struct ipc_perm perm;
1692
1693 perm.uid = ar->ar_arg_pipc_perm.pipc_uid;
1694 perm.gid = ar->ar_arg_pipc_perm.pipc_gid;
1695 perm.cuid = ar->ar_arg_pipc_perm.pipc_uid;
1696 perm.cgid = ar->ar_arg_pipc_perm.pipc_gid;
1697 perm.mode = ar->ar_arg_pipc_perm.pipc_mode;
1698 perm.seq = 0;
1699 perm.key = 0;
1700 tok = au_to_ipc_perm(&perm);
1701 kau_write(rec, tok);
1702 }
1703 break;
1704
1705 case AUE_SEMCLOSE:
1706 if (ARG_IS_VALID(kar, ARG_FD)) {
1707 tok = au_to_arg32(1, "sem", ar->ar_arg_fd);
1708 kau_write(rec, tok);
1709 }
1710 break;
1711
1712 case AUE_SYMLINK:
1713 case AUE_SYMLINKAT:
1714 if (ARG_IS_VALID(kar, ARG_TEXT)) {
1715 tok = au_to_text(ar->ar_arg_text);
1716 kau_write(rec, tok);
1717 }
1718 ATFD1_TOKENS(1);
1719 UPATH1_VNODE1_TOKENS;
1720 break;
1721
1722 case AUE_SYSCTL:
1723 case AUE_SYSCTL_NONADMIN:
1724 if (ARG_IS_VALID(kar, ARG_CTLNAME | ARG_LEN)) {
1725 for (ctr = 0; ctr < ar->ar_arg_len; ctr++) {
1726 tok = au_to_arg32(1, "name",
1727 ar->ar_arg_ctlname[ctr]);
1728 kau_write(rec, tok);
1729 }
1730 }
1731 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1732 tok = au_to_arg32(5, "newval", ar->ar_arg_value);
1733 kau_write(rec, tok);
1734 }
1735 if (ARG_IS_VALID(kar, ARG_TEXT)) {
1736 tok = au_to_text(ar->ar_arg_text);
1737 kau_write(rec, tok);
1738 }
1739 break;
1740
1741 case AUE_UMASK:
1742 if (ARG_IS_VALID(kar, ARG_MASK)) {
1743 tok = au_to_arg32(1, "new mask", ar->ar_arg_mask);
1744 kau_write(rec, tok);
1745 }
1746 tok = au_to_arg32(0, "prev mask", ar->ar_retval);
1747 kau_write(rec, tok);
1748 break;
1749
1750 case AUE_WAIT4:
1751 case AUE_WAIT6:
1752 PROCESS_PID_TOKENS(1);
1753 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1754 tok = au_to_arg32(3, "options", ar->ar_arg_value);
1755 kau_write(rec, tok);
1756 }
1757 break;
1758
1759 case AUE_CAP_RIGHTS_LIMIT:
1760 /*
1761 * XXXRW/XXXJA: Would be nice to audit socket/etc information.
1762 */
1763 FD_VNODE1_TOKENS;
1764 if (ARG_IS_VALID(kar, ARG_RIGHTS)) {
1765 tok = au_to_rights(&ar->ar_arg_rights);
1766 kau_write(rec, tok);
1767 }
1768 break;
1769
1770 case AUE_CAP_FCNTLS_GET:
1771 case AUE_CAP_IOCTLS_GET:
1772 case AUE_CAP_IOCTLS_LIMIT:
1773 case AUE_CAP_RIGHTS_GET:
1774 if (ARG_IS_VALID(kar, ARG_FD)) {
1775 tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
1776 kau_write(rec, tok);
1777 }
1778 break;
1779
1780 case AUE_CAP_FCNTLS_LIMIT:
1781 FD_VNODE1_TOKENS;
1782 if (ARG_IS_VALID(kar, ARG_FCNTL_RIGHTS)) {
1783 tok = au_to_arg32(2, "fcntlrights",
1784 ar->ar_arg_fcntl_rights);
1785 kau_write(rec, tok);
1786 }
1787 break;
1788
1789 case AUE_CAP_ENTER:
1790 case AUE_CAP_GETMODE:
1791 break;
1792
1793 case AUE_THR_NEW:
1794 case AUE_THR_KILL:
1795 case AUE_THR_EXIT:
1796 break;
1797
1798 case AUE_NULL:
1799 default:
1800 printf("BSM conversion requested for unknown event %d\n",
1801 ar->ar_event);
1802
1803 /*
1804 * Write the subject token so it is properly freed here.
1805 */
1806 if (jail_tok != NULL)
1807 kau_write(rec, jail_tok);
1808 kau_write(rec, subj_tok);
1809 kau_free(rec);
1810 return (BSM_NOAUDIT);
1811 }
1812
1813 if (jail_tok != NULL)
1814 kau_write(rec, jail_tok);
1815 kau_write(rec, subj_tok);
1816 tok = au_to_return32(au_errno_to_bsm(ar->ar_errno), ar->ar_retval);
1817 kau_write(rec, tok); /* Every record gets a return token */
1818
1819 kau_close(rec, &ar->ar_endtime, ar->ar_event);
1820
1821 *pau = rec;
1822 return (BSM_SUCCESS);
1823 }
1824
1825 /*
1826 * Verify that a record is a valid BSM record. This verification is simple
1827 * now, but may be expanded on sometime in the future. Return 1 if the
1828 * record is good, 0 otherwise.
1829 */
1830 int
bsm_rec_verify(void * rec)1831 bsm_rec_verify(void *rec)
1832 {
1833 char c = *(char *)rec;
1834
1835 /*
1836 * Check the token ID of the first token; it has to be a header
1837 * token.
1838 *
1839 * XXXAUDIT There needs to be a token structure to map a token.
1840 * XXXAUDIT 'Shouldn't be simply looking at the first char.
1841 */
1842 if ((c != AUT_HEADER32) && (c != AUT_HEADER32_EX) &&
1843 (c != AUT_HEADER64) && (c != AUT_HEADER64_EX))
1844 return (0);
1845 return (1);
1846 }
1847