xref: /minix/minix/net/lwip/pktsock.c (revision fb9c64b2)

/* LWIP service - pktsock.c - packet code shared between UDP and RAW */

#include "lwip.h"
#include "pktsock.h"
#include "ifaddr.h"

/*
 * This buffer should be much bigger (at least 10KB, according to RFC 3542),
 * but we do not support the ancillary options that take so much space anyway.
 */
#define PKTSOCK_CTLBUF_SIZE		256

static char pktsock_ctlbuf[PKTSOCK_CTLBUF_SIZE];

/*
 * Header structures with ancillary data for received packets.  The reason that
 * we do not simply use a generic pkthdr structure with ip_addr_t source and
 * destination addresses, is that for UDP packets, we put this structure in
 * place of the received (ethernet and IP headers), and such a full structure
 * (including IPv6-size addresses) would not fit in the header space for IPv4
 * packets.  So instead we use two address structures, one for IPv4 and one for
 * IPv6, and a generic header structure on top of it, which also identifies
 * which address structure is underneath.  The combination of the address
 * structure and the header structure must fit in the IP header.  The IPv6
 * packet header is already so close to the limit here that we have to use
 * packed addresses.  For IPv4 we use the regular addresses for simplicity.
 */
struct pkthdr {
	uint16_t port;			/* source port number (UDP only) */
	uint8_t dstif;			/* interface that received the pkt */
	uint8_t addrif;			/* interface that accepted the pkt */
	uint8_t tos;			/* TOS/TC value from the IP header */
	uint8_t ttl;			/* TTL/HL value from the IP header */
	uint8_t flags;			/* packet flags (PKTHF_) */
	uint8_t _unused;		/* all that is still available.. */
};

#define PKTHF_IPV6		0x01	/* packet has IPv6 header */
#define PKTHF_MCAST		0x02	/* packet has multicast destination */
#define PKTHF_BCAST		0x04	/* packet has broadcast destination */

struct pktaddr4 {
	ip4_addr_t srcaddr;
	ip4_addr_t dstaddr;
};

struct pktaddr6 {
	ip6_addr_p_t srcaddr;
	ip6_addr_p_t dstaddr;
};

/*
 * Create a packet socket.  Relay parameters and return values to and from the
 * IP module's socket creation function.  This function must not allocate any
 * resources in any form, as socket creation may still fail later, in which
 * case no destruction function is called.
 */
int
pktsock_socket(struct pktsock * pkt, int domain, size_t sndbuf, size_t rcvbuf,
	struct sock ** sockp)
{

	pkt->pkt_rcvhead = NULL;
	pkt->pkt_rcvtailp = &pkt->pkt_rcvhead;
	pkt->pkt_rcvlen = 0;

	mcast_reset(&pkt->pkt_mcast);

	memset(&pkt->pkt_srcaddr, 0, sizeof(pkt->pkt_srcaddr));
	pkt->pkt_ifindex = 0;

	/*
	 * Any PKTF_ type flags should be initialized on the socket only after
	 * the following call, as this call will clear the flags field.  For
	 * now, no PKTF_ flags need to be set by default, though.
	 */
	return ipsock_socket(&pkt->pkt_ipsock, domain, sndbuf, rcvbuf, sockp);
}

/*
 * Return TRUE if the given packet can and should be received on the given
 * socket, or FALSE if there is a reason not to receive the packet.
 */
static int
pktsock_may_recv(struct pktsock * pkt, struct pbuf * pbuf)
{

	/*
	 * By policy, multicast packets should not be received on sockets of
	 * which the owning application is not multicast aware.
	 */
	if (ip_addr_ismulticast(ip_current_dest_addr()) &&
	    !(ipsock_get_flag(&pkt->pkt_ipsock, PKTF_MCAWARE)))
		return FALSE;

	/*
	 * Due to fragment reassembly, we might end up with packets that take
	 * up more buffer space than their byte size, even after rounding up
	 * the latter.  The user probably does not want packets to get dropped
	 * for that reason, e.g. when they set a 64K limit and the packet ends
	 * up being estimated as 65K and dropped.  So, we test against
	 * 'pbuf->tot_len' rather than the rounded-up packet size.  However,
	 * 'pkt->pkt_rcvlen' itself is increased by the rounded-up packet size
	 * when enqueuing the packet, so that we still count the memory
	 * consumption (generally) conservatively, which is what we want.
	 */
	return (pkt->pkt_rcvlen + pbuf->tot_len <=
	    ipsock_get_rcvbuf(&pkt->pkt_ipsock));
}

/*
 * Check whether the given packet can and should be received on the given
 * socket.  If so, return the amount of space for ancillary information that
 * will be necessary for the packet.  If not, return a negative value.
 */
int
pktsock_test_input(struct pktsock * pkt, struct pbuf * pbuf)
{

	/*
	 * This check will be done again in pktsock_input(), but this function
	 * is called for raw packets only (not for UDP packets) and, if this
	 * (cheap) check fails, we can avoid a (rather expensive) packet copy.
	 */
	if (!pktsock_may_recv(pkt, pbuf))
		return -1;

	if (ip_current_is_v6())
		return (int)(sizeof(struct pktaddr6) + sizeof(struct pkthdr));
	else
		return (int)(sizeof(struct pktaddr4) + sizeof(struct pkthdr));
}

/*
 * A packet has arrived on a packet socket.  We own the given packet buffer,
 * and so we must free it if we do not want to keep it.
 */
void
pktsock_input(struct pktsock * pkt, struct pbuf * pbuf,
	const ip_addr_t * srcaddr, uint16_t port)
{
	struct pktaddr4 pktaddr4;
	struct pktaddr6 pktaddr6;
	struct pkthdr pkthdr;
	void *pktaddr;
	struct ifdev *ifdev;
	size_t pktaddrlen;

	/*
	 * We are going to mess with the packet's header and contents, so we
	 * must be the exclusive owner of the packet.  For UDP packets, lwIP
	 * must have made a copy for us in case of non-exclusive delivery
	 * (e.g., multicast packets).  For raw packets, we have made a copy of
	 * the packet ourselves just before the call to this function.
	 */
	if (pbuf->ref != 1)
		panic("input packet has multiple references!");

	/* If the packet should not be received on this socket, drop it. */
	if (!pktsock_may_recv(pkt, pbuf)) {
		pbuf_free(pbuf);

		return;
	}

	/*
	 * Enqueue the packet.  Overwrite the leading IP header with packet
	 * information that is used at the time of receipt by userland.  The
	 * data structures are such that the information always fits in what
	 * was the IP header.  The reference count check earlier ensures that
	 * we never overwrite part of a packet that is still in use elsewhere.
	 */
	if (ip_current_is_v6()) {
		assert(IP_IS_V6(srcaddr));
		assert(ip6_current_dest_addr() != NULL);

		ip6_addr_copy_to_packed(pktaddr6.srcaddr, *ip_2_ip6(srcaddr));
		ip6_addr_copy_to_packed(pktaddr6.dstaddr,
		    *ip6_current_dest_addr());
		pktaddr = &pktaddr6;
		pktaddrlen = sizeof(pktaddr6);

		assert(pktaddrlen + sizeof(pkthdr) <= IP6_HLEN);

		pkthdr.tos = IP6H_TC(ip6_current_header());
		pkthdr.ttl = IP6H_HOPLIM(ip6_current_header());
		pkthdr.flags = PKTHF_IPV6;
	} else {
		assert(IP_IS_V4(srcaddr));
		assert(ip4_current_dest_addr() != NULL);

		memcpy(&pktaddr4.srcaddr, ip_2_ip4(srcaddr),
		    sizeof(pktaddr4.srcaddr));
		memcpy(&pktaddr4.dstaddr, ip4_current_dest_addr(),
		    sizeof(pktaddr4.srcaddr));
		pktaddr = &pktaddr4;
		pktaddrlen = sizeof(pktaddr4);

		assert(pktaddrlen + sizeof(pkthdr) <= IP_HLEN);

		pkthdr.tos = IPH_TOS(ip4_current_header());
		pkthdr.ttl = IPH_TTL(ip4_current_header());
		pkthdr.flags = 0;
	}

	/*
	 * Save both the interface on which the packet was received (for
	 * PKTINFO) and the interface that owns the destination address of the
	 * packet (for the source address's zone ID).
	 */
	assert(ip_current_input_netif() != NULL);
	ifdev = netif_get_ifdev(ip_current_input_netif());
	pkthdr.dstif = (uint16_t)ifdev_get_index(ifdev);

	assert(ip_current_netif() != NULL);
	ifdev = netif_get_ifdev(ip_current_netif());
	pkthdr.addrif = (uint16_t)ifdev_get_index(ifdev);

	if ((pbuf->flags & PBUF_FLAG_LLMCAST) ||
	    ip_addr_ismulticast(ip_current_dest_addr()))
		pkthdr.flags |= PKTHF_MCAST;
	else if ((pbuf->flags & PBUF_FLAG_LLBCAST) ||
	    ip_addr_isbroadcast(ip_current_dest_addr(), ip_current_netif()))
		pkthdr.flags |= PKTHF_BCAST;

	pkthdr.port = port;

	util_pbuf_header(pbuf, sizeof(pkthdr));

	memcpy(pbuf->payload, &pkthdr, sizeof(pkthdr));

	util_pbuf_header(pbuf, pktaddrlen);

	memcpy(pbuf->payload, pktaddr, pktaddrlen);

	util_pbuf_header(pbuf, -(int)(sizeof(pkthdr) + pktaddrlen));

	*pkt->pkt_rcvtailp = pbuf;
	pkt->pkt_rcvtailp = pchain_end(pbuf);
	pkt->pkt_rcvlen += pchain_size(pbuf);

	sockevent_raise(ipsock_get_sock(&pkt->pkt_ipsock), SEV_RECV);
}

/*
 * Obtain interface and source address information for an outgoing packet.  In
 * particular, parse any IPV6_PKTINFO options provided as either sticky options
 * on the socket 'pkt' or as ancillary options in the packet options 'pkto'.
 * On success, return OK, with 'ifdevp' set to either the outgoing interface to
 * use for the packet, or NULL if no outgoing interface was specified using
 * either of the aforementioned options.  If, and only if, 'ifdevp' is set to
 * an actual interface (i.e., not NULL), then 'src_addrp' is filled with either
 * a locally owned, validated, unicast address to use as source of the packet,
 * or the unspecified ('any') address if no source address was specified using
 * the options.  On failure, return a negative error code.
 */
int
pktsock_get_pktinfo(struct pktsock * pkt, struct pktopt * pkto,
	struct ifdev ** ifdevp, ip_addr_t * src_addrp)
{
	struct ifdev *ifdev, *ifdev2;
	ip_addr_t ipaddr;
	uint32_t ifindex;
	int r;

	/* We support only IPV6_PKTINFO.  IP_PKTINFO is not supported. */
	if (!ipsock_is_ipv6(&pkt->pkt_ipsock)) {
		*ifdevp = NULL;
		return OK;
	}

	/*
	 * TODO: we are spending a lot of effort on initializing and copying
	 * stuff around, even just to find out whether there is anything to do
	 * at all here.  See if this can be optimized.
	 */
	ip_addr_set_zero_ip6(&ipaddr);

	/*
	 * Ancillary data takes precedence over sticky options.  We treat the
	 * source address and interface index fields as separate, overriding
	 * each earlier value only if non-zero.  TODO: is that correct?
	 */
	if (pkto->pkto_flags & PKTOF_PKTINFO) {
		memcpy(ip_2_ip6(&ipaddr)->addr, &pkto->pkto_srcaddr.addr,
		    sizeof(ip_2_ip6(&ipaddr)->addr));
		ifindex = pkto->pkto_ifindex;
	} else
		ifindex = 0;

	if (ip6_addr_isany(ip_2_ip6(&ipaddr)))
		memcpy(ip_2_ip6(&ipaddr)->addr, &pkt->pkt_srcaddr.addr,
		    sizeof(ip_2_ip6(&ipaddr)->addr));
	if (ifindex == 0)
		ifindex = pkt->pkt_ifindex;

	/* If both fields are blank, there is nothing more to do. */
	if (ip6_addr_isany(ip_2_ip6(&ipaddr)) && ifindex == 0) {
		*ifdevp = NULL;
		return OK;
	}

	/* If an interface index is specified, it must be valid. */
	ifdev = NULL;

	if (ifindex != 0 && (ifdev = ifdev_get_by_index(ifindex)) == NULL)
		return ENXIO;

	/*
	 * Use the interface index to set a zone on the source address, if the
	 * source address has a scope.
	 */
	if (ip6_addr_has_scope(ip_2_ip6(&ipaddr), IP6_UNKNOWN)) {
		if (ifindex == 0)
			return EADDRNOTAVAIL;

		ip6_addr_set_zone(ip_2_ip6(&ipaddr), ifindex);
	}

	/*
	 * We need to validate the given address just as thoroughly as an
	 * address given through bind().  If we don't, we could allow forged
	 * source addresses etcetera.  To be sure: this call may change the
	 * address to an IPv4 type address if needed.
	 */
	if ((r = ipsock_check_src_addr(pktsock_get_ipsock(pkt), &ipaddr,
	    FALSE /*allow_mcast*/, &ifdev2)) != OK)
		return r;

	if (ifdev2 != NULL) {
		if (ifdev == NULL)
			ifdev = ifdev2;
		else if (ifdev != ifdev2)
			return EADDRNOTAVAIL;
	} else {
		/*
		 * There should be no cases where the (non-multicast) address
		 * successfully parsed, is not unspecified, and yet did not map
		 * to an interface.  Eliminate the possibility anyway by
		 * throwing an error for this case.  As a result, we are left
		 * with one of two cases:
		 *
		 * 1) ifdevp is not NULL, and src_addrp is unspecified;
		 * 2) ifdevp is not NULL, and src_addrp is a locally assigned
		 *    (unicast) address.
		 *
		 * This is why we need not fill src_addrp when ifdevp is NULL.
		 */
		if (!ip_addr_isany(&ipaddr))
			return EADDRNOTAVAIL;
	}

	*ifdevp = ifdev;
	if (ifdev != NULL)
		*src_addrp = ipaddr;
	return OK;
}

/*
 * Parse a chunk of user-provided control data, on an IPv4 socket provided as
 * 'pkt'.  The control chunk is given as 'cmsg', and the length of the data
 * following the control header (possibly zero) is given as 'len'.  On success,
 * return OK, with any parsed options merged into the set of packet options
 * 'pkto'.  On failure, return a negative error code.
 */
static int
pktsock_parse_ctl_v4(struct pktsock * pkt __unused, struct cmsghdr * cmsg,
	socklen_t len, struct pktopt * pkto)
{
	uint8_t byte;
	int val;

	if (cmsg->cmsg_level != IPPROTO_IP)
		return EAFNOSUPPORT;

	switch (cmsg->cmsg_type) {
	case IP_TOS:
		/*
		 * Some userland code (bind's libisc in particular) supplies
		 * a single byte instead of a full integer for this option.
		 * We go out of our way to accept that format, too.
		 */
		if (len != sizeof(val) && len != sizeof(byte))
			return EINVAL;

		if (len == sizeof(byte)) {
			memcpy(&byte, CMSG_DATA(cmsg), sizeof(byte));
			val = (int)byte;
		} else
			memcpy(&val, CMSG_DATA(cmsg), sizeof(val));

		if (val < 0 || val > UINT8_MAX)
			return EINVAL;

		pkto->pkto_flags |= PKTOF_TOS;
		pkto->pkto_tos = (uint8_t)val;

		return OK;

	case IP_TTL:
		if (len != sizeof(val))
			return EINVAL;

		memcpy(&val, CMSG_DATA(cmsg), sizeof(val));

		if (val < 0 || val > UINT8_MAX)
			return EINVAL;

		pkto->pkto_flags |= PKTOF_TTL;
		pkto->pkto_ttl = (uint8_t)val;

		return OK;

	/*
	 * Implementing IP_PKTINFO might be a bit harder than its IPV6_PKTINFO
	 * sibling, because it would require the use of zone IDs (interface
	 * indices) for IPv4, which is not supported yet.
	 */
	}

	return EINVAL;
}

/*
 * Parse a chunk of user-provided control data, on an IPv6 socket provided as
 * 'pkt'.  The control chunk is given as 'cmsg', and the length of the data
 * following the control header (possibly zero) is given as 'len'.  On success,
 * return OK, with any parsed options merged into the set of packet options
 * 'pkto'.  On failure, return a negative error code.
 */
static int
pktsock_parse_ctl_v6(struct pktsock * pkt, struct cmsghdr * cmsg,
	socklen_t len, struct pktopt * pkto)
{
	struct in6_pktinfo ipi6;
	int val;

	if (cmsg->cmsg_level != IPPROTO_IPV6)
		return EAFNOSUPPORT;

	switch (cmsg->cmsg_type) {
	case IPV6_TCLASS:
		if (len != sizeof(val))
			return EINVAL;

		memcpy(&val, CMSG_DATA(cmsg), sizeof(val));

		if (val < -1 || val > UINT8_MAX)
			return EINVAL;

		if (val == -1)
			val = 0;

		pkto->pkto_flags |= PKTOF_TOS;
		pkto->pkto_tos = (uint8_t)val;

		return OK;

	case IPV6_HOPLIMIT:
		if (len != sizeof(val))
			return EINVAL;

		memcpy(&val, CMSG_DATA(cmsg), sizeof(val));

		if (val < -1 || val > UINT8_MAX)
			return EINVAL;

		if (val == -1)
			val = IP_DEFAULT_TTL;

		pkto->pkto_flags |= PKTOF_TTL;
		pkto->pkto_ttl = (uint8_t)val;

		return OK;

	case IPV6_PKTINFO:
		if (len != sizeof(ipi6))
			return EINVAL;

		memcpy(&ipi6, CMSG_DATA(cmsg), sizeof(ipi6));

		pkto->pkto_flags |= PKTOF_PKTINFO;
		memcpy(&pkto->pkto_srcaddr.addr, &ipi6.ipi6_addr,
		    sizeof(pkto->pkto_srcaddr.addr));
		pkto->pkto_ifindex = ipi6.ipi6_ifindex;

		return OK;

	case IPV6_USE_MIN_MTU:
		if (len != sizeof(int))
			return EINVAL;

		memcpy(&val, CMSG_DATA(cmsg), sizeof(val));

		if (val < -1 || val > 1)
			return EINVAL;

		/* TODO: not supported by lwIP, but needed by applications. */
		return OK;
	}

	return EINVAL;
}

/*
 * Copy in and parse control data, as part of sending a packet on socket 'pkt'.
 * The control data is accessible through 'ctl', with a user-provided length of
 * 'ctl_len'.  On success, return OK, with any parsed packet options stored in
 * 'pkto'.  On failure, return a negative error code.
 */
int
pktsock_get_ctl(struct pktsock * pkt, const struct sockdriver_data * ctl,
	socklen_t ctl_len, struct pktopt * pkto)
{
	struct msghdr msghdr;
	struct cmsghdr *cmsg;
	socklen_t left, len;
	int r;

	/* The default: no packet options are being overridden. */
	assert(pkto->pkto_flags == 0);

	/* If no control length is given, we are done here. */
	if (ctl_len == 0)
		return OK;

	/*
	 * For now, we put a rather aggressive limit on the size of the control
	 * data.  We copy in and parse the whole thing in a single buffer.
	 */
	if (ctl_len > sizeof(pktsock_ctlbuf)) {
		printf("LWIP: too much control data given (%u bytes)\n",
		    ctl_len);

		return ENOBUFS;
	}

	if ((r = sockdriver_copyin(ctl, 0, pktsock_ctlbuf, ctl_len)) != OK)
		return r;

	memset(&msghdr, 0, sizeof(msghdr));
	msghdr.msg_control = pktsock_ctlbuf;
	msghdr.msg_controllen = ctl_len;

	for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg != NULL;
	    cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
		/* Check for bogus lengths. */
		assert((socklen_t)((char *)cmsg - pktsock_ctlbuf) <= ctl_len);
		left = ctl_len - (socklen_t)((char *)cmsg - pktsock_ctlbuf);
		assert(left >= CMSG_LEN(0)); /* guaranteed by CMSG_xxHDR */

		if (cmsg->cmsg_len < CMSG_LEN(0) || cmsg->cmsg_len > left) {
			printf("LWIP: malformed control data rejected\n");

			return EINVAL;
		}

		len = cmsg->cmsg_len - CMSG_LEN(0);

		if (ipsock_is_ipv6(&pkt->pkt_ipsock))
			r = pktsock_parse_ctl_v6(pkt, cmsg, len, pkto);
		else
			r = pktsock_parse_ctl_v4(pkt, cmsg, len, pkto);

		if (r != OK)
			return r;
	}

	return OK;
}

/*
 * Copy in the packet data from the calling user process, and store it in the
 * buffer 'pbuf' that must already have been allocated with the appropriate
 * size.
 */
int
pktsock_get_data(struct pktsock * pkt, const struct sockdriver_data * data,
	size_t len, struct pbuf * pbuf)

{

	return util_copy_data(data, len, 0, pbuf, 0, TRUE /*copy_in*/);
}

/*
 * Dequeue and free the head of the receive queue of a packet socket.
 */
static void
pktsock_dequeue(struct pktsock * pkt)
{
	struct pbuf *pbuf, **pnext;
	size_t size;

	pbuf = pkt->pkt_rcvhead;
	assert(pbuf != NULL);

	pnext = pchain_end(pbuf);
	size = pchain_size(pbuf);

	if ((pkt->pkt_rcvhead = *pnext) == NULL)
		pkt->pkt_rcvtailp = &pkt->pkt_rcvhead;

	assert(pkt->pkt_rcvlen >= size);
	pkt->pkt_rcvlen -= size;

	*pnext = NULL;
	pbuf_free(pbuf);
}

/*
 * Perform preliminary checks on a receive request.
 */
int
pktsock_pre_recv(struct sock * sock __unused, endpoint_t user_endpt __unused,
	int flags)
{

	/*
	 * We accept the same flags across all socket types in LWIP, and then
	 * simply ignore the ones we do not support for packet sockets.
	 */
	if ((flags & ~(MSG_PEEK | MSG_WAITALL)) != 0)
		return EOPNOTSUPP;

	return OK;
}

/*
 * Add a chunk of control data to the global control buffer, starting from
 * offset 'off'.  The chunk has the given level and type, and its data is given
 * in the buffer 'ptr' with size 'len'.  Return the (padded) size of the chunk
 * that was generated as a result.
 */
static size_t
pktsock_add_ctl(int level, int type, void * ptr, socklen_t len, size_t off)
{
	struct cmsghdr cmsg;
	size_t size;

	size = CMSG_SPACE(len);

	/*
	 * The global control buffer must be large enough to store one chunk
	 * of each of the supported options.  If this panic triggers, increase
	 * PKTSOCK_CTLBUF_SIZE by as much as needed.
	 */
	if (off + size > sizeof(pktsock_ctlbuf))
		panic("control buffer too small, increase "
		    "PKTSOCK_CTLBUF_SIZE");

	memset(&cmsg, 0, sizeof(cmsg));
	cmsg.cmsg_len = CMSG_LEN(len);
	cmsg.cmsg_level = level;
	cmsg.cmsg_type = type;

	/*
	 * Clear any padding space.  This can be optimized, but in any case we
	 * must be careful not to copy out any bytes that have not been
	 * initialized at all.
	 */
	memset(&pktsock_ctlbuf[off], 0, size);

	memcpy(&pktsock_ctlbuf[off], &cmsg, sizeof(cmsg));
	memcpy(CMSG_DATA((struct cmsghdr *)&pktsock_ctlbuf[off]), ptr, len);

	return size;
}

/*
 * Generate and copy out control data, as part of delivering a packet from
 * socket 'pkt' to userland.  The control data buffer is given as 'ctl', with
 * a user-given length of 'ctl_len' bytes.  The packet's header information is
 * provided as 'pkthdr', and its source and destination addresses as 'pktaddr',
 * which maybe a pktaddr4 or pktaddr6 structure depending on the value of the
 * PKTHF_IPV6 flag in the 'flags' field in 'pkthdr'.  Note that we support
 * dual-stack sockets, and as such it is possible that the socket is of domain
 * AF_INET6 while the received packet is an IPv4 packet.  On success, return
 * the size of the control data copied out (possibly zero).  If more control
 * data were generated than copied out, also merge the MSG_CTRUNC flag into
 * 'rflags'.  On failure, return a negative error code.
 */
static int
pktsock_put_ctl(struct pktsock * pkt, const struct sockdriver_data * ctl,
	socklen_t ctl_len, struct pkthdr * pkthdr, void * pktaddr,
	int * rflags)
{
	struct pktaddr6 *pktaddr6;
	struct pktaddr4 *pktaddr4;
	struct in_pktinfo ipi;
	struct in6_pktinfo ipi6;
	ip_addr_t ipaddr;
	unsigned int flags;
	uint8_t byte;
	size_t off;
	int r, val;

	flags = ipsock_get_flags(&pkt->pkt_ipsock);

	if (!(flags & (PKTF_RECVINFO | PKTF_RECVTOS | PKTF_RECVTTL)))
		return 0;

	/*
	 * Important: all generated control chunks must fit in the global
	 * control buffer together.  When adding more options here, ensure that
	 * the control buffer remains large enough to receive all options at
	 * once.  See also the panic in pktsock_add_ctl().
	 */
	off = 0;

	/*
	 * IPv6 sockets may receive IPv4 packets.  The ancillary data is in the
	 * format corresponding to the socket, which means we may have to
	 * convert any IPv4 addresses from the packet to IPv4-mapped IPv6
	 * addresses for the ancillary data, just like the source address.
	 */
	if (ipsock_is_ipv6(&pkt->pkt_ipsock)) {
		if (flags & PKTF_RECVTTL) {
			val = pkthdr->ttl;

			off += pktsock_add_ctl(IPPROTO_IPV6, IPV6_HOPLIMIT,
			    &val, sizeof(val), off);
		}

		if (flags & PKTF_RECVTOS) {
			val = pkthdr->tos;

			off += pktsock_add_ctl(IPPROTO_IPV6, IPV6_TCLASS, &val,
			    sizeof(val), off);
		}

		if (flags & PKTF_RECVINFO) {
			memset(&ipi6, 0, sizeof(ipi6));

			if (pkthdr->flags & PKTHF_IPV6) {
				pktaddr6 = (struct pktaddr6 *)pktaddr;
				memcpy(&ipi6.ipi6_addr, &pktaddr6->dstaddr,
				    sizeof(ipi6.ipi6_addr));
			} else {
				pktaddr4 = (struct pktaddr4 *)pktaddr;

				addr_make_v4mapped_v6(&ipaddr,
				    &pktaddr4->dstaddr);

				memcpy(&ipi6.ipi6_addr,
				    ip_2_ip6(&ipaddr)->addr,
				    sizeof(ipi6.ipi6_addr));
			}
			ipi6.ipi6_ifindex = pkthdr->dstif;

			off += pktsock_add_ctl(IPPROTO_IPV6, IPV6_PKTINFO,
			    &ipi6, sizeof(ipi6), off);
		}
	} else {
		if (flags & PKTF_RECVTTL) {
			byte = pkthdr->ttl;

			off += pktsock_add_ctl(IPPROTO_IP, IP_TTL, &byte,
			    sizeof(byte), off);
		}

		if (flags & PKTF_RECVINFO) {
			assert(!(pkthdr->flags & PKTHF_IPV6));
			pktaddr4 = (struct pktaddr4 *)pktaddr;

			memset(&ipi, 0, sizeof(ipi));
			memcpy(&ipi.ipi_addr, &pktaddr4->dstaddr,
			    sizeof(ipi.ipi_addr));
			ipi.ipi_ifindex = pkthdr->dstif;

			off += pktsock_add_ctl(IPPROTO_IP, IP_PKTINFO, &ipi,
			    sizeof(ipi), off);
		}
	}

	assert(off > 0);

	if (ctl_len >= off)
		ctl_len = off;
	else
		*rflags |= MSG_CTRUNC;

	if (ctl_len > 0 &&
	    (r = sockdriver_copyout(ctl, 0, pktsock_ctlbuf, ctl_len)) != OK)
		return r;

	return ctl_len;
}

/*
 * Receive data on a packet socket.
 */
int
pktsock_recv(struct sock * sock, const struct sockdriver_data * data,
	size_t len, size_t * off, const struct sockdriver_data * ctl,
	socklen_t ctl_len, socklen_t * ctl_off, struct sockaddr * addr,
	socklen_t * addr_len, endpoint_t user_endpt __unused, int flags,
	size_t min __unused, int * rflags)
{
	struct pktsock *pkt = (struct pktsock *)sock;
	struct pktaddr4 pktaddr4;
	struct pktaddr6 pktaddr6;
	struct pkthdr pkthdr;
	void *pktaddr;
	struct pbuf *pbuf;
	ip_addr_t srcaddr;
	int r;

	if ((pbuf = pkt->pkt_rcvhead) == NULL)
		return SUSPEND;

	/*
	 * Get the ancillary data for the packet.  The format of the ancillary
	 * data depends on the received packet type, which may be different
	 * from the socket type.
	 */
	util_pbuf_header(pbuf, sizeof(pkthdr));

	memcpy(&pkthdr, pbuf->payload, sizeof(pkthdr));

	if (pkthdr.flags & PKTHF_IPV6) {
		util_pbuf_header(pbuf, sizeof(pktaddr6));

		memcpy(&pktaddr6, pbuf->payload, sizeof(pktaddr6));
		pktaddr = &pktaddr6;

		ip_addr_copy_from_ip6_packed(srcaddr, pktaddr6.srcaddr);
		if (ip6_addr_has_scope(ip_2_ip6(&srcaddr), IP6_UNICAST))
			ip6_addr_set_zone(ip_2_ip6(&srcaddr), pkthdr.addrif);

		util_pbuf_header(pbuf,
		    -(int)(sizeof(pkthdr) + sizeof(pktaddr6)));
	} else {
		util_pbuf_header(pbuf, sizeof(pktaddr4));

		memcpy(&pktaddr4, pbuf->payload, sizeof(pktaddr4));
		pktaddr = &pktaddr4;

		ip_addr_copy_from_ip4(srcaddr, pktaddr4.srcaddr);

		util_pbuf_header(pbuf,
		    -(int)(sizeof(pkthdr) + sizeof(pktaddr4)));
	}

	/* Copy out the packet data to the calling user process. */
	if (len >= pbuf->tot_len)
		len = pbuf->tot_len;
	else
		*rflags |= MSG_TRUNC;

	r = util_copy_data(data, len, 0, pbuf, 0, FALSE /*copy_in*/);

	if (r != OK)
		return r;

	/* Generate and copy out ancillary (control) data, if requested. */
	if ((r = pktsock_put_ctl(pkt, ctl, ctl_len, &pkthdr, pktaddr,
	    rflags)) < 0)
		return r;

	/* Store the source IP address. */
	ipsock_put_addr(&pkt->pkt_ipsock, addr, addr_len, &srcaddr,
	    pkthdr.port);

	/* Set multicast or broadcast message flag, if applicable. */
	if (pkthdr.flags & PKTHF_MCAST)
		*rflags |= MSG_MCAST;
	else if (pkthdr.flags & PKTHF_BCAST)
		*rflags |= MSG_BCAST;

	/* Discard the packet now, unless we were instructed to peek only. */
	if (!(flags & MSG_PEEK))
		pktsock_dequeue(pkt);

	/* Return the received part of the packet length. */
	*off = len;
	*ctl_off = r;
	return OK;
}

/*
 * Test whether data can be received on a packet socket, and if so, how many
 * bytes of data.
 */
int
pktsock_test_recv(struct sock * sock, size_t min __unused, size_t * size)
{
	struct pktsock *pkt = (struct pktsock *)sock;

	if (pkt->pkt_rcvhead == NULL)
		return SUSPEND;

	if (size != NULL)
		*size = pkt->pkt_rcvhead->tot_len;
	return OK;
}

/*
 * The caller has performed a multicast operation on the given socket.  Thus,
 * the caller is multicast aware.  Remember this, because that means the socket
 * may also receive traffic to multicast destinations.
 */
void
pktsock_set_mcaware(struct pktsock * pkt)
{

	ipsock_set_flag(&pkt->pkt_ipsock, PKTF_MCAWARE);
}

/*
 * Set socket options on a packet socket.
 */
int
pktsock_setsockopt(struct pktsock * pkt, int level, int name,
	const struct sockdriver_data * data, socklen_t len,
	struct ipopts * ipopts)
{
	struct ip_mreq imr;
	struct ipv6_mreq ipv6mr;
	struct in6_pktinfo ipi6;
	ip_addr_t ipaddr, ifaddr;
	struct ifdev *ifdev;
	unsigned int flag;
	uint32_t ifindex;
	int r, val, has_scope;

	switch (level) {
	case IPPROTO_IP:
		if (ipsock_is_ipv6(&pkt->pkt_ipsock))
			break;

		switch (name) {
		case IP_ADD_MEMBERSHIP:
		case IP_DROP_MEMBERSHIP:
			pktsock_set_mcaware(pkt);

			if ((r = sockdriver_copyin_opt(data, &imr, sizeof(imr),
			    len)) != OK)
				return r;

			ip_addr_set_ip4_u32(&ipaddr, imr.imr_multiaddr.s_addr);
			ip_addr_set_ip4_u32(&ifaddr, imr.imr_interface.s_addr);

			if (!ip_addr_isany(&ifaddr)) {
				ifdev = ifaddr_map_by_addr(&ifaddr);

				if (ifdev == NULL)
					return EADDRNOTAVAIL;
			} else
				ifdev = NULL;

			if (name == IP_ADD_MEMBERSHIP)
				r = mcast_join(&pkt->pkt_mcast, &ipaddr,
				    ifdev);
			else
				r = mcast_leave(&pkt->pkt_mcast, &ipaddr,
				    ifdev);

			return r;

		case IP_RECVTTL:
		case IP_RECVPKTINFO:
			if ((r = sockdriver_copyin_opt(data, &val, sizeof(val),
			    len)) != OK)
				return r;

			switch (name) {
			case IP_RECVTTL:	flag = PKTF_RECVTTL; break;
			case IP_RECVPKTINFO:	flag = PKTF_RECVINFO; break;
			default:		flag = 0; assert(0); break;
			}

			if (val)
				ipsock_set_flag(&pkt->pkt_ipsock, flag);
			else
				ipsock_clear_flag(&pkt->pkt_ipsock, flag);

			return OK;
		}

		break;

	case IPPROTO_IPV6:
		if (!ipsock_is_ipv6(&pkt->pkt_ipsock))
			break;

		switch (name) {
		case IPV6_JOIN_GROUP:
		case IPV6_LEAVE_GROUP:
			pktsock_set_mcaware(pkt);

			if ((r = sockdriver_copyin_opt(data, &ipv6mr,
			    sizeof(ipv6mr), len)) != OK)
				return r;

			ip_addr_set_zero_ip6(&ipaddr);
			memcpy(ip_2_ip6(&ipaddr)->addr,
			    &ipv6mr.ipv6mr_multiaddr,
			    sizeof(ip_2_ip6(&ipaddr)->addr));

			/*
			 * We currently do not support joining IPv4 multicast
			 * groups on IPv6 sockets.  The reason for this is that
			 * this would require decisions on what to do if the
			 * socket is set to V6ONLY later, as well as various
			 * additional exceptions for a case that hopefully
			 * doesn't occur in practice anyway.
			 */
			if (ip6_addr_isipv4mappedipv6(ip_2_ip6(&ipaddr)))
				return EADDRNOTAVAIL;

			has_scope = ip6_addr_has_scope(ip_2_ip6(&ipaddr),
			    IP6_UNKNOWN);

			if ((ifindex = ipv6mr.ipv6mr_interface) != 0) {
				ifdev = ifdev_get_by_index(ifindex);

				if (ifdev == NULL)
					return ENXIO;

				if (has_scope)
					ip6_addr_set_zone(ip_2_ip6(&ipaddr),
					    ifindex);
			} else {
				if (has_scope)
					return EADDRNOTAVAIL;

				ifdev = NULL;
			}

			if (name == IPV6_JOIN_GROUP)
				r = mcast_join(&pkt->pkt_mcast, &ipaddr,
				    ifdev);
			else
				r = mcast_leave(&pkt->pkt_mcast, &ipaddr,
				    ifdev);

			return r;

		case IPV6_USE_MIN_MTU:
			if ((r = sockdriver_copyin_opt(data, &val, sizeof(val),
			    len)) != OK)
				return r;

			if (val < -1 || val > 1)
				return EINVAL;

			/*
			 * lwIP does not support path MTU discovery, so do
			 * nothing.  TODO: see if this is actually good enough.
			 */
			return OK;

		case IPV6_PKTINFO:
			if ((r = sockdriver_copyin_opt(data, &ipi6,
			    sizeof(ipi6), len)) != OK)
				return r;

			/*
			 * Simply copy in what is given.  The values will be
			 * parsed only once a packet is sent, in
			 * pktsock_get_pktinfo().  Otherwise, if we perform
			 * checks here, they may be outdated by the time the
			 * values are actually used.
			 */
			memcpy(&pkt->pkt_srcaddr.addr, &ipi6.ipi6_addr,
			    sizeof(pkt->pkt_srcaddr.addr));
			pkt->pkt_ifindex = ipi6.ipi6_ifindex;

			return OK;

		case IPV6_RECVPKTINFO:
		case IPV6_RECVHOPLIMIT:
		case IPV6_RECVTCLASS:
			if ((r = sockdriver_copyin_opt(data, &val, sizeof(val),
			    len)) != OK)
				return r;

			switch (name) {
			case IPV6_RECVPKTINFO:	flag = PKTF_RECVINFO; break;
			case IPV6_RECVHOPLIMIT:	flag = PKTF_RECVTTL; break;
			case IPV6_RECVTCLASS:	flag = PKTF_RECVTOS; break;
			default:		flag = 0; assert(0); break;
			}

			if (val)
				ipsock_set_flag(&pkt->pkt_ipsock, flag);
			else
				ipsock_clear_flag(&pkt->pkt_ipsock, flag);

			return OK;
		}

		break;
	}

	return ipsock_setsockopt(&pkt->pkt_ipsock, level, name, data, len,
	    ipopts);
}

/*
 * Retrieve socket options on a packet socket.
 */
int
pktsock_getsockopt(struct pktsock * pkt, int level, int name,
	const struct sockdriver_data * data, socklen_t * len,
	struct ipopts * ipopts)
{
	struct in6_pktinfo ipi6;
	unsigned int flag;
	int val;

	switch (level) {
	case IPPROTO_IP:
		if (ipsock_is_ipv6(&pkt->pkt_ipsock))
			break;

		switch (name) {
		case IP_RECVTTL:
		case IP_RECVPKTINFO:
			switch (name) {
			case IP_RECVTTL:	flag = PKTF_RECVTTL; break;
			case IP_RECVPKTINFO:	flag = PKTF_RECVINFO; break;
			default:		flag = 0; assert(0); break;
			}

			val = !!(ipsock_get_flag(&pkt->pkt_ipsock, flag));

			return sockdriver_copyout_opt(data, &val, sizeof(val),
			    len);
		}

		break;

	case IPPROTO_IPV6:
		if (!ipsock_is_ipv6(&pkt->pkt_ipsock))
			break;

		switch (name) {
		case IPV6_USE_MIN_MTU:
			/*
			 * TODO: sort out exactly what lwIP actually supports
			 * in the way of path MTU discovery.  Value 1 means
			 * that path MTU discovery is disabled and packets are
			 * sent at the minimum MTU (RFC 3542).
			 */
			val = 1;

			return sockdriver_copyout_opt(data, &val, sizeof(val),
			    len);

		case IPV6_PKTINFO:
			memset(&ipi6, 0, sizeof(ipi6));

			/*
			 * Simply copy out whatever was given before.  These
			 * fields are initialized to zero on socket creation.
			 */
			memcpy(&ipi6.ipi6_addr, &pkt->pkt_srcaddr.addr,
			    sizeof(ipi6.ipi6_addr));
			ipi6.ipi6_ifindex = pkt->pkt_ifindex;

			return sockdriver_copyout_opt(data, &ipi6,
			    sizeof(ipi6), len);

		case IPV6_RECVPKTINFO:
		case IPV6_RECVHOPLIMIT:
		case IPV6_RECVTCLASS:
			switch (name) {
			case IPV6_RECVPKTINFO:	flag = PKTF_RECVINFO; break;
			case IPV6_RECVHOPLIMIT:	flag = PKTF_RECVTTL; break;
			case IPV6_RECVTCLASS:	flag = PKTF_RECVTOS; break;
			default:		flag = 0; assert(0); break;
			}

			val = !!(ipsock_get_flag(&pkt->pkt_ipsock, flag));

			return sockdriver_copyout_opt(data, &val, sizeof(val),
			    len);
		}

		break;
	}

	return ipsock_getsockopt(&pkt->pkt_ipsock, level, name, data, len,
	    ipopts);
}

/*
 * Drain the receive queue of a packet socket.
 */
static void
pktsock_drain(struct pktsock * pkt)
{

	while (pkt->pkt_rcvhead != NULL)
		pktsock_dequeue(pkt);

	assert(pkt->pkt_rcvlen == 0);
	assert(pkt->pkt_rcvtailp == &pkt->pkt_rcvhead);
}

/*
 * Shut down a packet socket for reading and/or writing.
 */
void
pktsock_shutdown(struct pktsock * pkt, unsigned int mask)
{

	if (mask & SFL_SHUT_RD)
		pktsock_drain(pkt);
}

/*
 * Close a packet socket.
 */
void
pktsock_close(struct pktsock * pkt)
{

	pktsock_drain(pkt);

	mcast_leave_all(&pkt->pkt_mcast);
}

/*
 * Return the rounded-up number of bytes in the packet socket's receive queue,
 * for sysctl(7).  NetBSD returns the used portion of each buffer, but that
 * would be quite some extra effort for us (TODO).
 */
size_t
pktsock_get_recvlen(struct pktsock * pkt)
{

	return pkt->pkt_rcvlen;
}