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
27 * $P4: //depot/projects/trustedbsd/openbsm/test/bsm/generate.c#14 $
31 * Generate a series of BSM token samples in the requested directory.
34 #include <sys/types.h>
35 #include <sys/socket.h>
38 #include <netinet/in.h>
39 #include <netinet/in_systm.h>
40 #include <netinet/ip.h>
42 #include <arpa/inet.h>
44 #include <bsm/audit_kevents.h>
45 #include <bsm/libbsm.h>
57 static int do_records, do_tokens;
63 fprintf(stderr, "generate [-rt] path\n");
68 open_file(const char *directory, const char *name)
70 char pathname[PATH_MAX];
73 snprintf(pathname, PATH_MAX, "%s/%s", directory, name);
74 (void)unlink(pathname);
75 fd = open(pathname, O_WRONLY | O_CREAT | O_EXCL, 0600);
77 err(EX_CANTCREAT, "open: %s", name);
82 write_file(int fd, void *buffer, size_t buflen, const char *filename)
86 len = write(fd, buffer, buflen);
88 err(EX_OSERR, "write_file: %s", filename);
90 err(EX_OSERR, "write_file: short write: %s", filename);
94 * Write a single token to a file.
97 write_token(const char *directory, const char *filename, token_t *tok)
99 u_char buffer[MAX_AUDIT_RECORD_SIZE];
103 buflen = MAX_AUDIT_RECORD_SIZE;
104 if (au_close_token(tok, buffer, &buflen) < 0)
105 err(EX_UNAVAILABLE, "au_close_token");
106 fd = open_file(directory, filename);
107 write_file(fd, buffer, buflen, filename);
112 * Write a token to a file, wrapped in audit record header and trailer.
115 write_record(const char *directory, const char *filename, token_t *tok,
118 u_char buffer[MAX_AUDIT_RECORD_SIZE];
124 err(EX_UNAVAILABLE, "au_open");
125 if (au_write(au, tok) < 0)
126 err(EX_UNAVAILABLE, "au_write");
127 buflen = MAX_AUDIT_RECORD_SIZE;
128 if (au_close_buffer(au, event, buffer, &buflen) < 0)
129 err(EX_UNAVAILABLE, "au_close_buffer");
130 fd = open_file(directory, filename);
131 write_file(fd, buffer, buflen, filename);
135 static struct timeval file_token_timeval = { 0x12345, 0x67890} ;
138 generate_file_token(const char *directory, const char *token_filename)
142 file_token = au_to_file("test", file_token_timeval);
143 if (file_token == NULL)
144 err(EX_UNAVAILABLE, "au_to_file");
145 write_token(directory, token_filename, file_token);
149 generate_file_record(const char *directory, const char *record_filename)
153 file_token = au_to_file("test", file_token_timeval);
154 if (file_token == NULL)
155 err(EX_UNAVAILABLE, "au_to_file");
156 write_record(directory, record_filename, file_token, AUE_NULL);
163 static int trailer_token_len = 0x12345678;
166 generate_trailer_token(const char *directory, const char *token_filename)
168 token_t *trailer_token;
170 trailer_token = au_to_trailer(trailer_token_len);
171 if (trailer_token == NULL)
172 err(EX_UNAVAILABLE, "au_to_trailer");
173 write_token(directory, token_filename, trailer_token);
176 static int header32_token_len = 0x12345678;
177 static au_event_t header32_e_type = AUE_OPEN;
178 static au_emod_t header32_e_mod = 0x4567;
179 static struct timeval header32_tm = { 0x12345, 0x67890 };
182 generate_header32_token(const char *directory, const char *token_filename)
184 token_t *header32_token;
186 header32_token = au_to_header32_tm(header32_token_len,
187 header32_e_type, header32_e_mod, header32_tm);
188 if (header32_token == NULL)
189 err(EX_UNAVAILABLE, "au_to_header32");
190 write_token(directory, token_filename, header32_token);
197 static char data_token_unit_print = AUP_STRING;
198 static char data_token_unit_type = AUR_CHAR;
199 static char *data_token_data = "SomeData";
200 static char data_token_unit_count = sizeof("SomeData") + 1;
203 generate_data_token(const char *directory, const char *token_filename)
207 data_token = au_to_data(data_token_unit_print, data_token_unit_type,
208 data_token_unit_count, data_token_data);
209 if (data_token == NULL)
210 err(EX_UNAVAILABLE, "au_to_data");
211 write_token(directory, token_filename, data_token);
215 generate_data_record(const char *directory, const char *record_filename)
219 data_token = au_to_data(data_token_unit_print, data_token_unit_type,
220 data_token_unit_count, data_token_data);
221 if (data_token == NULL)
222 err(EX_UNAVAILABLE, "au_to_data");
223 write_record(directory, record_filename, data_token, AUE_NULL);
226 static char ipc_type = AT_IPC_MSG;
227 static int ipc_id = 0x12345678;
230 generate_ipc_token(const char *directory, const char *token_filename)
234 ipc_token = au_to_ipc(ipc_type, ipc_id);
235 if (ipc_token == NULL)
236 err(EX_UNAVAILABLE, "au_to_ipc");
237 write_token(directory, token_filename, ipc_token);
241 generate_ipc_record(const char *directory, const char *record_filename)
245 ipc_token = au_to_ipc(ipc_type, ipc_id);
246 if (ipc_token == NULL)
247 err(EX_UNAVAILABLE, "au_to_ipc");
248 write_record(directory, record_filename, ipc_token, AUE_NULL);
251 static char *path_token_path = "/test/this/is/a/test";
254 generate_path_token(const char *directory, const char *token_filename)
258 path_token = au_to_path(path_token_path);
259 if (path_token == NULL)
260 err(EX_UNAVAILABLE, "au_to_path");
261 write_token(directory, token_filename, path_token);
265 generate_path_record(const char *directory, const char *record_filename)
269 path_token = au_to_path(path_token_path);
270 if (path_token == NULL)
271 err(EX_UNAVAILABLE, "au_to_path");
272 write_record(directory, record_filename, path_token, AUE_NULL);
275 static au_id_t subject32_auid = 0x12345678;
276 static uid_t subject32_euid = 0x01234567;
277 static gid_t subject32_egid = 0x23456789;
278 static uid_t subject32_ruid = 0x98765432;
279 static gid_t subject32_rgid = 0x09876543;
280 static pid_t subject32_pid = 0x13243546;
281 static au_asid_t subject32_sid = 0x97867564;
282 static au_tid_t subject32_tid = { 0x16593746 };
283 static au_tid_addr_t subject32_tid_addr = { 0x16593746 };
286 generate_subject32_token(const char *directory, const char *token_filename)
288 token_t *subject32_token;
290 subject32_tid.machine = inet_addr("127.0.0.1");
292 subject32_token = au_to_subject32(subject32_auid, subject32_euid,
293 subject32_egid, subject32_ruid, subject32_rgid, subject32_pid,
294 subject32_sid, &subject32_tid);
295 if (subject32_token == NULL)
296 err(EX_UNAVAILABLE, "au_to_subject32");
297 write_token(directory, token_filename, subject32_token);
301 generate_subject32_record(const char *directory, const char *record_filename)
303 token_t *subject32_token;
305 subject32_tid.machine = inet_addr("127.0.0.1");
307 subject32_token = au_to_subject32(subject32_auid, subject32_euid,
308 subject32_egid, subject32_ruid, subject32_rgid, subject32_pid,
309 subject32_sid, &subject32_tid);
310 if (subject32_token == NULL)
311 err(EX_UNAVAILABLE, "au_to_subject32");
312 write_record(directory, record_filename, subject32_token, AUE_NULL);
316 generate_subject32ex_token(const char *directory, const char *token_filename,
319 token_t *subject32ex_token;
322 buf = (char *)malloc(strlen(token_filename) + 6);
323 if (type == AU_IPv6) {
324 inet_pton(AF_INET6, "fe80::1", subject32_tid_addr.at_addr);
325 subject32_tid_addr.at_type = AU_IPv6;
326 sprintf(buf, "%s%s", token_filename, "-IPv6");
328 subject32_tid_addr.at_addr[0] = inet_addr("127.0.0.1");
329 subject32_tid_addr.at_type = AU_IPv4;
330 sprintf(buf, "%s%s", token_filename, "-IPv4");
333 subject32ex_token = au_to_subject32_ex(subject32_auid, subject32_euid,
334 subject32_egid, subject32_ruid, subject32_rgid, subject32_pid,
335 subject32_sid, &subject32_tid_addr);
336 if (subject32ex_token == NULL)
337 err(EX_UNAVAILABLE, "au_to_subject32_ex");
338 write_token(directory, buf, subject32ex_token);
343 generate_subject32ex_record(const char *directory, const char *record_filename,
346 token_t *subject32ex_token;
349 buf = (char *)malloc(strlen(record_filename) + 6);
350 if (type == AU_IPv6) {
351 inet_pton(AF_INET6, "fe80::1", subject32_tid_addr.at_addr);
352 subject32_tid_addr.at_type = AU_IPv6;
353 sprintf(buf, "%s%s", record_filename, "-IPv6");
355 subject32_tid_addr.at_addr[0] = inet_addr("127.0.0.1");
356 subject32_tid_addr.at_type = AU_IPv4;
357 sprintf(buf, "%s%s", record_filename, "-IPv4");
360 subject32ex_token = au_to_subject32_ex(subject32_auid, subject32_euid,
361 subject32_egid, subject32_ruid, subject32_rgid, subject32_pid,
362 subject32_sid, &subject32_tid_addr);
363 if (subject32ex_token == NULL)
364 err(EX_UNAVAILABLE, "au_to_subject32_ex");
365 write_record(directory, record_filename, subject32ex_token, AUE_NULL);
369 static au_id_t process32_auid = 0x12345678;
370 static uid_t process32_euid = 0x01234567;
371 static gid_t process32_egid = 0x23456789;
372 static uid_t process32_ruid = 0x98765432;
373 static gid_t process32_rgid = 0x09876543;
374 static pid_t process32_pid = 0x13243546;
375 static au_asid_t process32_sid = 0x97867564;
376 static au_tid_t process32_tid = { 0x16593746 };
377 static au_tid_addr_t process32_tid_addr = { 0x16593746 };
380 generate_process32_token(const char *directory, const char *token_filename)
382 token_t *process32_token;
384 process32_tid.machine = inet_addr("127.0.0.1");
386 process32_token = au_to_process32(process32_auid, process32_euid,
387 process32_egid, process32_ruid, process32_rgid, process32_pid,
388 process32_sid, &process32_tid);
389 if (process32_token == NULL)
390 err(EX_UNAVAILABLE, "au_to_process32");
391 write_token(directory, token_filename, process32_token);
395 generate_process32_record(const char *directory, const char *record_filename)
397 token_t *process32_token;
399 process32_tid.machine = inet_addr("127.0.0.1");
401 process32_token = au_to_process32(process32_auid, process32_euid,
402 process32_egid, process32_ruid, process32_rgid, process32_pid,
403 process32_sid, &process32_tid);
404 if (process32_token == NULL)
405 err(EX_UNAVAILABLE, "au_ti_process32");
406 write_record(directory, record_filename, process32_token, AUE_NULL);
410 generate_process32ex_token(const char *directory, const char *token_filename,
413 token_t *process32ex_token;
416 buf = (char *)malloc(strlen(token_filename) + 6);
417 if (type == AU_IPv6) {
418 inet_pton(AF_INET6, "fe80::1", process32_tid_addr.at_addr);
419 process32_tid_addr.at_type = AU_IPv6;
420 sprintf(buf, "%s%s", token_filename, "-IPv6");
422 process32_tid_addr.at_addr[0] = inet_addr("127.0.0.1");
423 process32_tid_addr.at_type = AU_IPv4;
424 sprintf(buf, "%s%s", token_filename, "-IPv4");
427 process32ex_token = au_to_process32_ex(process32_auid, process32_euid,
428 process32_egid, process32_ruid, process32_rgid, process32_pid,
429 process32_sid, &process32_tid_addr);
430 if (process32ex_token == NULL)
431 err(EX_UNAVAILABLE, "au_to_process32_ex");
432 write_token(directory, buf, process32ex_token);
437 generate_process32ex_record(const char *directory, const char *record_filename,
440 token_t *process32ex_token;
443 buf = (char *)malloc(strlen(record_filename) + 6);
444 if (type == AU_IPv6) {
445 inet_pton(AF_INET6, "fe80::1", process32_tid_addr.at_addr);
446 process32_tid_addr.at_type = AU_IPv6;
447 sprintf(buf, "%s%s", record_filename, "-IPv6");
449 process32_tid_addr.at_addr[0] = inet_addr("127.0.0.1");
450 process32_tid_addr.at_type = AU_IPv4;
451 sprintf(buf, "%s%s", record_filename, "-IPv4");
454 process32ex_token = au_to_process32_ex(process32_auid, process32_euid,
455 process32_egid, process32_ruid, process32_rgid, process32_pid,
456 process32_sid, &process32_tid_addr);
457 if (process32ex_token == NULL)
458 err(EX_UNAVAILABLE, "au_to_process32_ex");
459 write_record(directory, buf, process32ex_token, AUE_NULL);
463 static au_id_t process64_auid = 0x12345678;
464 static uid_t process64_euid = 0x01234567;
465 static gid_t process64_egid = 0x23456789;
466 static uid_t process64_ruid = 0x98765432;
467 static gid_t process64_rgid = 0x09876543;
468 static pid_t process64_pid = 0x13243546;
469 static au_asid_t process64_sid = 0x97867564;
470 static au_tid_t process64_tid = { 0x16593746 };
471 static au_tid_addr_t process64_tid_addr = { 0x16593746 };
474 generate_process64_token(const char *directory, const char *token_filename)
476 token_t *process64_token;
478 process64_tid.machine = inet_addr("127.0.0.1");
480 process64_token = au_to_process64(process64_auid, process64_euid,
481 process64_egid, process64_ruid, process64_rgid, process64_pid,
482 process64_sid, &process64_tid);
483 if (process64_token == NULL)
484 err(EX_UNAVAILABLE, "au_to_process64");
485 write_token(directory, token_filename, process64_token);
489 generate_process64_record(const char *directory, const char *record_filename)
491 token_t *process64_token;
493 process64_tid.machine = inet_addr("127.0.0.1");
495 process64_token = au_to_process64(process64_auid, process64_euid,
496 process64_egid, process64_ruid, process64_rgid, process64_pid,
497 process64_sid, &process64_tid);
498 if (process64_token == NULL)
499 err(EX_UNAVAILABLE, "au_ti_process64");
500 write_record(directory, record_filename, process64_token, AUE_NULL);
504 generate_process64ex_token(const char *directory, const char *token_filename,
507 token_t *process64ex_token;
510 buf = (char *)malloc(strlen(token_filename) + 6);
511 if (type == AU_IPv6) {
512 inet_pton(AF_INET6, "fe80::1", process64_tid_addr.at_addr);
513 process64_tid_addr.at_type = AU_IPv6;
514 sprintf(buf, "%s%s", token_filename, "-IPv6");
516 process64_tid_addr.at_addr[0] = inet_addr("127.0.0.1");
517 process64_tid_addr.at_type = AU_IPv4;
518 sprintf(buf, "%s%s", token_filename, "-IPv4");
521 process64ex_token = au_to_process64_ex(process64_auid, process64_euid,
522 process64_egid, process64_ruid, process64_rgid, process64_pid,
523 process64_sid, &process64_tid_addr);
524 if (process64ex_token == NULL)
525 err(EX_UNAVAILABLE, "au_to_process64_ex");
526 write_token(directory, buf, process64ex_token);
531 generate_process64ex_record(const char *directory, const char *record_filename,
534 token_t *process64ex_token;
537 buf = (char *)malloc(strlen(record_filename) + 6);
538 if (type == AU_IPv6) {
539 inet_pton(AF_INET6, "fe80::1", process64_tid_addr.at_addr);
540 process64_tid_addr.at_type = AU_IPv6;
541 sprintf(buf, "%s%s", record_filename, "-IPv6");
543 process64_tid_addr.at_addr[0] = inet_addr("127.0.0.1");
544 process64_tid_addr.at_type = AU_IPv4;
545 sprintf(buf, "%s%s", record_filename, "-IPv4");
548 process64ex_token = au_to_process64_ex(process64_auid, process64_euid,
549 process64_egid, process64_ruid, process64_rgid, process64_pid,
550 process64_sid, &process64_tid_addr);
551 if (process64ex_token == NULL)
552 err(EX_UNAVAILABLE, "au_to_process64_ex");
553 write_record(directory, buf, process64ex_token, AUE_NULL);
557 static char return32_status = EINVAL;
558 static uint32_t return32_ret = 0x12345678;
561 generate_return32_token(const char *directory, const char *token_filename)
563 token_t *return32_token;
565 return32_token = au_to_return32(au_errno_to_bsm(return32_status),
567 if (return32_token == NULL)
568 err(EX_UNAVAILABLE, "au_to_return32");
569 write_token(directory, token_filename, return32_token);
573 generate_return32_record(const char *directory, const char *record_filename)
575 token_t *return32_token;
577 return32_token = au_to_return32(au_errno_to_bsm(return32_status),
579 if (return32_token == NULL)
580 err(EX_UNAVAILABLE, "au_to_return32");
581 write_record(directory, record_filename, return32_token, AUE_NULL);
584 static char *text_token_text = "This is a test.";
587 generate_text_token(const char *directory, const char *token_filename)
591 text_token = au_to_text(text_token_text);
592 if (text_token == NULL)
593 err(EX_UNAVAILABLE, "au_to_text");
594 write_token(directory, token_filename, text_token);
598 generate_text_record(const char *directory, const char *record_filename)
602 text_token = au_to_text(text_token_text);
603 if (text_token == NULL)
604 err(EX_UNAVAILABLE, "au_to_text");
605 write_record(directory, record_filename, text_token, AUE_NULL);
608 static char opaque_token_data[] = {0xaa, 0xbb, 0xcc, 0xdd};
609 static int opaque_token_bytes = sizeof(opaque_token_data);
612 generate_opaque_token(const char *directory, const char *token_filename)
614 token_t *opaque_token;
616 opaque_token = au_to_opaque(opaque_token_data, opaque_token_bytes);
617 if (opaque_token == NULL)
618 err(EX_UNAVAILABLE, "au_to_opaque");
619 write_token(directory, token_filename, opaque_token);
623 generate_opaque_record(const char *directory, const char *record_filename)
625 token_t *opaque_token;
627 opaque_token = au_to_opaque(opaque_token_data, opaque_token_bytes);
628 if (opaque_token == NULL)
629 err(EX_UNAVAILABLE, "au_to_opaque");
630 write_record(directory, record_filename, opaque_token, AUE_NULL);
633 static struct in_addr in_addr_token_addr;
636 generate_in_addr_token(const char *directory, const char *token_filename)
638 token_t *in_addr_token;
640 in_addr_token_addr.s_addr = inet_addr("192.168.100.15");
642 in_addr_token = au_to_in_addr(&in_addr_token_addr);
643 if (in_addr_token == NULL)
644 err(EX_UNAVAILABLE, "au_to_in_addr");
645 write_token(directory, token_filename, in_addr_token);
649 generate_in_addr_record(const char *directory, const char *record_filename)
651 token_t *in_addr_token;
653 in_addr_token_addr.s_addr = inet_addr("192.168.100.15");
655 in_addr_token = au_to_in_addr(&in_addr_token_addr);
656 if (in_addr_token == NULL)
657 err(EX_UNAVAILABLE, "au_to_in_addr");
658 write_record(directory, record_filename, in_addr_token, AUE_NULL);
661 static struct ip ip_token_ip;
662 static u_char ip_token_ip_v = 4;
663 static uint16_t ip_token_ip_id = 0x5478;
664 static u_char ip_token_ip_ttl = 64;
665 static u_char ip_token_ip_p = IPPROTO_ICMP;
666 static struct in_addr ip_token_ip_src;
667 static struct in_addr ip_token_ip_dst;
670 generate_ip_token(const char *directory, const char *token_filename)
674 ip_token_ip_src.s_addr = inet_addr("192.168.100.155");
675 ip_token_ip_dst.s_addr = inet_addr("192.168.110.48");
677 memset(&ip_token_ip, 0, sizeof(ip_token_ip));
678 ip_token_ip.ip_v = ip_token_ip_v;
679 ip_token_ip.ip_len = htons(sizeof(ip_token_ip));
680 ip_token_ip.ip_id = htons(ip_token_ip_id);
681 ip_token_ip.ip_ttl = ip_token_ip_ttl;
682 ip_token_ip.ip_p = ip_token_ip_p;
683 ip_token_ip.ip_src = ip_token_ip_src;
684 ip_token_ip.ip_dst = ip_token_ip_dst;
686 ip_token = au_to_ip(&ip_token_ip);
687 if (ip_token == NULL)
688 err(EX_UNAVAILABLE, "au_to_ip");
689 write_token(directory, token_filename, ip_token);
693 generate_ip_record(const char *directory, const char *record_filename)
697 ip_token_ip_src.s_addr = inet_addr("192.168.100.155");
698 ip_token_ip_dst.s_addr = inet_addr("192.168.110.48");
700 memset(&ip_token_ip, 0, sizeof(ip_token_ip));
701 ip_token_ip.ip_v = ip_token_ip_v;
702 ip_token_ip.ip_len = htons(sizeof(ip_token_ip));
703 ip_token_ip.ip_id = htons(ip_token_ip_id);
704 ip_token_ip.ip_ttl = ip_token_ip_ttl;
705 ip_token_ip.ip_p = ip_token_ip_p;
706 ip_token_ip.ip_src = ip_token_ip_src;
707 ip_token_ip.ip_dst = ip_token_ip_dst;
709 ip_token = au_to_ip(&ip_token_ip);
710 if (ip_token == NULL)
711 err(EX_UNAVAILABLE, "au_to_ip");
712 write_record(directory, record_filename, ip_token, AUE_NULL);
715 static u_int16_t iport_token_iport;
718 generate_iport_token(const char *directory, const char *token_filename)
720 token_t *iport_token;
722 iport_token_iport = htons(80);
724 iport_token = au_to_iport(iport_token_iport);
725 if (iport_token == NULL)
726 err(EX_UNAVAILABLE, "au_to_iport");
727 write_token(directory, token_filename, iport_token);
731 generate_iport_record(const char *directory, const char *record_filename)
733 token_t *iport_token;
735 iport_token_iport = htons(80);
737 iport_token = au_to_iport(iport_token_iport);
738 if (iport_token == NULL)
739 err(EX_UNAVAILABLE, "au_to_iport");
740 write_record(directory, record_filename, iport_token, AUE_NULL);
743 static char arg32_token_n = 3;
744 static char *arg32_token_text = "test_arg32_token";
745 static uint32_t arg32_token_v = 0xabcdef00;
748 generate_arg32_token(const char *directory, const char *token_filename)
750 token_t *arg32_token;
752 arg32_token = au_to_arg32(arg32_token_n, arg32_token_text,
754 if (arg32_token == NULL)
755 err(EX_UNAVAILABLE, "au_to_arg32");
756 write_token(directory, token_filename, arg32_token);
760 generate_arg32_record(const char *directory, const char *record_filename)
762 token_t *arg32_token;
764 arg32_token = au_to_arg32(arg32_token_n, arg32_token_text,
766 if (arg32_token == NULL)
767 err(EX_UNAVAILABLE, "au_to_arg32");
768 write_record(directory, record_filename, arg32_token, AUE_NULL);
771 static long seq_audit_count = 0x12345678;
774 generate_seq_token(const char *directory, const char *token_filename)
778 seq_token = au_to_seq(seq_audit_count);
779 if (seq_token == NULL)
780 err(EX_UNAVAILABLE, "au_to_seq");
781 write_token(directory, token_filename, seq_token);
785 generate_seq_record(const char *directory, const char *record_filename)
789 seq_token = au_to_seq(seq_audit_count);
790 if (seq_token == NULL)
791 err(EX_UNAVAILABLE, "au_to_seq");
792 write_record(directory, record_filename, seq_token, AUE_NULL);
801 generate_attr_token(const char *directory, const char *token_filename)
808 generate_attr_record(const char *directory, const char *record_filename)
815 generate_ipc_perm_token(const char *directory, const char *token_filename)
817 token_t *ipc_perm_token;
822 generate_ipc_perm_record(const char *directory, const char *record_filename)
824 token_t *ipc_perm_token;
835 generate_groups_token(const char *directory, const char *token_filename)
837 token_t *groups_token;
842 generate_groups_record(const char *directory, const char *record_filename)
844 token_t *groups_token;
887 generate_attr32_token(const char *directory, const char *token_filename)
889 token_t *attr32_token;
894 generate_attr32_record(const char *directory, const char *record_filename)
896 token_t *attr32_token;
901 static char *zonename_sample = "testzone";
904 generate_zonename_token(const char *directory, const char *token_filename)
906 token_t *zonename_token;
908 zonename_token = au_to_zonename(zonename_sample);
909 if (zonename_token == NULL)
910 err(EX_UNAVAILABLE, "au_to_zonename");
911 write_token(directory, token_filename, zonename_token);
915 generate_zonename_record(const char *directory, const char *record_filename)
917 token_t *zonename_token;
919 zonename_token = au_to_zonename(zonename_sample);
920 if (zonename_token == NULL)
921 err(EX_UNAVAILABLE, "au_to_zonename");
922 write_record(directory, record_filename, zonename_token, AUE_NULL);
925 static u_short socketex_domain = PF_INET;
926 static u_short socketex_type = SOCK_STREAM;
927 static struct sockaddr_in socketex_laddr, socketex_raddr;
930 generate_socketex_token(const char *directory, const char *token_filename)
932 token_t *socketex_token;
934 bzero(&socketex_laddr, sizeof(socketex_laddr));
935 socketex_laddr.sin_family = AF_INET;
936 socketex_laddr.sin_len = sizeof(socketex_laddr);
937 socketex_laddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
939 bzero(&socketex_raddr, sizeof(socketex_raddr));
940 socketex_raddr.sin_family = AF_INET;
941 socketex_raddr.sin_len = sizeof(socketex_raddr);
942 socketex_raddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
944 socketex_token = au_to_socket_ex(au_domain_to_bsm(socketex_domain),
945 au_socket_type_to_bsm(socketex_type),
946 (struct sockaddr *)&socketex_laddr,
947 (struct sockaddr *)&socketex_raddr);
948 if (socketex_token == NULL)
949 err(EX_UNAVAILABLE, "au_to_socket_ex");
950 write_token(directory, token_filename, socketex_token);
954 generate_socketex_record(const char *directory, const char *record_filename)
956 token_t *socketex_token;
958 bzero(&socketex_laddr, sizeof(socketex_laddr));
959 socketex_laddr.sin_family = AF_INET;
960 socketex_laddr.sin_len = sizeof(socketex_laddr);
961 socketex_laddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
963 bzero(&socketex_raddr, sizeof(socketex_raddr));
964 socketex_raddr.sin_family = AF_INET;
965 socketex_raddr.sin_len = sizeof(socketex_raddr);
966 socketex_raddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
968 socketex_token = au_to_socket_ex(au_domain_to_bsm(socketex_domain),
969 au_socket_type_to_bsm(socketex_type),
970 (struct sockaddr *)&socketex_laddr,
971 (struct sockaddr *)&socketex_raddr);
972 if (socketex_token == NULL)
973 err(EX_UNAVAILABLE, "au_to_socket_ex");
974 write_record(directory, record_filename, socketex_token, AUE_NULL);
978 * Generate a series of error-number specific return tokens in records.
981 generate_error_record(const char *directory, const char *filename, int error)
983 char pathname[PATH_MAX];
984 token_t *return32_token;
986 return32_token = au_to_return32(au_errno_to_bsm(error), -1);
987 if (return32_token == NULL)
988 err(EX_UNAVAILABLE, "au_to_return32");
989 (void)snprintf(pathname, PATH_MAX, "%s_record", filename);
990 write_record(directory, pathname, return32_token, AUE_NULL);
994 * Not all the error numbers, just a few present on all platforms for now.
998 const char *error_name;
1001 { ENOENT, "ENOENT" },
1007 { ENOEXEC, "ENOEXEC" },
1009 { ECHILD, "ECHILD" },
1010 { EDEADLK, "EDEADLK" },
1011 { ENOMEM, "ENOMEM" },
1012 { EACCES, "EACCES" },
1013 { EFAULT, "EFAULT" },
1014 { ENOTBLK, "ENOTBLK" },
1016 { EEXIST, "EEXIST" },
1018 { ENODEV, "ENODEV" },
1019 { ENOTDIR, "ENOTDIR" },
1020 { EISDIR, "EISDIR" },
1021 { EINVAL, "EINVAL" },
1022 { ENFILE, "ENFILE" },
1023 { EMFILE, "EMFILE" },
1024 { ENOTTY, "ENOTTY" },
1025 { ETXTBSY, "ETXTBSY" },
1027 { ENOSPC, "ENOSPC" },
1028 { ESPIPE, "ESPIPE" },
1030 { EMLINK, "EMLINK" },
1033 const int error_list_count = sizeof(error_list)/sizeof(error_list[0]);
1036 do_error_records(const char *directory)
1040 for (i = 0; i < error_list_count; i++)
1041 generate_error_record(directory, error_list[i].error_name,
1042 error_list[i].error_number);
1046 main(int argc, char *argv[])
1048 const char *directory;
1051 while ((ch = getopt(argc, argv, "rt")) != -1) {
1072 directory = argv[0];
1074 if (mkdir(directory, 0755) < 0 && errno != EEXIST)
1075 err(EX_OSERR, "mkdir: %s", directory);
1078 generate_file_token(directory, "file_token");
1079 generate_trailer_token(directory, "trailer_token");
1080 generate_header32_token(directory, "header32_token");
1081 generate_data_token(directory, "data_token");
1082 generate_ipc_token(directory, "ipc_token");
1083 generate_path_token(directory, "path_token");
1084 generate_subject32_token(directory, "subject32_token");
1085 generate_subject32ex_token(directory, "subject32ex_token",
1087 generate_subject32ex_token(directory, "subject32ex_token",
1089 generate_process32_token(directory, "process32_token");
1090 generate_process32ex_token(directory, "process32ex_token",
1092 generate_process32ex_token(directory, "process32ex_token",
1094 generate_process64_token(directory, "process64_token");
1095 generate_process64ex_token(directory, "process64ex_token",
1097 generate_process64ex_token(directory, "process64ex_token",
1099 generate_return32_token(directory, "return32_token");
1100 generate_text_token(directory, "text_token");
1101 generate_opaque_token(directory, "opaque_token");
1102 generate_in_addr_token(directory, "in_addr_token");
1103 generate_ip_token(directory, "ip_token");
1104 generate_iport_token(directory, "iport_token");
1105 generate_arg32_token(directory, "arg32_token");
1106 generate_seq_token(directory, "seq_token");
1108 generate_attr_token(directory, "attr_token");
1109 generate_ipc_perm_token(directory, "ipc_perm_token");
1110 generate_groups_token(directory, "groups_token");
1111 generate_attr32_token(directory, "attr32_token");
1113 generate_zonename_token(directory, "zonename_token");
1114 generate_socketex_token(directory, "socketex_token");
1118 generate_file_record(directory, "file_record");
1119 generate_data_record(directory, "data_record");
1120 generate_ipc_record(directory, "ipc_record");
1121 generate_path_record(directory, "path_record");
1122 generate_subject32_record(directory, "subject32_record");
1123 generate_subject32ex_record(directory, "subject32ex_record",
1125 generate_subject32ex_record(directory, "subject32ex_record",
1127 generate_process32_record(directory, "process32_record");
1128 generate_process32ex_record(directory, "process32ex_record",
1130 generate_process32ex_record(directory, "process32ex_record",
1132 generate_process64_record(directory, "process64_record");
1133 generate_process64ex_record(directory, "process64ex_record",
1135 generate_process64ex_record(directory, "process64ex_record",
1137 generate_return32_record(directory, "return32_record");
1138 generate_text_record(directory, "text_record");
1139 generate_opaque_record(directory, "opaque_record");
1140 generate_in_addr_record(directory, "in_addr_record");
1141 generate_ip_record(directory, "ip_record");
1142 generate_iport_record(directory, "iport_record");
1143 generate_arg32_record(directory, "arg32_record");
1144 generate_seq_record(directory, "seq_record");
1146 generate_attr_record(directory, "attr_record");
1147 generate_ipc_perm_record(directory, "ipc_perm_record");
1148 generate_groups_record(directory, "groups_record");
1149 generate_attr32_record(directory, "attr32_record");
1151 generate_zonename_record(directory, "zonename_record");
1152 generate_socketex_record(directory, "socketex_record");
1153 do_error_records(directory);