2 * SPDX-License-Identifier: BSD-3-Clause
4 * Copyright (c) 1999-2009 Apple Inc.
5 * Copyright (c) 2016-2017 Robert N. M. Watson
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.
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
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.
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.
38 #include <sys/cdefs.h>
39 __FBSDID("$FreeBSD$");
41 #include <sys/param.h>
42 #include <sys/vnode.h>
45 #include <sys/malloc.h>
46 #include <sys/mutex.h>
47 #include <sys/socket.h>
48 #include <sys/extattr.h>
49 #include <sys/fcntl.h>
51 #include <sys/systm.h>
53 #include <bsm/audit.h>
54 #include <bsm/audit_internal.h>
55 #include <bsm/audit_record.h>
56 #include <bsm/audit_kevents.h>
58 #include <security/audit/audit.h>
59 #include <security/audit/audit_private.h>
61 #include <netinet/in_systm.h>
62 #include <netinet/in.h>
63 #include <netinet/ip.h>
65 MALLOC_DEFINE(M_AUDITBSM, "audit_bsm", "Audit BSM data");
67 static void audit_sys_auditon(struct audit_record *ar,
68 struct au_record *rec);
71 * Initialize the BSM auditing subsystem.
82 * This call reserves memory for the audit record. Memory must be guaranteed
83 * before any auditable event can be generated. The au_record structure
84 * maintains a reference to the memory allocated above and also the list of
85 * tokens associated with this record.
87 static struct au_record *
90 struct au_record *rec;
92 rec = malloc(sizeof(*rec), M_AUDITBSM, M_WAITOK);
94 TAILQ_INIT(&rec->token_q);
102 * Store the token with the record descriptor.
105 kau_write(struct au_record *rec, struct au_token *tok)
108 KASSERT(tok != NULL, ("kau_write: tok == NULL"));
110 TAILQ_INSERT_TAIL(&rec->token_q, tok, tokens);
111 rec->len += tok->len;
115 * Close out the audit record by adding the header token, identifying any
116 * missing tokens. Write out the tokens to the record memory.
119 kau_close(struct au_record *rec, struct timespec *ctime, short event)
123 token_t *cur, *hdr, *trail;
126 struct auditinfo_addr ak;
129 audit_get_kinfo(&ak);
131 switch (ak.ai_termid.at_type) {
133 hdrsize = (ak.ai_termid.at_addr[0] == INADDR_ANY) ?
134 AUDIT_HEADER_SIZE : AUDIT_HEADER_EX_SIZE(&ak);
137 ap = (struct in6_addr *)&ak.ai_termid.at_addr[0];
138 hdrsize = (IN6_IS_ADDR_UNSPECIFIED(ap)) ? AUDIT_HEADER_SIZE :
139 AUDIT_HEADER_EX_SIZE(&ak);
142 panic("kau_close: invalid address family");
144 tot_rec_size = rec->len + hdrsize + AUDIT_TRAILER_SIZE;
145 rec->data = malloc(tot_rec_size, M_AUDITBSM, M_WAITOK | M_ZERO);
147 tm.tv_usec = ctime->tv_nsec / 1000;
148 tm.tv_sec = ctime->tv_sec;
149 if (hdrsize != AUDIT_HEADER_SIZE)
150 hdr = au_to_header32_ex_tm(tot_rec_size, event, 0, tm, &ak);
152 hdr = au_to_header32_tm(tot_rec_size, event, 0, tm);
153 TAILQ_INSERT_HEAD(&rec->token_q, hdr, tokens);
155 trail = au_to_trailer(tot_rec_size);
156 TAILQ_INSERT_TAIL(&rec->token_q, trail, tokens);
158 rec->len = tot_rec_size;
160 TAILQ_FOREACH(cur, &rec->token_q, tokens) {
161 memcpy(dptr, cur->t_data, cur->len);
167 * Free a BSM audit record by releasing all the tokens and clearing the audit
168 * record information.
171 kau_free(struct au_record *rec)
173 struct au_token *tok;
175 /* Free the token list. */
176 while ((tok = TAILQ_FIRST(&rec->token_q))) {
177 TAILQ_REMOVE(&rec->token_q, tok, tokens);
178 free(tok->t_data, M_AUDITBSM);
179 free(tok, M_AUDITBSM);
184 free(rec->data, M_AUDITBSM);
185 free(rec, M_AUDITBSM);
189 * XXX: May want turn some (or all) of these macros into functions in order
190 * to reduce the generated code size.
192 * XXXAUDIT: These macros assume that 'kar', 'ar', 'rec', and 'tok' in the
193 * caller are OK with this.
195 #define ATFD1_TOKENS(argnum) do { \
196 if (ARG_IS_VALID(kar, ARG_ATFD1)) { \
197 tok = au_to_arg32(argnum, "at fd 1", ar->ar_arg_atfd1); \
198 kau_write(rec, tok); \
202 #define ATFD2_TOKENS(argnum) do { \
203 if (ARG_IS_VALID(kar, ARG_ATFD2)) { \
204 tok = au_to_arg32(argnum, "at fd 2", ar->ar_arg_atfd2); \
205 kau_write(rec, tok); \
209 #define UPATH1_TOKENS do { \
210 if (ARG_IS_VALID(kar, ARG_UPATH1)) { \
211 tok = au_to_path(ar->ar_arg_upath1); \
212 kau_write(rec, tok); \
216 #define UPATH2_TOKENS do { \
217 if (ARG_IS_VALID(kar, ARG_UPATH2)) { \
218 tok = au_to_path(ar->ar_arg_upath2); \
219 kau_write(rec, tok); \
223 #define VNODE1_TOKENS do { \
224 if (ARG_IS_VALID(kar, ARG_ATFD)) { \
225 tok = au_to_arg32(1, "at fd", ar->ar_arg_atfd); \
226 kau_write(rec, tok); \
228 if (ARG_IS_VALID(kar, ARG_VNODE1)) { \
229 tok = au_to_attr32(&ar->ar_arg_vnode1); \
230 kau_write(rec, tok); \
234 #define UPATH1_VNODE1_TOKENS do { \
236 if (ARG_IS_VALID(kar, ARG_VNODE1)) { \
237 tok = au_to_attr32(&ar->ar_arg_vnode1); \
238 kau_write(rec, tok); \
242 #define VNODE2_TOKENS do { \
243 if (ARG_IS_VALID(kar, ARG_VNODE2)) { \
244 tok = au_to_attr32(&ar->ar_arg_vnode2); \
245 kau_write(rec, tok); \
249 #define FD_VNODE1_TOKENS do { \
250 if (ARG_IS_VALID(kar, ARG_VNODE1)) { \
251 if (ARG_IS_VALID(kar, ARG_FD)) { \
252 tok = au_to_arg32(1, "fd", ar->ar_arg_fd); \
253 kau_write(rec, tok); \
255 tok = au_to_attr32(&ar->ar_arg_vnode1); \
256 kau_write(rec, tok); \
258 if (ARG_IS_VALID(kar, ARG_FD)) { \
259 tok = au_to_arg32(1, "non-file: fd", \
261 kau_write(rec, tok); \
266 #define PROCESS_PID_TOKENS(argn) do { \
267 if ((ar->ar_arg_pid > 0) /* Reference a single process */ \
268 && (ARG_IS_VALID(kar, ARG_PROCESS))) { \
269 tok = au_to_process32_ex(ar->ar_arg_auid, \
270 ar->ar_arg_euid, ar->ar_arg_egid, \
271 ar->ar_arg_ruid, ar->ar_arg_rgid, \
272 ar->ar_arg_pid, ar->ar_arg_asid, \
273 &ar->ar_arg_termid_addr); \
274 kau_write(rec, tok); \
275 } else if (ARG_IS_VALID(kar, ARG_PID)) { \
276 tok = au_to_arg32(argn, "process", ar->ar_arg_pid); \
277 kau_write(rec, tok); \
281 #define EXTATTR_TOKENS(namespace_argnum) do { \
282 if (ARG_IS_VALID(kar, ARG_VALUE)) { \
283 switch (ar->ar_arg_value) { \
284 case EXTATTR_NAMESPACE_USER: \
285 tok = au_to_text(EXTATTR_NAMESPACE_USER_STRING);\
287 case EXTATTR_NAMESPACE_SYSTEM: \
288 tok = au_to_text(EXTATTR_NAMESPACE_SYSTEM_STRING);\
291 tok = au_to_arg32((namespace_argnum), \
292 "attrnamespace", ar->ar_arg_value); \
295 kau_write(rec, tok); \
297 /* attrname is in the text field */ \
298 if (ARG_IS_VALID(kar, ARG_TEXT)) { \
299 tok = au_to_text(ar->ar_arg_text); \
300 kau_write(rec, tok); \
305 * Not all pointer arguments to system calls are of interest, but in some
306 * cases they reflect delegation of rights, such as mmap(2) followed by
307 * minherit(2) before execve(2), so do the best we can.
309 #define ADDR_TOKEN(argnum, argname) do { \
310 if (ARG_IS_VALID(kar, ARG_ADDR)) { \
311 if (sizeof(void *) == sizeof(uint32_t)) \
312 tok = au_to_arg32((argnum), (argname), \
313 (uint32_t)(uintptr_t)ar->ar_arg_addr); \
315 tok = au_to_arg64((argnum), (argname), \
316 (uint64_t)(uintptr_t)ar->ar_arg_addr); \
317 kau_write(rec, tok); \
323 * Implement auditing for the auditon() system call. The audit tokens that
324 * are generated depend on the command that was sent into the auditon()
328 audit_sys_auditon(struct audit_record *ar, struct au_record *rec)
330 struct au_token *tok;
332 tok = au_to_arg32(3, "length", ar->ar_arg_len);
334 switch (ar->ar_arg_cmd) {
336 if ((size_t)ar->ar_arg_len == sizeof(int64_t)) {
337 tok = au_to_arg64(2, "policy",
338 ar->ar_arg_auditon.au_policy64);
345 tok = au_to_arg32(2, "policy", ar->ar_arg_auditon.au_policy);
350 tok = au_to_arg32(2, "setkmask:as_success",
351 ar->ar_arg_auditon.au_mask.am_success);
353 tok = au_to_arg32(2, "setkmask:as_failure",
354 ar->ar_arg_auditon.au_mask.am_failure);
359 if ((size_t)ar->ar_arg_len == sizeof(au_qctrl64_t)) {
360 tok = au_to_arg64(2, "setqctrl:aq_hiwater",
361 ar->ar_arg_auditon.au_qctrl64.aq64_hiwater);
363 tok = au_to_arg64(2, "setqctrl:aq_lowater",
364 ar->ar_arg_auditon.au_qctrl64.aq64_lowater);
366 tok = au_to_arg64(2, "setqctrl:aq_bufsz",
367 ar->ar_arg_auditon.au_qctrl64.aq64_bufsz);
369 tok = au_to_arg64(2, "setqctrl:aq_delay",
370 ar->ar_arg_auditon.au_qctrl64.aq64_delay);
372 tok = au_to_arg64(2, "setqctrl:aq_minfree",
373 ar->ar_arg_auditon.au_qctrl64.aq64_minfree);
380 tok = au_to_arg32(2, "setqctrl:aq_hiwater",
381 ar->ar_arg_auditon.au_qctrl.aq_hiwater);
383 tok = au_to_arg32(2, "setqctrl:aq_lowater",
384 ar->ar_arg_auditon.au_qctrl.aq_lowater);
386 tok = au_to_arg32(2, "setqctrl:aq_bufsz",
387 ar->ar_arg_auditon.au_qctrl.aq_bufsz);
389 tok = au_to_arg32(2, "setqctrl:aq_delay",
390 ar->ar_arg_auditon.au_qctrl.aq_delay);
392 tok = au_to_arg32(2, "setqctrl:aq_minfree",
393 ar->ar_arg_auditon.au_qctrl.aq_minfree);
398 tok = au_to_arg32(2, "setumask:as_success",
399 ar->ar_arg_auditon.au_auinfo.ai_mask.am_success);
401 tok = au_to_arg32(2, "setumask:as_failure",
402 ar->ar_arg_auditon.au_auinfo.ai_mask.am_failure);
407 tok = au_to_arg32(2, "setsmask:as_success",
408 ar->ar_arg_auditon.au_auinfo.ai_mask.am_success);
410 tok = au_to_arg32(2, "setsmask:as_failure",
411 ar->ar_arg_auditon.au_auinfo.ai_mask.am_failure);
416 if ((size_t)ar->ar_arg_len == sizeof(int64_t)) {
417 tok = au_to_arg64(2, "setcond",
418 ar->ar_arg_auditon.au_cond64);
425 tok = au_to_arg32(2, "setcond", ar->ar_arg_auditon.au_cond);
430 tok = au_to_arg32(2, "setclass:ec_event",
431 ar->ar_arg_auditon.au_evclass.ec_number);
433 tok = au_to_arg32(2, "setclass:ec_class",
434 ar->ar_arg_auditon.au_evclass.ec_class);
439 tok = au_to_arg32(2, "setpmask:as_success",
440 ar->ar_arg_auditon.au_aupinfo.ap_mask.am_success);
442 tok = au_to_arg32(2, "setpmask:as_failure",
443 ar->ar_arg_auditon.au_aupinfo.ap_mask.am_failure);
448 tok = au_to_arg32(2, "setfsize:filesize",
449 ar->ar_arg_auditon.au_fstat.af_filesz);
459 * Convert an internal kernel audit record to a BSM record and return a
460 * success/failure indicator. The BSM record is passed as an out parameter to
464 * BSM_SUCCESS: The BSM record is valid
465 * BSM_FAILURE: Failure; the BSM record is NULL.
466 * BSM_NOAUDIT: The event is not auditable for BSM; the BSM record is NULL.
469 kaudit_to_bsm(struct kaudit_record *kar, struct au_record **pau)
471 struct au_token *tok, *subj_tok, *jail_tok;
472 struct au_record *rec;
474 struct audit_record *ar;
477 KASSERT(kar != NULL, ("kaudit_to_bsm: kar == NULL"));
484 * Create the subject token. If this credential was jailed be sure to
485 * generate a zonename token.
487 if (ar->ar_jailname[0] != '\0')
488 jail_tok = au_to_zonename(ar->ar_jailname);
491 switch (ar->ar_subj_term_addr.at_type) {
493 tid.port = ar->ar_subj_term_addr.at_port;
494 tid.machine = ar->ar_subj_term_addr.at_addr[0];
495 subj_tok = au_to_subject32(ar->ar_subj_auid, /* audit ID */
496 ar->ar_subj_cred.cr_uid, /* eff uid */
497 ar->ar_subj_egid, /* eff group id */
498 ar->ar_subj_ruid, /* real uid */
499 ar->ar_subj_rgid, /* real group id */
500 ar->ar_subj_pid, /* process id */
501 ar->ar_subj_asid, /* session ID */
505 subj_tok = au_to_subject32_ex(ar->ar_subj_auid,
506 ar->ar_subj_cred.cr_uid,
512 &ar->ar_subj_term_addr);
515 bzero(&tid, sizeof(tid));
516 subj_tok = au_to_subject32(ar->ar_subj_auid,
517 ar->ar_subj_cred.cr_uid,
527 * The logic inside each case fills in the tokens required for the
528 * event, except for the header, trailer, and return tokens. The
529 * header and trailer tokens are added by the kau_close() function.
530 * The return token is added outside of the switch statement.
532 switch(ar->ar_event) {
534 if (ARG_IS_VALID(kar, ARG_FD)) {
535 tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
538 if (ARG_IS_VALID(kar, ARG_SADDRINET)) {
539 tok = au_to_sock_inet((struct sockaddr_in *)
540 &ar->ar_arg_sockaddr);
543 if (ARG_IS_VALID(kar, ARG_SADDRUNIX)) {
544 tok = au_to_sock_unix((struct sockaddr_un *)
545 &ar->ar_arg_sockaddr);
561 * Socket-related events.
563 if (ARG_IS_VALID(kar, ARG_FD)) {
564 tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
567 if (ARG_IS_VALID(kar, ARG_SADDRINET)) {
568 tok = au_to_sock_inet((struct sockaddr_in *)
569 &ar->ar_arg_sockaddr);
572 if (ARG_IS_VALID(kar, ARG_SADDRUNIX)) {
573 tok = au_to_sock_unix((struct sockaddr_un *)
574 &ar->ar_arg_sockaddr);
578 /* XXX Need to handle ARG_SADDRINET6 */
584 if (ARG_IS_VALID(kar, ARG_FD)) {
585 tok = au_to_arg32(2, "fd", ar->ar_arg_fd);
588 if (ARG_IS_VALID(kar, ARG_SADDRUNIX)) {
589 tok = au_to_sock_unix((struct sockaddr_un *)
590 &ar->ar_arg_sockaddr);
598 if (ARG_IS_VALID(kar, ARG_SADDRINET)) {
599 tok = au_to_sock_inet((struct sockaddr_in *)
600 &ar->ar_arg_sockaddr);
603 if (ARG_IS_VALID(kar, ARG_SADDRUNIX)) {
604 tok = au_to_sock_unix((struct sockaddr_un *)
605 &ar->ar_arg_sockaddr);
609 /* XXX Need to handle ARG_SADDRINET6 */
614 if (ARG_IS_VALID(kar, ARG_SOCKINFO)) {
615 tok = au_to_arg32(1, "domain",
616 ar->ar_arg_sockinfo.so_domain);
618 tok = au_to_arg32(2, "type",
619 ar->ar_arg_sockinfo.so_type);
621 tok = au_to_arg32(3, "protocol",
622 ar->ar_arg_sockinfo.so_protocol);
629 if (ARG_IS_VALID(kar, ARG_FD)) {
630 tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
636 if (ARG_IS_VALID(kar, ARG_UPATH1)) {
637 UPATH1_VNODE1_TOKENS;
639 tok = au_to_arg32(1, "accounting off", 0);
645 if (ARG_IS_VALID(kar, ARG_AUID)) {
646 tok = au_to_arg32(2, "setauid", ar->ar_arg_auid);
652 if (ARG_IS_VALID(kar, ARG_AUID) &&
653 ARG_IS_VALID(kar, ARG_ASID) &&
654 ARG_IS_VALID(kar, ARG_AMASK) &&
655 ARG_IS_VALID(kar, ARG_TERMID)) {
656 tok = au_to_arg32(1, "setaudit:auid",
659 tok = au_to_arg32(1, "setaudit:port",
660 ar->ar_arg_termid.port);
662 tok = au_to_arg32(1, "setaudit:machine",
663 ar->ar_arg_termid.machine);
665 tok = au_to_arg32(1, "setaudit:as_success",
666 ar->ar_arg_amask.am_success);
668 tok = au_to_arg32(1, "setaudit:as_failure",
669 ar->ar_arg_amask.am_failure);
671 tok = au_to_arg32(1, "setaudit:asid",
677 case AUE_SETAUDIT_ADDR:
678 if (ARG_IS_VALID(kar, ARG_AUID) &&
679 ARG_IS_VALID(kar, ARG_ASID) &&
680 ARG_IS_VALID(kar, ARG_AMASK) &&
681 ARG_IS_VALID(kar, ARG_TERMID_ADDR)) {
682 tok = au_to_arg32(1, "setaudit_addr:auid",
685 tok = au_to_arg32(1, "setaudit_addr:as_success",
686 ar->ar_arg_amask.am_success);
688 tok = au_to_arg32(1, "setaudit_addr:as_failure",
689 ar->ar_arg_amask.am_failure);
691 tok = au_to_arg32(1, "setaudit_addr:asid",
694 tok = au_to_arg32(1, "setaudit_addr:type",
695 ar->ar_arg_termid_addr.at_type);
697 tok = au_to_arg32(1, "setaudit_addr:port",
698 ar->ar_arg_termid_addr.at_port);
700 if (ar->ar_arg_termid_addr.at_type == AU_IPv6)
701 tok = au_to_in_addr_ex((struct in6_addr *)
702 &ar->ar_arg_termid_addr.at_addr[0]);
703 if (ar->ar_arg_termid_addr.at_type == AU_IPv4)
704 tok = au_to_in_addr((struct in_addr *)
705 &ar->ar_arg_termid_addr.at_addr[0]);
712 * For AUDITON commands without own event, audit the cmd.
714 if (ARG_IS_VALID(kar, ARG_CMD)) {
715 tok = au_to_arg32(1, "cmd", ar->ar_arg_cmd);
720 case AUE_AUDITON_GETCAR:
721 case AUE_AUDITON_GETCLASS:
722 case AUE_AUDITON_GETCOND:
723 case AUE_AUDITON_GETCWD:
724 case AUE_AUDITON_GETKMASK:
725 case AUE_AUDITON_GETSTAT:
726 case AUE_AUDITON_GPOLICY:
727 case AUE_AUDITON_GQCTRL:
728 case AUE_AUDITON_SETCLASS:
729 case AUE_AUDITON_SETCOND:
730 case AUE_AUDITON_SETKMASK:
731 case AUE_AUDITON_SETSMASK:
732 case AUE_AUDITON_SETSTAT:
733 case AUE_AUDITON_SETUMASK:
734 case AUE_AUDITON_SPOLICY:
735 case AUE_AUDITON_SQCTRL:
736 if (ARG_IS_VALID(kar, ARG_AUDITON))
737 audit_sys_auditon(ar, rec);
741 UPATH1_VNODE1_TOKENS;
745 if (ARG_IS_VALID(kar, ARG_EXIT)) {
746 tok = au_to_exit(ar->ar_arg_exitretval,
747 ar->ar_arg_exitstatus);
753 case AUE_CLOCK_SETTIME:
757 case AUE_GETAUDIT_ADDR:
767 case AUE_NTP_ADJTIME:
769 case AUE_POSIX_OPENPT:
777 case AUE_SETTIMEOFDAY:
781 * Header, subject, and return tokens added at end.
785 case AUE_ACL_DELETE_FD:
786 case AUE_ACL_DELETE_FILE:
787 case AUE_ACL_CHECK_FD:
788 case AUE_ACL_CHECK_FILE:
789 case AUE_ACL_CHECK_LINK:
790 case AUE_ACL_DELETE_LINK:
792 case AUE_ACL_GET_FILE:
793 case AUE_ACL_GET_LINK:
795 case AUE_ACL_SET_FILE:
796 case AUE_ACL_SET_LINK:
797 if (ARG_IS_VALID(kar, ARG_VALUE)) {
798 tok = au_to_arg32(1, "type", ar->ar_arg_value);
802 UPATH1_VNODE1_TOKENS;
809 case AUE_GETATTRLIST:
821 case AUE_SETATTRLIST:
832 UPATH1_VNODE1_TOKENS;
839 UPATH1_VNODE1_TOKENS;
840 if (ARG_IS_VALID(kar, ARG_VALUE)) {
841 tok = au_to_arg32(2, "mode", ar->ar_arg_value);
849 /* XXXRW: Need to audit vnode argument. */
854 if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
855 tok = au_to_arg32(2, "flags", ar->ar_arg_fflags);
858 UPATH1_VNODE1_TOKENS;
863 if (ARG_IS_VALID(kar, ARG_MODE)) {
864 tok = au_to_arg32(2, "new file mode",
868 UPATH1_VNODE1_TOKENS;
873 if (ARG_IS_VALID(kar, ARG_MODE)) {
874 tok = au_to_arg32(3, "new file mode",
878 UPATH1_VNODE1_TOKENS;
883 if (ARG_IS_VALID(kar, ARG_UID)) {
884 tok = au_to_arg32(2, "new file uid", ar->ar_arg_uid);
887 if (ARG_IS_VALID(kar, ARG_GID)) {
888 tok = au_to_arg32(3, "new file gid", ar->ar_arg_gid);
891 UPATH1_VNODE1_TOKENS;
896 if (ARG_IS_VALID(kar, ARG_UID)) {
897 tok = au_to_arg32(3, "new file uid", ar->ar_arg_uid);
900 if (ARG_IS_VALID(kar, ARG_GID)) {
901 tok = au_to_arg32(4, "new file gid", ar->ar_arg_gid);
904 UPATH1_VNODE1_TOKENS;
907 case AUE_EXCHANGEDATA:
908 UPATH1_VNODE1_TOKENS;
913 if (ARG_IS_VALID(kar, ARG_FD)) {
914 tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
917 UPATH1_VNODE1_TOKENS;
921 if (ARG_IS_VALID(kar, ARG_FD)) {
922 tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
928 if (ARG_IS_VALID(kar, ARG_SIGNUM)) {
929 tok = au_to_arg32(1, "signal", ar->ar_arg_signum);
932 UPATH1_VNODE1_TOKENS;
936 UPATH1_VNODE1_TOKENS;
937 if (ARG_IS_VALID(kar, ARG_CMD)) {
938 tok = au_to_arg32(2, "cmd", ar->ar_arg_cmd);
941 /* extattrctl(2) filename parameter is in upath2/vnode2 */
947 case AUE_EXTATTR_GET_FILE:
948 case AUE_EXTATTR_SET_FILE:
949 case AUE_EXTATTR_LIST_FILE:
950 case AUE_EXTATTR_DELETE_FILE:
951 case AUE_EXTATTR_GET_LINK:
952 case AUE_EXTATTR_SET_LINK:
953 case AUE_EXTATTR_LIST_LINK:
954 case AUE_EXTATTR_DELETE_LINK:
955 UPATH1_VNODE1_TOKENS;
959 case AUE_EXTATTR_GET_FD:
960 case AUE_EXTATTR_SET_FD:
961 case AUE_EXTATTR_LIST_FD:
962 case AUE_EXTATTR_DELETE_FD:
963 if (ARG_IS_VALID(kar, ARG_FD)) {
964 tok = au_to_arg32(2, "fd", ar->ar_arg_fd);
971 if (ARG_IS_VALID(kar, ARG_FD)) {
972 tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
979 if (ARG_IS_VALID(kar, ARG_ARGV)) {
980 tok = au_to_exec_args(ar->ar_arg_argv,
984 if (ARG_IS_VALID(kar, ARG_ENVV)) {
985 tok = au_to_exec_env(ar->ar_arg_envv,
989 UPATH1_VNODE1_TOKENS;
993 if (ARG_IS_VALID(kar, ARG_MODE)) {
994 tok = au_to_arg32(2, "new file mode",
1002 * XXXRW: Some of these need to handle non-vnode cases as well.
1011 case AUE_GETDIRENTRIES:
1012 case AUE_GETDIRENTRIESATTR:
1015 case AUE_POSIX_FALLOCATE:
1026 if (ARG_IS_VALID(kar, ARG_UID)) {
1027 tok = au_to_arg32(2, "new file uid", ar->ar_arg_uid);
1028 kau_write(rec, tok);
1030 if (ARG_IS_VALID(kar, ARG_GID)) {
1031 tok = au_to_arg32(3, "new file gid", ar->ar_arg_gid);
1032 kau_write(rec, tok);
1038 if (ARG_IS_VALID(kar, ARG_CMD)) {
1039 tok = au_to_arg32(2, "cmd",
1040 au_fcntl_cmd_to_bsm(ar->ar_arg_cmd));
1041 kau_write(rec, tok);
1047 if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
1048 tok = au_to_arg32(2, "flags", ar->ar_arg_fflags);
1049 kau_write(rec, tok);
1055 if (ARG_IS_VALID(kar, ARG_CMD)) {
1056 tok = au_to_arg32(2, "operation", ar->ar_arg_cmd);
1057 kau_write(rec, tok);
1063 if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
1064 tok = au_to_arg32(1, "flags", ar->ar_arg_fflags);
1065 kau_write(rec, tok);
1071 if (ARG_IS_VALID(kar, ARG_PID)) {
1072 tok = au_to_arg32(0, "child PID", ar->ar_arg_pid);
1073 kau_write(rec, tok);
1078 if (ARG_IS_VALID(kar, ARG_CMD)) {
1079 tok = au_to_arg32(2, "cmd", ar->ar_arg_cmd);
1080 kau_write(rec, tok);
1082 if (ARG_IS_VALID(kar, ARG_VNODE1))
1085 if (ARG_IS_VALID(kar, ARG_SOCKINFO)) {
1086 tok = kau_to_socket(&ar->ar_arg_sockinfo);
1087 kau_write(rec, tok);
1089 if (ARG_IS_VALID(kar, ARG_FD)) {
1090 tok = au_to_arg32(1, "fd",
1092 kau_write(rec, tok);
1100 if (ARG_IS_VALID(kar, ARG_SIGNUM)) {
1101 tok = au_to_arg32(2, "signal", ar->ar_arg_signum);
1102 kau_write(rec, tok);
1104 PROCESS_PID_TOKENS(1);
1108 if (ARG_IS_VALID(kar, ARG_CMD)) {
1109 tok = au_to_arg32(2, "ops", ar->ar_arg_cmd);
1110 kau_write(rec, tok);
1112 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1113 tok = au_to_arg32(3, "trpoints", ar->ar_arg_value);
1114 kau_write(rec, tok);
1116 PROCESS_PID_TOKENS(4);
1117 UPATH1_VNODE1_TOKENS;
1125 UPATH1_VNODE1_TOKENS;
1130 case AUE_LOADSHFILE:
1131 ADDR_TOKEN(4, "base addr");
1132 UPATH1_VNODE1_TOKENS;
1140 if (ARG_IS_VALID(kar, ARG_MODE)) {
1141 tok = au_to_arg32(2, "mode", ar->ar_arg_mode);
1142 kau_write(rec, tok);
1144 UPATH1_VNODE1_TOKENS;
1150 if (ARG_IS_VALID(kar, ARG_MODE)) {
1151 tok = au_to_arg32(2, "mode", ar->ar_arg_mode);
1152 kau_write(rec, tok);
1154 if (ARG_IS_VALID(kar, ARG_DEV)) {
1155 tok = au_to_arg32(3, "dev", ar->ar_arg_dev);
1156 kau_write(rec, tok);
1158 UPATH1_VNODE1_TOKENS;
1167 ADDR_TOKEN(1, "addr");
1168 if (ARG_IS_VALID(kar, ARG_LEN)) {
1169 tok = au_to_arg32(2, "len", ar->ar_arg_len);
1170 kau_write(rec, tok);
1172 if (ar->ar_event == AUE_MMAP)
1174 if (ar->ar_event == AUE_MPROTECT) {
1175 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1176 tok = au_to_arg32(3, "protection",
1178 kau_write(rec, tok);
1181 if (ar->ar_event == AUE_MINHERIT) {
1182 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1183 tok = au_to_arg32(3, "inherit",
1185 kau_write(rec, tok);
1192 /* XXX Need to handle NFS mounts */
1193 if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
1194 tok = au_to_arg32(3, "flags", ar->ar_arg_fflags);
1195 kau_write(rec, tok);
1197 if (ARG_IS_VALID(kar, ARG_TEXT)) {
1198 tok = au_to_text(ar->ar_arg_text);
1199 kau_write(rec, tok);
1204 if (ARG_IS_VALID(kar, ARG_CMD)) {
1205 tok = au_to_arg32(1, "flags", ar->ar_arg_cmd);
1206 kau_write(rec, tok);
1211 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1212 tok = au_to_arg32(2, "flags", ar->ar_arg_value);
1213 kau_write(rec, tok);
1215 UPATH1_VNODE1_TOKENS;
1216 if (ARG_IS_VALID(kar, ARG_TEXT)) {
1217 tok = au_to_text(ar->ar_arg_text);
1218 kau_write(rec, tok);
1223 ar->ar_event = audit_msgctl_to_event(ar->ar_arg_svipc_cmd);
1228 tok = au_to_arg32(1, "msg ID", ar->ar_arg_svipc_id);
1229 kau_write(rec, tok);
1230 if (ar->ar_errno != EINVAL) {
1231 tok = au_to_ipc(AT_IPC_MSG, ar->ar_arg_svipc_id);
1232 kau_write(rec, tok);
1237 if (ar->ar_errno == 0) {
1238 if (ARG_IS_VALID(kar, ARG_SVIPC_ID)) {
1239 tok = au_to_ipc(AT_IPC_MSG,
1240 ar->ar_arg_svipc_id);
1241 kau_write(rec, tok);
1246 case AUE_RESETSHFILE:
1247 ADDR_TOKEN(1, "base addr");
1257 if (ARG_IS_VALID(kar, ARG_MODE)) {
1258 tok = au_to_arg32(3, "mode", ar->ar_arg_mode);
1259 kau_write(rec, tok);
1269 if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
1270 tok = au_to_arg32(2, "flags", ar->ar_arg_fflags);
1271 kau_write(rec, tok);
1273 UPATH1_VNODE1_TOKENS;
1277 case AUE_OPENAT_RTC:
1278 case AUE_OPENAT_RWC:
1279 case AUE_OPENAT_RWTC:
1281 case AUE_OPENAT_WTC:
1282 if (ARG_IS_VALID(kar, ARG_MODE)) {
1283 tok = au_to_arg32(3, "mode", ar->ar_arg_mode);
1284 kau_write(rec, tok);
1291 case AUE_OPENAT_RWT:
1294 if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
1295 tok = au_to_arg32(2, "flags", ar->ar_arg_fflags);
1296 kau_write(rec, tok);
1299 UPATH1_VNODE1_TOKENS;
1303 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1304 tok = au_to_arg32(1, "idtype", ar->ar_arg_value);
1305 kau_write(rec, tok);
1307 if (ARG_IS_VALID(kar, ARG_CMD)) {
1308 tok = au_to_arg32(2, "com", ar->ar_arg_cmd);
1309 kau_write(rec, tok);
1311 PROCESS_PID_TOKENS(3);
1315 if (ARG_IS_VALID(kar, ARG_CMD)) {
1316 tok = au_to_arg32(1, "request", ar->ar_arg_cmd);
1317 kau_write(rec, tok);
1319 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1320 tok = au_to_arg32(4, "data", ar->ar_arg_value);
1321 kau_write(rec, tok);
1323 PROCESS_PID_TOKENS(2);
1327 if (ARG_IS_VALID(kar, ARG_CMD)) {
1328 tok = au_to_arg32(2, "command", ar->ar_arg_cmd);
1329 kau_write(rec, tok);
1331 if (ARG_IS_VALID(kar, ARG_UID)) {
1332 tok = au_to_arg32(3, "uid", ar->ar_arg_uid);
1333 kau_write(rec, tok);
1335 if (ARG_IS_VALID(kar, ARG_GID)) {
1336 tok = au_to_arg32(3, "gid", ar->ar_arg_gid);
1337 kau_write(rec, tok);
1339 UPATH1_VNODE1_TOKENS;
1343 if (ARG_IS_VALID(kar, ARG_CMD)) {
1344 tok = au_to_arg32(1, "howto", ar->ar_arg_cmd);
1345 kau_write(rec, tok);
1350 ar->ar_event = audit_semctl_to_event(ar->ar_arg_svipc_cmd);
1354 if (ARG_IS_VALID(kar, ARG_SVIPC_ID)) {
1355 tok = au_to_arg32(1, "sem ID", ar->ar_arg_svipc_id);
1356 kau_write(rec, tok);
1357 if (ar->ar_errno != EINVAL) {
1358 tok = au_to_ipc(AT_IPC_SEM,
1359 ar->ar_arg_svipc_id);
1360 kau_write(rec, tok);
1366 if (ar->ar_errno == 0) {
1367 if (ARG_IS_VALID(kar, ARG_SVIPC_ID)) {
1368 tok = au_to_ipc(AT_IPC_SEM,
1369 ar->ar_arg_svipc_id);
1370 kau_write(rec, tok);
1376 if (ARG_IS_VALID(kar, ARG_EGID)) {
1377 tok = au_to_arg32(1, "egid", ar->ar_arg_egid);
1378 kau_write(rec, tok);
1383 if (ARG_IS_VALID(kar, ARG_EUID)) {
1384 tok = au_to_arg32(1, "euid", ar->ar_arg_euid);
1385 kau_write(rec, tok);
1390 if (ARG_IS_VALID(kar, ARG_RGID)) {
1391 tok = au_to_arg32(1, "rgid", ar->ar_arg_rgid);
1392 kau_write(rec, tok);
1394 if (ARG_IS_VALID(kar, ARG_EGID)) {
1395 tok = au_to_arg32(2, "egid", ar->ar_arg_egid);
1396 kau_write(rec, tok);
1401 if (ARG_IS_VALID(kar, ARG_RUID)) {
1402 tok = au_to_arg32(1, "ruid", ar->ar_arg_ruid);
1403 kau_write(rec, tok);
1405 if (ARG_IS_VALID(kar, ARG_EUID)) {
1406 tok = au_to_arg32(2, "euid", ar->ar_arg_euid);
1407 kau_write(rec, tok);
1412 if (ARG_IS_VALID(kar, ARG_RGID)) {
1413 tok = au_to_arg32(1, "rgid", ar->ar_arg_rgid);
1414 kau_write(rec, tok);
1416 if (ARG_IS_VALID(kar, ARG_EGID)) {
1417 tok = au_to_arg32(2, "egid", ar->ar_arg_egid);
1418 kau_write(rec, tok);
1420 if (ARG_IS_VALID(kar, ARG_SGID)) {
1421 tok = au_to_arg32(3, "sgid", ar->ar_arg_sgid);
1422 kau_write(rec, tok);
1427 if (ARG_IS_VALID(kar, ARG_RUID)) {
1428 tok = au_to_arg32(1, "ruid", ar->ar_arg_ruid);
1429 kau_write(rec, tok);
1431 if (ARG_IS_VALID(kar, ARG_EUID)) {
1432 tok = au_to_arg32(2, "euid", ar->ar_arg_euid);
1433 kau_write(rec, tok);
1435 if (ARG_IS_VALID(kar, ARG_SUID)) {
1436 tok = au_to_arg32(3, "suid", ar->ar_arg_suid);
1437 kau_write(rec, tok);
1442 if (ARG_IS_VALID(kar, ARG_GID)) {
1443 tok = au_to_arg32(1, "gid", ar->ar_arg_gid);
1444 kau_write(rec, tok);
1449 if (ARG_IS_VALID(kar, ARG_UID)) {
1450 tok = au_to_arg32(1, "uid", ar->ar_arg_uid);
1451 kau_write(rec, tok);
1456 if (ARG_IS_VALID(kar, ARG_GROUPSET)) {
1457 for(ctr = 0; ctr < ar->ar_arg_groups.gidset_size; ctr++)
1459 tok = au_to_arg32(1, "setgroups",
1460 ar->ar_arg_groups.gidset[ctr]);
1461 kau_write(rec, tok);
1467 if (ARG_IS_VALID(kar, ARG_LOGIN)) {
1468 tok = au_to_text(ar->ar_arg_login);
1469 kau_write(rec, tok);
1473 case AUE_SETPRIORITY:
1474 if (ARG_IS_VALID(kar, ARG_CMD)) {
1475 tok = au_to_arg32(1, "which", ar->ar_arg_cmd);
1476 kau_write(rec, tok);
1478 if (ARG_IS_VALID(kar, ARG_UID)) {
1479 tok = au_to_arg32(2, "who", ar->ar_arg_uid);
1480 kau_write(rec, tok);
1482 PROCESS_PID_TOKENS(2);
1483 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1484 tok = au_to_arg32(3, "priority", ar->ar_arg_value);
1485 kau_write(rec, tok);
1489 case AUE_SETPRIVEXEC:
1490 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1491 tok = au_to_arg32(1, "flag", ar->ar_arg_value);
1492 kau_write(rec, tok);
1496 /* AUE_SHMAT, AUE_SHMCTL, AUE_SHMDT and AUE_SHMGET are SysV IPC */
1498 if (ARG_IS_VALID(kar, ARG_SVIPC_ID)) {
1499 tok = au_to_arg32(1, "shmid", ar->ar_arg_svipc_id);
1500 kau_write(rec, tok);
1501 /* XXXAUDIT: Does having the ipc token make sense? */
1502 tok = au_to_ipc(AT_IPC_SHM, ar->ar_arg_svipc_id);
1503 kau_write(rec, tok);
1505 if (ARG_IS_VALID(kar, ARG_SVIPC_ADDR)) {
1506 tok = au_to_arg32(2, "shmaddr",
1507 (int)(uintptr_t)ar->ar_arg_svipc_addr);
1508 kau_write(rec, tok);
1510 if (ARG_IS_VALID(kar, ARG_SVIPC_PERM)) {
1511 tok = au_to_ipc_perm(&ar->ar_arg_svipc_perm);
1512 kau_write(rec, tok);
1517 if (ARG_IS_VALID(kar, ARG_SVIPC_ID)) {
1518 tok = au_to_arg32(1, "shmid", ar->ar_arg_svipc_id);
1519 kau_write(rec, tok);
1520 /* XXXAUDIT: Does having the ipc token make sense? */
1521 tok = au_to_ipc(AT_IPC_SHM, ar->ar_arg_svipc_id);
1522 kau_write(rec, tok);
1524 switch (ar->ar_arg_svipc_cmd) {
1526 ar->ar_event = AUE_SHMCTL_STAT;
1529 ar->ar_event = AUE_SHMCTL_RMID;
1532 ar->ar_event = AUE_SHMCTL_SET;
1533 if (ARG_IS_VALID(kar, ARG_SVIPC_PERM)) {
1534 tok = au_to_ipc_perm(&ar->ar_arg_svipc_perm);
1535 kau_write(rec, tok);
1539 break; /* We will audit a bad command */
1544 if (ARG_IS_VALID(kar, ARG_SVIPC_ADDR)) {
1545 tok = au_to_arg32(1, "shmaddr",
1546 (int)(uintptr_t)ar->ar_arg_svipc_addr);
1547 kau_write(rec, tok);
1552 /* This is unusual; the return value is in an argument token */
1553 if (ARG_IS_VALID(kar, ARG_SVIPC_ID)) {
1554 tok = au_to_arg32(0, "shmid", ar->ar_arg_svipc_id);
1555 kau_write(rec, tok);
1556 tok = au_to_ipc(AT_IPC_SHM, ar->ar_arg_svipc_id);
1557 kau_write(rec, tok);
1559 if (ARG_IS_VALID(kar, ARG_SVIPC_PERM)) {
1560 tok = au_to_ipc_perm(&ar->ar_arg_svipc_perm);
1561 kau_write(rec, tok);
1565 /* AUE_SHMOPEN, AUE_SHMUNLINK, AUE_SEMOPEN, AUE_SEMCLOSE
1566 * and AUE_SEMUNLINK are Posix IPC */
1568 if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
1569 tok = au_to_arg32(2, "flags", ar->ar_arg_fflags);
1570 kau_write(rec, tok);
1572 if (ARG_IS_VALID(kar, ARG_MODE)) {
1573 tok = au_to_arg32(3, "mode", ar->ar_arg_mode);
1574 kau_write(rec, tok);
1580 if (ARG_IS_VALID(kar, ARG_POSIX_IPC_PERM)) {
1581 struct ipc_perm perm;
1583 perm.uid = ar->ar_arg_pipc_perm.pipc_uid;
1584 perm.gid = ar->ar_arg_pipc_perm.pipc_gid;
1585 perm.cuid = ar->ar_arg_pipc_perm.pipc_uid;
1586 perm.cgid = ar->ar_arg_pipc_perm.pipc_gid;
1587 perm.mode = ar->ar_arg_pipc_perm.pipc_mode;
1590 tok = au_to_ipc_perm(&perm);
1591 kau_write(rec, tok);
1596 if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
1597 tok = au_to_arg32(2, "flags", ar->ar_arg_fflags);
1598 kau_write(rec, tok);
1600 if (ARG_IS_VALID(kar, ARG_MODE)) {
1601 tok = au_to_arg32(3, "mode", ar->ar_arg_mode);
1602 kau_write(rec, tok);
1604 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1605 tok = au_to_arg32(4, "value", ar->ar_arg_value);
1606 kau_write(rec, tok);
1611 if (ARG_IS_VALID(kar, ARG_TEXT)) {
1612 tok = au_to_text(ar->ar_arg_text);
1613 kau_write(rec, tok);
1615 if (ARG_IS_VALID(kar, ARG_POSIX_IPC_PERM)) {
1616 struct ipc_perm perm;
1618 perm.uid = ar->ar_arg_pipc_perm.pipc_uid;
1619 perm.gid = ar->ar_arg_pipc_perm.pipc_gid;
1620 perm.cuid = ar->ar_arg_pipc_perm.pipc_uid;
1621 perm.cgid = ar->ar_arg_pipc_perm.pipc_gid;
1622 perm.mode = ar->ar_arg_pipc_perm.pipc_mode;
1625 tok = au_to_ipc_perm(&perm);
1626 kau_write(rec, tok);
1631 if (ARG_IS_VALID(kar, ARG_FD)) {
1632 tok = au_to_arg32(1, "sem", ar->ar_arg_fd);
1633 kau_write(rec, tok);
1639 if (ARG_IS_VALID(kar, ARG_TEXT)) {
1640 tok = au_to_text(ar->ar_arg_text);
1641 kau_write(rec, tok);
1644 UPATH1_VNODE1_TOKENS;
1648 case AUE_SYSCTL_NONADMIN:
1649 if (ARG_IS_VALID(kar, ARG_CTLNAME | ARG_LEN)) {
1650 for (ctr = 0; ctr < ar->ar_arg_len; ctr++) {
1651 tok = au_to_arg32(1, "name",
1652 ar->ar_arg_ctlname[ctr]);
1653 kau_write(rec, tok);
1656 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1657 tok = au_to_arg32(5, "newval", ar->ar_arg_value);
1658 kau_write(rec, tok);
1660 if (ARG_IS_VALID(kar, ARG_TEXT)) {
1661 tok = au_to_text(ar->ar_arg_text);
1662 kau_write(rec, tok);
1667 if (ARG_IS_VALID(kar, ARG_MASK)) {
1668 tok = au_to_arg32(1, "new mask", ar->ar_arg_mask);
1669 kau_write(rec, tok);
1671 tok = au_to_arg32(0, "prev mask", ar->ar_retval);
1672 kau_write(rec, tok);
1677 PROCESS_PID_TOKENS(1);
1678 if (ARG_IS_VALID(kar, ARG_VALUE)) {
1679 tok = au_to_arg32(3, "options", ar->ar_arg_value);
1680 kau_write(rec, tok);
1684 case AUE_CAP_RIGHTS_LIMIT:
1686 * XXXRW/XXXJA: Would be nice to audit socket/etc information.
1689 if (ARG_IS_VALID(kar, ARG_RIGHTS)) {
1690 tok = au_to_rights(&ar->ar_arg_rights);
1691 kau_write(rec, tok);
1695 case AUE_CAP_FCNTLS_GET:
1696 case AUE_CAP_IOCTLS_GET:
1697 case AUE_CAP_IOCTLS_LIMIT:
1698 case AUE_CAP_RIGHTS_GET:
1699 if (ARG_IS_VALID(kar, ARG_FD)) {
1700 tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
1701 kau_write(rec, tok);
1705 case AUE_CAP_FCNTLS_LIMIT:
1707 if (ARG_IS_VALID(kar, ARG_FCNTL_RIGHTS)) {
1708 tok = au_to_arg32(2, "fcntlrights",
1709 ar->ar_arg_fcntl_rights);
1710 kau_write(rec, tok);
1715 case AUE_CAP_GETMODE:
1720 printf("BSM conversion requested for unknown event %d\n",
1724 * Write the subject token so it is properly freed here.
1726 if (jail_tok != NULL)
1727 kau_write(rec, jail_tok);
1728 kau_write(rec, subj_tok);
1730 return (BSM_NOAUDIT);
1733 if (jail_tok != NULL)
1734 kau_write(rec, jail_tok);
1735 kau_write(rec, subj_tok);
1736 tok = au_to_return32(au_errno_to_bsm(ar->ar_errno), ar->ar_retval);
1737 kau_write(rec, tok); /* Every record gets a return token */
1739 kau_close(rec, &ar->ar_endtime, ar->ar_event);
1742 return (BSM_SUCCESS);
1746 * Verify that a record is a valid BSM record. This verification is simple
1747 * now, but may be expanded on sometime in the future. Return 1 if the
1748 * record is good, 0 otherwise.
1751 bsm_rec_verify(void *rec)
1753 char c = *(char *)rec;
1756 * Check the token ID of the first token; it has to be a header
1759 * XXXAUDIT There needs to be a token structure to map a token.
1760 * XXXAUDIT 'Shouldn't be simply looking at the first char.
1762 if ((c != AUT_HEADER32) && (c != AUT_HEADER32_EX) &&
1763 (c != AUT_HEADER64) && (c != AUT_HEADER64_EX))