[mirror_frr.git] / ldpd / init.c

/*	$OpenBSD$ */

/*
 * 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 <zebra.h>

#include "ldpd.h"
#include "ldpe.h"
#include "log.h"
#include "ldp_debug.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;

	debug_msg_send("initialization: lsr-id %s", 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;

	debug_msg_recv("initialization: lsr-id %s", 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 != ldp_rtr_id_get(leconf) ||
	    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);
	nbr->stats.capability_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));
}
Commit	Line	Data
8429abe0 RW	1	/* $OpenBSD$ */
	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
eac6e3f0	19	#include <zebra.h>
8429abe0 RW	20
	21	#include "ldpd.h"
	22	#include "ldpe.h"
	23	#include "log.h"
eac6e3f0	24	#include "ldp_debug.h"
8429abe0 RW	25
8429abe0 RW	26	static int gen_init_prms_tlv(struct ibuf , struct nbr );
8819fc38	27	static int gen_cap_dynamic_tlv(struct ibuf *);
d4afb819	28	static int gen_cap_twcard_tlv(struct ibuf *, int);
257799cd	29	static int gen_cap_unotif_tlv(struct ibuf *, int);
8429abe0 RW	30
	31	void
	32	send_init(struct nbr *nbr)
	33	{
	34	struct ibuf *buf;
	35	uint16_t size;
	36	int err = 0;
	37
eac6e3f0	38	debug_msg_send("initialization: lsr-id %s", inet_ntoa(nbr->id));
8429abe0	39
8819fc38	40	size = LDP_HDR_SIZE + LDP_MSG_SIZE + SESS_PRMS_SIZE +
257799cd	41	CAP_TLV_DYNAMIC_SIZE + CAP_TLV_TWCARD_SIZE + CAP_TLV_UNOTIF_SIZE;
8429abe0 RW	42	if ((buf = ibuf_open(size)) == NULL)
	43	fatal(__func__);
	44
	45	err \|= gen_ldp_hdr(buf, size);
	46	size -= LDP_HDR_SIZE;
	47	err \|= gen_msg_hdr(buf, MSG_TYPE_INIT, size);
8429abe0	48	err \|= gen_init_prms_tlv(buf, nbr);
8819fc38	49	err \|= gen_cap_dynamic_tlv(buf);
d4afb819	50	err \|= gen_cap_twcard_tlv(buf, 1);
257799cd	51	err \|= gen_cap_unotif_tlv(buf, 1);
8429abe0 RW	52	if (err) {
	53	ibuf_free(buf);
	54	return;
	55	}
	56
	57	evbuf_enqueue(&nbr->tcp->wbuf, buf);
	58	}
	59
	60	int
	61	recv_init(struct nbr nbr, char buf, uint16_t len)
	62	{
	63	struct ldp_msg msg;
	64	struct sess_prms_tlv sess;
	65	uint16_t max_pdu_len;
8819fc38	66	int caps_rcvd = 0;
8429abe0	67
eac6e3f0	68	debug_msg_recv("initialization: lsr-id %s", inet_ntoa(nbr->id));
8429abe0 RW	69
	70	memcpy(&msg, buf, sizeof(msg));
	71	buf += LDP_MSG_SIZE;
	72	len -= LDP_MSG_SIZE;
	73
	74	if (len < SESS_PRMS_SIZE) {
	75	session_shutdown(nbr, S_BAD_MSG_LEN, msg.id, msg.type);
	76	return (-1);
	77	}
	78	memcpy(&sess, buf, sizeof(sess));
	79	if (ntohs(sess.length) != SESS_PRMS_LEN) {
	80	session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type);
	81	return (-1);
	82	}
	83	if (ntohs(sess.proto_version) != LDP_VERSION) {
	84	session_shutdown(nbr, S_BAD_PROTO_VER, msg.id, msg.type);
	85	return (-1);
	86	}
	87	if (ntohs(sess.keepalive_time) < MIN_KEEPALIVE) {
	88	session_shutdown(nbr, S_KEEPALIVE_BAD, msg.id, msg.type);
	89	return (-1);
	90	}
eac6e3f0	91	if (sess.lsr_id != ldp_rtr_id_get(leconf) \|\|
8429abe0 RW	92	ntohs(sess.lspace_id) != 0) {
	93	session_shutdown(nbr, S_NO_HELLO, msg.id, msg.type);
	94	return (-1);
	95	}
	96
	97	buf += SESS_PRMS_SIZE;
	98	len -= SESS_PRMS_SIZE;
	99
	100	/* Optional Parameters */
	101	while (len > 0) {
	102	struct tlv tlv;
8819fc38	103	uint16_t tlv_type;
8429abe0 RW	104	uint16_t tlv_len;
	105
	106	if (len < sizeof(tlv)) {
	107	session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type);
	108	return (-1);
	109	}
	110
	111	memcpy(&tlv, buf, TLV_HDR_SIZE);
8819fc38	112	tlv_type = ntohs(tlv.type);
8429abe0 RW	113	tlv_len = ntohs(tlv.length);
	114	if (tlv_len + TLV_HDR_SIZE > len) {
	115	session_shutdown(nbr, S_BAD_TLV_LEN, msg.id, msg.type);
	116	return (-1);
	117	}
	118	buf += TLV_HDR_SIZE;
	119	len -= TLV_HDR_SIZE;
	120
8819fc38 RW	121	/*
	122	* RFC 5561 - Section 6:
	123	* "The S-bit of a Capability Parameter in an Initialization
	124	* message MUST be 1 and SHOULD be ignored on receipt".
	125	*/
	126	switch (tlv_type) {
8429abe0 RW	127	case TLV_TYPE_ATMSESSIONPAR:
	128	session_shutdown(nbr, S_BAD_TLV_VAL, msg.id, msg.type);
	129	return (-1);
	130	case TLV_TYPE_FRSESSION:
	131	session_shutdown(nbr, S_BAD_TLV_VAL, msg.id, msg.type);
	132	return (-1);
8819fc38 RW	133	case TLV_TYPE_DYNAMIC_CAP:
	134	if (tlv_len != CAP_TLV_DYNAMIC_LEN) {
	135	session_shutdown(nbr, S_BAD_TLV_LEN, msg.id,
	136	msg.type);
	137	return (-1);
	138	}
	139
	140	if (caps_rcvd & F_CAP_TLV_RCVD_DYNAMIC) {
	141	session_shutdown(nbr, S_BAD_TLV_VAL, msg.id,
	142	msg.type);
	143	return (-1);
	144	}
	145	caps_rcvd \|= F_CAP_TLV_RCVD_DYNAMIC;
	146
	147	nbr->flags \|= F_NBR_CAP_DYNAMIC;
	148
	149	log_debug("%s: lsr-id %s announced the Dynamic "
	150	"Capability Announcement capability", __func__,
	151	inet_ntoa(nbr->id));
	152	break;
d4afb819 RW	153	case TLV_TYPE_TWCARD_CAP:
	154	if (tlv_len != CAP_TLV_TWCARD_LEN) {
	155	session_shutdown(nbr, S_BAD_TLV_LEN, msg.id,
	156	msg.type);
	157	return (-1);
	158	}
	159
	160	if (caps_rcvd & F_CAP_TLV_RCVD_TWCARD) {
	161	session_shutdown(nbr, S_BAD_TLV_VAL, msg.id,
	162	msg.type);
	163	return (-1);
	164	}
	165	caps_rcvd \|= F_CAP_TLV_RCVD_TWCARD;
	166
	167	nbr->flags \|= F_NBR_CAP_TWCARD;
	168
	169	log_debug("%s: lsr-id %s announced the Typed Wildcard "
	170	"FEC capability", __func__, inet_ntoa(nbr->id));
	171	break;
257799cd RW	172	case TLV_TYPE_UNOTIF_CAP:
	173	if (tlv_len != CAP_TLV_UNOTIF_LEN) {
	174	session_shutdown(nbr, S_BAD_TLV_LEN, msg.id,
	175	msg.type);
	176	return (-1);
	177	}
	178
	179	if (caps_rcvd & F_CAP_TLV_RCVD_UNOTIF) {
	180	session_shutdown(nbr, S_BAD_TLV_VAL, msg.id,
	181	msg.type);
	182	return (-1);
	183	}
	184	caps_rcvd \|= F_CAP_TLV_RCVD_UNOTIF;
	185
	186	nbr->flags \|= F_NBR_CAP_UNOTIF;
	187
	188	log_debug("%s: lsr-id %s announced the Unrecognized "
	189	"Notification capability", __func__,
	190	inet_ntoa(nbr->id));
	191	break;
8429abe0 RW	192	default:
8429abe0 RW	193	if (!(ntohs(tlv.type) & UNKNOWN_FLAG))
8819fc38 RW	194	send_notification_rtlvs(nbr, S_UNSSUPORTDCAP,
8819fc38 RW	195	msg.id, msg.type, tlv_type, tlv_len, buf);
8429abe0 RW	196	/* ignore unknown tlv */
	197	break;
	198	}
	199	buf += tlv_len;
	200	len -= tlv_len;
	201	}
	202
	203	nbr->keepalive = min(nbr_get_keepalive(nbr->af, nbr->id),
	204	ntohs(sess.keepalive_time));
	205
	206	max_pdu_len = ntohs(sess.max_pdu_len);
	207	/*
	208	* RFC 5036 - Section 3.5.3:
	209	* "A value of 255 or less specifies the default maximum length of
	210	* 4096 octets".
	211	*/
	212	if (max_pdu_len <= 255)
	213	max_pdu_len = LDP_MAX_LEN;
	214	nbr->max_pdu_len = min(max_pdu_len, LDP_MAX_LEN);
	215
	216	nbr_fsm(nbr, NBR_EVT_INIT_RCVD);
	217
	218	return (0);
	219	}
	220
8819fc38 RW	221	void
	222	send_capability(struct nbr *nbr, uint16_t capability, int enable)
	223	{
	224	struct ibuf *buf;
	225	uint16_t size;
	226	int err = 0;
	227
	228	log_debug("%s: lsr-id %s", __func__, inet_ntoa(nbr->id));
	229
	230	size = LDP_HDR_SIZE + LDP_MSG_SIZE + CAP_TLV_DYNAMIC_SIZE;
	231	if ((buf = ibuf_open(size)) == NULL)
	232	fatal(__func__);
	233
	234	err \|= gen_ldp_hdr(buf, size);
	235	size -= LDP_HDR_SIZE;
	236	err \|= gen_msg_hdr(buf, MSG_TYPE_CAPABILITY, size);
	237
	238	switch (capability) {
d4afb819 RW	239	case TLV_TYPE_TWCARD_CAP:
	240	err \|= gen_cap_twcard_tlv(buf, enable);
	241	break;
257799cd RW	242	case TLV_TYPE_UNOTIF_CAP:
	243	err \|= gen_cap_unotif_tlv(buf, enable);
	244	break;
8819fc38 RW	245	case TLV_TYPE_DYNAMIC_CAP:
	246	/*
	247	* RFC 5561 - Section 9:
	248	* "An LDP speaker MUST NOT include the Dynamic Capability
	249	* Announcement Parameter in Capability messages sent to
	250	* its peers".
	251	*/
	252	/* FALLTHROUGH */
	253	default:
	254	fatalx("send_capability: unsupported capability");
	255	}
	256
	257	if (err) {
	258	ibuf_free(buf);
	259	return;
	260	}
	261
	262	evbuf_enqueue(&nbr->tcp->wbuf, buf);
	263	nbr_fsm(nbr, NBR_EVT_PDU_SENT);
0f7b5df9	264	nbr->stats.capability_sent++;
8819fc38 RW	265	}
	266
	267	int
	268	recv_capability(struct nbr nbr, char buf, uint16_t len)
	269	{
	270	struct ldp_msg msg;
d4afb819 RW	271	int enable = 0;
d4afb819 RW	272	int caps_rcvd = 0;
8819fc38 RW	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;
d4afb819	285	uint8_t reserved;
8819fc38 RW	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) {
d4afb819 RW	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;
257799cd RW	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;
8819fc38 RW	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
8429abe0 RW	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	}
8819fc38 RW	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	}
d4afb819 RW	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	}
257799cd RW	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	}