2 * Copyright (c) 2006 "David Kirchner" <dpk@dpk.net>. All rights reserved.
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 #include <sys/cdefs.h>
27 __FBSDID("$FreeBSD$");
29 #define L2CAP_SOCKET_CHECKED
31 #include <sys/types.h>
33 #include <sys/capsicum.h>
34 #include <sys/event.h>
35 #include <sys/extattr.h>
36 #include <sys/linker.h>
38 #include <sys/mount.h>
39 #include <sys/procctl.h>
40 #include <sys/ptrace.h>
41 #include <sys/reboot.h>
42 #include <sys/resource.h>
43 #include <sys/rtprio.h>
46 #include <sys/socket.h>
50 #include <machine/sysarch.h>
51 #include <netinet/in.h>
52 #include <netinet/sctp.h>
53 #include <netinet/tcp.h>
54 #include <netinet/udp.h>
55 #include <netinet/udplite.h>
56 #include <nfsserver/nfs.h>
57 #include <ufs/ufs/quota.h>
59 #include <vm/vm_param.h>
67 #include <sysdecode.h>
69 #include <sys/bitstring.h>
70 #include <netgraph/bluetooth/include/ng_hci.h>
71 #include <netgraph/bluetooth/include/ng_l2cap.h>
72 #include <netgraph/bluetooth/include/ng_btsocket.h>
76 #define X(a) { a, #a },
77 #define XEND { 0, NULL }
79 #define TABLE_START(n) static struct name_table n[] = {
81 #define TABLE_END XEND };
90 sysdecode_atfd(int fd)
99 sysdecode_atflags(FILE *fp, int flag, int *rem)
102 return (print_mask_int(fp, atflags, flag, rem));
105 static struct name_table semctlops[] = {
106 X(GETNCNT) X(GETPID) X(GETVAL) X(GETALL) X(GETZCNT) X(SETVAL) X(SETALL)
107 X(IPC_RMID) X(IPC_SET) X(IPC_STAT) XEND
111 sysdecode_semctl_cmd(int cmd)
114 return (lookup_value(semctlops, cmd));
117 static struct name_table shmctlops[] = {
118 X(IPC_RMID) X(IPC_SET) X(IPC_STAT) XEND
122 sysdecode_shmctl_cmd(int cmd)
125 return (lookup_value(shmctlops, cmd));
129 sysdecode_msgctl_cmd(int cmd)
132 return (sysdecode_shmctl_cmd(cmd));
135 static struct name_table semgetflags[] = {
136 X(IPC_CREAT) X(IPC_EXCL) X(SEM_R) X(SEM_A) X((SEM_R>>3)) X((SEM_A>>3))
137 X((SEM_R>>6)) X((SEM_A>>6)) XEND
141 sysdecode_semget_flags(FILE *fp, int flag, int *rem)
144 return (print_mask_int(fp, semgetflags, flag, rem));
147 static struct name_table idtypes[] = {
148 X(P_PID) X(P_PPID) X(P_PGID) X(P_SID) X(P_CID) X(P_UID) X(P_GID)
149 X(P_ALL) X(P_LWPID) X(P_TASKID) X(P_PROJID) X(P_POOLID) X(P_JAILID)
150 X(P_CTID) X(P_CPUID) X(P_PSETID) XEND
153 /* XXX: idtype is really an idtype_t */
155 sysdecode_idtype(int idtype)
158 return (lookup_value(idtypes, idtype));
162 * [g|s]etsockopt's level argument can either be SOL_SOCKET or a
163 * protocol-specific value.
166 sysdecode_sockopt_level(int level)
170 if (level == SOL_SOCKET)
171 return ("SOL_SOCKET");
173 /* SOL_* constants for Bluetooth sockets. */
174 str = lookup_value(ngbtsolevel, level);
179 * IP and Infiniband sockets use IP protocols as levels. Not all
180 * protocols are valid but it is simpler to just allow all of them.
182 * XXX: IPPROTO_IP == 0, but UNIX domain sockets use a level of 0
183 * for private options.
185 str = sysdecode_ipproto(level);
193 sysdecode_vmprot(FILE *fp, int type, int *rem)
196 return (print_mask_int(fp, vmprot, type, rem));
199 static struct name_table sockflags[] = {
200 X(SOCK_CLOEXEC) X(SOCK_NONBLOCK) XEND
204 sysdecode_socket_type(FILE *fp, int type, int *rem)
210 str = lookup_value(socktype, type & ~(SOCK_CLOEXEC | SOCK_NONBLOCK));
216 *rem = type & ~(SOCK_CLOEXEC | SOCK_NONBLOCK);
219 val = type & (SOCK_CLOEXEC | SOCK_NONBLOCK);
220 print_mask_part(fp, sockflags, &val, &printed);
225 sysdecode_access_mode(FILE *fp, int mode, int *rem)
228 return (print_mask_int(fp, accessmode, mode, rem));
231 /* XXX: 'type' is really an acl_type_t. */
233 sysdecode_acltype(int type)
236 return (lookup_value(acltype, type));
240 sysdecode_cap_fcntlrights(FILE *fp, uint32_t rights, uint32_t *rem)
243 return (print_mask_int(fp, capfcntl, rights, rem));
247 sysdecode_close_range_flags(FILE *fp, int flags, int *rem)
250 return (print_mask_int(fp, closerangeflags, flags, rem));
254 sysdecode_extattrnamespace(int namespace)
257 return (lookup_value(extattrns, namespace));
261 sysdecode_fadvice(int advice)
264 return (lookup_value(fadvisebehav, advice));
268 sysdecode_open_flags(FILE *fp, int flags, int *rem)
274 mode = flags & O_ACCMODE;
278 if (flags & O_EXEC) {
282 fputs("O_RDONLY", fp);
287 fputs("O_WRONLY", fp);
299 val = (unsigned)flags;
300 print_mask_part(fp, openflags, &val, &printed);
307 sysdecode_fcntl_fileflags(FILE *fp, int flags, int *rem)
313 * The file flags used with F_GETFL/F_SETFL mostly match the
314 * flags passed to open(2). However, a few open-only flag
315 * bits have been repurposed for fcntl-only flags.
317 oflags = flags & ~(O_NOFOLLOW | FRDAHEAD);
318 printed = sysdecode_open_flags(fp, oflags, rem);
319 if (flags & O_NOFOLLOW) {
320 fprintf(fp, "%sFPOIXSHM", printed ? "|" : "");
323 if (flags & FRDAHEAD) {
324 fprintf(fp, "%sFRDAHEAD", printed ? "|" : "");
331 sysdecode_flock_operation(FILE *fp, int operation, int *rem)
334 return (print_mask_int(fp, flockops, operation, rem));
337 static struct name_table getfsstatmode[] = {
338 X(MNT_WAIT) X(MNT_NOWAIT) XEND
342 sysdecode_getfsstat_mode(int mode)
345 return (lookup_value(getfsstatmode, mode));
349 sysdecode_getrusage_who(int who)
352 return (lookup_value(rusage, who));
355 static struct name_table kevent_user_ffctrl[] = {
356 X(NOTE_FFNOP) X(NOTE_FFAND) X(NOTE_FFOR) X(NOTE_FFCOPY)
360 static struct name_table kevent_rdwr_fflags[] = {
361 X(NOTE_LOWAT) X(NOTE_FILE_POLL) XEND
364 static struct name_table kevent_vnode_fflags[] = {
365 X(NOTE_DELETE) X(NOTE_WRITE) X(NOTE_EXTEND) X(NOTE_ATTRIB)
366 X(NOTE_LINK) X(NOTE_RENAME) X(NOTE_REVOKE) X(NOTE_OPEN) X(NOTE_CLOSE)
367 X(NOTE_CLOSE_WRITE) X(NOTE_READ) XEND
370 static struct name_table kevent_proc_fflags[] = {
371 X(NOTE_EXIT) X(NOTE_FORK) X(NOTE_EXEC) X(NOTE_TRACK) X(NOTE_TRACKERR)
375 static struct name_table kevent_timer_fflags[] = {
376 X(NOTE_SECONDS) X(NOTE_MSECONDS) X(NOTE_USECONDS) X(NOTE_NSECONDS)
381 sysdecode_kevent_fflags(FILE *fp, short filter, int fflags, int base)
393 if (!print_mask_int(fp, kevent_rdwr_fflags, fflags, &rem))
394 fprintf(fp, "%#x", rem);
396 fprintf(fp, "|%#x", rem);
399 if (!print_mask_int(fp, kevent_vnode_fflags, fflags, &rem))
400 fprintf(fp, "%#x", rem);
402 fprintf(fp, "|%#x", rem);
405 case EVFILT_PROCDESC:
406 if (!print_mask_int(fp, kevent_proc_fflags, fflags, &rem))
407 fprintf(fp, "%#x", rem);
409 fprintf(fp, "|%#x", rem);
412 if (!print_mask_int(fp, kevent_timer_fflags, fflags, &rem))
413 fprintf(fp, "%#x", rem);
415 fprintf(fp, "|%#x", rem);
418 unsigned int ctrl, data;
420 ctrl = fflags & NOTE_FFCTRLMASK;
421 data = fflags & NOTE_FFLAGSMASK;
423 if (fflags & NOTE_TRIGGER) {
424 fputs("NOTE_TRIGGER", fp);
425 if (fflags == NOTE_TRIGGER)
431 * An event with 'ctrl' == NOTE_FFNOP is either a reported
432 * (output) event for which only 'data' should be output
433 * or a pointless input event. Assume that pointless
434 * input events don't occur in practice. An event with
435 * NOTE_TRIGGER is always an input event.
437 if (ctrl != NOTE_FFNOP || fflags & NOTE_TRIGGER) {
438 fprintf(fp, "%s|%#x",
439 lookup_value(kevent_user_ffctrl, ctrl), data);
441 print_integer(fp, data, base);
446 print_integer(fp, fflags, base);
452 sysdecode_kevent_flags(FILE *fp, int flags, int *rem)
455 return (print_mask_int(fp, keventflags, flags, rem));
459 sysdecode_kevent_filter(int filter)
462 return (lookup_value(keventfilters, filter));
466 sysdecode_kldsym_cmd(int cmd)
469 return (lookup_value(kldsymcmd, cmd));
473 sysdecode_kldunload_flags(int flags)
476 return (lookup_value(kldunloadfflags, flags));
480 sysdecode_lio_listio_mode(int mode)
483 return (lookup_value(lio_listiomodes, mode));
487 sysdecode_madvice(int advice)
490 return (lookup_value(madvisebehav, advice));
494 sysdecode_minherit_inherit(int inherit)
497 return (lookup_value(minheritflags, inherit));
501 sysdecode_mlockall_flags(FILE *fp, int flags, int *rem)
504 return (print_mask_int(fp, mlockallflags, flags, rem));
508 sysdecode_mmap_prot(FILE *fp, int prot, int *rem)
514 protm = PROT_MAX_EXTRACT(prot);
515 prot &= ~PROT_MAX(protm);
517 fputs("PROT_MAX(", fp);
518 printed = print_mask_int(fp, mmapprot, protm, rem);
521 return (print_mask_int(fp, mmapprot, prot, rem) || printed);
525 sysdecode_fileflags(FILE *fp, fflags_t flags, fflags_t *rem)
528 return (print_mask_0(fp, fileflags, flags, rem));
532 sysdecode_filemode(FILE *fp, int mode, int *rem)
535 return (print_mask_0(fp, filemode, mode, rem));
539 sysdecode_mount_flags(FILE *fp, int flags, int *rem)
542 return (print_mask_int(fp, mountflags, flags, rem));
546 sysdecode_msync_flags(FILE *fp, int flags, int *rem)
549 return (print_mask_int(fp, msyncflags, flags, rem));
553 sysdecode_nfssvc_flags(int flags)
556 return (lookup_value(nfssvcflags, flags));
559 static struct name_table pipe2flags[] = {
560 X(O_CLOEXEC) X(O_NONBLOCK) XEND
564 sysdecode_pipe2_flags(FILE *fp, int flags, int *rem)
567 return (print_mask_0(fp, pipe2flags, flags, rem));
571 sysdecode_prio_which(int which)
574 return (lookup_value(prio, which));
578 sysdecode_procctl_cmd(int cmd)
581 return (lookup_value(procctlcmd, cmd));
585 sysdecode_ptrace_request(int request)
588 return (lookup_value(ptraceop, request));
591 static struct name_table quotatypes[] = {
592 X(GRPQUOTA) X(USRQUOTA) XEND
596 sysdecode_quotactl_cmd(FILE *fp, int cmd)
598 const char *primary, *type;
600 primary = lookup_value(quotactlcmds, cmd >> SUBCMDSHIFT);
603 fprintf(fp, "QCMD(%s,", primary);
604 type = lookup_value(quotatypes, cmd & SUBCMDMASK);
606 fprintf(fp, "%s", type);
608 fprintf(fp, "%#x", cmd & SUBCMDMASK);
614 sysdecode_reboot_howto(FILE *fp, int howto, int *rem)
619 * RB_AUTOBOOT is special in that its value is zero, but it is
620 * also an implied argument if a different operation is not
621 * requested via RB_HALT, RB_POWERCYCLE, RB_POWEROFF, or
624 if (howto != 0 && (howto & (RB_HALT | RB_POWEROFF | RB_REROOT |
625 RB_POWERCYCLE)) == 0) {
626 fputs("RB_AUTOBOOT|", fp);
630 return (print_mask_int(fp, rebootopt, howto, rem) || printed);
634 sysdecode_rfork_flags(FILE *fp, int flags, int *rem)
637 return (print_mask_int(fp, rforkflags, flags, rem));
641 sysdecode_rlimit(int resource)
644 return (lookup_value(rlimit, resource));
648 sysdecode_scheduler_policy(int policy)
651 return (lookup_value(schedpolicy, policy));
655 sysdecode_sendfile_flags(FILE *fp, int flags, int *rem)
658 return (print_mask_int(fp, sendfileflags, flags, rem));
662 sysdecode_shmat_flags(FILE *fp, int flags, int *rem)
665 return (print_mask_int(fp, shmatflags, flags, rem));
669 sysdecode_shutdown_how(int how)
672 return (lookup_value(shutdownhow, how));
676 sysdecode_sigbus_code(int si_code)
679 return (lookup_value(sigbuscode, si_code));
683 sysdecode_sigchld_code(int si_code)
686 return (lookup_value(sigchldcode, si_code));
690 sysdecode_sigfpe_code(int si_code)
693 return (lookup_value(sigfpecode, si_code));
697 sysdecode_sigill_code(int si_code)
700 return (lookup_value(sigillcode, si_code));
704 sysdecode_sigsegv_code(int si_code)
707 return (lookup_value(sigsegvcode, si_code));
711 sysdecode_sigtrap_code(int si_code)
714 return (lookup_value(sigtrapcode, si_code));
718 sysdecode_sigprocmask_how(int how)
721 return (lookup_value(sigprocmaskhow, how));
725 sysdecode_socketdomain(int domain)
728 return (lookup_value(sockdomain, domain));
732 sysdecode_socket_protocol(int domain, int protocol)
738 return (lookup_value(sockipproto, protocol));
745 sysdecode_sockaddr_family(int sa_family)
748 return (lookup_value(sockfamily, sa_family));
752 sysdecode_ipproto(int protocol)
755 return (lookup_value(sockipproto, protocol));
759 sysdecode_sockopt_name(int level, int optname)
762 if (level == SOL_SOCKET)
763 return (lookup_value(sockopt, optname));
764 if (level == IPPROTO_IP)
765 /* XXX: UNIX domain socket options use a level of 0 also. */
766 return (lookup_value(sockoptip, optname));
767 if (level == IPPROTO_IPV6)
768 return (lookup_value(sockoptipv6, optname));
769 if (level == IPPROTO_SCTP)
770 return (lookup_value(sockoptsctp, optname));
771 if (level == IPPROTO_TCP)
772 return (lookup_value(sockopttcp, optname));
773 if (level == IPPROTO_UDP)
774 return (lookup_value(sockoptudp, optname));
775 if (level == IPPROTO_UDPLITE)
776 return (lookup_value(sockoptudplite, optname));
781 sysdecode_thr_create_flags(FILE *fp, int flags, int *rem)
784 return (print_mask_int(fp, thrcreateflags, flags, rem));
788 sysdecode_umtx_op(int op)
791 return (lookup_value(umtxop, op));
795 sysdecode_umtx_op_flags(FILE *fp, int op, int *rem)
802 print_mask_part(fp, umtxopflags, &val, &printed);
809 sysdecode_vmresult(int result)
812 return (lookup_value(vmresult, result));
816 sysdecode_wait4_options(FILE *fp, int options, int *rem)
821 /* A flags value of 0 is normal. */
830 * These flags are implicit and aren't valid flags for wait4()
831 * directly (though they don't fail with EINVAL).
833 opt6 = options & (WEXITED | WTRAPPED);
835 printed = print_mask_int(fp, wait6opt, options, rem);
842 sysdecode_wait6_options(FILE *fp, int options, int *rem)
845 return (print_mask_int(fp, wait6opt, options, rem));
849 sysdecode_whence(int whence)
852 return (lookup_value(seekwhence, whence));
856 sysdecode_fcntl_cmd(int cmd)
859 return (lookup_value(fcntlcmd, cmd));
862 static struct name_table fcntl_fd_arg[] = {
863 X(FD_CLOEXEC) X(0) XEND
867 sysdecode_fcntl_arg_p(int cmd)
881 sysdecode_fcntl_arg(FILE *fp, int cmd, uintptr_t arg, int base)
887 if (!print_value(fp, fcntl_fd_arg, arg))
888 print_integer(fp, arg, base);
891 if (!sysdecode_fcntl_fileflags(fp, arg, &rem))
892 fprintf(fp, "%#x", rem);
894 fprintf(fp, "|%#x", rem);
899 fprintf(fp, "%p", (void *)arg);
902 print_integer(fp, arg, base);
908 sysdecode_mmap_flags(FILE *fp, int flags, int *rem)
915 * MAP_ALIGNED can't be handled directly by print_mask_int().
916 * MAP_32BIT is also problematic since it isn't defined for
920 align = flags & MAP_ALIGNMENT_MASK;
921 val = (unsigned)flags & ~MAP_ALIGNMENT_MASK;
922 print_mask_part(fp, mmapflags, &val, &printed);
924 if (val & MAP_32BIT) {
925 fprintf(fp, "%sMAP_32BIT", printed ? "|" : "");
933 if (align == MAP_ALIGNED_SUPER)
934 fputs("MAP_ALIGNED_SUPER", fp);
936 fprintf(fp, "MAP_ALIGNED(%d)",
937 align >> MAP_ALIGNMENT_SHIFT);
946 sysdecode_pathconf_name(int name)
949 return (lookup_value(pathconfname, name));
953 sysdecode_rtprio_function(int function)
956 return (lookup_value(rtpriofuncs, function));
960 sysdecode_msg_flags(FILE *fp, int flags, int *rem)
963 return (print_mask_0(fp, msgflags, flags, rem));
967 sysdecode_sigcode(int sig, int si_code)
971 str = lookup_value(sigcode, si_code);
977 return (sysdecode_sigill_code(si_code));
979 return (sysdecode_sigbus_code(si_code));
981 return (sysdecode_sigsegv_code(si_code));
983 return (sysdecode_sigfpe_code(si_code));
985 return (sysdecode_sigtrap_code(si_code));
987 return (sysdecode_sigchld_code(si_code));
994 sysdecode_sysarch_number(int number)
997 return (lookup_value(sysarchnum, number));
1001 sysdecode_umtx_cvwait_flags(FILE *fp, u_long flags, u_long *rem)
1004 return (print_mask_0ul(fp, umtxcvwaitflags, flags, rem));
1008 sysdecode_umtx_rwlock_flags(FILE *fp, u_long flags, u_long *rem)
1011 return (print_mask_0ul(fp, umtxrwlockflags, flags, rem));
1015 sysdecode_cap_rights(FILE *fp, cap_rights_t *rightsp)
1017 cap_rights_t diff, sum, zero;
1018 const struct name_table *t;
1022 for (i = 0; i < CAPARSIZE(rightsp); i++) {
1023 if (CAPIDXBIT(rightsp->cr_rights[i]) != 1 << i) {
1024 fprintf(fp, "invalid cap_rights_t");
1028 cap_rights_init(&sum);
1030 for (t = caprights, comma = false; t->str != NULL; t++) {
1031 if (cap_rights_is_set(rightsp, t->val)) {
1032 cap_rights_clear(&diff, t->val);
1033 if (cap_rights_is_set(&sum, t->val)) {
1034 /* Don't print redundant rights. */
1037 cap_rights_set(&sum, t->val);
1039 fprintf(fp, "%s%s", comma ? "," : "", t->str);
1044 fprintf(fp, "CAP_NONE");
1047 * Provide a breadcrumb if some of the provided rights are not included
1048 * in the table, likely due to a bug in the mktables script.
1051 if (!cap_rights_contains(&zero, &diff))
1052 fprintf(fp, ",unknown rights");
1056 * Pre-sort the set of rights, which has a partial ordering defined by the
1057 * subset relation. This lets sysdecode_cap_rights() print a list of minimal
1058 * length with a single pass over the "caprights" table.
1060 static void __attribute__((constructor))
1061 sysdecode_cap_rights_init(void)
1063 cap_rights_t tr, qr;
1064 struct name_table *t, *q, tmp;
1068 for (t = caprights, swapped = false; t->str != NULL; t++) {
1069 cap_rights_init(&tr, t->val);
1070 for (q = t + 1; q->str != NULL; q++) {
1071 cap_rights_init(&qr, q->val);
1072 if (cap_rights_contains(&qr, &tr)) {
1083 static struct name_table cmsgtypeip[] = {
1084 X(IP_RECVDSTADDR) X(IP_RECVTTL) X(IP_RECVOPTS) X(IP_RECVRETOPTS)
1085 X(IP_RECVIF) X(IP_RECVTOS) X(IP_FLOWID) X(IP_FLOWTYPE)
1086 X(IP_RSSBUCKETID) XEND
1089 static struct name_table cmsgtypeipv6[] = {
1091 /* The RFC 2292 defines are kernel space only. */
1092 X(IPV6_2292PKTINFO) X(IPV6_2292HOPLIMIT) X(IPV6_2292HOPOPTS)
1093 X(IPV6_2292DSTOPTS) X(IPV6_2292RTHDR) X(IPV6_2292NEXTHOP)
1095 X(IPV6_PKTINFO) X(IPV6_HOPLIMIT) X(IPV6_HOPOPTS)
1096 X(IPV6_DSTOPTS) X(IPV6_RTHDR) X(IPV6_NEXTHOP)
1097 X(IPV6_TCLASS) X(IPV6_FLOWID) X(IPV6_FLOWTYPE) X(IPV6_RSSBUCKETID)
1098 X(IPV6_PATHMTU) X(IPV6_RTHDRDSTOPTS) X(IPV6_USE_MIN_MTU)
1099 X(IPV6_DONTFRAG) X(IPV6_PREFER_TEMPADDR) XEND
1102 static struct name_table cmsgtypesctp[] = {
1103 X(SCTP_INIT) X(SCTP_SNDRCV) X(SCTP_EXTRCV) X(SCTP_SNDINFO)
1104 X(SCTP_RCVINFO) X(SCTP_NXTINFO) X(SCTP_PRINFO) X(SCTP_AUTHINFO)
1105 X(SCTP_DSTADDRV4) X(SCTP_DSTADDRV6) XEND
1109 sysdecode_cmsg_type(int cmsg_level, int cmsg_type)
1112 if (cmsg_level == SOL_SOCKET)
1113 return (lookup_value(cmsgtypesocket, cmsg_type));
1114 if (cmsg_level == IPPROTO_IP)
1115 return (lookup_value(cmsgtypeip, cmsg_type));
1116 if (cmsg_level == IPPROTO_IPV6)
1117 return (lookup_value(cmsgtypeipv6, cmsg_type));
1118 if (cmsg_level == IPPROTO_SCTP)
1119 return (lookup_value(cmsgtypesctp, cmsg_type));
1124 sysdecode_sctp_pr_policy(int policy)
1127 return (lookup_value(sctpprpolicy, policy));
1130 static struct name_table sctpsndflags[] = {
1131 X(SCTP_EOF) X(SCTP_ABORT) X(SCTP_UNORDERED) X(SCTP_ADDR_OVER)
1132 X(SCTP_SENDALL) X(SCTP_EOR) X(SCTP_SACK_IMMEDIATELY) XEND
1136 sysdecode_sctp_snd_flags(FILE *fp, int flags, int *rem)
1139 return (print_mask_int(fp, sctpsndflags, flags, rem));
1142 static struct name_table sctprcvflags[] = {
1143 X(SCTP_UNORDERED) XEND
1147 sysdecode_sctp_rcv_flags(FILE *fp, int flags, int *rem)
1150 return (print_mask_int(fp, sctprcvflags, flags, rem));
1153 static struct name_table sctpnxtflags[] = {
1154 X(SCTP_UNORDERED) X(SCTP_COMPLETE) X(SCTP_NOTIFICATION) XEND
1158 sysdecode_sctp_nxt_flags(FILE *fp, int flags, int *rem)
1161 return (print_mask_int(fp, sctpnxtflags, flags, rem));
1164 static struct name_table sctpsinfoflags[] = {
1165 X(SCTP_EOF) X(SCTP_ABORT) X(SCTP_UNORDERED) X(SCTP_ADDR_OVER)
1166 X(SCTP_SENDALL) X(SCTP_EOR) X(SCTP_SACK_IMMEDIATELY) XEND
1170 sysdecode_sctp_sinfo_flags(FILE *fp, int sinfo_flags)
1176 printed = print_mask_0(fp, sctpsinfoflags, sinfo_flags, &rem);
1177 if (rem & ~SCTP_PR_SCTP_ALL) {
1178 fprintf(fp, "%s%#x", printed ? "|" : "", rem & ~SCTP_PR_SCTP_ALL);
1180 rem &= ~SCTP_PR_SCTP_ALL;
1183 temp = sysdecode_sctp_pr_policy(rem);
1185 fprintf(fp, "%s%s", printed ? "|" : "", temp);
1187 fprintf(fp, "%s%#x", printed ? "|" : "", rem);
1193 sysdecode_shmflags(FILE *fp, int flags, int *rem)
1196 return (print_mask_0(fp, shmflags, flags, rem));
1200 sysdecode_itimer(int which)
1203 return (lookup_value(itimerwhich, which));