Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/eigrpd/packet.c	Lines:	0	345	0.0 %
Date:	2017-11-07	Branches:	0	223	0.0 %


/*	$OpenBSD: packet.c,v 1.18 2016/09/02 16:44:33 renato Exp $ */

/*
 * Copyright (c) 2015 Renato Westphal <renato@openbsd.org>
 * Copyright (c) 2004, 2005 Esben Norby <norby@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>
#include <net/if_dl.h>
#include <netinet/in.h>
#include <netinet/ip.h>

#include <arpa/inet.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "eigrpd.h"
#include "eigrpe.h"
#include "log.h"

static int	 send_packet_v4(struct iface *, struct nbr *, struct ibuf *);
static int	 send_packet_v6(struct iface *, struct nbr *, struct ibuf *);
static int	 recv_packet_nbr(struct nbr *, struct eigrp_hdr *,
		    struct seq_addr_head *, struct tlv_mcast_seq *);
static void	 recv_packet_eigrp(int, union eigrpd_addr *,
		    union eigrpd_addr *, struct iface *, struct eigrp_hdr *,
		    char *, uint16_t);
static int	 eigrp_hdr_sanity_check(int, union eigrpd_addr *,
		    struct eigrp_hdr *, uint16_t, const struct iface *);
static struct iface *find_iface(unsigned int, int, union eigrpd_addr *);

int
gen_eigrp_hdr(struct ibuf *buf, uint16_t opcode, uint8_t flags,
    uint32_t seq_num, uint16_t as)
{
	struct eigrp_hdr	eigrp_hdr;

	memset(&eigrp_hdr, 0, sizeof(eigrp_hdr));
	eigrp_hdr.version = EIGRP_VERSION;
	eigrp_hdr.opcode = opcode;
	/* chksum will be set later */
	eigrp_hdr.flags = htonl(flags);
	eigrp_hdr.seq_num = htonl(seq_num);
	/* ack_num will be set later */
	eigrp_hdr.vrid = htons(EIGRP_VRID_UNICAST_AF);
	eigrp_hdr.as = htons(as);

	return (ibuf_add(buf, &eigrp_hdr, sizeof(eigrp_hdr)));
}

/* send and receive packets */
static int
send_packet_v4(struct iface *iface, struct nbr *nbr, struct ibuf *buf)
{
	struct sockaddr_in	 dst;
	struct msghdr		 msg;
	struct iovec		 iov[2];
	struct ip		 ip_hdr;

	/* setup sockaddr */
	dst.sin_family = AF_INET;
	dst.sin_len = sizeof(struct sockaddr_in);
	if (nbr)
		dst.sin_addr = nbr->addr.v4;
	else
		dst.sin_addr = global.mcast_addr_v4;

	/* setup IP hdr */
	memset(&ip_hdr, 0, sizeof(ip_hdr));
	ip_hdr.ip_v = IPVERSION;
	ip_hdr.ip_hl = sizeof(ip_hdr) >> 2;
	ip_hdr.ip_tos = IPTOS_PREC_INTERNETCONTROL;
	ip_hdr.ip_len = htons(ibuf_size(buf) + sizeof(ip_hdr));
	ip_hdr.ip_id = 0;  /* 0 means kernel set appropriate value */
	ip_hdr.ip_off = 0;
	ip_hdr.ip_ttl = EIGRP_IP_TTL;
	ip_hdr.ip_p = IPPROTO_EIGRP;
	ip_hdr.ip_sum = 0;
	ip_hdr.ip_src.s_addr = if_primary_addr(iface);
	ip_hdr.ip_dst = dst.sin_addr;

	/* setup buffer */
	memset(&msg, 0, sizeof(msg));
	iov[0].iov_base = &ip_hdr;
	iov[0].iov_len = sizeof(ip_hdr);
	iov[1].iov_base = buf->buf;
	iov[1].iov_len = ibuf_size(buf);
	msg.msg_name = &dst;
	msg.msg_namelen = sizeof(dst);
	msg.msg_iov = iov;
	msg.msg_iovlen = 2;

	/* set outgoing interface for multicast traffic */
	if (IN_MULTICAST(ntohl(dst.sin_addr.s_addr)))
		if (if_set_ipv4_mcast(iface) == -1) {
			log_warn("%s: error setting multicast interface, %s",
			    __func__, iface->name);
			return (-1);
		}

	if (sendmsg(global.eigrp_socket_v4, &msg, 0) == -1) {
		log_warn("%s: error sending packet on interface %s",
		    __func__, iface->name);
		return (-1);
	}

	return (0);
}

static int
send_packet_v6(struct iface *iface, struct nbr *nbr, struct ibuf *buf)
{
	struct sockaddr_in6	 sa6;

	/* setup sockaddr */
	memset(&sa6, 0, sizeof(sa6));
	sa6.sin6_family = AF_INET6;
	sa6.sin6_len = sizeof(struct sockaddr_in6);
	if (nbr) {
		sa6.sin6_addr = nbr->addr.v6;
		addscope(&sa6, iface->ifindex);
	} else
		sa6.sin6_addr = global.mcast_addr_v6;

	/* set outgoing interface for multicast traffic */
	if (IN6_IS_ADDR_MULTICAST(&sa6.sin6_addr))
		if (if_set_ipv6_mcast(iface) == -1) {
			log_warn("%s: error setting multicast interface, %s",
			    __func__, iface->name);
			return (-1);
		}

	if (sendto(global.eigrp_socket_v6, buf->buf, buf->wpos, 0,
	    (struct sockaddr *)&sa6, sizeof(sa6)) == -1) {
		log_warn("%s: error sending packet on interface %s",
		    __func__, iface->name);
		return (-1);
	}

	return (0);
}

int
send_packet(struct eigrp_iface *ei, struct nbr *nbr, uint32_t flags,
    struct ibuf *buf)
{
	struct eigrp		*eigrp = ei->eigrp;
	struct iface		*iface = ei->iface;
	struct eigrp_hdr	*eigrp_hdr;

	if (!(iface->flags & IFF_UP) || !LINK_STATE_IS_UP(iface->linkstate))
		return (-1);

	/* update ack number, flags and checksum */
	if ((eigrp_hdr = ibuf_seek(buf, 0, sizeof(*eigrp_hdr))) == NULL)
                fatalx("send_packet: buf_seek failed");
	if (nbr) {
		eigrp_hdr->ack_num = htonl(nbr->recv_seq);
		rtp_ack_stop_timer(nbr);
	}
	if (flags) {
		eigrp_hdr->flags = ntohl(eigrp_hdr->flags) | flags;
		eigrp_hdr->flags = htonl(eigrp_hdr->flags);
	}
	eigrp_hdr->chksum = 0;
	eigrp_hdr->chksum = in_cksum(buf->buf, ibuf_size(buf));

	/* log packet being sent */
	if (eigrp_hdr->opcode != EIGRP_OPC_HELLO) {
		char	buffer[64];

		if (nbr)
			snprintf(buffer, sizeof(buffer), "nbr %s",
			    log_addr(eigrp->af, &nbr->addr));
		else
			snprintf(buffer, sizeof(buffer), "(multicast)");

		log_debug("%s: type %s iface %s %s AS %u seq %u ack %u",
		    __func__, opcode_name(eigrp_hdr->opcode), iface->name,
		    buffer, ntohs(eigrp_hdr->as), ntohl(eigrp_hdr->seq_num),
		    ntohl(eigrp_hdr->ack_num));
	}

	switch (eigrp->af) {
	case AF_INET:
		if (send_packet_v4(iface, nbr, buf) < 0)
			return (-1);
		break;
	case AF_INET6:
		if (send_packet_v6(iface, nbr, buf) < 0)
			return (-1);
		break;
	default:
		fatalx("send_packet: unknown af");
	}

	switch (eigrp_hdr->opcode) {
	case EIGRP_OPC_HELLO:
		if (ntohl(eigrp_hdr->ack_num) == 0)
			ei->eigrp->stats.hellos_sent++;
		else
			ei->eigrp->stats.acks_sent++;
		break;
	case EIGRP_OPC_UPDATE:
		ei->eigrp->stats.updates_sent++;
		break;
	case EIGRP_OPC_QUERY:
		ei->eigrp->stats.queries_sent++;
		break;
	case EIGRP_OPC_REPLY:
		ei->eigrp->stats.replies_sent++;
		break;
	case EIGRP_OPC_SIAQUERY:
		ei->eigrp->stats.squeries_sent++;
		break;
	case EIGRP_OPC_SIAREPLY:
		ei->eigrp->stats.sreplies_sent++;
		break;
	default:
		break;
	}

	return (0);
}

static int
recv_packet_nbr(struct nbr *nbr, struct eigrp_hdr *eigrp_hdr,
    struct seq_addr_head *seq_addr_list, struct tlv_mcast_seq *tm)
{
	uint32_t		 seq, ack;
	struct seq_addr_entry	*sa;

	seq = ntohl(eigrp_hdr->seq_num);
	ack = ntohl(eigrp_hdr->ack_num);

	/*
	 * draft-savage-eigrp-04 - Section 5.3.1:
	 * "In addition to the HELLO packet, if any packet is received within
	 * the hold time period, then the Hold Time period will be reset."
	 */
	nbr_start_timeout(nbr);

	/* handle the sequence tlv */
	if (eigrp_hdr->opcode == EIGRP_OPC_HELLO &&
	    !TAILQ_EMPTY(seq_addr_list)) {
		nbr->flags |= F_EIGRP_NBR_CR_MODE;

		TAILQ_FOREACH(sa, seq_addr_list, entry) {
			switch (sa->af) {
			case AF_INET:
				if (sa->addr.v4.s_addr ==
				    if_primary_addr(nbr->ei->iface)) {
					nbr->flags &= ~F_EIGRP_NBR_CR_MODE;
					break;
				}
				break;
			case AF_INET6:
				if (IN6_ARE_ADDR_EQUAL(&sa->addr.v6,
				    &nbr->ei->iface->linklocal)) {
					nbr->flags &= ~F_EIGRP_NBR_CR_MODE;
					break;
				}
				break;
			default:
				break;
			}
		}
		if (tm)
			nbr->next_mcast_seq = ntohl(tm->seq);
	}

	if ((ntohl(eigrp_hdr->flags) & EIGRP_HDR_FLAG_CR)) {
		if (!(nbr->flags & F_EIGRP_NBR_CR_MODE))
			return (-1);
		nbr->flags &= ~F_EIGRP_NBR_CR_MODE;
		if (ntohl(eigrp_hdr->seq_num) != nbr->next_mcast_seq)
			return (-1);
	}

	/* ack processing */
	if (ack != 0)
		rtp_process_ack(nbr, ack);
	if (seq != 0) {
		/* check for sequence wraparound */
		if (nbr->recv_seq >= seq &&
		   !(nbr->recv_seq == UINT32_MAX && seq == 1)) {
			log_debug("%s: duplicate packet", __func__);
			rtp_send_ack(nbr);
			return (-1);
		}
		nbr->recv_seq = seq;
	}

	return (0);
}

static void
recv_packet_eigrp(int af, union eigrpd_addr *src, union eigrpd_addr *dest,
    struct iface *iface, struct eigrp_hdr *eigrp_hdr, char *buf, uint16_t len)
{
	struct eigrp_iface	*ei;
	struct nbr		*nbr;
	struct tlv_parameter	*tp = NULL;
	struct tlv_sw_version	*tv = NULL;
	struct tlv_mcast_seq	*tm = NULL;
	struct rinfo		 ri;
	struct rinfo_entry	*re;
	struct seq_addr_head	 seq_addr_list;
	struct rinfo_head	 rinfo_list;

	/* EIGRP header sanity checks */
	if (eigrp_hdr_sanity_check(af, dest, eigrp_hdr, len, iface) == -1)
		return;

	buf += sizeof(*eigrp_hdr);
	len -= sizeof(*eigrp_hdr);

	TAILQ_INIT(&seq_addr_list);
	TAILQ_INIT(&rinfo_list);
	while (len > 0) {
		struct tlv 	tlv;
		uint16_t	tlv_type;

		if (len < sizeof(tlv)) {
			log_debug("%s: malformed packet (bad length)",
			    __func__);
			goto error;
		}

		memcpy(&tlv, buf, sizeof(tlv));
		if (ntohs(tlv.length) > len) {
			log_debug("%s: malformed packet (bad length)",
			    __func__);
			goto error;
		}

		tlv_type = ntohs(tlv.type);
		switch (tlv_type) {
		case TLV_TYPE_PARAMETER:
			if ((tp = tlv_decode_parameter(&tlv, buf)) == NULL)
				goto error;
			break;
		case TLV_TYPE_SEQ:
			if (tlv_decode_seq(af, &tlv, buf, &seq_addr_list) < 0)
				goto error;
			break;
		case TLV_TYPE_SW_VERSION:
			if ((tv = tlv_decode_sw_version(&tlv, buf)) == NULL)
				goto error;
			break;
		case TLV_TYPE_MCAST_SEQ:
			if ((tm = tlv_decode_mcast_seq(&tlv, buf)) == NULL)
				goto error;
			break;
		case TLV_TYPE_IPV4_INTERNAL:
		case TLV_TYPE_IPV4_EXTERNAL:
		case TLV_TYPE_IPV6_INTERNAL:
		case TLV_TYPE_IPV6_EXTERNAL:
			/* silently ignore TLV from different address-family */
			if ((tlv_type & TLV_PROTO_MASK) == TLV_PROTO_IPV4 &&
			    af != AF_INET)
				break;
			if ((tlv_type & TLV_PROTO_MASK) == TLV_PROTO_IPV6 &&
			    af != AF_INET6)
				break;

			if (tlv_decode_route(af, &tlv, buf, &ri) < 0)
				goto error;
			if ((re = calloc(1, sizeof(*re))) == NULL)
				fatal("recv_packet_eigrp");
			re->rinfo = ri;
			TAILQ_INSERT_TAIL(&rinfo_list, re, entry);
			break;
		case TLV_TYPE_AUTH:
		case TLV_TYPE_PEER_TERM:
			/*
			 * XXX There is no enough information in the draft
			 * to implement these TLVs properly.
			 */
		case TLV_TYPE_IPV4_COMMUNITY:
		case TLV_TYPE_IPV6_COMMUNITY:
			/* TODO */
		default:
			/* ignore unknown tlv */
			break;
		}
		buf += ntohs(tlv.length);
		len -= ntohs(tlv.length);
	}

	ei = eigrp_if_lookup(iface, af, ntohs(eigrp_hdr->as));
	if (ei == NULL || ei->passive)
		goto error;

	nbr = nbr_find(ei, src);
	if (nbr == NULL && (eigrp_hdr->opcode != EIGRP_OPC_HELLO ||
	    ntohl(eigrp_hdr->ack_num) != 0)) {
		log_debug("%s: unknown neighbor", __func__);
		goto error;
	} else if (nbr && recv_packet_nbr(nbr, eigrp_hdr, &seq_addr_list,
	    tm) < 0)
		goto error;

	/* log packet being received */
	if (eigrp_hdr->opcode != EIGRP_OPC_HELLO)
		log_debug("%s: type %s nbr %s AS %u seq %u ack %u", __func__,
		    opcode_name(eigrp_hdr->opcode), log_addr(af, &nbr->addr),
		    ei->eigrp->as, ntohl(eigrp_hdr->seq_num),
		    ntohl(eigrp_hdr->ack_num));

	/* switch EIGRP packet type */
	switch (eigrp_hdr->opcode) {
	case EIGRP_OPC_HELLO:
		if (ntohl(eigrp_hdr->ack_num) == 0) {
			recv_hello(ei, src, nbr, tp);
			ei->eigrp->stats.hellos_recv++;
		} else
			ei->eigrp->stats.acks_recv++;
		break;
	case EIGRP_OPC_UPDATE:
		recv_update(nbr, &rinfo_list, ntohl(eigrp_hdr->flags));
		ei->eigrp->stats.updates_recv++;
		break;
	case EIGRP_OPC_QUERY:
		recv_query(nbr, &rinfo_list, 0);
		ei->eigrp->stats.queries_recv++;
		break;
	case EIGRP_OPC_REPLY:
		recv_reply(nbr, &rinfo_list, 0);
		ei->eigrp->stats.replies_recv++;
		break;
	case EIGRP_OPC_SIAQUERY:
		recv_query(nbr, &rinfo_list, 1);
		ei->eigrp->stats.squeries_recv++;
		break;
	case EIGRP_OPC_SIAREPLY:
		recv_reply(nbr, &rinfo_list, 1);
		ei->eigrp->stats.sreplies_recv++;
		break;
	default:
		log_debug("%s: unknown EIGRP packet type, interface %s",
		    __func__, iface->name);
	}

error:
	/* free rinfo tlvs */
	message_list_clr(&rinfo_list);
	/* free seq addresses tlvs */
	seq_addr_list_clr(&seq_addr_list);
}

#define CMSG_MAXLEN max(sizeof(struct sockaddr_dl), sizeof(struct in6_pktinfo))
void
recv_packet(int fd, short event, void *bula)
{
	union {
		struct	cmsghdr hdr;
		char	buf[CMSG_SPACE(CMSG_MAXLEN)];
	} cmsgbuf;
	struct msghdr		 msg;
	struct sockaddr_storage	 from;
	struct iovec		 iov;
	struct ip		 ip_hdr;
	char			*buf;
	struct cmsghdr		*cmsg;
	ssize_t			 r;
	uint16_t		 len;
	int			 af;
	union eigrpd_addr	 src, dest;
	unsigned int		 ifindex = 0;
	struct iface		*iface;
	struct eigrp_hdr	*eigrp_hdr;

	if (event != EV_READ)
		return;

	/* setup buffer */
	memset(&msg, 0, sizeof(msg));
	iov.iov_base = buf = pkt_ptr;
	iov.iov_len = READ_BUF_SIZE;
	msg.msg_name = &from;
	msg.msg_namelen = sizeof(from);
	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;
	msg.msg_control = &cmsgbuf.buf;
	msg.msg_controllen = sizeof(cmsgbuf.buf);

	if ((r = recvmsg(fd, &msg, 0)) == -1) {
		if (errno != EAGAIN && errno != EINTR)
			log_debug("%s: read error: %s", __func__,
			    strerror(errno));
		return;
	}
	len = (uint16_t)r;

	sa2addr((struct sockaddr *)&from, &af, &src);
	if (bad_addr(af, &src)) {
		log_debug("%s: invalid source address: %s", __func__,
		    log_addr(af, &src));
		return;
	}

	for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL;
	    cmsg = CMSG_NXTHDR(&msg, cmsg)) {
		if (af == AF_INET && cmsg->cmsg_level == IPPROTO_IP &&
		    cmsg->cmsg_type == IP_RECVIF) {
			ifindex = ((struct sockaddr_dl *)
			    CMSG_DATA(cmsg))->sdl_index;
			break;
		}
		if (af == AF_INET6 && cmsg->cmsg_level == IPPROTO_IPV6 &&
		    cmsg->cmsg_type == IPV6_PKTINFO) {
			ifindex = ((struct in6_pktinfo *)
			    CMSG_DATA(cmsg))->ipi6_ifindex;
			dest.v6 = ((struct in6_pktinfo *)
			    CMSG_DATA(cmsg))->ipi6_addr;
			break;
		}
	}

	/* find a matching interface */
	if ((iface = find_iface(ifindex, af, &src)) == NULL)
		return;

	/* the IPv4 raw sockets API gives us direct access to the IP header */
	if (af == AF_INET) {
		if (len < sizeof(ip_hdr)) {
			log_debug("%s: bad packet size", __func__);
			return;
		}
		memcpy(&ip_hdr, buf, sizeof(ip_hdr));
		if (ntohs(ip_hdr.ip_len) != len) {
			log_debug("%s: invalid IP packet length %u", __func__,
			    ntohs(ip_hdr.ip_len));
			return;
		}
		buf += ip_hdr.ip_hl << 2;
		len -= ip_hdr.ip_hl << 2;
		dest.v4 = ip_hdr.ip_dst;
	}

	/* validate destination address */
	switch (af) {
	case AF_INET:
		/*
		 * Packet needs to be sent to 224.0.0.10 or to one of the
		 * interface addresses.
		 */
		if (dest.v4.s_addr != global.mcast_addr_v4.s_addr) {
			struct if_addr	*if_addr;
			int		 found = 0;

			TAILQ_FOREACH(if_addr, &iface->addr_list, entry)
				if (if_addr->af == AF_INET &&
				    dest.v4.s_addr == if_addr->addr.v4.s_addr) {
					found = 1;
					break;
				}
			if (found == 0) {
				log_debug("%s: packet sent to wrong address "
				    "%s, interface %s", __func__,
				    inet_ntoa(dest.v4), iface->name);
				return;
			}
		}
		break;
	case AF_INET6:
		/*
		 * Packet needs to be sent to ff02::a or to the link local
		 * address of the interface.
		 */
		if (!IN6_ARE_ADDR_EQUAL(&dest.v6, &global.mcast_addr_v6) &&
		    !IN6_ARE_ADDR_EQUAL(&dest.v6, &iface->linklocal)) {
			log_debug("%s: packet sent to wrong address %s, "
			    "interface %s", __func__, log_in6addr(&dest.v6),
			    iface->name);
			return;
		}
		break;
	default:
		fatalx("recv_packet: unknown af");
		break;
	}

	if (len < sizeof(*eigrp_hdr)) {
		log_debug("%s: bad packet size", __func__);
		return;
	}
	eigrp_hdr = (struct eigrp_hdr *)buf;

	recv_packet_eigrp(af, &src, &dest, iface, eigrp_hdr, buf, len);
}

static int
eigrp_hdr_sanity_check(int af, union eigrpd_addr *addr,
    struct eigrp_hdr *eigrp_hdr, uint16_t len, const struct iface *iface)
{
	if (in_cksum(eigrp_hdr, len)) {
		log_debug("%s: invalid checksum, interface %s", __func__,
		    iface->name);
		return (-1);
	}

	if (eigrp_hdr->version != EIGRP_HEADER_VERSION) {
		log_debug("%s: invalid EIGRP version %d, interface %s",
		    __func__, eigrp_hdr->version, iface->name);
		return (-1);
	}

	if (ntohs(eigrp_hdr->vrid) != EIGRP_VRID_UNICAST_AF) {
		log_debug("%s: unknown or unsupported vrid %u, interface %s",
		    __func__, ntohs(eigrp_hdr->vrid), iface->name);
		return (-1);
	}

	if (eigrp_hdr->opcode == EIGRP_OPC_HELLO &&
	    eigrp_hdr->ack_num != 0) {
		switch (af) {
		case AF_INET:
			if (IN_MULTICAST(addr->v4.s_addr)) {
				log_debug("%s: multicast ack (ipv4), "
				    "interface %s", __func__, iface->name);
				return (-1);
			}
			break;
		case AF_INET6:
			if (IN6_IS_ADDR_MULTICAST(&addr->v6)) {
				log_debug("%s: multicast ack (ipv6), "
				    "interface %s", __func__, iface->name);
				return (-1);
			}
			break;
		default:
			fatalx("eigrp_hdr_sanity_check: unknown af");
		}
	}

	return (0);
}

static struct iface *
find_iface(unsigned int ifindex, int af, union eigrpd_addr *src)
{
	struct iface	*iface;
	struct if_addr	*if_addr;
	in_addr_t	 mask;

	iface = if_lookup(econf, ifindex);
	if (iface == NULL)
		return (NULL);

	switch (af) {
	case AF_INET:
		/*
		 * From CCNP ROUTE 642-902 OCG:
		 * "EIGRP's rules about neighbor IP addresses being in the same
		 * subnet are less exact than OSPF. OSPF requires matching
		 * subnet numbers and masks. EIGRP just asks the question of
		 * whether the neighbor's IP address is in the range of
		 * addresses for the subnet as known to the local router."
		 */
		TAILQ_FOREACH(if_addr, &iface->addr_list, entry) {
			if (if_addr->af == AF_INET) {
				mask = prefixlen2mask(if_addr->prefixlen);

				if ((if_addr->addr.v4.s_addr & mask) ==
				    (src->v4.s_addr & mask))
					return (iface);
			}
		}
		break;
	case AF_INET6:
		/*
		 * draft-savage-eigrp-04 - Section 10.1:
		 * "EIGRP IPv6 will check that a received HELLO contains a valid
		 * IPv6 link-local source address."
		 */
		if (IN6_IS_ADDR_LINKLOCAL(&src->v6))
			return (iface);
		break;
	default:
		fatalx("find_iface: unknown af");
	}

	return (NULL);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: packet.c,v 1.18 2016/09/02 16:44:33 renato Exp $ */
2
3			/*
4			* Copyright (c) 2015 Renato Westphal <renato@openbsd.org>
5			* Copyright (c) 2004, 2005 Esben Norby <norby@openbsd.org>
6			*
7			* Permission to use, copy, modify, and distribute this software for any
8			* purpose with or without fee is hereby granted, provided that the above
9			* copyright notice and this permission notice appear in all copies.
10			*
11			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18			*/
19
20			#include <sys/types.h>
21			#include <net/if_dl.h>
22			#include <netinet/in.h>
23			#include <netinet/ip.h>
24
25			#include <arpa/inet.h>
26			#include <errno.h>
27			#include <stdio.h>
28			#include <stdlib.h>
29			#include <string.h>
30
31			#include "eigrpd.h"
32			#include "eigrpe.h"
33			#include "log.h"
34
35			static int send_packet_v4(struct iface , struct nbr , struct ibuf *);
36			static int send_packet_v6(struct iface , struct nbr , struct ibuf *);
37			static int recv_packet_nbr(struct nbr , struct eigrp_hdr ,
38			struct seq_addr_head , struct tlv_mcast_seq );
39			static void recv_packet_eigrp(int, union eigrpd_addr *,
40			union eigrpd_addr , struct iface , struct eigrp_hdr *,
41			char *, uint16_t);
42			static int eigrp_hdr_sanity_check(int, union eigrpd_addr *,
43			struct eigrp_hdr , uint16_t, const struct iface );
44			static struct iface find_iface(unsigned int, int, union eigrpd_addr );
45
46			int
47			gen_eigrp_hdr(struct ibuf *buf, uint16_t opcode, uint8_t flags,
48			uint32_t seq_num, uint16_t as)
49			{
50			struct eigrp_hdr eigrp_hdr;
51
52			memset(&eigrp_hdr, 0, sizeof(eigrp_hdr));
53			eigrp_hdr.version = EIGRP_VERSION;
54			eigrp_hdr.opcode = opcode;
55			/* chksum will be set later */
56			eigrp_hdr.flags = htonl(flags);
57			eigrp_hdr.seq_num = htonl(seq_num);
58			/* ack_num will be set later */
59			eigrp_hdr.vrid = htons(EIGRP_VRID_UNICAST_AF);
60			eigrp_hdr.as = htons(as);
61
62			return (ibuf_add(buf, &eigrp_hdr, sizeof(eigrp_hdr)));
63			}
64
65			/* send and receive packets */
66			static int
67			send_packet_v4(struct iface iface, struct nbr nbr, struct ibuf *buf)
68			{
69			struct sockaddr_in dst;
70			struct msghdr msg;
71			struct iovec iov[2];
72			struct ip ip_hdr;
73
74			/* setup sockaddr */
75			dst.sin_family = AF_INET;
76			dst.sin_len = sizeof(struct sockaddr_in);
77			if (nbr)
78			dst.sin_addr = nbr->addr.v4;
79			else
80			dst.sin_addr = global.mcast_addr_v4;
81
82			/* setup IP hdr */
83			memset(&ip_hdr, 0, sizeof(ip_hdr));
84			ip_hdr.ip_v = IPVERSION;
85			ip_hdr.ip_hl = sizeof(ip_hdr) >> 2;
86			ip_hdr.ip_tos = IPTOS_PREC_INTERNETCONTROL;
87			ip_hdr.ip_len = htons(ibuf_size(buf) + sizeof(ip_hdr));
88			ip_hdr.ip_id = 0; /* 0 means kernel set appropriate value */
89			ip_hdr.ip_off = 0;
90			ip_hdr.ip_ttl = EIGRP_IP_TTL;
91			ip_hdr.ip_p = IPPROTO_EIGRP;
92			ip_hdr.ip_sum = 0;
93			ip_hdr.ip_src.s_addr = if_primary_addr(iface);
94			ip_hdr.ip_dst = dst.sin_addr;
95
96			/* setup buffer */
97			memset(&msg, 0, sizeof(msg));
98			iov[0].iov_base = &ip_hdr;
99			iov[0].iov_len = sizeof(ip_hdr);
100			iov[1].iov_base = buf->buf;
101			iov[1].iov_len = ibuf_size(buf);
102			msg.msg_name = &dst;
103			msg.msg_namelen = sizeof(dst);
104			msg.msg_iov = iov;
105			msg.msg_iovlen = 2;
106
107			/* set outgoing interface for multicast traffic */
108			if (IN_MULTICAST(ntohl(dst.sin_addr.s_addr)))
109			if (if_set_ipv4_mcast(iface) == -1) {
110			log_warn("%s: error setting multicast interface, %s",
111			__func__, iface->name);
112			return (-1);
113			}
114
115			if (sendmsg(global.eigrp_socket_v4, &msg, 0) == -1) {
116			log_warn("%s: error sending packet on interface %s",
117			__func__, iface->name);
118			return (-1);
119			}
120
121			return (0);
122			}
123
124			static int
125			send_packet_v6(struct iface iface, struct nbr nbr, struct ibuf *buf)
126			{
127			struct sockaddr_in6 sa6;
128
129			/* setup sockaddr */
130			memset(&sa6, 0, sizeof(sa6));
131			sa6.sin6_family = AF_INET6;
132			sa6.sin6_len = sizeof(struct sockaddr_in6);
133			if (nbr) {
134			sa6.sin6_addr = nbr->addr.v6;
135			addscope(&sa6, iface->ifindex);
136			} else
137			sa6.sin6_addr = global.mcast_addr_v6;
138
139			/* set outgoing interface for multicast traffic */
140			if (IN6_IS_ADDR_MULTICAST(&sa6.sin6_addr))
141			if (if_set_ipv6_mcast(iface) == -1) {
142			log_warn("%s: error setting multicast interface, %s",
143			__func__, iface->name);
144			return (-1);
145			}
146
147			if (sendto(global.eigrp_socket_v6, buf->buf, buf->wpos, 0,
148			(struct sockaddr *)&sa6, sizeof(sa6)) == -1) {
149			log_warn("%s: error sending packet on interface %s",
150			__func__, iface->name);
151			return (-1);
152			}
153
154			return (0);
155			}
156
157			int
158			send_packet(struct eigrp_iface ei, struct nbr nbr, uint32_t flags,
159			struct ibuf *buf)
160			{
161			struct eigrp *eigrp = ei->eigrp;
162			struct iface *iface = ei->iface;
163			struct eigrp_hdr *eigrp_hdr;
164
165			if (!(iface->flags & IFF_UP) \|\| !LINK_STATE_IS_UP(iface->linkstate))
166			return (-1);
167
168			/* update ack number, flags and checksum */
169			if ((eigrp_hdr = ibuf_seek(buf, 0, sizeof(*eigrp_hdr))) == NULL)
170			fatalx("send_packet: buf_seek failed");
171			if (nbr) {
172			eigrp_hdr->ack_num = htonl(nbr->recv_seq);
173			rtp_ack_stop_timer(nbr);
174			}
175			if (flags) {
176			eigrp_hdr->flags = ntohl(eigrp_hdr->flags) \| flags;
177			eigrp_hdr->flags = htonl(eigrp_hdr->flags);
178			}
179			eigrp_hdr->chksum = 0;
180			eigrp_hdr->chksum = in_cksum(buf->buf, ibuf_size(buf));
181
182			/* log packet being sent */
183			if (eigrp_hdr->opcode != EIGRP_OPC_HELLO) {
184			char buffer[64];
185
186			if (nbr)
187			snprintf(buffer, sizeof(buffer), "nbr %s",
188			log_addr(eigrp->af, &nbr->addr));
189			else
190			snprintf(buffer, sizeof(buffer), "(multicast)");
191
192			log_debug("%s: type %s iface %s %s AS %u seq %u ack %u",
193			__func__, opcode_name(eigrp_hdr->opcode), iface->name,
194			buffer, ntohs(eigrp_hdr->as), ntohl(eigrp_hdr->seq_num),
195			ntohl(eigrp_hdr->ack_num));
196			}
197
198			switch (eigrp->af) {
199			case AF_INET:
200			if (send_packet_v4(iface, nbr, buf) < 0)
201			return (-1);
202			break;
203			case AF_INET6:
204			if (send_packet_v6(iface, nbr, buf) < 0)
205			return (-1);
206			break;
207			default:
208			fatalx("send_packet: unknown af");
209			}
210
211			switch (eigrp_hdr->opcode) {
212			case EIGRP_OPC_HELLO:
213			if (ntohl(eigrp_hdr->ack_num) == 0)
214			ei->eigrp->stats.hellos_sent++;
215			else
216			ei->eigrp->stats.acks_sent++;
217			break;
218			case EIGRP_OPC_UPDATE:
219			ei->eigrp->stats.updates_sent++;
220			break;
221			case EIGRP_OPC_QUERY:
222			ei->eigrp->stats.queries_sent++;
223			break;
224			case EIGRP_OPC_REPLY:
225			ei->eigrp->stats.replies_sent++;
226			break;
227			case EIGRP_OPC_SIAQUERY:
228			ei->eigrp->stats.squeries_sent++;
229			break;
230			case EIGRP_OPC_SIAREPLY:
231			ei->eigrp->stats.sreplies_sent++;
232			break;
233			default:
234			break;
235			}
236
237			return (0);
238			}
239
240			static int
241			recv_packet_nbr(struct nbr nbr, struct eigrp_hdr eigrp_hdr,
242			struct seq_addr_head seq_addr_list, struct tlv_mcast_seq tm)
243			{
244			uint32_t seq, ack;
245			struct seq_addr_entry *sa;
246
247			seq = ntohl(eigrp_hdr->seq_num);
248			ack = ntohl(eigrp_hdr->ack_num);
249
250			/*
251			* draft-savage-eigrp-04 - Section 5.3.1:
252			* "In addition to the HELLO packet, if any packet is received within
253			* the hold time period, then the Hold Time period will be reset."
254			*/
255			nbr_start_timeout(nbr);
256
257			/* handle the sequence tlv */
258			if (eigrp_hdr->opcode == EIGRP_OPC_HELLO &&
259			!TAILQ_EMPTY(seq_addr_list)) {
260			nbr->flags \|= F_EIGRP_NBR_CR_MODE;
261
262			TAILQ_FOREACH(sa, seq_addr_list, entry) {
263			switch (sa->af) {
264			case AF_INET:
265			if (sa->addr.v4.s_addr ==
266			if_primary_addr(nbr->ei->iface)) {
267			nbr->flags &= ~F_EIGRP_NBR_CR_MODE;
268			break;
269			}
270			break;
271			case AF_INET6:
272			if (IN6_ARE_ADDR_EQUAL(&sa->addr.v6,
273			&nbr->ei->iface->linklocal)) {
274			nbr->flags &= ~F_EIGRP_NBR_CR_MODE;
275			break;
276			}
277			break;
278			default:
279			break;
280			}
281			}
282			if (tm)
283			nbr->next_mcast_seq = ntohl(tm->seq);
284			}
285
286			if ((ntohl(eigrp_hdr->flags) & EIGRP_HDR_FLAG_CR)) {
287			if (!(nbr->flags & F_EIGRP_NBR_CR_MODE))
288			return (-1);
289			nbr->flags &= ~F_EIGRP_NBR_CR_MODE;
290			if (ntohl(eigrp_hdr->seq_num) != nbr->next_mcast_seq)
291			return (-1);
292			}
293
294			/* ack processing */
295			if (ack != 0)
296			rtp_process_ack(nbr, ack);
297			if (seq != 0) {
298			/* check for sequence wraparound */
299			if (nbr->recv_seq >= seq &&
300			!(nbr->recv_seq == UINT32_MAX && seq == 1)) {
301			log_debug("%s: duplicate packet", __func__);
302			rtp_send_ack(nbr);
303			return (-1);
304			}
305			nbr->recv_seq = seq;
306			}
307
308			return (0);
309			}
310
311			static void
312			recv_packet_eigrp(int af, union eigrpd_addr src, union eigrpd_addr dest,
313			struct iface iface, struct eigrp_hdr eigrp_hdr, char *buf, uint16_t len)
314			{
315			struct eigrp_iface *ei;
316			struct nbr *nbr;
317			struct tlv_parameter *tp = NULL;
318			struct tlv_sw_version *tv = NULL;
319			struct tlv_mcast_seq *tm = NULL;
320			struct rinfo ri;
321			struct rinfo_entry *re;
322			struct seq_addr_head seq_addr_list;
323			struct rinfo_head rinfo_list;
324
325			/* EIGRP header sanity checks */
326			if (eigrp_hdr_sanity_check(af, dest, eigrp_hdr, len, iface) == -1)
327			return;
328
329			buf += sizeof(*eigrp_hdr);
330			len -= sizeof(*eigrp_hdr);
331
332			TAILQ_INIT(&seq_addr_list);
333			TAILQ_INIT(&rinfo_list);
334			while (len > 0) {
335			struct tlv tlv;
336			uint16_t tlv_type;
337
338			if (len < sizeof(tlv)) {
339			log_debug("%s: malformed packet (bad length)",
340			__func__);
341			goto error;
342			}
343
344			memcpy(&tlv, buf, sizeof(tlv));
345			if (ntohs(tlv.length) > len) {
346			log_debug("%s: malformed packet (bad length)",
347			__func__);
348			goto error;
349			}
350
351			tlv_type = ntohs(tlv.type);
352			switch (tlv_type) {
353			case TLV_TYPE_PARAMETER:
354			if ((tp = tlv_decode_parameter(&tlv, buf)) == NULL)
355			goto error;
356			break;
357			case TLV_TYPE_SEQ:
358			if (tlv_decode_seq(af, &tlv, buf, &seq_addr_list) < 0)
359			goto error;
360			break;
361			case TLV_TYPE_SW_VERSION:
362			if ((tv = tlv_decode_sw_version(&tlv, buf)) == NULL)
363			goto error;
364			break;
365			case TLV_TYPE_MCAST_SEQ:
366			if ((tm = tlv_decode_mcast_seq(&tlv, buf)) == NULL)
367			goto error;
368			break;
369			case TLV_TYPE_IPV4_INTERNAL:
370			case TLV_TYPE_IPV4_EXTERNAL:
371			case TLV_TYPE_IPV6_INTERNAL:
372			case TLV_TYPE_IPV6_EXTERNAL:
373			/* silently ignore TLV from different address-family */
374			if ((tlv_type & TLV_PROTO_MASK) == TLV_PROTO_IPV4 &&
375			af != AF_INET)
376			break;
377			if ((tlv_type & TLV_PROTO_MASK) == TLV_PROTO_IPV6 &&
378			af != AF_INET6)
379			break;
380
381			if (tlv_decode_route(af, &tlv, buf, &ri) < 0)
382			goto error;
383			if ((re = calloc(1, sizeof(*re))) == NULL)
384			fatal("recv_packet_eigrp");
385			re->rinfo = ri;
386			TAILQ_INSERT_TAIL(&rinfo_list, re, entry);
387			break;
388			case TLV_TYPE_AUTH:
389			case TLV_TYPE_PEER_TERM:
390			/*
391			* XXX There is no enough information in the draft
392			* to implement these TLVs properly.
393			*/
394			case TLV_TYPE_IPV4_COMMUNITY:
395			case TLV_TYPE_IPV6_COMMUNITY:
396			/* TODO */
397			default:
398			/* ignore unknown tlv */
399			break;
400			}
401			buf += ntohs(tlv.length);
402			len -= ntohs(tlv.length);
403			}
404
405			ei = eigrp_if_lookup(iface, af, ntohs(eigrp_hdr->as));
406			if (ei == NULL \|\| ei->passive)
407			goto error;
408
409			nbr = nbr_find(ei, src);
410			if (nbr == NULL && (eigrp_hdr->opcode != EIGRP_OPC_HELLO \|\|
411			ntohl(eigrp_hdr->ack_num) != 0)) {
412			log_debug("%s: unknown neighbor", __func__);
413			goto error;
414			} else if (nbr && recv_packet_nbr(nbr, eigrp_hdr, &seq_addr_list,
415			tm) < 0)
416			goto error;
417
418			/* log packet being received */
419			if (eigrp_hdr->opcode != EIGRP_OPC_HELLO)
420			log_debug("%s: type %s nbr %s AS %u seq %u ack %u", __func__,
421			opcode_name(eigrp_hdr->opcode), log_addr(af, &nbr->addr),
422			ei->eigrp->as, ntohl(eigrp_hdr->seq_num),
423			ntohl(eigrp_hdr->ack_num));
424
425			/* switch EIGRP packet type */
426			switch (eigrp_hdr->opcode) {
427			case EIGRP_OPC_HELLO:
428			if (ntohl(eigrp_hdr->ack_num) == 0) {
429			recv_hello(ei, src, nbr, tp);
430			ei->eigrp->stats.hellos_recv++;
431			} else
432			ei->eigrp->stats.acks_recv++;
433			break;
434			case EIGRP_OPC_UPDATE:
435			recv_update(nbr, &rinfo_list, ntohl(eigrp_hdr->flags));
436			ei->eigrp->stats.updates_recv++;
437			break;
438			case EIGRP_OPC_QUERY:
439			recv_query(nbr, &rinfo_list, 0);
440			ei->eigrp->stats.queries_recv++;
441			break;
442			case EIGRP_OPC_REPLY:
443			recv_reply(nbr, &rinfo_list, 0);
444			ei->eigrp->stats.replies_recv++;
445			break;
446			case EIGRP_OPC_SIAQUERY:
447			recv_query(nbr, &rinfo_list, 1);
448			ei->eigrp->stats.squeries_recv++;
449			break;
450			case EIGRP_OPC_SIAREPLY:
451			recv_reply(nbr, &rinfo_list, 1);
452			ei->eigrp->stats.sreplies_recv++;
453			break;
454			default:
455			log_debug("%s: unknown EIGRP packet type, interface %s",
456			__func__, iface->name);
457			}
458
459			error:
460			/* free rinfo tlvs */
461			message_list_clr(&rinfo_list);
462			/* free seq addresses tlvs */
463			seq_addr_list_clr(&seq_addr_list);
464			}
465
466			#define CMSG_MAXLEN max(sizeof(struct sockaddr_dl), sizeof(struct in6_pktinfo))
467			void
468			recv_packet(int fd, short event, void *bula)
469			{
470			union {
471			struct cmsghdr hdr;
472			char buf[CMSG_SPACE(CMSG_MAXLEN)];
473			} cmsgbuf;
474			struct msghdr msg;
475			struct sockaddr_storage from;
476			struct iovec iov;
477			struct ip ip_hdr;
478			char *buf;
479			struct cmsghdr *cmsg;
480			ssize_t r;
481			uint16_t len;
482			int af;
483			union eigrpd_addr src, dest;
484			unsigned int ifindex = 0;
485			struct iface *iface;
486			struct eigrp_hdr *eigrp_hdr;
487
488			if (event != EV_READ)
489			return;
490
491			/* setup buffer */
492			memset(&msg, 0, sizeof(msg));
493			iov.iov_base = buf = pkt_ptr;
494			iov.iov_len = READ_BUF_SIZE;
495			msg.msg_name = &from;
496			msg.msg_namelen = sizeof(from);
497			msg.msg_iov = &iov;
498			msg.msg_iovlen = 1;
499			msg.msg_control = &cmsgbuf.buf;
500			msg.msg_controllen = sizeof(cmsgbuf.buf);
501
502			if ((r = recvmsg(fd, &msg, 0)) == -1) {
503			if (errno != EAGAIN && errno != EINTR)
504			log_debug("%s: read error: %s", __func__,
505			strerror(errno));
506			return;
507			}
508			len = (uint16_t)r;
509
510			sa2addr((struct sockaddr *)&from, &af, &src);
511			if (bad_addr(af, &src)) {
512			log_debug("%s: invalid source address: %s", __func__,
513			log_addr(af, &src));
514			return;
515			}
516
517			for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL;
518			cmsg = CMSG_NXTHDR(&msg, cmsg)) {
519			if (af == AF_INET && cmsg->cmsg_level == IPPROTO_IP &&
520			cmsg->cmsg_type == IP_RECVIF) {
521			ifindex = ((struct sockaddr_dl *)
522			CMSG_DATA(cmsg))->sdl_index;
523			break;
524			}
525			if (af == AF_INET6 && cmsg->cmsg_level == IPPROTO_IPV6 &&
526			cmsg->cmsg_type == IPV6_PKTINFO) {
527			ifindex = ((struct in6_pktinfo *)
528			CMSG_DATA(cmsg))->ipi6_ifindex;
529			dest.v6 = ((struct in6_pktinfo *)
530			CMSG_DATA(cmsg))->ipi6_addr;
531			break;
532			}
533			}
534
535			/* find a matching interface */
536			if ((iface = find_iface(ifindex, af, &src)) == NULL)
537			return;
538
539			/* the IPv4 raw sockets API gives us direct access to the IP header */
540			if (af == AF_INET) {
541			if (len < sizeof(ip_hdr)) {
542			log_debug("%s: bad packet size", __func__);
543			return;
544			}
545			memcpy(&ip_hdr, buf, sizeof(ip_hdr));
546			if (ntohs(ip_hdr.ip_len) != len) {
547			log_debug("%s: invalid IP packet length %u", __func__,
548			ntohs(ip_hdr.ip_len));
549			return;
550			}
551			buf += ip_hdr.ip_hl << 2;
552			len -= ip_hdr.ip_hl << 2;
553			dest.v4 = ip_hdr.ip_dst;
554			}
555
556			/* validate destination address */
557			switch (af) {
558			case AF_INET:
559			/*
560			* Packet needs to be sent to 224.0.0.10 or to one of the
561			* interface addresses.
562			*/
563			if (dest.v4.s_addr != global.mcast_addr_v4.s_addr) {
564			struct if_addr *if_addr;
565			int found = 0;
566
567			TAILQ_FOREACH(if_addr, &iface->addr_list, entry)
568			if (if_addr->af == AF_INET &&
569			dest.v4.s_addr == if_addr->addr.v4.s_addr) {
570			found = 1;
571			break;
572			}
573			if (found == 0) {
574			log_debug("%s: packet sent to wrong address "
575			"%s, interface %s", __func__,
576			inet_ntoa(dest.v4), iface->name);
577			return;
578			}
579			}
580			break;
581			case AF_INET6:
582			/*
583			* Packet needs to be sent to ff02::a or to the link local
584			* address of the interface.
585			*/
586			if (!IN6_ARE_ADDR_EQUAL(&dest.v6, &global.mcast_addr_v6) &&
587			!IN6_ARE_ADDR_EQUAL(&dest.v6, &iface->linklocal)) {
588			log_debug("%s: packet sent to wrong address %s, "
589			"interface %s", __func__, log_in6addr(&dest.v6),
590			iface->name);
591			return;
592			}
593			break;
594			default:
595			fatalx("recv_packet: unknown af");
596			break;
597			}
598
599			if (len < sizeof(*eigrp_hdr)) {
600			log_debug("%s: bad packet size", __func__);
601			return;
602			}
603			eigrp_hdr = (struct eigrp_hdr *)buf;
604
605			recv_packet_eigrp(af, &src, &dest, iface, eigrp_hdr, buf, len);
606			}
607
608			static int
609			eigrp_hdr_sanity_check(int af, union eigrpd_addr *addr,
610			struct eigrp_hdr eigrp_hdr, uint16_t len, const struct iface iface)
611			{
612			if (in_cksum(eigrp_hdr, len)) {
613			log_debug("%s: invalid checksum, interface %s", __func__,
614			iface->name);
615			return (-1);
616			}
617
618			if (eigrp_hdr->version != EIGRP_HEADER_VERSION) {
619			log_debug("%s: invalid EIGRP version %d, interface %s",
620			__func__, eigrp_hdr->version, iface->name);
621			return (-1);
622			}
623
624			if (ntohs(eigrp_hdr->vrid) != EIGRP_VRID_UNICAST_AF) {
625			log_debug("%s: unknown or unsupported vrid %u, interface %s",
626			__func__, ntohs(eigrp_hdr->vrid), iface->name);
627			return (-1);
628			}
629
630			if (eigrp_hdr->opcode == EIGRP_OPC_HELLO &&
631			eigrp_hdr->ack_num != 0) {
632			switch (af) {
633			case AF_INET:
634			if (IN_MULTICAST(addr->v4.s_addr)) {
635			log_debug("%s: multicast ack (ipv4), "
636			"interface %s", __func__, iface->name);
637			return (-1);
638			}
639			break;
640			case AF_INET6:
641			if (IN6_IS_ADDR_MULTICAST(&addr->v6)) {
642			log_debug("%s: multicast ack (ipv6), "
643			"interface %s", __func__, iface->name);
644			return (-1);
645			}
646			break;
647			default:
648			fatalx("eigrp_hdr_sanity_check: unknown af");
649			}
650			}
651
652			return (0);
653			}
654
655			static struct iface *
656			find_iface(unsigned int ifindex, int af, union eigrpd_addr *src)
657			{
658			struct iface *iface;
659			struct if_addr *if_addr;
660			in_addr_t mask;
661
662			iface = if_lookup(econf, ifindex);
663			if (iface == NULL)
664			return (NULL);
665
666			switch (af) {
667			case AF_INET:
668			/*
669			* From CCNP ROUTE 642-902 OCG:
670			* "EIGRP's rules about neighbor IP addresses being in the same
671			* subnet are less exact than OSPF. OSPF requires matching
672			* subnet numbers and masks. EIGRP just asks the question of
673			* whether the neighbor's IP address is in the range of
674			* addresses for the subnet as known to the local router."
675			*/
676			TAILQ_FOREACH(if_addr, &iface->addr_list, entry) {
677			if (if_addr->af == AF_INET) {
678			mask = prefixlen2mask(if_addr->prefixlen);
679
680			if ((if_addr->addr.v4.s_addr & mask) ==
681			(src->v4.s_addr & mask))
682			return (iface);
683			}
684			}
685			break;
686			case AF_INET6:
687			/*
688			* draft-savage-eigrp-04 - Section 10.1:
689			* "EIGRP IPv6 will check that a received HELLO contains a valid
690			* IPv6 link-local source address."
691			*/
692			if (IN6_IS_ADDR_LINKLOCAL(&src->v6))
693			return (iface);
694			break;
695			default:
696			fatalx("find_iface: unknown af");
697			}
698
699			return (NULL);
700			}