8000 minix/minix/net/lwip/rawsock.c at master · i-spark/minix · GitHub
[go: up one dir, main page]

Skip to content

Latest commit

 

History

History
1341 lines (1078 loc) · 35.6 KB

rawsock.c

File metadata and controls

1341 lines (1078 loc) · 35.6 KB
/* LWIP service - rawsock.c - RAW sockets */
/*
* For IPv6 sockets, this module attempts to implement a part of RFC 3542, but
* currently not more than what is supported by lwIP and/or what is expected by
* a handful of standard utilities (dhcpcd, ping6, traceroute6..).
*
* For general understanding, be aware that IPv4 raw sockets always receive
* packets including the IP header, and may be used to send packets including
* the IP header if IP_HDRINCL is set, while IPv6 raw sockets always send and
* receive actual payloads only, using ancillary (control) data to set and
* retrieve per-packet IP header fields.
*
* For packet headers we follow general BSD semantics. For example, some IPv4
* header fields are swapped both when sending and when receiving. Also, like
* on NetBSD, IPPROTO_RAW is not a special value in any way.
*/
#include "lwip.h"
#include "ifaddr.h"
#include "pktsock.h"
#include "lwip/raw.h"
#include "lwip/inet_chksum.h"
#include <net/route.h>
#include <netinet/icmp6.h>
#include <netinet/ip.h>
#include <netinet/in_pcb.h>
/* The number of RAW sockets. Inherited from the lwIP configuration. */
#define NR_RAWSOCK MEMP_NUM_RAW_PCB
/*
* Outgoing packets are not getting buffered, so the send buffer size simply
* determines the maximum size for sent packets. The send buffer maximum is
* therefore limited to the maximum size of a single packet (64K-1 bytes),
* which is already enforced by lwIP's 16-bit length parameter to pbuf_alloc().
*
* The actual transmission may enforce a lower limit, though. The full packet
* size must not exceed the same 64K-1 limit, and that includes any headers
* that still have to be prepended to the given packet. The size of those
* headers depends on the socket type (IPv4/IPv6) and the IP_HDRINCL setting.
*
* The default is equal to the maximum here, because if a (by definition,
* privileged) application wishes to send large raw packets, it probably has a
* good reason, and we do not want to get in its way.
*/
#define RAW_MAX_PAYLOAD (UINT16_MAX)
#define RAW_SNDBUF_MIN 1 /* minimum RAW send buffer size */
#define RAW_SNDBUF_DEF RAW_MAX_PAYLOAD /* default RAW send buffer size */
#define RAW_SNDBUF_MAX RAW_MAX_PAYLOAD /* maximum RAW send buffer size */
#define RAW_RCVBUF_MIN MEMPOOL_BUFSIZE /* minimum RAW receive buffer size */
#define RAW_RCVBUF_DEF 32768 /* default RAW receive buffer size */
#define RAW_RCVBUF_MAX 65536 /* maximum RAW receive buffer size */
static struct rawsock {
struct pktsock raw_pktsock; /* packet socket object */
struct raw_pcb *raw_pcb; /* lwIP RAW control block */
TAILQ_ENTRY(rawsock) raw_next; /* next in active/free list */
struct icmp6_filter raw_icmp6filter; /* ICMPv6 type filter */
} raw_array[NR_RAWSOCK];
static TAILQ_HEAD(, rawsock) raw_freelist; /* list of free RAW sockets */
static TAILQ_HEAD(, rawsock) raw_activelist; /* list, in-use RAW sockets */
static const struct sockevent_ops rawsock_ops;
#define rawsock_get_sock(raw) (ipsock_get_sock(rawsock_get_ipsock(raw)))
#define rawsock_get_ipsock(raw) (pktsock_get_ipsock(&(raw)->raw_pktsock))
#define rawsock_is_ipv6(raw) (ipsock_is_ipv6(rawsock_get_ipsock(raw)))
#define rawsock_is_v6only(raw) (ipsock_is_v6only(rawsock_get_ipsock(raw)))
#define rawsock_is_conn(raw) \
(raw_flags((raw)->raw_pcb) & RAW_FLAGS_CONNECTED)
#define rawsock_is_hdrincl(raw) \
(raw_flags((raw)->raw_pcb) & RAW_FLAGS_HDRINCL)
static ssize_t rawsock_pcblist(struct rmib_call *, struct rmib_node *,
struct rmib_oldp *, struct rmib_newp *);
/* The CTL_NET {PF_INET,PF_INET6} IPPROTO_RAW subtree. */
/* All dynamically numbered; the sendspace/recvspace entries are ours. */
static struct rmib_node net_inet_raw_table[] = {
RMIB_INT(RMIB_RO, RAW_SNDBUF_DEF, "sendspace",
"Default RAW send buffer size"),
RMIB_INT(RMIB_RO, RAW_RCVBUF_DEF, "recvspace",
"Default RAW receive buffer size"),
RMIB_FUNC(RMIB_RO | CTLTYPE_NODE, 0, rawsock_pcblist, "pcblist",
"RAW IP protocol control block list"),
};
static struct rmib_node net_inet_raw_node =
RMIB_NODE(RMIB_RO, net_inet_raw_table, "raw", "RAW IPv4 settings");
static struct rmib_node net_inet6_raw6_node =
RMIB_NODE(RMIB_RO, net_inet_raw_table, "raw6", "RAW IPv6 settings");
/*
* Initialize the raw sockets module.
*/
void
rawsock_init(void)
{
unsigned int slot;
/* Initialize the list of free RAW sockets. */
TAILQ_INIT(&raw_freelist);
for (slot = 0; slot < __arraycount(raw_array); slot++)
TAILQ_INSERT_TAIL(&raw_freelist, &raw_array[slot], raw_next);
/* Initialize the list of active RAW sockets. */
TAILQ_INIT(&raw_activelist);
/* Register the net.inet.raw and net.inet6.raw6 RMIB subtrees. */
mibtree_register_inet(PF_INET, IPPROTO_RAW, &net_inet_raw_node);
mibtree_register_inet(PF_INET6, IPPROTO_RAW, &net_inet6_raw6_node);
}
/*
* Check whether the given arrived IPv6 packet is fit to be received on the
* given raw socket.
*/
static int
rawsock_check_v6(struct rawsock * raw, struct pbuf * pbuf)
{
uint8_t type;
assert(rawsock_is_ipv6(raw));
/*
* For ICMPv6 packets, test against the configured type filter.
*/
if (raw->raw_pcb->protocol == IPPROTO_ICMPV6) {
if (pbuf->len < offsetof(struct icmp6_hdr, icmp6_dataun))
return FALSE;
memcpy(&type, &((struct icmp6_hdr *)pbuf->payload)->icmp6_type,
sizeof(type));
if (!ICMP6_FILTER_WILLPASS((int)type, &raw->raw_icmp6filter))
return FALSE;
}
/*
* For ICMPv6 packets, or if IPV6_CHECKSUM is enabled, we have to
* verify the checksum of the packet before passing it to the user.
* This is costly, but it needs to be done and lwIP is not doing it for
* us (as of writing, anyway), even though it maintains the offset..
*/
if (raw->raw_pcb->chksum_reqd &&
(pbuf->tot_len < raw->raw_pcb->chksum_offset + sizeof(uint16_t) ||
ip6_chksum_pseudo(pbuf, raw->raw_pcb->protocol, pbuf->tot_len,
ip6_current_src_addr(), ip6_current_dest_addr()) != 0)) {
return FALSE;
}
/* No reason to filter out this packet. */
return TRUE;
}
/*
* Adjust the given arrived IPv4 packet by changing the length and offset
* fields to host-byte order, as is done by the BSDs. This effectively mirrors
* the swapping part of the preparation done on IPv4 packets being sent if the
* IP_HDRINCL socket option is enabled.
*/
static void
rawsock_adjust_v4(struct pbuf * pbuf)
{
struct ip_hdr *iphdr;
if (pbuf->len < sizeof(struct ip_hdr))
return;
iphdr = (struct ip_hdr *)pbuf->payload;
/*
* W. Richard Stevens also mentions ip_id, but at least on NetBSD that
* field seems to be swapped neither when sending nor when receiving..
*/
IPH_LEN(iphdr) = htons(IPH_LEN(iphdr));
IPH_OFFSET(iphdr) = htons(IPH_OFFSET(iphdr));
}
/*
* A packet has arrived on a raw socket. Since the same packet may have to be
* delivered to multiple raw sockets, we always return 0 (= not consumed) from
* this function. As such, we must make a copy of the given packet if we want
* to keep it, and never free it.
*/
static uint 8000 8_t
rawsock_input(void * arg, struct raw_pcb * pcb __unused, struct pbuf * psrc,
const ip_addr_t * srcaddr)
{
struct rawsock *raw = (struct rawsock *)arg;
struct pbuf *pbuf;
int off, hdrlen;
assert(raw->raw_pcb == pcb);
/*
* If adding this packet would cause the receive buffer to go beyond
* the current limit, drop the new packet. This is just an estimation,
* because the copy we are about to make may not take the exact same
* amount of memory, due to the fact that 1) the pbuf we're given has
* an unknown set of headers in front of it, and 2) we need to store
* extra information in our copy. The return value of this call, if
* not -1, is the number of bytes we need to reserve to store that
* extra information.
*/
if ((hdrlen = pktsock_test_input(&raw->raw_pktsock, psrc)) < 0)
return 0;
/*
* Raw IPv6 sockets receive only the actual packet data, whereas raw
* IPv4 sockets receive the IP header as well.
*/
if (ip_current_is_v6()) {
off = ip_current_header_tot_len();
util_pbuf_header(psrc, -off);
if (!rawsock_check_v6(raw, psrc)) {
util_pbuf_header(psrc, off);
return 0;
}
} else {
/*
* For IPv6 sockets, drop the packet if it was sent as an IPv4
* packet and checksumming is enabled (this includes ICMPv6).
* Otherwise, the packet would bypass the above checks that we
* perform on IPv6 packets. Applications that want to use a
* dual-stack protocol with checksumming will have to do the
* checksum verification part themselves. Presumably the two
* different pseudoheaders would result in different checksums
* anyhow, so it would be useless to try to support that.
*
* Beyond that, for IPv4 packets on IPv6 sockets, hide the IPv4
* header.
*/
if (rawsock_is_ipv6(raw)) {
if (raw->raw_pcb->chksum_reqd)
return 0;
off = IP_HLEN;
util_pbuf_header(psrc, -off);
} else
off = 0;
}
/*
* We need to make a copy of the incoming packet. If we eat the one
* given to us, this will 1) stop any other raw sockets from getting
* the same packet, 2) allow a single raw socket to discard all TCP/UDP
* traffic, and 3) present us with a problem on how to store ancillary
* data. Raw sockets are not that performance critical so the extra
* copy -even when not always necessary- is not that big of a deal.
*/
if ((pbuf = pchain_alloc(PBUF_RAW, hdrlen + psrc->tot_len)) == NULL) {
if (off > 0)
util_pbuf_header(psrc, off);
return 0;
}
util_pbuf_header(pbuf, -hdrlen);
if (pbuf_copy(pbuf, psrc) != ERR_OK)
panic("unexpected pbuf copy failure");
pbuf->flags |= psrc->flags & (PBUF_FLAG_LLMCAST | PBUF_FLAG_LLBCAST);
if (off > 0)
util_pbuf_header(psrc, off);
if (!rawsock_is_ipv6(raw))
rawsock_adjust_v4(pbuf);
pktsock_input(&raw->raw_pktsock, pbuf, srcaddr, 0);
return 0;
}
/*
* Create a raw socket.
*/
sockid_t
rawsock_socket(int domain, int protocol, struct sock ** sockp,
const struct sockevent_ops ** ops)
{
struct rawsock *raw;
unsigned int flags;
uint8_t ip_type;
if (protocol < 0 || protocol > UINT8_MAX)
return EPROTONOSUPPORT;
if (TAILQ_EMPTY(&raw_freelist))
return ENOBUFS;
raw = TAILQ_FIRST(&raw_freelist);
/*
* Initialize the structure. Do not memset it to zero, as it is still
* part of the linked free list. Initialization may still fail.
*/
ip_type = pktsock_socket(&raw->raw_pktsock, domain, RAW_SNDBUF_DEF,
RAW_RCVBUF_DEF, sockp);
/* We should have enough PCBs so this call should not fail.. */
if ((raw->raw_pcb = raw_new_ip_type(ip_type, protocol)) == NULL)
return ENOBUFS;
raw_recv(raw->raw_pcb, rawsock_input, (void *)raw);
/* By default, the multicast TTL is 1 and looping is enabled. */
raw_set_multicast_ttl(raw->raw_pcb, 1);
flags = raw_flags(raw->raw_pcb) 8BD0 ;
raw_setflags(raw->raw_pcb, flags | RAW_FLAGS_MULTICAST_LOOP);
/*
* For ICMPv6, checksum generation and verification is mandatory and
* type filtering of incoming packets is supported (RFC 3542). For all
* other IPv6 protocols, checksumming may be turned on by the user.
*/
if (rawsock_is_ipv6(raw) && protocol == IPPROTO_ICMPV6) {
raw->raw_pcb->chksum_reqd = 1;
raw->raw_pcb->chksum_offset =
offsetof(struct icmp6_hdr, icmp6_cksum);
ICMP6_FILTER_SETPASSALL(&raw->raw_icmp6filter);
} else
raw->raw_pcb->chksum_reqd = 0;
TAILQ_REMOVE(&raw_freelist, raw, raw_next);
TAILQ_INSERT_TAIL(&raw_activelist, raw, raw_next);
*ops = &rawsock_ops;
return SOCKID_RAW | (sockid_t)(raw - raw_array);
}
/*
* Bind a raw socket to a local address.
*/
static int
rawsock_bind(struct sock * sock, const struct sockaddr * addr,
socklen_t addr_len, endpoint_t user_endpt)
{
struct rawsock *raw = (struct rawsock *)sock;
ip_addr_t ipaddr;
err_t err;
int r;
/*
* Raw sockets may be rebound even if that is not too useful. However,
* we do not allow (re)binding when the socket is connected, so as to
* eliminate any problems with source and destination type mismatches:
* such mismatches are detected at connect time, and rebinding would
* avoid those, possibly triggering lwIP asserts as a result.
*/
if (rawsock_is_conn(raw))
return EINVAL;
if ((r = ipsock_get_src_addr(rawsock_get_ipsock(raw), addr, addr_len,
user_endpt, &raw->raw_pcb->local_ip, 0 /*local_port*/,
TRUE /*allow_mcast*/, &ipaddr, NULL /*portp*/)) != OK)
return r;
err = raw_bind(raw->raw_pcb, &ipaddr);
return util_convert_err(err);
}
/*
* Connect a raw socket to a remote address.
*/
static int
rawsock_connect(struct sock * sock, const struct sockaddr * addr,
socklen_t addr_len, endpoint_t user_endpt __unused)
{
struct rawsock *raw = (struct rawsock *)sock;
const ip_addr_t *src_addr;
ip_addr_t dst_addr;
struct ifdev *ifdev;
uint32_t ifindex, ifindex2;
err_t err;
int r;
/*
* One may "unconnect" socket by providing an address with family
* AF_UNSPEC.
*/
if (addr_is_unspec(addr, addr_len)) {
raw_disconnect(raw->raw_pcb);
return OK;
}
if ((r = ipsock_get_dst_addr(rawsock_get_ipsock(raw), addr, addr_len,
&raw->raw_pcb->local_ip, &dst_addr, NULL /*dst_port*/)) != OK)
return r;
/*
* Bind explicitly to a source address if the PCB is not bound to one
* yet. This is expected in the BSD socket API, but lwIP does not do
* it for us.
*/
if (ip_addr_isany(&raw->raw_pcb->local_ip)) {
/* Help the multicast case a bit, if possible. */
ifdev = NULL;
if (ip_addr_ismulticast(&dst_addr)) {
ifindex = pktsock_get_ifindex(&raw->raw_pktsock);
ifindex2 = raw_get_multicast_netif_index(raw->raw_pcb);
if (ifindex == 0)
ifindex = ifindex2;
if (ifindex != 0) {
ifdev = ifdev_get_by_index(ifindex);
if (ifdev == NULL)
return ENXIO;
}
}
src_addr = ifaddr_select(&dst_addr, ifdev, NULL /*ifdevp*/);
if (src_addr == NULL)
return EHOSTUNREACH;
err = raw_bind(raw->raw_pcb, src_addr);
if (err != ERR_OK)
return util_convert_err(err);
}
/*
* Connecting a raw socket serves two main purposes: 1) the socket uses
* the address as destination when sending, and 2) the socket receives
* packets from only the connected address.
*/
err = raw_connect(raw->raw_pcb, &dst_addr);
if (err != ERR_OK)
return util_convert_err(err);
return OK;
}
/*
* Perform preliminary checks on a send request.
*/
static int
rawsock_pre_send(struct sock * sock, size_t len, socklen_t ctl_len __unused,
const struct sockaddr * addr, socklen_t addr_len __unused,
endpoint_t user_endpt __unused, int flags)
{
struct rawsock *raw = (struct rawsock *)sock;
if ((flags & ~MSG_DONTROUTE) != 0)
return EOPNOTSUPP;
if (!rawsock_is_conn(raw) && addr == NULL)
return EDESTADDRREQ;
/*
* This is only one part of the length check. The rest is done from
* rawsock_send(), once we have more information.
*/
if (len > ipsock_get_sndbuf(rawsock_get_ipsock(raw)))
return EMSGSIZE;
return OK;
}
/*
* Swap IP-level options between the RAW PCB and the packet options structure,
* for all options that have their flag set in the packet options structure.
* This function is called twice when sending a packet. The result is that the
* flagged options are overridden for only the packet being sent.
*/
static void
rawsock_swap_opt(struct rawsock * raw, struct pktopt * pkto)
{
uint8_t tos, ttl, mcast_ttl;
if (pkto->pkto_flags & PKTOF_TOS) {
tos = raw->raw_pcb->tos;
raw->raw_pcb->tos = pkto->pkto_tos;
pkto->pkto_tos = tos;
}
if (pkto->pkto_flags & PKTOF_TTL) {
ttl = raw->raw_pcb->ttl;
mcast_ttl = raw_get_multicast_ttl(raw->raw_pcb);
raw->raw_pcb->ttl = pkto->pkto_ttl;
raw_set_multicast_ttl(raw->raw_pcb, pkto->pkto_ttl);
pkto->pkto_ttl = ttl;
pkto->pkto_mcast_ttl = mcast_ttl;
}
}
/*
* We are about to send the given packet that already includes an IPv4 header,
* because the IP_HDRINCL option is enabled on a raw IPv4 socket. Prepare the
* IPv4 header for sending, by modifying a few fields in it, as expected by
* userland.
*/
static int
rawsock_prepare_hdrincl(struct rawsock * raw, struct pbuf * pbuf,
const ip_addr_t * src_addr)
{
struct ip_hdr *iphdr;
size_t hlen;
/*
* lwIP obtains the destination address from the IP packet header in
* this case, so make sure the packet has a full-sized header.
*/
if (pbuf->len < sizeof(struct ip_hdr))
return EINVAL;
iphdr = (struct ip_hdr *)pbuf->payload;
/*
* Fill in the source address if it is not set, and do the byte
* swapping and checksum computation common for the BSDs, without which
* ping(8) and traceroute(8) do not work properly. We consider this a
* convenience feature, so malformed packets are simply sent as is.
* TODO: deal with type punning..
*/
hlen = (size_t)IPH_HL(iphdr) << 2;
if (pbuf->len >= hlen) {
/* Fill in the source address if it is blank. */
if (iphdr->src.addr == PP_HTONL(INADDR_ANY)) {
assert(IP_IS_V4(src_addr));
iphdr->src.addr = ip_addr_get_ip4_u32(src_addr);
}
IPH_LEN(iphdr) = htons(IPH_LEN(iphdr));
IPH_OFFSET(iphdr) = htons(IPH_OFFSET(iphdr));
IPH_CHKSUM(iphdr) = 0;
IPH_CHKSUM(iphdr) = inet_chksum(iphdr, hlen);
}
return OK;
}
/*
* Send a packet on a raw socket.
*/
static int
rawsock_send(struct sock * sock, const struct sockdriver_data * data,
size_t len, size_t * off, const struct sockdriver_data * ctl __unused,
socklen_t ctl_len __unused, socklen_t * ctl_off __unused,
const struct sockaddr * addr, socklen_t addr_len,
endpoint_t user_endpt __unused, int flags, size_t min __unused)
{
struct rawsock *raw = (struct rawsock *)sock;
struct pktopt pktopt;
struct pbuf *pbuf;
struct ifdev *ifdev;
struct netif *netif;
const ip_addr_t *dst_addrp, *src_addrp;
ip_addr_t src_addr, dst_addr; /* for storage only; not always used! */
size_t hdrlen;
uint32_t ifindex;
err_t err;
int r;
/* Copy in and parse any packet options. */
pktopt.pkto_flags = 0;
if ((r = pktsock_get_ctl(&raw->raw_pktsock, ctl, ctl_len,
&pktopt)) != OK)
return r;
/*
* For a more in-depth explanation of what is going on here, see the
* udpsock module, which has largely the same code but with more
* elaborate comments.
*/
/*
* Start by checking whether the source address and/or the outgoing
* interface are overridden using sticky and/or ancillary options.
*/
if ((r = pktsock_get_pktinfo(&raw->raw_pktsock, &pktopt, &ifdev,
&src_addr)) != OK)
return r;
if (ifdev != NULL && !ip_addr_isany(&src_addr)) {
/* This is guaranteed to be a proper local unicast address. */
src_addrp = &src_addr;
} else {
src_addrp = &raw->raw_pcb->local_ip;
/*
* If the socket is bound to a multicast address, use the
* unspecified ('any') address as source address instead. A
* real source address will then be selected further below.
*/
if (ip_addr_ismulticast(src_addrp))
src_addrp = IP46_ADDR_ANY(IP_GET_TYPE(src_addrp));
}
/*
* Determine the destination address to use. If the socket is
* connected, always ignore any address provided in the send call.
*/
if (!rawsock_is_conn(raw)) {
assert(addr != NULL); /* already checked in pre_send */
if ((r = ipsock_get_dst_addr(rawsock_get_ipsock(raw), addr,
addr_len, src_addrp, &dst_addr, NULL /*dst_port*/)) != OK)
return r;
dst_addrp = &dst_addr;
} else
dst_addrp = &raw->raw_pcb->remote_ip;
/*
* If the destination is a multicast address, select the outgoing
* interface based on the multicast interface index, if one is set.
* This must however *not* override an interface index already
* specified using IPV6_PKTINFO, as per RFC 3542 Sec. 6.7.
*/
if (ifdev == NULL && ip_addr_ismulticast(dst_addrp)) {
ifindex = raw_get_multicast_netif_index(raw->raw_pcb);
if (ifindex != NETIF_NO_INDEX)
ifdev = ifdev_get_by_index(ifindex); /* (may fail) */
}
/*
* If an interface has been determined already now, the send operation
* will bypass routing. In that case, we must perform our own checks
* on address zone violations, because those will not be made anywhere
* else. Subsequent steps below will never introduce violations.
*/
if (ifdev != NULL && IP_IS_V6(dst_addrp)) {
if (ifaddr_is_zone_mismatch(ip_2_ip6(dst_addrp), ifdev))
return EHOSTUNREACH;
if (IP_IS_V6(src_addrp) &&
ifaddr_is_zone_mismatch(ip_2_ip6(src_addrp), ifdev))
return EHOSTUNREACH;
}
/*
* If we do not yet have an interface at this point, perform a route
* lookup to determine the outgoing interface, unless MSG_DONTROUTE is
* set.
*/
if (ifdev == NULL) {
if (!(flags & MSG_DONTROUTE)) {
/*
* ip_route() should never be called with an
* IPADDR_TYPE_ANY type address. This is a lwIP-
* internal requirement; while we override both routing
* functions, we do not deviate from it.
*/
if (IP_IS_ANY_TYPE_VAL(*src_addrp))
src_addrp =
IP46_ADDR_ANY(IP_GET_TYPE(dst_addrp));
/* Perform the route lookup. */
if ((netif = ip_route(src_addrp, dst_addrp)) == NULL)
return EHOSTUNREACH;
ifdev = netif_get_ifdev(netif);
} else {
if ((ifdev = ifaddr_map_by_subnet(dst_addrp)) == NULL)
return EHOSTUNREACH;
}
}
/*
* At this point we have an outgoing interface. If we do not have a
* source address yet, pick one now. As a sidenote, if the destination
* address is scoped but has no zone, we could also fill in the zone
* now. We let lwIP handle that instead, though.
*/
assert(ifdev != NULL);
if (ip_addr_isany(src_addrp)) {
src_addrp = ifaddr_select(dst_addrp, ifdev, NULL /*ifdevp*/);
if (src_addrp == NULL)
return EHOSTUNREACH;
}
/*
* Now that we know the full conditions of what we are about to send,
* check whether the packet size leaves enough room for lwIP to prepend
* headers. If so, allocate a chain of pbufs for the packet.
*/
assert(len <= RAW_MAX_PAYLOAD);
if (rawsock_is_hdrincl(raw))
hdrlen = 0;
else if (IP_IS_V6(dst_addrp))
hdrlen = IP6_HLEN;
else
hdrlen = IP_HLEN;
if (hdrlen + len > RAW_MAX_PAYLOAD)
return EMSGSIZE;
if ((pbuf = pchain_alloc(PBUF_IP, len)) == NULL)
return ENOBUFS;
/* Copy in the packet data. */
if ((r = pktsock_get_data(&raw->raw_pktsock, data, len, pbuf)) != OK) {
pbuf_free(pbuf);
return r;
}
/*
* If the user has turned on IPV6_CHECKSUM, ensure that the packet is
* not only large enough to have the checksum stored at the configured
* place, but also that the checksum fits within the first pbuf: if we
* do not test this here, an assert will trigger in lwIP later. Also
* zero out the checksum field first, because lwIP does not do that.
*/
if (raw->raw_pcb->chksum_reqd) {
if (pbuf->len < raw->raw_pcb->chksum_offset +
sizeof(uint16_t)) {
pbuf_free(pbuf);
return EINVAL;
}
memset((char *)pbuf->payload + raw->raw_pcb->chksum_offset, 0,
sizeof(uint16_t));
}
/*
* For sockets where an IPv4 header is already included in the packet,
* we need to alter a few header fields to be compatible with BSD.
*/
if (rawsock_is_hdrincl(raw) &&
(r = rawsock_prepare_hdrincl(raw, pbuf, src_addrp)) != OK) {
pbuf_free(pbuf);
return r;
}
/* Set broadcast/multicast flags for accounting purposes. */
if (ip_addr_ismulticast(dst_addrp))
pbuf->flags |= PBUF_FLAG_LLMCAST;
else if (ip_addr_isbroadcast(dst_addrp, ifdev_get_netif(ifdev)))
pbuf->flags |= PBUF_FLAG_LLBCAST;
/* Send the packet. */
rawsock_swap_opt(raw, &pktopt);
assert(!ip_addr_isany(src_addrp));
assert(!ip_addr_ismulticast(src_addrp));
err = raw_sendto_if_src(raw->raw_pcb, pbuf, dst_addrp,
ifdev_get_netif(ifdev), src_addrp);
rawsock_swap_opt(raw, &pktopt);
/* Free the pbuf again. */
pbuf_free(pbuf);
/*
* On success, make sure to return the size of the sent packet as well.
* As an aside: ctl_off need not be updated, as it is not returned.
*/
if ((r = util_convert_err(err)) == OK)
*off = len;
return r;
}
/*
* Update the set of flag-type socket options on a raw socket.
*/
static void
rawsock_setsockmask(struct sock * sock, unsigned int mask)
{
struct rawsock *raw = (struct rawsock *)sock;
/*
* FIXME: raw sockets are not supposed to have a broardcast check, so
* perhaps just remove this and instead always set SOF_BROADCAST?
*/
if (mask & SO_BROADCAST)
ip_set_option(raw->raw_pcb, SOF_BROADCAST);
else
ip_reset_option(raw->raw_pcb, SOF_BROADCAST);
}
/*
* Prepare a helper structure for IP-level option processing.
*/
static void
rawsock_get_ipopts(struct rawsock * raw, struct ipopts * ipopts)
{
ipopts->local_ip = &raw->raw_pcb->local_ip;
ipopts->remote_ip = &raw->raw_pcb->remote_ip;
ipopts->tos = &raw->raw_pcb->tos;
ipopts->ttl = &raw->raw_pcb->ttl;
ipopts->sndmin = RAW_SNDBUF_MIN;
ipopts->sndmax = RAW_SNDBUF_MAX;
ipopts->rcvmin = RAW_RCVBUF_MIN;
ipopts->rcvmax = RAW_RCVBUF_MAX;
}
/*
* Set socket options on a raw socket.
*/
static int
rawsock_setsockopt(struct sock * sock, int level, int name,
const struct sockdriver_data * data, socklen_t len)
{
struct rawsock *raw = (struct rawsock *)sock;
struct ipopts ipopts;
struct icmp6_filter filter;
ip_addr_t ipaddr;
struct in_addr in_addr;
struct ifdev *ifdev;
unsigned int flags;
uint32_t ifindex;
uint8_t byte;
int r, val;
/*
* Unfortunately, we have to duplicate most of the multicast options
* rather than sharing them with udpsock at the pktsock level. The
* reason is that each of the PCBs have their own multicast abstraction
* functions and so we cannot merge the rest. Same for getsockopt.
*/
switch (level) {
case IPPROTO_IP:
if (rawsock_is_ipv6(raw))
break;
switch (name) {
case IP_HDRINCL:
if ((r = sockdriver_copyin_opt(data, &val, sizeof(val),
len)) != OK)
return r;
if (val) {
raw_setflags(raw->raw_pcb,
raw_flags(raw->raw_pcb) |
RAW_FLAGS_HDRINCL);
} else {
raw_setflags(raw->raw_pcb,
raw_flags(raw->raw_pcb) &
~RAW_FLAGS_HDRINCL);
}
return OK;
case IP_MULTICAST_IF:
pktsock_set_mcaware(&raw->raw_pktsock);
if ((r = sockdriver_copyin_opt(data, &in_addr,
sizeof(in_addr), len)) != OK)
return r;
ip_addr_set_ip4_u32(&ipaddr, in_addr.s_addr);
if ((ifdev = ifaddr_map_by_addr(&ipaddr)) == NULL)
return EADDRNOTAVAIL;
raw_set_multicast_netif_index(raw->raw_pcb,
ifdev_get_index(ifdev));
return OK;
case IP_MULTICAST_LOOP:
pktsock_set_mcaware(&raw->raw_pktsock);
if ((r = sockdriver_copyin_opt(data, &byte,
sizeof(byte), len)) != OK)
return r;
flags = raw_flags(raw->raw_pcb);
if (byte)
flags |= RAW_FLAGS_MULTICAST_LOOP;
else
flags &= ~RAW_FLAGS_MULTICAST_LOOP;
raw_setflags(raw->raw_pcb, flags);
return OK;
case IP_MULTICAST_TTL:
pktsock_set_mcaware(&raw->raw_pktsock);
if ((r = sockdriver_copyin_opt(data, &byte,
sizeof(byte), len)) != OK)
return r;
raw_set_multicast_ttl(raw->raw_pcb, byte);
return OK;
}
break;
case IPPROTO_IPV6:
if (!rawsock_is_ipv6(raw))
break;
switch (name) {
case IPV6_CHECKSUM:
/* ICMPv6 checksums are always computed. */
if (raw->raw_pcb->protocol == IPPROTO_ICMPV6)
return EINVAL;
if ((r = sockdriver_copyin_opt(data, &val, sizeof(val),
len)) != OK)
return r;
if (val == -1) {
raw->raw_pcb->chksum_reqd = 0;
return OK;
} else if (val >= 0 && !(val & 1)) {
raw->raw_pcb->chksum_reqd = 1;
raw->raw_pcb->chksum_offset = val;
return OK;
} else
return EINVAL;
case IPV6_MULTICAST_IF:
pktsock_set_mcaware(&raw->raw_pktsock);
if ((r = sockdriver_copyin_opt(data, &val, sizeof(val),
len)) != OK)
return r;
if (val != 0) {
ifindex = (uint32_t)val;
ifdev = ifdev_get_by_index(ifindex);
if (ifdev == NULL)
return ENXIO;
} else
ifindex = NETIF_NO_INDEX;
raw_set_multicast_netif_index(raw->raw_pcb, ifindex);
return OK;
case IPV6_MULTICAST_LOOP:
pktsock_set_mcaware(&raw->raw_pktsock);
if ((r = sockdriver_copyin_opt(data, &val, sizeof(val),
len)) != OK)
return r;
if (val < 0 || val > 1)
return EINVAL;
flags = raw_flags(raw->raw_pcb);
if (val)
flags |= RAW_FLAGS_MULTICAST_LOOP;
else
flags &= ~RAW_FLAGS_MULTICAST_LOOP;
/*
* lwIP's IPv6 functionality does not actually check
* this flag at all yet. We set it in the hope that
* one day this will magically start working.
*/
raw_setflags(raw->raw_pcb, flags);
return OK;
case IPV6_MULTICAST_HOPS:
pktsock_set_mcaware(&raw->raw_pktsock);
if ((r = sockdriver_copyin_opt(data, &val, sizeof(val),
len)) != OK)
return r;
if (val < -1 || val > UINT8_MAX)
return EINVAL;
if (val == -1)
0