Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/eigrpd/rtp.c	Lines:	0	110	0.0 %
Date:	2017-11-07	Branches:	0	58	0.0 %


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

/*
 * Copyright (c) 2015 Renato Westphal <renato@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 <netinet/in.h>
#include <netinet/ip.h>

#include <stdlib.h>

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

static struct pbuf	*rtp_buf_new(struct ibuf *);
static struct pbuf	*rtp_buf_hold(struct pbuf *);
static void		 rtp_buf_release(struct pbuf *);
static struct packet	*rtp_packet_new(struct nbr *, uint32_t, struct pbuf *);
static void		 rtp_send_packet(struct packet *);
static void		 rtp_enqueue_packet(struct packet *);
static void		 rtp_send_mcast(struct eigrp_iface *, struct ibuf *);
static void		 rtp_retrans_timer(int, short, void *);
static void		 rtp_retrans_start_timer(struct packet *);
static void		 rtp_retrans_stop_timer(struct packet *);

static struct pbuf *
rtp_buf_new(struct ibuf *buf)
{
	struct pbuf	*pbuf;

	if ((pbuf = calloc(1, sizeof(*pbuf))) == NULL)
		fatal("rtp_buf_new");
	pbuf->buf = buf;

	return (pbuf);
}

static struct pbuf *
rtp_buf_hold(struct pbuf *pbuf)
{
	pbuf->refcnt++;
	return (pbuf);
}

static void
rtp_buf_release(struct pbuf *pbuf)
{
	if (--pbuf->refcnt == 0) {
		ibuf_free(pbuf->buf);
		free(pbuf);
	}
}

static struct packet *
rtp_packet_new(struct nbr *nbr, uint32_t seq_num, struct pbuf *pbuf)
{
	struct packet		*pkt;

	if ((pkt = calloc(1, sizeof(struct packet))) == NULL)
		fatal("rtp_packet_new");

	pkt->nbr = nbr;
	pkt->seq_num = seq_num;
	pkt->pbuf = rtp_buf_hold(pbuf);
	pkt->attempts = 1;
	evtimer_set(&pkt->ev_timeout, rtp_retrans_timer, pkt);

	return (pkt);
}

void
rtp_packet_del(struct packet *pkt)
{
	TAILQ_REMOVE(&pkt->nbr->retrans_list, pkt, entry);
	rtp_retrans_stop_timer(pkt);
	rtp_buf_release(pkt->pbuf);
	free(pkt);
}

void
rtp_process_ack(struct nbr *nbr, uint32_t ack_num)
{
	struct eigrp	*eigrp = nbr->ei->eigrp;
	struct packet	*pkt;

	/* window size is one */
	pkt = TAILQ_FIRST(&nbr->retrans_list);
	if (pkt && pkt->seq_num == ack_num) {
		log_debug("%s: nbr %s ack %u", __func__,
		    log_addr(eigrp->af, &nbr->addr), ack_num);

		/* dequeue packet from retransmission queue */
		rtp_packet_del(pkt);

		/* enqueue next packet from retransmission queue */
		pkt = TAILQ_FIRST(&nbr->retrans_list);
		if (pkt)
			rtp_send_packet(pkt);
	}
}

static void
rtp_send_packet(struct packet *pkt)
{
	rtp_retrans_start_timer(pkt);
	send_packet(pkt->nbr->ei, pkt->nbr, 0, pkt->pbuf->buf);
}

static void
rtp_enqueue_packet(struct packet *pkt)
{
	/* only send packet if transmission queue is empty */
	if (TAILQ_EMPTY(&pkt->nbr->retrans_list))
		rtp_send_packet(pkt);

	TAILQ_INSERT_TAIL(&pkt->nbr->retrans_list, pkt, entry);
}

static void
rtp_seq_inc(struct eigrp *eigrp)
{
	/* automatic wraparound with unsigned arithmetic */
	eigrp->seq_num++;

	/* sequence number 0 is reserved for unreliably transmission */
	if (eigrp->seq_num == 0)
		eigrp->seq_num = 1;
}

void
rtp_send_ucast(struct nbr *nbr, struct ibuf *buf)
{
	struct eigrp		*eigrp = nbr->ei->eigrp;
	struct packet		*pkt;
	struct pbuf		*pbuf;

	pbuf = rtp_buf_new(buf);
	pkt = rtp_packet_new(nbr, eigrp->seq_num, pbuf);
	rtp_enqueue_packet(pkt);
	rtp_seq_inc(eigrp);
}

static void
rtp_send_mcast(struct eigrp_iface *ei, struct ibuf *buf)
{
	struct eigrp		*eigrp = ei->eigrp;
	struct nbr		*nbr;
	int			 total = 0, pending = 0;
	struct packet		*pkt;
	struct pbuf		*pbuf;
	uint32_t		 flags = 0;
	struct seq_addr_entry	*sa;
	struct seq_addr_head	 seq_addr_list;

	TAILQ_FOREACH(nbr, &ei->nbr_list, entry) {
		if (nbr->flags & F_EIGRP_NBR_SELF)
			continue;
		if (!TAILQ_EMPTY(&nbr->retrans_list))
			pending++;
		total++;
	}
	if (total == 0)
		return;

	/*
	 * send a multicast if there's at least one neighbor with an empty
	 * queue on the interface.
	 */
	if (pending < total) {
		/*
		 * build a hello packet with a seq tlv indicating all the
		 * neighbors that have full queues.
		 */
		if (pending > 0) {
			flags |= EIGRP_HDR_FLAG_CR;
			TAILQ_INIT(&seq_addr_list);

			TAILQ_FOREACH(nbr, &ei->nbr_list, entry) {
				if (TAILQ_EMPTY(&nbr->retrans_list))
					continue;
				if ((sa = calloc(1, sizeof(*sa))) == NULL)
					fatal("rtp_send_mcast");
				sa->af = eigrp->af;
				sa->addr = nbr->addr;
				TAILQ_INSERT_TAIL(&seq_addr_list, sa, entry);
			}

			send_hello(ei, &seq_addr_list, eigrp->seq_num);
			seq_addr_list_clr(&seq_addr_list);
		}
		send_packet(ei, NULL, flags, buf);
	}

	/* schedule an unicast retransmission for each neighbor */
	pbuf = rtp_buf_new(buf);
	TAILQ_FOREACH(nbr, &ei->nbr_list, entry) {
		pkt = rtp_packet_new(nbr, eigrp->seq_num, pbuf);
		TAILQ_INSERT_TAIL(&nbr->retrans_list, pkt, entry);
	}

	rtp_seq_inc(eigrp);
}

void
rtp_send(struct eigrp_iface *ei, struct nbr *nbr, struct ibuf *buf)
{
	if (nbr)
		rtp_send_ucast(nbr, buf);
	else
		rtp_send_mcast(ei, buf);
}

void
rtp_send_ack(struct nbr *nbr)
{
	struct eigrp		*eigrp = nbr->ei->eigrp;
	struct ibuf		*buf;

	if ((buf = ibuf_dynamic(PKG_DEF_SIZE,
	    IP_MAXPACKET - sizeof(struct ip))) == NULL)
		fatal("rtp_send_ack");

	/* EIGRP header */
	if (gen_eigrp_hdr(buf, EIGRP_OPC_HELLO, 0, 0, eigrp->as)) {
		log_warnx("%s: failed to send message", __func__);
		ibuf_free(buf);
		return;
	}

	/* send unreliably */
	send_packet(nbr->ei, nbr, 0, buf);
	ibuf_free(buf);
}

/* timers */

/* ARGSUSED */
static void
rtp_retrans_timer(int fd, short event, void *arg)
{
	struct packet		*pkt = arg;
	struct eigrp		*eigrp = pkt->nbr->ei->eigrp;

	pkt->attempts++;

	if (pkt->attempts > RTP_RTRNS_MAX_ATTEMPTS) {
		log_warnx("%s: retry limit exceeded, nbr %s", __func__,
		    log_addr(eigrp->af, &pkt->nbr->addr));
		nbr_del(pkt->nbr);
		return;
	}

	rtp_send_packet(pkt);
}

static void
rtp_retrans_start_timer(struct packet *pkt)
{
	struct timeval		 tv;

	timerclear(&tv);
	tv.tv_sec = RTP_RTRNS_INTERVAL;
	if (evtimer_add(&pkt->ev_timeout, &tv) == -1)
		fatal("rtp_retrans_start_timer");
}

static void
rtp_retrans_stop_timer(struct packet *pkt)
{
	if (evtimer_pending(&pkt->ev_timeout, NULL) &&
	    evtimer_del(&pkt->ev_timeout) == -1)
		fatal("rtp_retrans_stop_timer");
}

/* ARGSUSED */
void
rtp_ack_timer(int fd, short event, void *arg)
{
	struct nbr		*nbr = arg;

	rtp_send_ack(nbr);
}

void
rtp_ack_start_timer(struct nbr *nbr)
{
	struct timeval		 tv;

	timerclear(&tv);
	tv.tv_usec = RTP_ACK_TIMEOUT;
	if (evtimer_add(&nbr->ev_ack, &tv) == -1)
		fatal("rtp_ack_start_timer");
}

void
rtp_ack_stop_timer(struct nbr *nbr)
{
	if (evtimer_pending(&nbr->ev_ack, NULL) &&
	    evtimer_del(&nbr->ev_ack) == -1)
		fatal("rtp_ack_stop_timer");
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: rtp.c,v 1.7 2016/09/02 16:44:33 renato Exp $ */
2
3			/*
4			* Copyright (c) 2015 Renato Westphal <renato@openbsd.org>
5			*
6			* Permission to use, copy, modify, and distribute this software for any
7			* purpose with or without fee is hereby granted, provided that the above
8			* copyright notice and this permission notice appear in all copies.
9			*
10			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17			*/
18
19			#include <sys/types.h>
20			#include <netinet/in.h>
21			#include <netinet/ip.h>
22
23			#include <stdlib.h>
24
25			#include "eigrpd.h"
26			#include "eigrpe.h"
27			#include "log.h"
28
29			static struct pbuf rtp_buf_new(struct ibuf );
30			static struct pbuf rtp_buf_hold(struct pbuf );
31			static void rtp_buf_release(struct pbuf *);
32			static struct packet rtp_packet_new(struct nbr , uint32_t, struct pbuf *);
33			static void rtp_send_packet(struct packet *);
34			static void rtp_enqueue_packet(struct packet *);
35			static void rtp_send_mcast(struct eigrp_iface , struct ibuf );
36			static void rtp_retrans_timer(int, short, void *);
37			static void rtp_retrans_start_timer(struct packet *);
38			static void rtp_retrans_stop_timer(struct packet *);
39
40			static struct pbuf *
41			rtp_buf_new(struct ibuf *buf)
42			{
43			struct pbuf *pbuf;
44
45			if ((pbuf = calloc(1, sizeof(*pbuf))) == NULL)
46			fatal("rtp_buf_new");
47			pbuf->buf = buf;
48
49			return (pbuf);
50			}
51
52			static struct pbuf *
53			rtp_buf_hold(struct pbuf *pbuf)
54			{
55			pbuf->refcnt++;
56			return (pbuf);
57			}
58
59			static void
60			rtp_buf_release(struct pbuf *pbuf)
61			{
62			if (--pbuf->refcnt == 0) {
63			ibuf_free(pbuf->buf);
64			free(pbuf);
65			}
66			}
67
68			static struct packet *
69			rtp_packet_new(struct nbr nbr, uint32_t seq_num, struct pbuf pbuf)
70			{
71			struct packet *pkt;
72
73			if ((pkt = calloc(1, sizeof(struct packet))) == NULL)
74			fatal("rtp_packet_new");
75
76			pkt->nbr = nbr;
77			pkt->seq_num = seq_num;
78			pkt->pbuf = rtp_buf_hold(pbuf);
79			pkt->attempts = 1;
80			evtimer_set(&pkt->ev_timeout, rtp_retrans_timer, pkt);
81
82			return (pkt);
83			}
84
85			void
86			rtp_packet_del(struct packet *pkt)
87			{
88			TAILQ_REMOVE(&pkt->nbr->retrans_list, pkt, entry);
89			rtp_retrans_stop_timer(pkt);
90			rtp_buf_release(pkt->pbuf);
91			free(pkt);
92			}
93
94			void
95			rtp_process_ack(struct nbr *nbr, uint32_t ack_num)
96			{
97			struct eigrp *eigrp = nbr->ei->eigrp;
98			struct packet *pkt;
99
100			/* window size is one */
101			pkt = TAILQ_FIRST(&nbr->retrans_list);
102			if (pkt && pkt->seq_num == ack_num) {
103			log_debug("%s: nbr %s ack %u", __func__,
104			log_addr(eigrp->af, &nbr->addr), ack_num);
105
106			/* dequeue packet from retransmission queue */
107			rtp_packet_del(pkt);
108
109			/* enqueue next packet from retransmission queue */
110			pkt = TAILQ_FIRST(&nbr->retrans_list);
111			if (pkt)
112			rtp_send_packet(pkt);
113			}
114			}
115
116			static void
117			rtp_send_packet(struct packet *pkt)
118			{
119			rtp_retrans_start_timer(pkt);
120			send_packet(pkt->nbr->ei, pkt->nbr, 0, pkt->pbuf->buf);
121			}
122
123			static void
124			rtp_enqueue_packet(struct packet *pkt)
125			{
126			/* only send packet if transmission queue is empty */
127			if (TAILQ_EMPTY(&pkt->nbr->retrans_list))
128			rtp_send_packet(pkt);
129
130			TAILQ_INSERT_TAIL(&pkt->nbr->retrans_list, pkt, entry);
131			}
132
133			static void
134			rtp_seq_inc(struct eigrp *eigrp)
135			{
136			/* automatic wraparound with unsigned arithmetic */
137			eigrp->seq_num++;
138
139			/* sequence number 0 is reserved for unreliably transmission */
140			if (eigrp->seq_num == 0)
141			eigrp->seq_num = 1;
142			}
143
144			void
145			rtp_send_ucast(struct nbr nbr, struct ibuf buf)
146			{
147			struct eigrp *eigrp = nbr->ei->eigrp;
148			struct packet *pkt;
149			struct pbuf *pbuf;
150
151			pbuf = rtp_buf_new(buf);
152			pkt = rtp_packet_new(nbr, eigrp->seq_num, pbuf);
153			rtp_enqueue_packet(pkt);
154			rtp_seq_inc(eigrp);
155			}
156
157			static void
158			rtp_send_mcast(struct eigrp_iface ei, struct ibuf buf)
159			{
160			struct eigrp *eigrp = ei->eigrp;
161			struct nbr *nbr;
162			int total = 0, pending = 0;
163			struct packet *pkt;
164			struct pbuf *pbuf;
165			uint32_t flags = 0;
166			struct seq_addr_entry *sa;
167			struct seq_addr_head seq_addr_list;
168
169			TAILQ_FOREACH(nbr, &ei->nbr_list, entry) {
170			if (nbr->flags & F_EIGRP_NBR_SELF)
171			continue;
172			if (!TAILQ_EMPTY(&nbr->retrans_list))
173			pending++;
174			total++;
175			}
176			if (total == 0)
177			return;
178
179			/*
180			* send a multicast if there's at least one neighbor with an empty
181			* queue on the interface.
182			*/
183			if (pending < total) {
184			/*
185			* build a hello packet with a seq tlv indicating all the
186			* neighbors that have full queues.
187			*/
188			if (pending > 0) {
189			flags \|= EIGRP_HDR_FLAG_CR;
190			TAILQ_INIT(&seq_addr_list);
191
192			TAILQ_FOREACH(nbr, &ei->nbr_list, entry) {
193			if (TAILQ_EMPTY(&nbr->retrans_list))
194			continue;
195			if ((sa = calloc(1, sizeof(*sa))) == NULL)
196			fatal("rtp_send_mcast");
197			sa->af = eigrp->af;
198			sa->addr = nbr->addr;
199			TAILQ_INSERT_TAIL(&seq_addr_list, sa, entry);
200			}
201
202			send_hello(ei, &seq_addr_list, eigrp->seq_num);
203			seq_addr_list_clr(&seq_addr_list);
204			}
205			send_packet(ei, NULL, flags, buf);
206			}
207
208			/* schedule an unicast retransmission for each neighbor */
209			pbuf = rtp_buf_new(buf);
210			TAILQ_FOREACH(nbr, &ei->nbr_list, entry) {
211			pkt = rtp_packet_new(nbr, eigrp->seq_num, pbuf);
212			TAILQ_INSERT_TAIL(&nbr->retrans_list, pkt, entry);
213			}
214
215			rtp_seq_inc(eigrp);
216			}
217
218			void
219			rtp_send(struct eigrp_iface ei, struct nbr nbr, struct ibuf *buf)
220			{
221			if (nbr)
222			rtp_send_ucast(nbr, buf);
223			else
224			rtp_send_mcast(ei, buf);
225			}
226
227			void
228			rtp_send_ack(struct nbr *nbr)
229			{
230			struct eigrp *eigrp = nbr->ei->eigrp;
231			struct ibuf *buf;
232
233			if ((buf = ibuf_dynamic(PKG_DEF_SIZE,
234			IP_MAXPACKET - sizeof(struct ip))) == NULL)
235			fatal("rtp_send_ack");
236
237			/* EIGRP header */
238			if (gen_eigrp_hdr(buf, EIGRP_OPC_HELLO, 0, 0, eigrp->as)) {
239			log_warnx("%s: failed to send message", __func__);
240			ibuf_free(buf);
241			return;
242			}
243
244			/* send unreliably */
245			send_packet(nbr->ei, nbr, 0, buf);
246			ibuf_free(buf);
247			}
248
249			/* timers */
250
251			/* ARGSUSED */
252			static void
253			rtp_retrans_timer(int fd, short event, void *arg)
254			{
255			struct packet *pkt = arg;
256			struct eigrp *eigrp = pkt->nbr->ei->eigrp;
257
258			pkt->attempts++;
259
260			if (pkt->attempts > RTP_RTRNS_MAX_ATTEMPTS) {
261			log_warnx("%s: retry limit exceeded, nbr %s", __func__,
262			log_addr(eigrp->af, &pkt->nbr->addr));
263			nbr_del(pkt->nbr);
264			return;
265			}
266
267			rtp_send_packet(pkt);
268			}
269
270			static void
271			rtp_retrans_start_timer(struct packet *pkt)
272			{
273			struct timeval tv;
274
275			timerclear(&tv);
276			tv.tv_sec = RTP_RTRNS_INTERVAL;
277			if (evtimer_add(&pkt->ev_timeout, &tv) == -1)
278			fatal("rtp_retrans_start_timer");
279			}
280
281			static void
282			rtp_retrans_stop_timer(struct packet *pkt)
283			{
284			if (evtimer_pending(&pkt->ev_timeout, NULL) &&
285			evtimer_del(&pkt->ev_timeout) == -1)
286			fatal("rtp_retrans_stop_timer");
287			}
288
289			/* ARGSUSED */
290			void
291			rtp_ack_timer(int fd, short event, void *arg)
292			{
293			struct nbr *nbr = arg;
294
295			rtp_send_ack(nbr);
296			}
297
298			void
299			rtp_ack_start_timer(struct nbr *nbr)
300			{
301			struct timeval tv;
302
303			timerclear(&tv);
304			tv.tv_usec = RTP_ACK_TIMEOUT;
305			if (evtimer_add(&nbr->ev_ack, &tv) == -1)
306			fatal("rtp_ack_start_timer");
307			}
308
309			void
310			rtp_ack_stop_timer(struct nbr *nbr)
311			{
312			if (evtimer_pending(&nbr->ev_ack, NULL) &&
313			evtimer_del(&nbr->ev_ack) == -1)
314			fatal("rtp_ack_stop_timer");
315			}