path: root/sys/socket.txt

# Copyright 2015 syzkaller project authors. All rights reserved.
# Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file.

include <linux/net_tstamp.h>
include <linux/isdn/capilli.h>
include <linux/crypto.h>
include <net/bluetooth/bluetooth.h>
include <net/bluetooth/hci_sock.h>
include <net/bluetooth/l2cap.h>
include <net/bluetooth/cmtp/cmtp.h>
include <net/bluetooth/bnep/bnep.h>
include <net/bluetooth/hidp/hidp.h>
include <net/bluetooth/sco.h>
include <net/bluetooth/rfcomm.h>

socket(domain flags[socket_domain], type flags[socket_type], proto int8) fd[sock]
socketpair(domain flags[socket_domain], type flags[socket_type], proto int8, fds ptr[out, pipefd])
accept(fd fd[sock], peer ptr[out, sockaddr, opt], peerlen ptr[inout, len[peer, int32]]) fd[sock]
accept4(fd fd[sock], peer ptr[out, sockaddr, opt], peerlen ptr[inout, len[peer, int32]], flags flags[accept_flags]) fd[sock]
# TODO: must not bind to port 0, that will result in a random port which is not reproducible
bind(fd fd[sock], addr ptr[in, sockaddr], addrlen len[addr])
listen(fd fd[sock], backlog int32)
connect(fd fd[sock], addr ptr[in, sockaddr], addrlen len[addr])
shutdown(fd fd[sock], how flags[shutdown_flags])
sendto(fd fd[sock], buf buffer[in], len len[buf], f flags[send_flags], addr ptr[in, sockaddr, opt], addrlen len[addr])
sendmsg(fd fd[sock], msg ptr[in, send_msghdr], f flags[send_flags])
sendmmsg(fd fd[sock], mmsg ptr[in, array[send_msghdr]], vlen len[mmsg], f flags[send_flags])
recvfrom(fd fd[sock], buf buffer[out], len len[buf], f flags[recv_flags], addr ptr[in, sockaddr, opt], addrlen len[addr])
recvmsg(fd fd[sock], msg ptr[in, recv_msghdr], f flags[recv_flags])
recvmmsg(fd fd[sock], mmsg ptr[in, array[recv_msghdr]], vlen len[mmsg], f flags[recv_flags])
getsockname(fd fd[sock], addr ptr[out, sockaddr], addrlen ptr[inout, len[addr, int32]])
getpeername(fd fd[sock], peer ptr[out, sockaddr], peerlen ptr[inout, len[peer, int32]])
getsockopt(fd fd[sock], level int32, optname int32, optval buffer[out], optlen ptr[inout, len[optval, int32]])
setsockopt(fd fd[sock], level int32, optname int32, optval buffer[in], optlen len[optval])
ioctl$SIOCOUTQ(fd fd[sock], cmd const[SIOCOUTQ], arg ptr[out, int32])
ioctl$SIOCINQ(fd fd[sock], cmd const[SIOCINQ], arg ptr[out, int32])

# SOL_SOCKET
setsockopt$sock_void(fd fd[sock], level const[SOL_SOCKET], optname flags[sockopt_opt_sock_void], optval const[0], optlen const[0])
getsockopt$sock_int(fd fd[sock], level const[SOL_SOCKET], optname flags[sockopt_opt_sock_int], optval ptr[out, int32], optlen ptr[inout, len[optval, int32]])
setsockopt$sock_int(fd fd[sock], level const[SOL_SOCKET], optname flags[sockopt_opt_sock_int], optval ptr[in, int32], optlen len[optval])
setsockopt$sock_str(fd fd[sock], level const[SOL_SOCKET], optname const[SO_BINDTODEVICE], optval string, optlen len[optval])
getsockopt$sock_linger(fd fd[sock], level const[SOL_SOCKET], optname const[SO_LINGER], optval ptr[out, linger], optlen ptr[inout, len[optval, int32]])
setsockopt$sock_linger(fd fd[sock], level const[SOL_SOCKET], optname const[SO_LINGER], optval ptr[in, linger], optlen len[optval])
getsockopt$sock_cred(fd fd[sock], level const[SOL_SOCKET], optname const[SO_PEERCRED], optval ptr[out, ucred], optlen ptr[inout, len[optval, int32]])
setsockopt$sock_cred(fd fd[sock], level const[SOL_SOCKET], optname const[SO_PEERCRED], optval ptr[in, ucred], optlen len[optval])
getsockopt$sock_timeval(fd fd[sock], level const[SOL_SOCKET], optname flags[sockopt_opt_sock_timeval], optval ptr[out, timeval], optlen ptr[inout, len[optval, int32]])
setsockopt$sock_timeval(fd fd[sock], level const[SOL_SOCKET], optname flags[sockopt_opt_sock_timeval], optval ptr[in, timeval], optlen len[optval])
setsockopt$sock_attach_bpf(fd fd[sock], level const[SOL_SOCKET], optname const[SO_ATTACH_BPF], optval ptr[in, fd[bpf_prog]], optlen len[optval])
setsockopt$SO_TIMESTAMPING(fd fd[sock], level const[SOL_SOCKET], optname const[SO_TIMESTAMPING], optval ptr[in, flags[sockopt_so_timestamping, int32]], optlen len[optval])
getsockopt$SO_TIMESTAMPING(fd fd[sock], level const[SOL_SOCKET], optname const[SO_TIMESTAMPING], optval ptr[out, int32], optlen ptr[inout, len[optval, int32]])
setsockopt$SO_ATTACH_FILTER(fd fd[sock], level const[SOL_SOCKET], optname const[SO_ATTACH_FILTER], optval ptr[in, sock_fprog], optlen len[optval])
getsockopt$sock_buf(fd fd[sock], level const[SOL_SOCKET], optname flags[sockopt_opt_sock_buf], optval buffer[out], optlen ptr[inout, len[optval, int32]])

# IPPROTO_TCP
getsockopt$tcp_int(fd fd[sock], level const[IPPROTO_TCP], optname flags[sockopt_opt_tcp_int], optval ptr[out, int32], optlen ptr[inout, len[optval, int32]])
setsockopt$tcp_int(fd fd[sock], level const[IPPROTO_TCP], optname flags[sockopt_opt_tcp_int], optval ptr[in, int32], optlen len[optval])
getsockopt$tcp_buf(fd fd[sock], level const[IPPROTO_TCP], optname const[TCP_INFO], optval buffer[out], optlen ptr[inout, len[optval, int32]])
setsockopt$tcp_buf(fd fd[sock], level const[IPPROTO_TCP], optname const[TCP_INFO], optval buffer[in], optlen len[optval])
getsockopt$udp_int(fd fd[sock], level const[IPPROTO_UDP], optname const[UDP_CORK], optval ptr[out, int32], optlen ptr[inout, len[optval, int32]])
setsockopt$udp_int(fd fd[sock], level const[IPPROTO_UDP], optname const[UDP_CORK], optval ptr[in, int32], optlen len[optval])
getsockopt$ip_int(fd fd[sock], level const[IPPROTO_IP], optname flags[sockopt_opt_ip_int], optval ptr[out, int32], optlen ptr[inout, len[optval, int32]])
setsockopt$ip_int(fd fd[sock], level const[IPPROTO_IP], optname flags[sockopt_opt_ip_int], optval ptr[in, int32], optlen len[optval])
getsockopt$ip_buf(fd fd[sock], level const[IPPROTO_IP], optname flags[sockopt_opt_ip_buf], optval buffer[out], optlen ptr[inout, len[optval, int32]])
getsockopt$ip_mreq(fd fd[sock], level const[IPPROTO_IP], optname flags[sockopt_opt_ip_mreq], optval ptr[out, ip_mreq], optlen ptr[inout, len[optval, int32]])
setsockopt$ip_mreq(fd fd[sock], level const[IPPROTO_IP], optname flags[sockopt_opt_ip_mreq], optval ptr[in, ip_mreq], optlen len[optval])
getsockopt$ip_mreqn(fd fd[sock], level const[IPPROTO_IP], optname flags[sockopt_opt_ip_mreq], optval ptr[out, ip_mreqn], optlen ptr[inout, len[optval, int32]])
setsockopt$ip_mreqn(fd fd[sock], level const[IPPROTO_IP], optname flags[sockopt_opt_ip_mreq], optval ptr[in, ip_mreqn], optlen len[optval])
getsockopt$ip_mreqsrc(fd fd[sock], level const[IPPROTO_IP], optname flags[sockopt_opt_ip_mreqsrc], optval ptr[out, ip_mreq_source], optlen ptr[inout, len[optval, int32]])
setsockopt$ip_mreqsrc(fd fd[sock], level const[IPPROTO_IP], optname flags[sockopt_opt_ip_mreqsrc], optval ptr[in, ip_mreq_source], optlen len[optval])
setsockopt$ip_msfilter(fd fd[sock], level const[IPPROTO_IP], optname const[IP_MSFILTER], optval ptr[in, ip_msfilter], optlen len[optval])
getsockopt$ip_mtu(fd fd[sock], level const[IPPROTO_IP], optname const[IP_MTU_DISCOVER], optval ptr[out, flags[ip_mtu_discover, int32]], optlen ptr[inout, len[optval, int32]])
setsockopt$ip_mtu(fd fd[sock], level const[IPPROTO_IP], optname const[IP_MTU_DISCOVER], optval ptr[in, flags[ip_mtu_discover, int32]], optlen len[optval])
getsockopt$ip_opts(fd fd[sock], level const[IPPROTO_IP], optname flags[sockopt_opt_ip_opts], optval buffer[out], optlen ptr[inout, len[optval, int32]])
setsockopt$ip_opts(fd fd[sock], level const[IPPROTO_IP], optname flags[sockopt_opt_ip_opts], optval buffer[in], optlen len[optval])
getsockopt$ip_pktinfo(fd fd[sock], level const[IPPROTO_IP], optname const[IP_PKTINFO], optval ptr[out, in_pktinfo], optlen ptr[inout, len[optval, int32]])
setsockopt$ip_pktinfo(fd fd[sock], level const[IPPROTO_IP], optname const[IP_PKTINFO], optval ptr[in, in_pktinfo], optlen len[optval])
getsockopt$ip_ipsec(fd fd[sock], level const[IPPROTO_IP], optname const[IP_IPSEC_POLICY], optval ptr[out, xfrm_filer], optlen ptr[inout, len[optval, int32]])
setsockopt$ip_ipsec(fd fd[sock], level const[IPPROTO_IP], optname const[IP_IPSEC_POLICY], optval ptr[in, xfrm_filer], optlen len[optval])

# IPPROTO_IPV6
getsockopt$ipv6_int(fd fd[sock], level const[IPPROTO_IPV6], optname flags[sockopt_opt_ipv6_int], optval ptr[out, int32], optlen ptr[inout, len[optval, int32]])
setsockopt$ipv6_int(fd fd[sock], level const[IPPROTO_IPV6], optname flags[sockopt_opt_ipv6_int], optval ptr[in, int32], optlen len[optval])
getsockopt$ipv6_mreq(fd fd[sock], level const[IPPROTO_IPV6], optname flags[sockopt_opt_ipv6_mreq], optval ptr[out, ipv6_mreq], optlen ptr[inout, len[optval, int32]])
setsockopt$ipv6_mreq(fd fd[sock], level const[IPPROTO_IPV6], optname flags[sockopt_opt_ipv6_mreq], optval ptr[in, ipv6_mreq], optlen len[optval])
getsockopt$ipv6_mtu(fd fd[sock], level const[IPPROTO_IPV6], optname const[IPV6_MTU_DISCOVER], optval ptr[out, flags[ip_mtu_discover, int32]], optlen ptr[inout, len[optval, int32]])
setsockopt$ipv6_mtu(fd fd[sock], level const[IPPROTO_IPV6], optname const[IPV6_MTU_DISCOVER], optval ptr[in, flags[ip_mtu_discover, int32]], optlen len[optval])
getsockopt$ipv6_opts(fd fd[sock], level const[IPPROTO_IPV6], optname const[IPV6_2292PKTOPTIONS], optval buffer[out], optlen ptr[inout, len[optval, int32]])
setsockopt$ipv6_opts(fd fd[sock], level const[IPPROTO_IPV6], optname const[IPV6_2292PKTOPTIONS], optval buffer[in], optlen len[optval])

socket_domain = AF_UNIX, AF_INET, AF_INET6, AF_IPX, AF_NETLINK, AF_X25, AF_AX25, AF_ATMPVC, AF_APPLETALK, AF_PACKET
socket_type = SOCK_STREAM, SOCK_DGRAM, SOCK_SEQPACKET, SOCK_RAW, SOCK_RDM, SOCK_PACKET, SOCK_NONBLOCK, SOCK_CLOEXEC
accept_flags = SOCK_NONBLOCK, SOCK_CLOEXEC
shutdown_flags  = SHUT_RD, SHUT_WR
send_flags = MSG_CONFIRM, MSG_DONTROUTE, MSG_DONTWAIT, MSG_EOR, MSG_MORE, MSG_NOSIGNAL, MSG_OOB
recv_flags = MSG_CMSG_CLOEXEC, MSG_DONTWAIT, MSG_ERRQUEUE, MSG_OOB, MSG_PEEK, MSG_TRUNC, MSG_WAITALL, MSG_WAITFORONE
sockopt_opt_sock_void = SO_DETACH_FILTER, SO_MARK
sockopt_opt_sock_int = SO_ACCEPTCONN, SO_BROADCAST, SO_DEBUG, SO_DOMAIN, SO_ERROR, SO_DONTROUTE, SO_KEEPALIVE, SO_PEEK_OFF, SO_PRIORITY, SO_PROTOCOL, SO_RCVBUF, SO_RCVBUFFORCE, SO_RCVLOWAT, SO_SNDLOWAT, SO_REUSEADDR, SO_SNDBUF, SO_SNDBUFFORCE, SO_TIMESTAMP, SO_TYPE, SO_REUSEPORT, SO_OOBINLINE, SO_NO_CHECK, SO_PASSCRED, SO_TIMESTAMPNS, SO_LOCK_FILTER, SO_PASSSEC, SO_RXQ_OVFL, SO_WIFI_STATUS, SO_NOFCS, SO_SELECT_ERR_QUEUE, SO_BUSY_POLL, SO_MAX_PACING_RATE
sockopt_opt_sock_timeval = SO_RCVTIMEO, SO_SNDTIMEO
sockopt_opt_sock_buf = SO_BINDTODEVICE, SO_PEERCRED, SO_PEERNAME, SO_PEERSEC, SO_GET_FILTER
sockopt_so_timestamping = SOF_TIMESTAMPING_TX_HARDWARE, SOF_TIMESTAMPING_TX_SOFTWARE, SOF_TIMESTAMPING_RX_HARDWARE, SOF_TIMESTAMPING_RX_SOFTWARE, SOF_TIMESTAMPING_SOFTWARE, SOF_TIMESTAMPING_SYS_HARDWARE, SOF_TIMESTAMPING_RAW_HARDWARE, SOF_TIMESTAMPING_OPT_ID, SOF_TIMESTAMPING_TX_SCHED, SOF_TIMESTAMPING_TX_ACK, SOF_TIMESTAMPING_OPT_CMSG, SOF_TIMESTAMPING_OPT_TSONLY
sockopt_opt_tcp_int = TCP_CORK, TCP_DEFER_ACCEPT, TCP_KEEPCNT, TCP_KEEPIDLE, TCP_KEEPINTVL, TCP_LINGER2, TCP_MAXSEG, TCP_NODELAY, TCP_QUICKACK, TCP_SYNCNT, TCP_WINDOW_CLAMP
sockopt_opt_ip_int = IP_FREEBIND, IP_HDRINCL, IP_MTU, IP_MULTICAST_ALL, IP_MULTICAST_LOOP, IP_MULTICAST_TTL, IP_NODEFRAG, IP_RECVOPTS, IP_RECVORIGDSTADDR, IP_RECVTOS, IP_RECVTTL, IP_RETOPTS, IP_ROUTER_ALERT, IP_TOS, IP_TRANSPARENT, IP_TTL, IP_RECVERR, IP_PASSSEC, IP_MINTTL, IP_CHECKSUM, IP_BIND_ADDRESS_NO_PORT
sockopt_opt_ip_buf = IP_MSFILTER
sockopt_opt_ip_mreq = IP_ADD_MEMBERSHIP, IP_DROP_MEMBERSHIP, IP_MULTICAST_IF
sockopt_opt_ip_mreqsrc = IP_ADD_SOURCE_MEMBERSHIP, IP_BLOCK_SOURCE, IP_DROP_SOURCE_MEMBERSHIP, IP_UNBLOCK_SOURCE
sockopt_opt_ip_opts = IP_OPTIONS, IP_PKTOPTIONS
ip_msfilter_mode = MCAST_INCLUDE, MCAST_EXCLUDE
ip_mtu_discover = IP_PMTUDISC_DONT, IP_PMTUDISC_WANT, IP_PMTUDISC_DO, IP_PMTUDISC_PROBE, IP_PMTUDISC_INTERFACE, IP_PMTUDISC_OMIT
sockopt_opt_ipv6_int = IPV6_ADDRFORM, IPV6_MTU, IPV6_MULTICAST_HOPS, IPV6_MULTICAST_IF, IPV6_MULTICAST_LOOP, IPV6_RECVPKTINFO, IPV6_RECVERR, IPV6_ROUTER_ALERT, IPV6_UNICAST_HOPS, IPV6_V6ONLY, IPV6_RTHDR, IPV6_AUTHHDR, IPV6_DSTOPTS, IPV6_HOPOPTS, IPV6_FLOWINFO, IPV6_HOPLIMIT, IPV6_CHECKSUM, IPV6_2292PKTINFO, IPV6_2292HOPOPTS, IPV6_2292DSTOPTS, IPV6_2292RTHDR, IPV6_2292HOPLIMIT
sockopt_opt_ipv6_mreq = IPV6_ADD_MEMBERSHIP, IPV6_DROP_MEMBERSHIP, IPV6_JOIN_ANYCAST, IPV6_LEAVE_ANYCAST

sockaddr_in {
	family	const[AF_INET, int16]
	port	in_port
	addr	in_addr
}

sockaddr_storage_in {
	addr	sockaddr_in
	pad	array[const[0, int64], 15]
}

sockaddr_in6 {
	family	const[AF_INET6, int16]
	port	in_port
	flow	int32
	addr	in6_addr
	scope	int32
}

sockaddr_storage_in6 {
	addr	sockaddr_in6
	pad	array[const[0, int64], 12]
}

send_msghdr {
	addr	ptr[in, sockaddr, opt]
	addrlen	len[addr, int32]
	vec	ptr[in, array[iovec_in]]
	vlen	len[vec, intptr]
	ctrl	ptr[in, array[cmsghdr]]
	ctrllen	len[ctrl, intptr]
	f	flags[send_flags, int32]
}

recv_msghdr {
	addr	ptr[out, sockaddr, opt]
	addrlen	len[addr, int32]
	vec	ptr[in, array[iovec_out]]
	vlen	len[vec, intptr]
	ctrl	buffer[out]
	ctrllen	len[ctrl, intptr]
	f	int32
}

cmsghdr {
	len	len[parent, intptr]
	level	int32
	type	int32
	data	array[int8]
}




# AF_UNIX support.

socket$unix(domain const[AF_UNIX], type flags[unix_socket_type], proto const[0]) fd[unix]
socketpair$unix(domain const[AF_UNIX], type flags[unix_socket_type], proto const[0], fds ptr[out, unix_pair])
bind$unix(fd fd[unix], addr ptr[in, sockaddr_un], addrlen len[addr])
connect$unix(fd fd[unix], addr ptr[in, sockaddr_un], addrlen len[addr])
accept$unix(fd fd[unix], peer ptr[out, sockaddr_un, opt], peerlen ptr[inout, len[peer, int32]]) fd[unix]
accept4$unix(fd fd[unix], peer ptr[out, sockaddr_un, opt], peerlen ptr[inout, len[peer, int32]], flags flags[accept_flags]) fd[unix]

sendto$unix(fd fd[unix], buf buffer[in], len len[buf], f flags[send_flags], addr ptr[in, sockaddr_un, opt], addrlen len[addr])
sendmsg$unix(fd fd[unix], msg ptr[in, msghdr_un], f flags[send_flags])
sendmmsg$unix(fd fd[unix], mmsg ptr[in, array[msghdr_un]], vlen len[mmsg], f flags[send_flags])
recvfrom$unix(fd fd[unix], buf buffer[out], len len[buf], f flags[recv_flags], addr ptr[in, sockaddr_un, opt], addrlen len[addr])
getsockname$unix(fd fd[unix], addr ptr[out, sockaddr_un], addrlen ptr[inout, len[addr, int32]])
getpeername$unix(fd fd[unix], peer ptr[out, sockaddr_un], peerlen ptr[inout, len[peer, int32]])

unix_socket_type = SOCK_STREAM, SOCK_DGRAM, SOCK_SEQPACKET
unix_socket_family = AF_UNIX, AF_UNSPEC

unix_pair {
	fd0	fd[unix]
	fd1	fd[unix]
}

sockaddr_un [
	file	sockaddr_un_file
	abs	sockaddr_un_abstract
] [varlen]

sockaddr_un_file {
	family	flags[unix_socket_family, int16]
# TODO: this must be an embeded file name (currently filename implies indirection).
	path	array[int8]
}

sockaddr_un_abstract {
	family	flags[unix_socket_family, int16]
	ind	const[0, int8]
# To ensure isolation.
# This does not work: prog tries to use output sockaddr_un to create pid's.
# But since it is in a union, the call does not always creates the resource. 
#	pid	pid
	id	int32
}

msghdr_un {
	addr	ptr[in, sockaddr_un]
	addrlen	len[addr, int32]
	vec	ptr[in, array[iovec_in]]
	vlen	len[vec, intptr]
	ctrl	ptr[in, array[cmsghdr_un], opt]
	ctrllen	len[ctrl, intptr]
	f	flags[send_flags, int32]
}

cmsghdr_un [
	rights	cmsghdr_un_rights
	cred	cmsghdr_un_cred
] [varlen]

cmsghdr_un_rights {
	len	len[parent, intptr]
	level	const[SOL_SOCKET, int32]
	type	const[SCM_RIGHTS, int32]
	fds	array[fd]
# TODO: this struct must be padded to intptr (see CMSG_ALIGN)
}

cmsghdr_un_cred {
	len	len[parent, intptr]
	level	const[SOL_SOCKET, int32]
	type	const[SCM_CREDENTIALS, int32]
	pid	pid
	uid	uid
	gid	gid
}




# AF_ALG support.

socket$alg(domain const[AF_ALG], type const[SOCK_SEQPACKET], proto const[0]) fd[alg]
bind$alg(fd fd[alg], addr ptr[in, sockaddr_alg], addrlen len[addr])
setsockopt$ALG_SET_KEY(fd fd[alg], level const[SOL_ALG], opt const[ALG_SET_KEY], key buffer[in], keylen len[key])
setsockopt$ALG_SET_AEAD_AUTHSIZE(fd fd[alg], level const[SOL_ALG], opt const[ALG_SET_AEAD_AUTHSIZE], val const[0], size intptr)
accept$alg(fd fd[alg], peer ptr[out, sockaddr_alg, opt], peerlen ptr[inout, len[peer, int32]]) fd[algconn]
sendmsg$alg(fd fd[algconn], msg ptr[in, msghdr_alg], f flags[send_flags])
sendmmsg$alg(fd fd[algconn], mmsg ptr[in, array[msghdr_alg]], vlen len[mmsg], f flags[send_flags])

sockaddr_alg {
	family	const[AF_ALG, int16]
	type	salg_type
	feat	flags[af_alg_type, int32]
	mask	flags[af_alg_type, int32]
	name	salg_name
}

msghdr_alg {
	addr	const[0, intptr]
	addrlen	const[0, int32]
	vec	ptr[in, array[iovec_in]]
	vlen	len[vec, intptr]
	ctrl	ptr[in, array[cmsghdr_alg], opt]
	ctrllen	bytesize[ctrl, intptr]
	f	flags[send_flags, int32]
}

cmsghdr_alg [
	iv	cmsghdr_alg_iv
	op	cmsghdr_alg_op
	assoc	cmsghdr_alg_assoc
] [varlen]

cmsghdr_alg_iv {
	len	len[parent, intptr]
	level	const[SOL_ALG, int32]
	type	const[ALG_SET_IV, int32]
	ivlen	len[iv, int32]
	iv	array[int8]
# TODO: this struct must be padded to intptr (see CMSG_ALIGN)
}

cmsghdr_alg_op {
	len	len[parent, intptr]
	level	const[SOL_ALG, int32]
	type	const[ALG_SET_OP, int32]
	op	int32
}

cmsghdr_alg_assoc {
	len	len[parent, intptr]
	level	const[SOL_ALG, int32]
	type	const[ALG_SET_AEAD_ASSOCLEN, int32]
	assoc	int32
}

af_alg_type = CRYPTO_ALG_TYPE_MASK, CRYPTO_ALG_TYPE_CIPHER, CRYPTO_ALG_TYPE_COMPRESS, CRYPTO_ALG_TYPE_AEAD, CRYPTO_ALG_TYPE_BLKCIPHER, CRYPTO_ALG_TYPE_ABLKCIPHER, CRYPTO_ALG_TYPE_GIVCIPHER, CRYPTO_ALG_TYPE_DIGEST, CRYPTO_ALG_TYPE_HASH, CRYPTO_ALG_TYPE_SHASH, CRYPTO_ALG_TYPE_AHASH, CRYPTO_ALG_TYPE_RNG, CRYPTO_ALG_TYPE_AKCIPHER, CRYPTO_ALG_TYPE_PCOMPRESS, CRYPTO_ALG_LARVAL, CRYPTO_ALG_DEAD, CRYPTO_ALG_DYING, CRYPTO_ALG_ASYNC, CRYPTO_ALG_NEED_FALLBACK, CRYPTO_ALG_GENIV, CRYPTO_ALG_TESTED, CRYPTO_ALG_INSTANCE, CRYPTO_ALG_KERN_DRIVER_ONLY, CRYPTO_ALG_INTERNAL




# AF_KEY support.

# See net/key/af_key.c, requires root.
# socket$key(domain const[AF_KEY], type const[SOCK_RAW], proto const[PF_KEY_V2]) fd[key]




# AF_NFC support.

socket$nfc_llcp(domain const[AF_NFC], type flags[nfc_llcp_type], proto const[NFC_SOCKPROTO_LLCP]) fd[nfc_llcp]
bind$nfc_llcp(fd fd[nfc_llcp], addr ptr[in, sockaddr_nfc_llcp], addrlen len[addr])
connect$nfc_llcp(fd fd[nfc_llcp], addr ptr[in, sockaddr_nfc_llcp], addrlen len[addr])
accept$nfc_llcp(fd fd[nfc_llcp], peer ptr[out, sockaddr_nfc_llcp, opt], peerlen ptr[inout, len[peer, int32]]) fd[nfc_llcp]
setsockopt$NFC_LLCP_RW(fd fd[nfc_llcp], level const[SOL_NFC], opt const[NFC_LLCP_RW], arg ptr[in, int32], arglen len[arg])
setsockopt$NFC_LLCP_MIUX(fd fd[nfc_llcp], level const[SOL_NFC], opt const[NFC_LLCP_MIUX], arg ptr[in, int32], arglen len[arg])
getsockopt$nfc_llcp(fd fd[nfc_llcp], level const[SOL_NFC], opt flags[nfc_llcp_opts], arg buffer[out], arglen len[arg])
sendmsg$nfc_llcp(fd fd[nfc_llcp], msg ptr[in, nfc_llcp_send_msghdr], f flags[send_flags])
sendmmsg$nfc_llcp(fd fd[nfc_llcp], mmsg ptr[in, array[nfc_llcp_send_msghdr]], vlen len[mmsg], f flags[send_flags])

socket$nfc_raw(domain const[AF_NFC], type flags[nfc_raw_type], proto const[NFC_SOCKPROTO_RAW]) fd[nfc_raw]
connect$nfc_raw(fd fd[nfc_raw], addr ptr[in, sockaddr_nfc], addrlen len[addr])

nfc_llcp_type = SOCK_STREAM, SOCK_DGRAM, SOCK_RAW
nfc_raw_type = SOCK_STREAM, SOCK_RAW
nfc_proto = NFC_PROTO_JEWEL, NFC_PROTO_MIFARE, NFC_PROTO_FELICA, NFC_PROTO_ISO14443, NFC_PROTO_NFC_DEP, NFC_PROTO_ISO14443_B, NFC_PROTO_ISO15693
nfc_llcp_opts = NFC_LLCP_RW, NFC_LLCP_MIUX, NFC_LLCP_REMOTE_MIU, NFC_LLCP_REMOTE_LTO, NFC_LLCP_REMOTE_RW

sockaddr_nfc_llcp {
	family	const[AF_NFC, int16]
	devidx	int32
	target	int32
	proto	flags[nfc_proto, int32]
	dsap	int8
	ssap	int8
	serv	array[int8, 63]
	servlen	intptr
}

sockaddr_nfc {
	family	const[AF_NFC, int16]
	dev	int32
	targ	int32
	proto	flags[nfc_proto, int32]
}

nfc_llcp_send_msghdr {
	addr	ptr[in, sockaddr_nfc_llcp]
	addrlen	len[addr, int32]
	vec	ptr[in, array[iovec_in]]
	vlen	len[vec, intptr]
	ctrl	ptr[in, cmsghdr]
	ctrllen	len[ctrl, intptr]
	f	flags[send_flags, int32]
}




# AF_BLUETOOTH support.

socket$bt_hci(fam const[AF_BLUETOOTH], type const[SOCK_RAW], proto const[BTPROTO_HCI]) fd[bt_hci]
bind$bt_hci(fd fd[bt_hci], addr ptr[in, sockaddr_hci], addrlen len[addr])
ioctl$bt_hci(fd fd[bt_hci], cmd flags[bt_hci_ioctl], arg buffer[inout])
setsockopt$HCI_DATA_DIR(fd fd[bt_hci], level const[0], opt const[HCI_DATA_DIR], arg ptr[in, int32], arglen len[arg])
setsockopt$HCI_TIME_STAMP(fd fd[bt_hci], level const[0], opt const[HCI_TIME_STAMP], arg ptr[in, int32], arglen len[arg])
setsockopt$HCI_FILTER(fd fd[bt_hci], level const[0], opt const[HCI_FILTER], arg ptr[in, hci_ufilter], arglen len[arg])
getsockopt$bt_hci(fd fd[sock], level const[0], opt flags[bt_hci_sockopt], arg buffer[out], arglen ptr[inout, len[arg, int32]])

socket$bt_sco(fam const[AF_BLUETOOTH], type const[SOCK_SEQPACKET], proto const[BTPROTO_SCO]) fd[bt_sco]
bind$bt_sco(fd fd[bt_sco], addr ptr[in, sockaddr_sco], addrlen len[addr])
connect$bt_sco(fd fd[bt_sco], addr ptr[in, sockaddr_sco], addrlen len[addr])
getsockopt$SCO_OPTIONS(fd fd[bt_sco], level const[SOL_SCO], opt const[SCO_OPTIONS], arg buffer[out], arglen ptr[inout, len[arg, int32]])
getsockopt$SCO_CONNINFO(fd fd[bt_sco], level const[SOL_SCO], opt const[SCO_CONNINFO], arg buffer[out], arglen ptr[inout, len[arg, int32]])

socket$bt_l2cap(fam const[AF_BLUETOOTH], type flags[bt_l2cap_type], proto const[BTPROTO_L2CAP]) fd[bt_l2cap]
bind$bt_l2cap(fd fd[bt_l2cap], addr ptr[in, sockaddr_l2], addrlen len[addr])
connect$bt_l2cap(fd fd[bt_l2cap], addr ptr[in, sockaddr_l2], addrlen len[addr])
setsockopt$L2CAP_OPTIONS(fd fd[bt_l2cap], level const[SOL_L2CAP], opt const[L2CAP_OPTIONS], arg ptr[in, l2cap_options], arglen len[arg])
getsockopt$L2CAP_OPTIONS(fd fd[bt_l2cap], level const[SOL_L2CAP], opt const[L2CAP_OPTIONS], arg ptr[out, l2cap_options], arglen ptr[inout, len[arg, int32]])
setsockopt$L2CAP_LM(fd fd[bt_l2cap], level const[SOL_L2CAP], opt const[L2CAP_LM], arg ptr[in, flags[bt_l2cap_lm, int32]], arglen len[arg])
getsockopt$L2CAP_LM(fd fd[bt_l2cap], level const[SOL_L2CAP], opt const[L2CAP_LM], arg ptr[out, int32], arglen ptr[inout, len[arg, int32]])
setsockopt$L2CAP_CONNINFO(fd fd[bt_l2cap], level const[SOL_L2CAP], opt const[L2CAP_CONNINFO], arg ptr[in, l2cap_conninfo], arglen len[arg])
getsockopt$L2CAP_CONNINFO(fd fd[bt_l2cap], level const[SOL_L2CAP], opt const[L2CAP_CONNINFO], arg ptr[out, l2cap_conninfo], arglen ptr[inout, len[arg, int32]])

socket$bt_rfcomm(fam const[AF_BLUETOOTH], type flags[bt_rfcomm_type], proto const[BTPROTO_RFCOMM]) fd[bt_rfcomm]
bind$bt_rfcomm(fd fd[bt_rfcomm], addr ptr[in, sockaddr_rc], addrlen len[addr])
connect$bt_rfcomm(fd fd[bt_rfcomm], addr ptr[in, sockaddr_rc], addrlen len[addr])
setsockopt$RFCOMM_LM(fd fd[bt_rfcomm], level const[SOL_RFCOMM], opt const[RFCOMM_LM], arg ptr[in, flags[bt_l2cap_lm, int32]], arglen len[arg])
getsockopt$RFCOMM_LM(fd fd[bt_rfcomm], level const[SOL_RFCOMM], opt const[RFCOMM_LM], arg ptr[out, int32], arglen ptr[inout, len[arg, int32]])
getsockopt$RFCOMM_CONNINFO(fd fd[bt_rfcomm], level const[SOL_RFCOMM], opt const[RFCOMM_CONNINFO], arg buffer[out], arglen ptr[inout, len[arg, int32]])

socket$bt_hidp(fam const[AF_BLUETOOTH], type const[SOCK_RAW], proto const[BTPROTO_HIDP]) fd[bt_hidp]
ioctl$HIDPCONNADD(fd fd[bt_hidp], cmd const[HIDPCONNADD], arg ptr[in, hidp_connadd_req])
ioctl$HIDPCONNDEL(fd fd[bt_hidp], cmd const[HIDPCONNDEL], arg ptr[in, hidp_conndel_req])
ioctl$HIDPGETCONNLIST(fd fd[bt_hidp], cmd const[HIDPGETCONNLIST], arg ptr[in, hidp_connlist_req])
ioctl$HIDPGETCONNINFO(fd fd[bt_hidp], cmd const[HIDPGETCONNINFO], arg ptr[in, hidp_conninfo])

socket$bt_cmtp(fam const[AF_BLUETOOTH], type const[SOCK_RAW], proto const[BTPROTO_CMTP]) fd[bt_cmtp]
ioctl$CMTPCONNADD(fd fd[bt_cmtp], cmd const[CMTPCONNADD], arg ptr[in, cmtp_connadd_req])
ioctl$CMTPCONNDEL(fd fd[bt_cmtp], cmd const[CMTPCONNDEL], arg ptr[in, cmtp_conndel_req])
ioctl$CMTPGETCONNLIST(fd fd[bt_cmtp], cmd const[CMTPGETCONNLIST], arg ptr[in, cmtp_connlist_req])
ioctl$CMTPGETCONNINFO(fd fd[bt_cmtp], cmd const[CMTPGETCONNINFO], arg ptr[in, cmtp_conninfo])

socket$bt_bnep(fam const[AF_BLUETOOTH], type const[SOCK_RAW], proto const[BTPROTO_BNEP]) fd[bt_bnep]
ioctl$BNEPCONNADD(fd fd[bt_bnep], cmd const[BNEPCONNADD], arg ptr[in, bnep_connadd_req])
ioctl$BNEPCONNDEL(fd fd[bt_bnep], cmd const[BNEPCONNDEL], arg ptr[in, bnep_conndel_req])
ioctl$BNEPGETCONNLIST(fd fd[bt_bnep], cmd const[BNEPGETCONNLIST], arg ptr[in, bnep_connlist_req])
ioctl$BNEPGETCONNINFO(fd fd[bt_bnep], cmd const[BNEPGETCONNINFO], arg ptr[in, bnep_conninfo])
ioctl$BNEPGETSUPPFEAT(fd fd[bt_bnep], cmd const[BNEPGETSUPPFEAT], arg ptr[in, int32])

# These are common for several bluetooth sockets (sco, l2cap, rfcomm).
ioctl$bt(fd fd, cmd flags[bt_ioctl], arg buffer[inout])
setsockopt$BT_SECURITY(fd fd, level const[SOL_BLUETOOTH], opt const[BT_SECURITY], arg ptr[in, bt_security], arglen len[arg])
getsockopt$BT_SECURITY(fd fd, level const[SOL_BLUETOOTH], opt const[BT_SECURITY], arg ptr[out, bt_security], arglen len[arg])
setsockopt$BT_DEFER_SETUP(fd fd, level const[SOL_BLUETOOTH], opt const[BT_DEFER_SETUP], arg ptr[in, int32], arglen len[arg])
getsockopt$BT_DEFER_SETUP(fd fd, level const[SOL_BLUETOOTH], opt const[BT_DEFER_SETUP], arg ptr[in, int32], arglen ptr[in, len[arg, intptr]])
setsockopt$BT_VOICE(fd fd, level const[SOL_BLUETOOTH], opt const[BT_VOICE], arg ptr[in, int16], arglen len[arg])
getsockopt$BT_VOICE(fd fd, level const[SOL_BLUETOOTH], opt const[BT_VOICE], arg ptr[in, int16], arglen ptr[in, len[arg, intptr]])
setsockopt$BT_FLUSHABLE(fd fd, level const[SOL_BLUETOOTH], opt const[BT_FLUSHABLE], arg ptr[in, int32], arglen len[arg])
getsockopt$BT_FLUSHABLE(fd fd, level const[SOL_BLUETOOTH], opt const[BT_FLUSHABLE], arg ptr[in, int32], arglen ptr[in, len[arg, intptr]])
setsockopt$BT_POWER(fd fd, level const[SOL_BLUETOOTH], opt const[BT_POWER], arg ptr[in, int8], arglen len[arg])
getsockopt$BT_POWER(fd fd, level const[SOL_BLUETOOTH], opt const[BT_POWER], arg ptr[in, int8], arglen ptr[in, len[arg, intptr]])
setsockopt$BT_CHANNEL_POLICY(fd fd, level const[SOL_BLUETOOTH], opt const[BT_CHANNEL_POLICY], arg ptr[in, int32], arglen len[arg])
getsockopt$BT_CHANNEL_POLICY(fd fd, level const[SOL_BLUETOOTH], opt const[BT_CHANNEL_POLICY], arg ptr[in, int32], arglen ptr[in, len[arg, intptr]])
setsockopt$BT_SNDMTU(fd fd, level const[SOL_BLUETOOTH], opt const[BT_SNDMTU], arg ptr[in, int16], arglen len[arg])
getsockopt$BT_SNDMTU(fd fd, level const[SOL_BLUETOOTH], opt const[BT_SNDMTU], arg ptr[in, int16], arglen ptr[in, len[arg, intptr]])
setsockopt$BT_RCVMTU(fd fd, level const[SOL_BLUETOOTH], opt const[BT_RCVMTU], arg ptr[in, int16], arglen len[arg])
getsockopt$BT_RCVMTU(fd fd, level const[SOL_BLUETOOTH], opt const[BT_RCVMTU], arg ptr[in, int16], arglen ptr[in, len[arg, intptr]])

sockaddr_hci {
	fam	const[AF_BLUETOOTH, int16]
	dev	int16
	chan	flags[bt_chi_chan, int16]
}

hci_inquiry_req {
	dev	int16
	flags	int16
	lap0	int8
	lap1	int8
	lap2	int8
	len	int8
	rsp	int8
}

hci_ufilter {
	type	int32
	event0	int32
	event1	int32
	opcode	int16
}

sockaddr_sco {
	fam	const[AF_BLUETOOTH, int16]
	addr	bdaddr
}

sockaddr_l2 {
	fam	const[AF_BLUETOOTH, int16]
	psm	int16
	addr	bdaddr
	cid	int16
	typ	int8
} 

bdaddr {
	addr0	int8
	addr1	int8
	addr2	int8
	addr3	int8
	addr4	int8
	addr5	int8
}

bt_security {
	lev	int8
	keysize	int8
}

l2cap_options {
	omtu	int16
	imtu	int16
	flushto	int16
	mode	int8
	fcs	int8
	maxtx	int8
	txwin	int16
}

l2cap_conninfo {
	handle	int16
	devcls0	int8
	devcls1	int8
	devcls2	int8
}

sockaddr_rc {
	fam	const[AF_BLUETOOTH, int16]
	addr	bdaddr
	chan	int8
}

hidp_connadd_req {
	ctrlsk	fd
	intrsk	fd
	parser	int16
	rdsize	int16
	rddata	buffer[in]
	country	int8
	subclas	int8
	vendor	int16
	product	int16
	version	int16
	flags	int32
	idleto	int32
	name	array[int8]
}

hidp_conndel_req {
	addr	bdaddr
	flags	int32
}

hidp_conninfo {
	addr	bdaddr
	flags	int32
	state	int16
	vendor	int16
	product	int16
	ver	int16
	name	array[int8]
}

hidp_connlist_req {
	cnum	len[ci, int32]
	ci	ptr[out, array[hidp_conninfo]]
}

cmtp_connadd_req {
	sock	fd
	flags	int32
}

cmtp_conndel_req {
	addr	bdaddr
	flags	int32
}

cmtp_conninfo {
	addr	bdaddr
	flags	int32
	state	int16
	num	int32
}

cmtp_connlist_req {
	cnum	len[ci, int32]
	ci	ptr[out, array[cmtp_conninfo]]
}

bnep_connadd_req {
	sock	fd
	flags	int32
	role	int16
	device	array[int8]
}

bnep_conndel_req {
	flags	int32
	dst	array[int8, 6]
}

bnep_conninfo {
	flags	int32
	role	int16
	state	int16
	dst	array[int8, 6]
	device	array[int8, 16]
}

bnep_connlist_req {
	cnum	len[ci, int32]
	ci	ptr[out, array[bnep_conninfo]]
} 

bt_chi_chan = HCI_CHANNEL_RAW, HCI_CHANNEL_USER, HCI_CHANNEL_MONITOR, HCI_CHANNEL_CONTROL
bt_hci_ioctl = HCIDEVUP, HCIDEVDOWN, HCIDEVRESET, HCIDEVRESTAT, HCIGETDEVLIST, HCIGETDEVINFO, HCIGETCONNLIST, HCIGETCONNINFO, HCIGETAUTHINFO, HCISETRAW, HCISETSCAN, HCISETAUTH, HCISETENCRYPT, HCISETPTYPE, HCISETLINKPOL, HCISETLINKMODE, HCISETACLMTU, HCISETSCOMTU, HCIBLOCKADDR, HCIUNBLOCKADDR, HCIINQUIRY
bt_hci_sockopt = HCI_DATA_DIR, HCI_TIME_STAMP, HCI_FILTER
bt_ioctl = TIOCOUTQ, TIOCINQ, SIOCGSTAMP, SIOCGSTAMPNS
bt_l2cap_type = SOCK_SEQPACKET, SOCK_STREAM, SOCK_DGRAM, SOCK_RAW
bt_l2cap_lm = L2CAP_LM_MASTER, L2CAP_LM_AUTH, L2CAP_LM_ENCRYPT, L2CAP_LM_TRUSTED, L2CAP_LM_RELIABLE, L2CAP_LM_SECURE, L2CAP_LM_FIPS
bt_rfcomm_type = SOCK_STREAM, SOCK_RAW