Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/ldpd/init.c	Lines:	0	209	0.0 %
Date:	2017-11-07	Branches:	0	78	0.0 %


/*	$OpenBSD: init.c,v 1.37 2017/03/04 00:15:35 renato Exp $ */

/*
 * Copyright (c) 2009 Michele Marchetto <michele@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 <arpa/inet.h>
#include <string.h>

#include "ldpd.h"
#include "ldpe.h"
#include "log.h"

static int	gen_init_prms_tlv(struct ibuf *, struct nbr *);
static int	gen_cap_dynamic_tlv(struct ibuf *);
static int	gen_cap_twcard_tlv(struct ibuf *, int);
static int	gen_cap_unotif_tlv(struct ibuf *, int);

void
send_init(struct nbr *nbr)
{
	struct ibuf		*buf;
	uint16_t		 size;
	int			 err = 0;

	log_debug("%s: lsr-id %s", __func__, inet_ntoa(nbr->id));

	size = LDP_HDR_SIZE + LDP_MSG_SIZE + SESS_PRMS_SIZE +
	    CAP_TLV_DYNAMIC_SIZE + CAP_TLV_TWCARD_SIZE + CAP_TLV_UNOTIF_SIZE;
	if ((buf = ibuf_open(size)) == NULL)
		fatal(__func__);

	err |= gen_ldp_hdr(buf, size);
	size -= LDP_HDR_SIZE;
	err |= gen_msg_hdr(buf, MSG_TYPE_INIT, size);
	err |= gen_init_prms_tlv(buf, nbr);
	err |= gen_cap_dynamic_tlv(buf);
	err |= gen_cap_twcard_tlv(buf, 1);
	err |= gen_cap_unotif_tlv(buf, 1);
	if (err) {
		ibuf_free(buf);
		return;
	}

	evbuf_enqueue(&nbr->tcp->wbuf, buf);
}

int
recv_init(struct nbr *nbr, char *buf, uint16_t len)
{
	struct ldp_msg		msg;
	struct sess_prms_tlv	sess;
	uint16_t		max_pdu_len;
	int			caps_rcvd = 0;

	log_debug("%s: lsr-id %s", __func__, inet_ntoa(nbr->id));

	memcpy(&msg, buf, sizeof(msg));
	buf += LDP_MSG_SIZE;
	len -= LDP_MSG_SIZE;

	if (len < SESS_PRMS_SIZE) {
		session_shutdown(nbr, S_BAD_MSG_LEN, msg.id, msg.type);
		return (-1);
	}
	memcpy(&sess, buf, sizeof(sess));
	if (ntohs(sess.length) != SESS_PRMS_LEN) {
		session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type);
		return (-1);
	}
	if (ntohs(sess.proto_version) != LDP_VERSION) {
		session_shutdown(nbr, S_BAD_PROTO_VER, msg.id, msg.type);
		return (-1);
	}
	if (ntohs(sess.keepalive_time) < MIN_KEEPALIVE) {
		session_shutdown(nbr, S_KEEPALIVE_BAD, msg.id, msg.type);
		return (-1);
	}
	if (sess.lsr_id != leconf->rtr_id.s_addr ||
	    ntohs(sess.lspace_id) != 0) {
		session_shutdown(nbr, S_NO_HELLO, msg.id, msg.type);
		return (-1);
	}

	buf += SESS_PRMS_SIZE;
	len -= SESS_PRMS_SIZE;

	/* Optional Parameters */
	while (len > 0) {
		struct tlv 	tlv;
		uint16_t	tlv_type;
		uint16_t	tlv_len;

		if (len < sizeof(tlv)) {
			session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type);
			return (-1);
		}

		memcpy(&tlv, buf, TLV_HDR_SIZE);
		tlv_type = ntohs(tlv.type);
		tlv_len = ntohs(tlv.length);
		if (tlv_len + TLV_HDR_SIZE > len) {
			session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type);
			return (-1);
		}
		buf += TLV_HDR_SIZE;
		len -= TLV_HDR_SIZE;

		/*
		 * RFC 5561 - Section 6:
		 * "The S-bit of a Capability Parameter in an Initialization
		 * message MUST be 1 and SHOULD be ignored on receipt".
		 */
		switch (tlv_type) {
		case TLV_TYPE_ATMSESSIONPAR:
			session_shutdown(nbr, S_BAD_TLV_VAL, msg.id, msg.type);
			return (-1);
		case TLV_TYPE_FRSESSION:
			session_shutdown(nbr, S_BAD_TLV_VAL, msg.id, msg.type);
			return (-1);
		case TLV_TYPE_DYNAMIC_CAP:
			if (tlv_len != CAP_TLV_DYNAMIC_LEN) {
				session_shutdown(nbr, S_BAD_TLV_LEN, msg.id,
				    msg.type);
				return (-1);
			}

			if (caps_rcvd & F_CAP_TLV_RCVD_DYNAMIC) {
				session_shutdown(nbr, S_BAD_TLV_VAL, msg.id,
				    msg.type);
				return (-1);
			}
			caps_rcvd |= F_CAP_TLV_RCVD_DYNAMIC;

			nbr->flags |= F_NBR_CAP_DYNAMIC;

			log_debug("%s: lsr-id %s announced the Dynamic "
			    "Capability Announcement capability", __func__,
			    inet_ntoa(nbr->id));
			break;
		case TLV_TYPE_TWCARD_CAP:
			if (tlv_len != CAP_TLV_TWCARD_LEN) {
				session_shutdown(nbr, S_BAD_TLV_LEN, msg.id,
				    msg.type);
				return (-1);
			}

			if (caps_rcvd & F_CAP_TLV_RCVD_TWCARD) {
				session_shutdown(nbr, S_BAD_TLV_VAL, msg.id,
				    msg.type);
				return (-1);
			}
			caps_rcvd |= F_CAP_TLV_RCVD_TWCARD;

			nbr->flags |= F_NBR_CAP_TWCARD;

			log_debug("%s: lsr-id %s announced the Typed Wildcard "
			    "FEC capability", __func__, inet_ntoa(nbr->id));
			break;
		case TLV_TYPE_UNOTIF_CAP:
			if (tlv_len != CAP_TLV_UNOTIF_LEN) {
				session_shutdown(nbr, S_BAD_TLV_LEN, msg.id,
				    msg.type);
				return (-1);
			}

			if (caps_rcvd & F_CAP_TLV_RCVD_UNOTIF) {
				session_shutdown(nbr, S_BAD_TLV_VAL, msg.id,
				    msg.type);
				return (-1);
			}
			caps_rcvd |= F_CAP_TLV_RCVD_UNOTIF;

			nbr->flags |= F_NBR_CAP_UNOTIF;

			log_debug("%s: lsr-id %s announced the Unrecognized "
			    "Notification capability", __func__,
			    inet_ntoa(nbr->id));
			break;
		default:
			if (!(ntohs(tlv.type) & UNKNOWN_FLAG))
				send_notification_rtlvs(nbr, S_UNSSUPORTDCAP,
				    msg.id, msg.type, tlv_type, tlv_len, buf);
			/* ignore unknown tlv */
			break;
		}
		buf += tlv_len;
		len -= tlv_len;
	}

	nbr->keepalive = min(nbr_get_keepalive(nbr->af, nbr->id),
	    ntohs(sess.keepalive_time));

	max_pdu_len = ntohs(sess.max_pdu_len);
	/*
	 * RFC 5036 - Section 3.5.3:
	 * "A value of 255 or less specifies the default maximum length of
	 * 4096 octets".
	 */
	if (max_pdu_len <= 255)
		max_pdu_len = LDP_MAX_LEN;
	nbr->max_pdu_len = min(max_pdu_len, LDP_MAX_LEN);

	nbr_fsm(nbr, NBR_EVT_INIT_RCVD);

	return (0);
}

void
send_capability(struct nbr *nbr, uint16_t capability, int enable)
{
	struct ibuf		*buf;
	uint16_t		 size;
	int			 err = 0;

	log_debug("%s: lsr-id %s", __func__, inet_ntoa(nbr->id));

	size = LDP_HDR_SIZE + LDP_MSG_SIZE + CAP_TLV_DYNAMIC_SIZE;
	if ((buf = ibuf_open(size)) == NULL)
		fatal(__func__);

	err |= gen_ldp_hdr(buf, size);
	size -= LDP_HDR_SIZE;
	err |= gen_msg_hdr(buf, MSG_TYPE_CAPABILITY, size);

	switch (capability) {
	case TLV_TYPE_TWCARD_CAP:
		err |= gen_cap_twcard_tlv(buf, enable);
		break;
	case TLV_TYPE_UNOTIF_CAP:
		err |= gen_cap_unotif_tlv(buf, enable);
		break;
	case TLV_TYPE_DYNAMIC_CAP:
		/*
		 * RFC 5561 - Section 9:
		 * "An LDP speaker MUST NOT include the Dynamic Capability
		 * Announcement Parameter in Capability messages sent to
		 * its peers".
		 */
		/* FALLTHROUGH */
	default:
		fatalx("send_capability: unsupported capability");
	}

	if (err) {
		ibuf_free(buf);
		return;
	}

	evbuf_enqueue(&nbr->tcp->wbuf, buf);
	nbr_fsm(nbr, NBR_EVT_PDU_SENT);
}

int
recv_capability(struct nbr *nbr, char *buf, uint16_t len)
{
	struct ldp_msg	 msg;
	int		 enable = 0;
	int		 caps_rcvd = 0;

	log_debug("%s: lsr-id %s", __func__, inet_ntoa(nbr->id));

	memcpy(&msg, buf, sizeof(msg));
	buf += LDP_MSG_SIZE;
	len -= LDP_MSG_SIZE;

	/* Optional Parameters */
	while (len > 0) {
		struct tlv 	 tlv;
		uint16_t	 tlv_type;
		uint16_t	 tlv_len;
		uint8_t		 reserved;

		if (len < sizeof(tlv)) {
			session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type);
			return (-1);
		}

		memcpy(&tlv, buf, TLV_HDR_SIZE);
		tlv_type = ntohs(tlv.type);
		tlv_len = ntohs(tlv.length);
		if (tlv_len + TLV_HDR_SIZE > len) {
			session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type);
			return (-1);
		}
		buf += TLV_HDR_SIZE;
		len -= TLV_HDR_SIZE;

		switch (tlv_type) {
		case TLV_TYPE_TWCARD_CAP:
			if (tlv_len != CAP_TLV_TWCARD_LEN) {
				session_shutdown(nbr, S_BAD_TLV_LEN, msg.id,
				    msg.type);
				return (-1);
			}

			if (caps_rcvd & F_CAP_TLV_RCVD_TWCARD) {
				session_shutdown(nbr, S_BAD_TLV_VAL, msg.id,
				    msg.type);
				return (-1);
			}
			caps_rcvd |= F_CAP_TLV_RCVD_TWCARD;

			memcpy(&reserved, buf, sizeof(reserved));
			enable = reserved & STATE_BIT;
			if (enable)
				nbr->flags |= F_NBR_CAP_TWCARD;
			else
				nbr->flags &= ~F_NBR_CAP_TWCARD;

			log_debug("%s: lsr-id %s %s the Typed Wildcard FEC "
			    "capability", __func__, inet_ntoa(nbr->id),
			    (enable) ? "announced" : "withdrew");
			break;
		case TLV_TYPE_UNOTIF_CAP:
			if (tlv_len != CAP_TLV_UNOTIF_LEN) {
				session_shutdown(nbr, S_BAD_TLV_LEN, msg.id,
				    msg.type);
				return (-1);
			}

			if (caps_rcvd & F_CAP_TLV_RCVD_UNOTIF) {
				session_shutdown(nbr, S_BAD_TLV_VAL, msg.id,
				    msg.type);
				return (-1);
			}
			caps_rcvd |= F_CAP_TLV_RCVD_UNOTIF;

			memcpy(&reserved, buf, sizeof(reserved));
			enable = reserved & STATE_BIT;
			if (enable)
				nbr->flags |= F_NBR_CAP_UNOTIF;
			else
				nbr->flags &= ~F_NBR_CAP_UNOTIF;

			log_debug("%s: lsr-id %s %s the Unrecognized "
			    "Notification capability", __func__,
			    inet_ntoa(nbr->id), (enable) ? "announced" :
			    "withdrew");
			break;
		case TLV_TYPE_DYNAMIC_CAP:
			/*
		 	 * RFC 5561 - Section 9:
			 * "An LDP speaker that receives a Capability message
			 * from a peer that includes the Dynamic Capability
			 * Announcement Parameter SHOULD silently ignore the
			 * parameter and process any other Capability Parameters
			 * in the message".
			 */
			/* FALLTHROUGH */
		default:
			if (!(ntohs(tlv.type) & UNKNOWN_FLAG))
				send_notification_rtlvs(nbr, S_UNSSUPORTDCAP,
				    msg.id, msg.type, tlv_type, tlv_len, buf);
			/* ignore unknown tlv */
			break;
		}
		buf += tlv_len;
		len -= tlv_len;
	}

	nbr_fsm(nbr, NBR_EVT_PDU_RCVD);

	return (0);
}

static int
gen_init_prms_tlv(struct ibuf *buf, struct nbr *nbr)
{
	struct sess_prms_tlv	parms;

	memset(&parms, 0, sizeof(parms));
	parms.type = htons(TLV_TYPE_COMMONSESSION);
	parms.length = htons(SESS_PRMS_LEN);
	parms.proto_version = htons(LDP_VERSION);
	parms.keepalive_time = htons(nbr_get_keepalive(nbr->af, nbr->id));
	parms.reserved = 0;
	parms.pvlim = 0;
	parms.max_pdu_len = 0;
	parms.lsr_id = nbr->id.s_addr;
	parms.lspace_id = 0;

	return (ibuf_add(buf, &parms, SESS_PRMS_SIZE));
}

static int
gen_cap_dynamic_tlv(struct ibuf *buf)
{
	struct capability_tlv	cap;

	memset(&cap, 0, sizeof(cap));
	cap.type = htons(TLV_TYPE_DYNAMIC_CAP);
	cap.length = htons(CAP_TLV_DYNAMIC_LEN);
	/* the S-bit is always 1 for the Dynamic Capability Announcement */
	cap.reserved = STATE_BIT;

	return (ibuf_add(buf, &cap, CAP_TLV_DYNAMIC_SIZE));
}

static int
gen_cap_twcard_tlv(struct ibuf *buf, int enable)
{
	struct capability_tlv	cap;

	memset(&cap, 0, sizeof(cap));
	cap.type = htons(TLV_TYPE_TWCARD_CAP);
	cap.length = htons(CAP_TLV_TWCARD_LEN);
	if (enable)
		cap.reserved = STATE_BIT;

	return (ibuf_add(buf, &cap, CAP_TLV_TWCARD_SIZE));
}

static int
gen_cap_unotif_tlv(struct ibuf *buf, int enable)
{
	struct capability_tlv	cap;

	memset(&cap, 0, sizeof(cap));
	cap.type = htons(TLV_TYPE_UNOTIF_CAP);
	cap.length = htons(CAP_TLV_UNOTIF_LEN);
	if (enable)
		cap.reserved = STATE_BIT;

	return (ibuf_add(buf, &cap, CAP_TLV_UNOTIF_SIZE));
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: init.c,v 1.37 2017/03/04 00:15:35 renato Exp $ */
2
3			/*
4			* Copyright (c) 2009 Michele Marchetto <michele@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 <arpa/inet.h>
21			#include <string.h>
22
23			#include "ldpd.h"
24			#include "ldpe.h"
25			#include "log.h"
26
27			static int gen_init_prms_tlv(struct ibuf , struct nbr );
28			static int gen_cap_dynamic_tlv(struct ibuf *);
29			static int gen_cap_twcard_tlv(struct ibuf *, int);
30			static int gen_cap_unotif_tlv(struct ibuf *, int);
31
32			void
33			send_init(struct nbr *nbr)
34			{
35			struct ibuf *buf;
36			uint16_t size;
37			int err = 0;
38
39			log_debug("%s: lsr-id %s", __func__, inet_ntoa(nbr->id));
40
41			size = LDP_HDR_SIZE + LDP_MSG_SIZE + SESS_PRMS_SIZE +
42			CAP_TLV_DYNAMIC_SIZE + CAP_TLV_TWCARD_SIZE + CAP_TLV_UNOTIF_SIZE;
43			if ((buf = ibuf_open(size)) == NULL)
44			fatal(__func__);
45
46			err \|= gen_ldp_hdr(buf, size);
47			size -= LDP_HDR_SIZE;
48			err \|= gen_msg_hdr(buf, MSG_TYPE_INIT, size);
49			err \|= gen_init_prms_tlv(buf, nbr);
50			err \|= gen_cap_dynamic_tlv(buf);
51			err \|= gen_cap_twcard_tlv(buf, 1);
52			err \|= gen_cap_unotif_tlv(buf, 1);
53			if (err) {
54			ibuf_free(buf);
55			return;
56			}
57
58			evbuf_enqueue(&nbr->tcp->wbuf, buf);
59			}
60
61			int
62			recv_init(struct nbr nbr, char buf, uint16_t len)
63			{
64			struct ldp_msg msg;
65			struct sess_prms_tlv sess;
66			uint16_t max_pdu_len;
67			int caps_rcvd = 0;
68
69			log_debug("%s: lsr-id %s", __func__, inet_ntoa(nbr->id));
70
71			memcpy(&msg, buf, sizeof(msg));
72			buf += LDP_MSG_SIZE;
73			len -= LDP_MSG_SIZE;
74
75			if (len < SESS_PRMS_SIZE) {
76			session_shutdown(nbr, S_BAD_MSG_LEN, msg.id, msg.type);
77			return (-1);
78			}
79			memcpy(&sess, buf, sizeof(sess));
80			if (ntohs(sess.length) != SESS_PRMS_LEN) {
81			session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type);
82			return (-1);
83			}
84			if (ntohs(sess.proto_version) != LDP_VERSION) {
85			session_shutdown(nbr, S_BAD_PROTO_VER, msg.id, msg.type);
86			return (-1);
87			}
88			if (ntohs(sess.keepalive_time) < MIN_KEEPALIVE) {
89			session_shutdown(nbr, S_KEEPALIVE_BAD, msg.id, msg.type);
90			return (-1);
91			}
92			if (sess.lsr_id != leconf->rtr_id.s_addr \|\|
93			ntohs(sess.lspace_id) != 0) {
94			session_shutdown(nbr, S_NO_HELLO, msg.id, msg.type);
95			return (-1);
96			}
97
98			buf += SESS_PRMS_SIZE;
99			len -= SESS_PRMS_SIZE;
100
101			/* Optional Parameters */
102			while (len > 0) {
103			struct tlv tlv;
104			uint16_t tlv_type;
105			uint16_t tlv_len;
106
107			if (len < sizeof(tlv)) {
108			session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type);
109			return (-1);
110			}
111
112			memcpy(&tlv, buf, TLV_HDR_SIZE);
113			tlv_type = ntohs(tlv.type);
114			tlv_len = ntohs(tlv.length);
115			if (tlv_len + TLV_HDR_SIZE > len) {
116			session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type);
117			return (-1);
118			}
119			buf += TLV_HDR_SIZE;
120			len -= TLV_HDR_SIZE;
121
122			/*
123			* RFC 5561 - Section 6:
124			* "The S-bit of a Capability Parameter in an Initialization
125			* message MUST be 1 and SHOULD be ignored on receipt".
126			*/
127			switch (tlv_type) {
128			case TLV_TYPE_ATMSESSIONPAR:
129			session_shutdown(nbr, S_BAD_TLV_VAL, msg.id, msg.type);
130			return (-1);
131			case TLV_TYPE_FRSESSION:
132			session_shutdown(nbr, S_BAD_TLV_VAL, msg.id, msg.type);
133			return (-1);
134			case TLV_TYPE_DYNAMIC_CAP:
135			if (tlv_len != CAP_TLV_DYNAMIC_LEN) {
136			session_shutdown(nbr, S_BAD_TLV_LEN, msg.id,
137			msg.type);
138			return (-1);
139			}
140
141			if (caps_rcvd & F_CAP_TLV_RCVD_DYNAMIC) {
142			session_shutdown(nbr, S_BAD_TLV_VAL, msg.id,
143			msg.type);
144			return (-1);
145			}
146			caps_rcvd \|= F_CAP_TLV_RCVD_DYNAMIC;
147
148			nbr->flags \|= F_NBR_CAP_DYNAMIC;
149
150			log_debug("%s: lsr-id %s announced the Dynamic "
151			"Capability Announcement capability", __func__,
152			inet_ntoa(nbr->id));
153			break;
154			case TLV_TYPE_TWCARD_CAP:
155			if (tlv_len != CAP_TLV_TWCARD_LEN) {
156			session_shutdown(nbr, S_BAD_TLV_LEN, msg.id,
157			msg.type);
158			return (-1);
159			}
160
161			if (caps_rcvd & F_CAP_TLV_RCVD_TWCARD) {
162			session_shutdown(nbr, S_BAD_TLV_VAL, msg.id,
163			msg.type);
164			return (-1);
165			}
166			caps_rcvd \|= F_CAP_TLV_RCVD_TWCARD;
167
168			nbr->flags \|= F_NBR_CAP_TWCARD;
169
170			log_debug("%s: lsr-id %s announced the Typed Wildcard "
171			"FEC capability", __func__, inet_ntoa(nbr->id));
172			break;
173			case TLV_TYPE_UNOTIF_CAP:
174			if (tlv_len != CAP_TLV_UNOTIF_LEN) {
175			session_shutdown(nbr, S_BAD_TLV_LEN, msg.id,
176			msg.type);
177			return (-1);
178			}
179
180			if (caps_rcvd & F_CAP_TLV_RCVD_UNOTIF) {
181			session_shutdown(nbr, S_BAD_TLV_VAL, msg.id,
182			msg.type);
183			return (-1);
184			}
185			caps_rcvd \|= F_CAP_TLV_RCVD_UNOTIF;
186
187			nbr->flags \|= F_NBR_CAP_UNOTIF;
188
189			log_debug("%s: lsr-id %s announced the Unrecognized "
190			"Notification capability", __func__,
191			inet_ntoa(nbr->id));
192			break;
193			default:
194			if (!(ntohs(tlv.type) & UNKNOWN_FLAG))
195			send_notification_rtlvs(nbr, S_UNSSUPORTDCAP,
196			msg.id, msg.type, tlv_type, tlv_len, buf);
197			/* ignore unknown tlv */
198			break;
199			}
200			buf += tlv_len;
201			len -= tlv_len;
202			}
203
204			nbr->keepalive = min(nbr_get_keepalive(nbr->af, nbr->id),
205			ntohs(sess.keepalive_time));
206
207			max_pdu_len = ntohs(sess.max_pdu_len);
208			/*
209			* RFC 5036 - Section 3.5.3:
210			* "A value of 255 or less specifies the default maximum length of
211			* 4096 octets".
212			*/
213			if (max_pdu_len <= 255)
214			max_pdu_len = LDP_MAX_LEN;
215			nbr->max_pdu_len = min(max_pdu_len, LDP_MAX_LEN);
216
217			nbr_fsm(nbr, NBR_EVT_INIT_RCVD);
218
219			return (0);
220			}
221
222			void
223			send_capability(struct nbr *nbr, uint16_t capability, int enable)
224			{
225			struct ibuf *buf;
226			uint16_t size;
227			int err = 0;
228
229			log_debug("%s: lsr-id %s", __func__, inet_ntoa(nbr->id));
230
231			size = LDP_HDR_SIZE + LDP_MSG_SIZE + CAP_TLV_DYNAMIC_SIZE;
232			if ((buf = ibuf_open(size)) == NULL)
233			fatal(__func__);
234
235			err \|= gen_ldp_hdr(buf, size);
236			size -= LDP_HDR_SIZE;
237			err \|= gen_msg_hdr(buf, MSG_TYPE_CAPABILITY, size);
238
239			switch (capability) {
240			case TLV_TYPE_TWCARD_CAP:
241			err \|= gen_cap_twcard_tlv(buf, enable);
242			break;
243			case TLV_TYPE_UNOTIF_CAP:
244			err \|= gen_cap_unotif_tlv(buf, enable);
245			break;
246			case TLV_TYPE_DYNAMIC_CAP:
247			/*
248			* RFC 5561 - Section 9:
249			* "An LDP speaker MUST NOT include the Dynamic Capability
250			* Announcement Parameter in Capability messages sent to
251			* its peers".
252			*/
253			/* FALLTHROUGH */
254			default:
255			fatalx("send_capability: unsupported capability");
256			}
257
258			if (err) {
259			ibuf_free(buf);
260			return;
261			}
262
263			evbuf_enqueue(&nbr->tcp->wbuf, buf);
264			nbr_fsm(nbr, NBR_EVT_PDU_SENT);
265			}
266
267			int
268			recv_capability(struct nbr nbr, char buf, uint16_t len)
269			{
270			struct ldp_msg msg;
271			int enable = 0;
272			int caps_rcvd = 0;
273
274			log_debug("%s: lsr-id %s", __func__, inet_ntoa(nbr->id));
275
276			memcpy(&msg, buf, sizeof(msg));
277			buf += LDP_MSG_SIZE;
278			len -= LDP_MSG_SIZE;
279
280			/* Optional Parameters */
281			while (len > 0) {
282			struct tlv tlv;
283			uint16_t tlv_type;
284			uint16_t tlv_len;
285			uint8_t reserved;
286
287			if (len < sizeof(tlv)) {
288			session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type);
289			return (-1);
290			}
291
292			memcpy(&tlv, buf, TLV_HDR_SIZE);
293			tlv_type = ntohs(tlv.type);
294			tlv_len = ntohs(tlv.length);
295			if (tlv_len + TLV_HDR_SIZE > len) {
296			session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type);
297			return (-1);
298			}
299			buf += TLV_HDR_SIZE;
300			len -= TLV_HDR_SIZE;
301
302			switch (tlv_type) {
303			case TLV_TYPE_TWCARD_CAP:
304			if (tlv_len != CAP_TLV_TWCARD_LEN) {
305			session_shutdown(nbr, S_BAD_TLV_LEN, msg.id,
306			msg.type);
307			return (-1);
308			}
309
310			if (caps_rcvd & F_CAP_TLV_RCVD_TWCARD) {
311			session_shutdown(nbr, S_BAD_TLV_VAL, msg.id,
312			msg.type);
313			return (-1);
314			}
315			caps_rcvd \|= F_CAP_TLV_RCVD_TWCARD;
316
317			memcpy(&reserved, buf, sizeof(reserved));
318			enable = reserved & STATE_BIT;
319			if (enable)
320			nbr->flags \|= F_NBR_CAP_TWCARD;
321			else
322			nbr->flags &= ~F_NBR_CAP_TWCARD;
323
324			log_debug("%s: lsr-id %s %s the Typed Wildcard FEC "
325			"capability", __func__, inet_ntoa(nbr->id),
326			(enable) ? "announced" : "withdrew");
327			break;
328			case TLV_TYPE_UNOTIF_CAP:
329			if (tlv_len != CAP_TLV_UNOTIF_LEN) {
330			session_shutdown(nbr, S_BAD_TLV_LEN, msg.id,
331			msg.type);
332			return (-1);
333			}
334
335			if (caps_rcvd & F_CAP_TLV_RCVD_UNOTIF) {
336			session_shutdown(nbr, S_BAD_TLV_VAL, msg.id,
337			msg.type);
338			return (-1);
339			}
340			caps_rcvd \|= F_CAP_TLV_RCVD_UNOTIF;
341
342			memcpy(&reserved, buf, sizeof(reserved));
343			enable = reserved & STATE_BIT;
344			if (enable)
345			nbr->flags \|= F_NBR_CAP_UNOTIF;
346			else
347			nbr->flags &= ~F_NBR_CAP_UNOTIF;
348
349			log_debug("%s: lsr-id %s %s the Unrecognized "
350			"Notification capability", __func__,
351			inet_ntoa(nbr->id), (enable) ? "announced" :
352			"withdrew");
353			break;
354			case TLV_TYPE_DYNAMIC_CAP:
355			/*
356			* RFC 5561 - Section 9:
357			* "An LDP speaker that receives a Capability message
358			* from a peer that includes the Dynamic Capability
359			* Announcement Parameter SHOULD silently ignore the
360			* parameter and process any other Capability Parameters
361			* in the message".
362			*/
363			/* FALLTHROUGH */
364			default:
365			if (!(ntohs(tlv.type) & UNKNOWN_FLAG))
366			send_notification_rtlvs(nbr, S_UNSSUPORTDCAP,
367			msg.id, msg.type, tlv_type, tlv_len, buf);
368			/* ignore unknown tlv */
369			break;
370			}
371			buf += tlv_len;
372			len -= tlv_len;
373			}
374
375			nbr_fsm(nbr, NBR_EVT_PDU_RCVD);
376
377			return (0);
378			}
379
380			static int
381			gen_init_prms_tlv(struct ibuf buf, struct nbr nbr)
382			{
383			struct sess_prms_tlv parms;
384
385			memset(&parms, 0, sizeof(parms));
386			parms.type = htons(TLV_TYPE_COMMONSESSION);
387			parms.length = htons(SESS_PRMS_LEN);
388			parms.proto_version = htons(LDP_VERSION);
389			parms.keepalive_time = htons(nbr_get_keepalive(nbr->af, nbr->id));
390			parms.reserved = 0;
391			parms.pvlim = 0;
392			parms.max_pdu_len = 0;
393			parms.lsr_id = nbr->id.s_addr;
394			parms.lspace_id = 0;
395
396			return (ibuf_add(buf, &parms, SESS_PRMS_SIZE));
397			}
398
399			static int
400			gen_cap_dynamic_tlv(struct ibuf *buf)
401			{
402			struct capability_tlv cap;
403
404			memset(&cap, 0, sizeof(cap));
405			cap.type = htons(TLV_TYPE_DYNAMIC_CAP);
406			cap.length = htons(CAP_TLV_DYNAMIC_LEN);
407			/* the S-bit is always 1 for the Dynamic Capability Announcement */
408			cap.reserved = STATE_BIT;
409
410			return (ibuf_add(buf, &cap, CAP_TLV_DYNAMIC_SIZE));
411			}
412
413			static int
414			gen_cap_twcard_tlv(struct ibuf *buf, int enable)
415			{
416			struct capability_tlv cap;
417
418			memset(&cap, 0, sizeof(cap));
419			cap.type = htons(TLV_TYPE_TWCARD_CAP);
420			cap.length = htons(CAP_TLV_TWCARD_LEN);
421			if (enable)
422			cap.reserved = STATE_BIT;
423
424			return (ibuf_add(buf, &cap, CAP_TLV_TWCARD_SIZE));
425			}
426
427			static int
428			gen_cap_unotif_tlv(struct ibuf *buf, int enable)
429			{
430			struct capability_tlv cap;
431
432			memset(&cap, 0, sizeof(cap));
433			cap.type = htons(TLV_TYPE_UNOTIF_CAP);
434			cap.length = htons(CAP_TLV_UNOTIF_LEN);
435			if (enable)
436			cap.reserved = STATE_BIT;
437
438			return (ibuf_add(buf, &cap, CAP_TLV_UNOTIF_SIZE));
439			}