2 * Copyright (c) 2006-2007 Robert N. M. Watson
3 * Copyright (c) 2008 Apple Inc.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * Generate a series of BSM token samples in the requested directory.
32 #include <sys/types.h>
33 #include <sys/socket.h>
36 #include <netinet/in.h>
37 #include <netinet/in_systm.h>
38 #include <netinet/ip.h>
40 #include <arpa/inet.h>
42 #include <bsm/audit_kevents.h>
43 #include <bsm/libbsm.h>
55 static int do_records, do_tokens;
61 fprintf(stderr, "generate [-rt] path\n");
66 open_file(const char *directory, const char *name)
68 char pathname[PATH_MAX];
71 snprintf(pathname, PATH_MAX, "%s/%s", directory, name);
72 (void)unlink(pathname);
73 fd = open(pathname, O_WRONLY | O_CREAT | O_EXCL, 0600);
75 err(EX_CANTCREAT, "open: %s", name);
80 write_file(int fd, void *buffer, size_t buflen, const char *filename)
84 len = write(fd, buffer, buflen);
86 err(EX_OSERR, "write_file: %s", filename);
88 err(EX_OSERR, "write_file: short write: %s", filename);
92 * Write a single token to a file.
95 write_token(const char *directory, const char *filename, token_t *tok)
97 u_char buffer[MAX_AUDIT_RECORD_SIZE];
101 buflen = MAX_AUDIT_RECORD_SIZE;
102 if (au_close_token(tok, buffer, &buflen) < 0)
103 err(EX_UNAVAILABLE, "au_close_token");
104 fd = open_file(directory, filename);
105 write_file(fd, buffer, buflen, filename);
110 * Write a token to a file, wrapped in audit record header and trailer.
113 write_record(const char *directory, const char *filename, token_t *tok,
116 u_char buffer[MAX_AUDIT_RECORD_SIZE];
122 err(EX_UNAVAILABLE, "au_open");
123 if (au_write(au, tok) < 0)
124 err(EX_UNAVAILABLE, "au_write");
125 buflen = MAX_AUDIT_RECORD_SIZE;
126 if (au_close_buffer(au, event, buffer, &buflen) < 0)
127 err(EX_UNAVAILABLE, "au_close_buffer");
128 fd = open_file(directory, filename);
129 write_file(fd, buffer, buflen, filename);
133 static struct timeval file_token_timeval = { 0x12345, 0x67890} ;
136 generate_file_token(const char *directory, const char *token_filename)
140 file_token = au_to_file("test", file_token_timeval);
141 if (file_token == NULL)
142 err(EX_UNAVAILABLE, "au_to_file");
143 write_token(directory, token_filename, file_token);
147 generate_file_record(const char *directory, const char *record_filename)
151 file_token = au_to_file("test", file_token_timeval);
152 if (file_token == NULL)
153 err(EX_UNAVAILABLE, "au_to_file");
154 write_record(directory, record_filename, file_token, AUE_NULL);
161 static int trailer_token_len = 0x12345678;
164 generate_trailer_token(const char *directory, const char *token_filename)
166 token_t *trailer_token;
168 trailer_token = au_to_trailer(trailer_token_len);
169 if (trailer_token == NULL)
170 err(EX_UNAVAILABLE, "au_to_trailer");
171 write_token(directory, token_filename, trailer_token);
174 static int header32_token_len = 0x12345678;
175 static au_event_t header32_e_type = AUE_OPEN;
176 static au_emod_t header32_e_mod = 0x4567;
177 static struct timeval header32_tm = { 0x12345, 0x67890 };
180 generate_header32_token(const char *directory, const char *token_filename)
182 token_t *header32_token;
184 header32_token = au_to_header32_tm(header32_token_len,
185 header32_e_type, header32_e_mod, header32_tm);
186 if (header32_token == NULL)
187 err(EX_UNAVAILABLE, "au_to_header32");
188 write_token(directory, token_filename, header32_token);
195 static char data_token_unit_print = AUP_STRING;
196 static char data_token_unit_type = AUR_CHAR;
197 static char *data_token_data = "SomeData";
198 static char data_token_unit_count = sizeof("SomeData") + 1;
201 generate_data_token(const char *directory, const char *token_filename)
205 data_token = au_to_data(data_token_unit_print, data_token_unit_type,
206 data_token_unit_count, data_token_data);
207 if (data_token == NULL)
208 err(EX_UNAVAILABLE, "au_to_data");
209 write_token(directory, token_filename, data_token);
213 generate_data_record(const char *directory, const char *record_filename)
217 data_token = au_to_data(data_token_unit_print, data_token_unit_type,
218 data_token_unit_count, data_token_data);
219 if (data_token == NULL)
220 err(EX_UNAVAILABLE, "au_to_data");
221 write_record(directory, record_filename, data_token, AUE_NULL);
224 static char ipc_type = AT_IPC_MSG;
225 static int ipc_id = 0x12345678;
228 generate_ipc_token(const char *directory, const char *token_filename)
232 ipc_token = au_to_ipc(ipc_type, ipc_id);
233 if (ipc_token == NULL)
234 err(EX_UNAVAILABLE, "au_to_ipc");
235 write_token(directory, token_filename, ipc_token);
239 generate_ipc_record(const char *directory, const char *record_filename)
243 ipc_token = au_to_ipc(ipc_type, ipc_id);
244 if (ipc_token == NULL)
245 err(EX_UNAVAILABLE, "au_to_ipc");
246 write_record(directory, record_filename, ipc_token, AUE_NULL);
249 static char *path_token_path = "/test/this/is/a/test";
252 generate_path_token(const char *directory, const char *token_filename)
256 path_token = au_to_path(path_token_path);
257 if (path_token == NULL)
258 err(EX_UNAVAILABLE, "au_to_path");
259 write_token(directory, token_filename, path_token);
263 generate_path_record(const char *directory, const char *record_filename)
267 path_token = au_to_path(path_token_path);
268 if (path_token == NULL)
269 err(EX_UNAVAILABLE, "au_to_path");
270 write_record(directory, record_filename, path_token, AUE_NULL);
273 static au_id_t subject32_auid = 0x12345678;
274 static uid_t subject32_euid = 0x01234567;
275 static gid_t subject32_egid = 0x23456789;
276 static uid_t subject32_ruid = 0x98765432;
277 static gid_t subject32_rgid = 0x09876543;
278 static pid_t subject32_pid = 0x13243546;
279 static au_asid_t subject32_sid = 0x97867564;
280 static au_tid_t subject32_tid = { 0x16593746 };
281 static au_tid_addr_t subject32_tid_addr = { 0x16593746 };
284 generate_subject32_token(const char *directory, const char *token_filename)
286 token_t *subject32_token;
288 subject32_tid.machine = inet_addr("127.0.0.1");
290 subject32_token = au_to_subject32(subject32_auid, subject32_euid,
291 subject32_egid, subject32_ruid, subject32_rgid, subject32_pid,
292 subject32_sid, &subject32_tid);
293 if (subject32_token == NULL)
294 err(EX_UNAVAILABLE, "au_to_subject32");
295 write_token(directory, token_filename, subject32_token);
299 generate_subject32_record(const char *directory, const char *record_filename)
301 token_t *subject32_token;
303 subject32_tid.machine = inet_addr("127.0.0.1");
305 subject32_token = au_to_subject32(subject32_auid, subject32_euid,
306 subject32_egid, subject32_ruid, subject32_rgid, subject32_pid,
307 subject32_sid, &subject32_tid);
308 if (subject32_token == NULL)
309 err(EX_UNAVAILABLE, "au_to_subject32");
310 write_record(directory, record_filename, subject32_token, AUE_NULL);
314 generate_subject32ex_token(const char *directory, const char *token_filename,
317 token_t *subject32ex_token;
320 buf = (char *)malloc(strlen(token_filename) + 6);
321 if (type == AU_IPv6) {
322 inet_pton(AF_INET6, "fe80::1", subject32_tid_addr.at_addr);
323 subject32_tid_addr.at_type = AU_IPv6;
324 sprintf(buf, "%s%s", token_filename, "-IPv6");
326 subject32_tid_addr.at_addr[0] = inet_addr("127.0.0.1");
327 subject32_tid_addr.at_type = AU_IPv4;
328 sprintf(buf, "%s%s", token_filename, "-IPv4");
331 subject32ex_token = au_to_subject32_ex(subject32_auid, subject32_euid,
332 subject32_egid, subject32_ruid, subject32_rgid, subject32_pid,
333 subject32_sid, &subject32_tid_addr);
334 if (subject32ex_token == NULL)
335 err(EX_UNAVAILABLE, "au_to_subject32_ex");
336 write_token(directory, buf, subject32ex_token);
341 generate_subject32ex_record(const char *directory, const char *record_filename,
344 token_t *subject32ex_token;
347 buf = (char *)malloc(strlen(record_filename) + 6);
348 if (type == AU_IPv6) {
349 inet_pton(AF_INET6, "fe80::1", subject32_tid_addr.at_addr);
350 subject32_tid_addr.at_type = AU_IPv6;
351 sprintf(buf, "%s%s", record_filename, "-IPv6");
353 subject32_tid_addr.at_addr[0] = inet_addr("127.0.0.1");
354 subject32_tid_addr.at_type = AU_IPv4;
355 sprintf(buf, "%s%s", record_filename, "-IPv4");
358 subject32ex_token = au_to_subject32_ex(subject32_auid, subject32_euid,
359 subject32_egid, subject32_ruid, subject32_rgid, subject32_pid,
360 subject32_sid, &subject32_tid_addr);
361 if (subject32ex_token == NULL)
362 err(EX_UNAVAILABLE, "au_to_subject32_ex");
363 write_record(directory, record_filename, subject32ex_token, AUE_NULL);
367 static au_id_t process32_auid = 0x12345678;
368 static uid_t process32_euid = 0x01234567;
369 static gid_t process32_egid = 0x23456789;
370 static uid_t process32_ruid = 0x98765432;
371 static gid_t process32_rgid = 0x09876543;
372 static pid_t process32_pid = 0x13243546;
373 static au_asid_t process32_sid = 0x97867564;
374 static au_tid_t process32_tid = { 0x16593746 };
375 static au_tid_addr_t process32_tid_addr = { 0x16593746 };
378 generate_process32_token(const char *directory, const char *token_filename)
380 token_t *process32_token;
382 process32_tid.machine = inet_addr("127.0.0.1");
384 process32_token = au_to_process32(process32_auid, process32_euid,
385 process32_egid, process32_ruid, process32_rgid, process32_pid,
386 process32_sid, &process32_tid);
387 if (process32_token == NULL)
388 err(EX_UNAVAILABLE, "au_to_process32");
389 write_token(directory, token_filename, process32_token);
393 generate_process32_record(const char *directory, const char *record_filename)
395 token_t *process32_token;
397 process32_tid.machine = inet_addr("127.0.0.1");
399 process32_token = au_to_process32(process32_auid, process32_euid,
400 process32_egid, process32_ruid, process32_rgid, process32_pid,
401 process32_sid, &process32_tid);
402 if (process32_token == NULL)
403 err(EX_UNAVAILABLE, "au_ti_process32");
404 write_record(directory, record_filename, process32_token, AUE_NULL);
408 generate_process32ex_token(const char *directory, const char *token_filename,
411 token_t *process32ex_token;
414 buf = (char *)malloc(strlen(token_filename) + 6);
415 if (type == AU_IPv6) {
416 inet_pton(AF_INET6, "fe80::1", process32_tid_addr.at_addr);
417 process32_tid_addr.at_type = AU_IPv6;
418 sprintf(buf, "%s%s", token_filename, "-IPv6");
420 process32_tid_addr.at_addr[0] = inet_addr("127.0.0.1");
421 process32_tid_addr.at_type = AU_IPv4;
422 sprintf(buf, "%s%s", token_filename, "-IPv4");
425 process32ex_token = au_to_process32_ex(process32_auid, process32_euid,
426 process32_egid, process32_ruid, process32_rgid, process32_pid,
427 process32_sid, &process32_tid_addr);
428 if (process32ex_token == NULL)
429 err(EX_UNAVAILABLE, "au_to_process32_ex");
430 write_token(directory, buf, process32ex_token);
435 generate_process32ex_record(const char *directory, const char *record_filename,
438 token_t *process32ex_token;
441 buf = (char *)malloc(strlen(record_filename) + 6);
442 if (type == AU_IPv6) {
443 inet_pton(AF_INET6, "fe80::1", process32_tid_addr.at_addr);
444 process32_tid_addr.at_type = AU_IPv6;
445 sprintf(buf, "%s%s", record_filename, "-IPv6");
447 process32_tid_addr.at_addr[0] = inet_addr("127.0.0.1");
448 process32_tid_addr.at_type = AU_IPv4;
449 sprintf(buf, "%s%s", record_filename, "-IPv4");
452 process32ex_token = au_to_process32_ex(process32_auid, process32_euid,
453 process32_egid, process32_ruid, process32_rgid, process32_pid,
454 process32_sid, &process32_tid_addr);
455 if (process32ex_token == NULL)
456 err(EX_UNAVAILABLE, "au_to_process32_ex");
457 write_record(directory, buf, process32ex_token, AUE_NULL);
461 static au_id_t process64_auid = 0x12345678;
462 static uid_t process64_euid = 0x01234567;
463 static gid_t process64_egid = 0x23456789;
464 static uid_t process64_ruid = 0x98765432;
465 static gid_t process64_rgid = 0x09876543;
466 static pid_t process64_pid = 0x13243546;
467 static au_asid_t process64_sid = 0x97867564;
468 static au_tid_t process64_tid = { 0x16593746 };
469 static au_tid_addr_t process64_tid_addr = { 0x16593746 };
472 generate_process64_token(const char *directory, const char *token_filename)
474 token_t *process64_token;
476 process64_tid.machine = inet_addr("127.0.0.1");
478 process64_token = au_to_process64(process64_auid, process64_euid,
479 process64_egid, process64_ruid, process64_rgid, process64_pid,
480 process64_sid, &process64_tid);
481 if (process64_token == NULL)
482 err(EX_UNAVAILABLE, "au_to_process64");
483 write_token(directory, token_filename, process64_token);
487 generate_process64_record(const char *directory, const char *record_filename)
489 token_t *process64_token;
491 process64_tid.machine = inet_addr("127.0.0.1");
493 process64_token = au_to_process64(process64_auid, process64_euid,
494 process64_egid, process64_ruid, process64_rgid, process64_pid,
495 process64_sid, &process64_tid);
496 if (process64_token == NULL)
497 err(EX_UNAVAILABLE, "au_ti_process64");
498 write_record(directory, record_filename, process64_token, AUE_NULL);
502 generate_process64ex_token(const char *directory, const char *token_filename,
505 token_t *process64ex_token;
508 buf = (char *)malloc(strlen(token_filename) + 6);
509 if (type == AU_IPv6) {
510 inet_pton(AF_INET6, "fe80::1", process64_tid_addr.at_addr);
511 process64_tid_addr.at_type = AU_IPv6;
512 sprintf(buf, "%s%s", token_filename, "-IPv6");
514 process64_tid_addr.at_addr[0] = inet_addr("127.0.0.1");
515 process64_tid_addr.at_type = AU_IPv4;
516 sprintf(buf, "%s%s", token_filename, "-IPv4");
519 process64ex_token = au_to_process64_ex(process64_auid, process64_euid,
520 process64_egid, process64_ruid, process64_rgid, process64_pid,
521 process64_sid, &process64_tid_addr);
522 if (process64ex_token == NULL)
523 err(EX_UNAVAILABLE, "au_to_process64_ex");
524 write_token(directory, buf, process64ex_token);
529 generate_process64ex_record(const char *directory, const char *record_filename,
532 token_t *process64ex_token;
535 buf = (char *)malloc(strlen(record_filename) + 6);
536 if (type == AU_IPv6) {
537 inet_pton(AF_INET6, "fe80::1", process64_tid_addr.at_addr);
538 process64_tid_addr.at_type = AU_IPv6;
539 sprintf(buf, "%s%s", record_filename, "-IPv6");
541 process64_tid_addr.at_addr[0] = inet_addr("127.0.0.1");
542 process64_tid_addr.at_type = AU_IPv4;
543 sprintf(buf, "%s%s", record_filename, "-IPv4");
546 process64ex_token = au_to_process64_ex(process64_auid, process64_euid,
547 process64_egid, process64_ruid, process64_rgid, process64_pid,
548 process64_sid, &process64_tid_addr);
549 if (process64ex_token == NULL)
550 err(EX_UNAVAILABLE, "au_to_process64_ex");
551 write_record(directory, buf, process64ex_token, AUE_NULL);
555 static char return32_status = EINVAL;
556 static uint32_t return32_ret = 0x12345678;
559 generate_return32_token(const char *directory, const char *token_filename)
561 token_t *return32_token;
563 return32_token = au_to_return32(au_errno_to_bsm(return32_status),
565 if (return32_token == NULL)
566 err(EX_UNAVAILABLE, "au_to_return32");
567 write_token(directory, token_filename, return32_token);
571 generate_return32_record(const char *directory, const char *record_filename)
573 token_t *return32_token;
575 return32_token = au_to_return32(au_errno_to_bsm(return32_status),
577 if (return32_token == NULL)
578 err(EX_UNAVAILABLE, "au_to_return32");
579 write_record(directory, record_filename, return32_token, AUE_NULL);
582 static char *text_token_text = "This is a test.";
585 generate_text_token(const char *directory, const char *token_filename)
589 text_token = au_to_text(text_token_text);
590 if (text_token == NULL)
591 err(EX_UNAVAILABLE, "au_to_text");
592 write_token(directory, token_filename, text_token);
596 generate_text_record(const char *directory, const char *record_filename)
600 text_token = au_to_text(text_token_text);
601 if (text_token == NULL)
602 err(EX_UNAVAILABLE, "au_to_text");
603 write_record(directory, record_filename, text_token, AUE_NULL);
606 static char opaque_token_data[] = {0xaa, 0xbb, 0xcc, 0xdd};
607 static int opaque_token_bytes = sizeof(opaque_token_data);
610 generate_opaque_token(const char *directory, const char *token_filename)
612 token_t *opaque_token;
614 opaque_token = au_to_opaque(opaque_token_data, opaque_token_bytes);
615 if (opaque_token == NULL)
616 err(EX_UNAVAILABLE, "au_to_opaque");
617 write_token(directory, token_filename, opaque_token);
621 generate_opaque_record(const char *directory, const char *record_filename)
623 token_t *opaque_token;
625 opaque_token = au_to_opaque(opaque_token_data, opaque_token_bytes);
626 if (opaque_token == NULL)
627 err(EX_UNAVAILABLE, "au_to_opaque");
628 write_record(directory, record_filename, opaque_token, AUE_NULL);
631 static struct in_addr in_addr_token_addr;
634 generate_in_addr_token(const char *directory, const char *token_filename)
636 token_t *in_addr_token;
638 in_addr_token_addr.s_addr = inet_addr("192.168.100.15");
640 in_addr_token = au_to_in_addr(&in_addr_token_addr);
641 if (in_addr_token == NULL)
642 err(EX_UNAVAILABLE, "au_to_in_addr");
643 write_token(directory, token_filename, in_addr_token);
647 generate_in_addr_record(const char *directory, const char *record_filename)
649 token_t *in_addr_token;
651 in_addr_token_addr.s_addr = inet_addr("192.168.100.15");
653 in_addr_token = au_to_in_addr(&in_addr_token_addr);
654 if (in_addr_token == NULL)
655 err(EX_UNAVAILABLE, "au_to_in_addr");
656 write_record(directory, record_filename, in_addr_token, AUE_NULL);
659 static struct ip ip_token_ip;
660 static u_char ip_token_ip_v = 4;
661 static uint16_t ip_token_ip_id = 0x5478;
662 static u_char ip_token_ip_ttl = 64;
663 static u_char ip_token_ip_p = IPPROTO_ICMP;
664 static struct in_addr ip_token_ip_src;
665 static struct in_addr ip_token_ip_dst;
668 generate_ip_token(const char *directory, const char *token_filename)
672 ip_token_ip_src.s_addr = inet_addr("192.168.100.155");
673 ip_token_ip_dst.s_addr = inet_addr("192.168.110.48");
675 memset(&ip_token_ip, 0, sizeof(ip_token_ip));
676 ip_token_ip.ip_v = ip_token_ip_v;
677 ip_token_ip.ip_len = htons(sizeof(ip_token_ip));
678 ip_token_ip.ip_id = htons(ip_token_ip_id);
679 ip_token_ip.ip_ttl = ip_token_ip_ttl;
680 ip_token_ip.ip_p = ip_token_ip_p;
681 ip_token_ip.ip_src = ip_token_ip_src;
682 ip_token_ip.ip_dst = ip_token_ip_dst;
684 ip_token = au_to_ip(&ip_token_ip);
685 if (ip_token == NULL)
686 err(EX_UNAVAILABLE, "au_to_ip");
687 write_token(directory, token_filename, ip_token);
691 generate_ip_record(const char *directory, const char *record_filename)
695 ip_token_ip_src.s_addr = inet_addr("192.168.100.155");
696 ip_token_ip_dst.s_addr = inet_addr("192.168.110.48");
698 memset(&ip_token_ip, 0, sizeof(ip_token_ip));
699 ip_token_ip.ip_v = ip_token_ip_v;
700 ip_token_ip.ip_len = htons(sizeof(ip_token_ip));
701 ip_token_ip.ip_id = htons(ip_token_ip_id);
702 ip_token_ip.ip_ttl = ip_token_ip_ttl;
703 ip_token_ip.ip_p = ip_token_ip_p;
704 ip_token_ip.ip_src = ip_token_ip_src;
705 ip_token_ip.ip_dst = ip_token_ip_dst;
707 ip_token = au_to_ip(&ip_token_ip);
708 if (ip_token == NULL)
709 err(EX_UNAVAILABLE, "au_to_ip");
710 write_record(directory, record_filename, ip_token, AUE_NULL);
713 static u_int16_t iport_token_iport;
716 generate_iport_token(const char *directory, const char *token_filename)
718 token_t *iport_token;
720 iport_token_iport = htons(80);
722 iport_token = au_to_iport(iport_token_iport);
723 if (iport_token == NULL)
724 err(EX_UNAVAILABLE, "au_to_iport");
725 write_token(directory, token_filename, iport_token);
729 generate_iport_record(const char *directory, const char *record_filename)
731 token_t *iport_token;
733 iport_token_iport = htons(80);
735 iport_token = au_to_iport(iport_token_iport);
736 if (iport_token == NULL)
737 err(EX_UNAVAILABLE, "au_to_iport");
738 write_record(directory, record_filename, iport_token, AUE_NULL);
741 static char arg32_token_n = 3;
742 static char *arg32_token_text = "test_arg32_token";
743 static uint32_t arg32_token_v = 0xabcdef00;
746 generate_arg32_token(const char *directory, const char *token_filename)
748 token_t *arg32_token;
750 arg32_token = au_to_arg32(arg32_token_n, arg32_token_text,
752 if (arg32_token == NULL)
753 err(EX_UNAVAILABLE, "au_to_arg32");
754 write_token(directory, token_filename, arg32_token);
758 generate_arg32_record(const char *directory, const char *record_filename)
760 token_t *arg32_token;
762 arg32_token = au_to_arg32(arg32_token_n, arg32_token_text,
764 if (arg32_token == NULL)
765 err(EX_UNAVAILABLE, "au_to_arg32");
766 write_record(directory, record_filename, arg32_token, AUE_NULL);
769 static long seq_audit_count = 0x12345678;
772 generate_seq_token(const char *directory, const char *token_filename)
776 seq_token = au_to_seq(seq_audit_count);
777 if (seq_token == NULL)
778 err(EX_UNAVAILABLE, "au_to_seq");
779 write_token(directory, token_filename, seq_token);
783 generate_seq_record(const char *directory, const char *record_filename)
787 seq_token = au_to_seq(seq_audit_count);
788 if (seq_token == NULL)
789 err(EX_UNAVAILABLE, "au_to_seq");
790 write_record(directory, record_filename, seq_token, AUE_NULL);
799 generate_attr_token(const char *directory, const char *token_filename)
806 generate_attr_record(const char *directory, const char *record_filename)
813 generate_ipc_perm_token(const char *directory, const char *token_filename)
815 token_t *ipc_perm_token;
820 generate_ipc_perm_record(const char *directory, const char *record_filename)
822 token_t *ipc_perm_token;
833 generate_groups_token(const char *directory, const char *token_filename)
835 token_t *groups_token;
840 generate_groups_record(const char *directory, const char *record_filename)
842 token_t *groups_token;
885 generate_attr32_token(const char *directory, const char *token_filename)
887 token_t *attr32_token;
892 generate_attr32_record(const char *directory, const char *record_filename)
894 token_t *attr32_token;
899 static char *zonename_sample = "testzone";
902 generate_zonename_token(const char *directory, const char *token_filename)
904 token_t *zonename_token;
906 zonename_token = au_to_zonename(zonename_sample);
907 if (zonename_token == NULL)
908 err(EX_UNAVAILABLE, "au_to_zonename");
909 write_token(directory, token_filename, zonename_token);
913 generate_zonename_record(const char *directory, const char *record_filename)
915 token_t *zonename_token;
917 zonename_token = au_to_zonename(zonename_sample);
918 if (zonename_token == NULL)
919 err(EX_UNAVAILABLE, "au_to_zonename");
920 write_record(directory, record_filename, zonename_token, AUE_NULL);
923 static u_short socketex_domain = PF_INET;
924 static u_short socketex_type = SOCK_STREAM;
925 static struct sockaddr_in socketex_laddr, socketex_raddr;
928 generate_socketex_token(const char *directory, const char *token_filename)
930 token_t *socketex_token;
932 bzero(&socketex_laddr, sizeof(socketex_laddr));
933 socketex_laddr.sin_family = AF_INET;
934 socketex_laddr.sin_len = sizeof(socketex_laddr);
935 socketex_laddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
937 bzero(&socketex_raddr, sizeof(socketex_raddr));
938 socketex_raddr.sin_family = AF_INET;
939 socketex_raddr.sin_len = sizeof(socketex_raddr);
940 socketex_raddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
942 socketex_token = au_to_socket_ex(au_domain_to_bsm(socketex_domain),
943 au_socket_type_to_bsm(socketex_type),
944 (struct sockaddr *)&socketex_laddr,
945 (struct sockaddr *)&socketex_raddr);
946 if (socketex_token == NULL)
947 err(EX_UNAVAILABLE, "au_to_socket_ex");
948 write_token(directory, token_filename, socketex_token);
952 generate_socketex_record(const char *directory, const char *record_filename)
954 token_t *socketex_token;
956 bzero(&socketex_laddr, sizeof(socketex_laddr));
957 socketex_laddr.sin_family = AF_INET;
958 socketex_laddr.sin_len = sizeof(socketex_laddr);
959 socketex_laddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
961 bzero(&socketex_raddr, sizeof(socketex_raddr));
962 socketex_raddr.sin_family = AF_INET;
963 socketex_raddr.sin_len = sizeof(socketex_raddr);
964 socketex_raddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
966 socketex_token = au_to_socket_ex(au_domain_to_bsm(socketex_domain),
967 au_socket_type_to_bsm(socketex_type),
968 (struct sockaddr *)&socketex_laddr,
969 (struct sockaddr *)&socketex_raddr);
970 if (socketex_token == NULL)
971 err(EX_UNAVAILABLE, "au_to_socket_ex");
972 write_record(directory, record_filename, socketex_token, AUE_NULL);
976 * Generate a series of error-number specific return tokens in records.
979 generate_error_record(const char *directory, const char *filename, int error)
981 char pathname[PATH_MAX];
982 token_t *return32_token;
984 return32_token = au_to_return32(au_errno_to_bsm(error), -1);
985 if (return32_token == NULL)
986 err(EX_UNAVAILABLE, "au_to_return32");
987 (void)snprintf(pathname, PATH_MAX, "%s_record", filename);
988 write_record(directory, pathname, return32_token, AUE_NULL);
992 * Not all the error numbers, just a few present on all platforms for now.
996 const char *error_name;
999 { ENOENT, "ENOENT" },
1005 { ENOEXEC, "ENOEXEC" },
1007 { ECHILD, "ECHILD" },
1008 { EDEADLK, "EDEADLK" },
1009 { ENOMEM, "ENOMEM" },
1010 { EACCES, "EACCES" },
1011 { EFAULT, "EFAULT" },
1012 { ENOTBLK, "ENOTBLK" },
1014 { EEXIST, "EEXIST" },
1016 { ENODEV, "ENODEV" },
1017 { ENOTDIR, "ENOTDIR" },
1018 { EISDIR, "EISDIR" },
1019 { EINVAL, "EINVAL" },
1020 { ENFILE, "ENFILE" },
1021 { EMFILE, "EMFILE" },
1022 { ENOTTY, "ENOTTY" },
1023 { ETXTBSY, "ETXTBSY" },
1025 { ENOSPC, "ENOSPC" },
1026 { ESPIPE, "ESPIPE" },
1028 { EMLINK, "EMLINK" },
1031 const int error_list_count = sizeof(error_list)/sizeof(error_list[0]);
1034 do_error_records(const char *directory)
1038 for (i = 0; i < error_list_count; i++)
1039 generate_error_record(directory, error_list[i].error_name,
1040 error_list[i].error_number);
1044 main(int argc, char *argv[])
1046 const char *directory;
1049 while ((ch = getopt(argc, argv, "rt")) != -1) {
1070 directory = argv[0];
1072 if (mkdir(directory, 0755) < 0 && errno != EEXIST)
1073 err(EX_OSERR, "mkdir: %s", directory);
1076 generate_file_token(directory, "file_token");
1077 generate_trailer_token(directory, "trailer_token");
1078 generate_header32_token(directory, "header32_token");
1079 generate_data_token(directory, "data_token");
1080 generate_ipc_token(directory, "ipc_token");
1081 generate_path_token(directory, "path_token");
1082 generate_subject32_token(directory, "subject32_token");
1083 generate_subject32ex_token(directory, "subject32ex_token",
1085 generate_subject32ex_token(directory, "subject32ex_token",
1087 generate_process32_token(directory, "process32_token");
1088 generate_process32ex_token(directory, "process32ex_token",
1090 generate_process32ex_token(directory, "process32ex_token",
1092 generate_process64_token(directory, "process64_token");
1093 generate_process64ex_token(directory, "process64ex_token",
1095 generate_process64ex_token(directory, "process64ex_token",
1097 generate_return32_token(directory, "return32_token");
1098 generate_text_token(directory, "text_token");
1099 generate_opaque_token(directory, "opaque_token");
1100 generate_in_addr_token(directory, "in_addr_token");
1101 generate_ip_token(directory, "ip_token");
1102 generate_iport_token(directory, "iport_token");
1103 generate_arg32_token(directory, "arg32_token");
1104 generate_seq_token(directory, "seq_token");
1106 generate_attr_token(directory, "attr_token");
1107 generate_ipc_perm_token(directory, "ipc_perm_token");
1108 generate_groups_token(directory, "groups_token");
1109 generate_attr32_token(directory, "attr32_token");
1111 generate_zonename_token(directory, "zonename_token");
1112 generate_socketex_token(directory, "socketex_token");
1116 generate_file_record(directory, "file_record");
1117 generate_data_record(directory, "data_record");
1118 generate_ipc_record(directory, "ipc_record");
1119 generate_path_record(directory, "path_record");
1120 generate_subject32_record(directory, "subject32_record");
1121 generate_subject32ex_record(directory, "subject32ex_record",
1123 generate_subject32ex_record(directory, "subject32ex_record",
1125 generate_process32_record(directory, "process32_record");
1126 generate_process32ex_record(directory, "process32ex_record",
1128 generate_process32ex_record(directory, "process32ex_record",
1130 generate_process64_record(directory, "process64_record");
1131 generate_process64ex_record(directory, "process64ex_record",
1133 generate_process64ex_record(directory, "process64ex_record",
1135 generate_return32_record(directory, "return32_record");
1136 generate_text_record(directory, "text_record");
1137 generate_opaque_record(directory, "opaque_record");
1138 generate_in_addr_record(directory, "in_addr_record");
1139 generate_ip_record(directory, "ip_record");
1140 generate_iport_record(directory, "iport_record");
1141 generate_arg32_record(directory, "arg32_record");
1142 generate_seq_record(directory, "seq_record");
1144 generate_attr_record(directory, "attr_record");
1145 generate_ipc_perm_record(directory, "ipc_perm_record");
1146 generate_groups_record(directory, "groups_record");
1147 generate_attr32_record(directory, "attr32_record");
1149 generate_zonename_record(directory, "zonename_record");
1150 generate_socketex_record(directory, "socketex_record");
1151 do_error_records(directory);