[mirror_frr.git] / zebra / irdp_main.c

/*
 *
 * Copyright (C) 2000  Robert Olsson.
 * Swedish University of Agricultural Sciences
 *
 * This file is part of GNU Zebra.
 *
 * GNU Zebra is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * GNU Zebra is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

/*
 * This work includes work with the following copywrite:
 *
 * Copyright (C) 1997, 2000 Kunihiro Ishiguro
 *
 */

/*
 * Thanks to Jens Laas at Swedish University of Agricultural Sciences
 * for reviewing and tests.
 */


#include <zebra.h>

#include "if.h"
#include "vty.h"
#include "sockunion.h"
#include "sockopt.h"
#include "prefix.h"
#include "command.h"
#include "memory.h"
#include "zebra_memory.h"
#include "stream.h"
#include "ioctl.h"
#include "connected.h"
#include "log.h"
#include "zclient.h"
#include "thread.h"
#include "privs.h"
#include "libfrr.h"
#include "lib_errors.h"
#include "version.h"
#include "zebra/interface.h"
#include "zebra/rtadv.h"
#include "zebra/rib.h"
#include "zebra/zserv.h"
#include "zebra/redistribute.h"
#include "zebra/irdp.h"
#include "zebra/zebra_errors.h"
#include <netinet/ip_icmp.h>

#include "checksum.h"
#include "if.h"
#include "sockunion.h"
#include "log.h"

/* GLOBAL VARS */

extern struct zebra_privs_t zserv_privs;

struct thread *t_irdp_raw;

/* Timer interval of irdp. */
int irdp_timer_interval = IRDP_DEFAULT_INTERVAL;

int irdp_sock_init(void)
{
	int ret, i;
	int save_errno;
	int sock;

	frr_elevate_privs(&zserv_privs) {

		sock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
		save_errno = errno;

	}

	if (sock < 0) {
		flog_err_sys(EC_LIB_SOCKET, "IRDP: can't create irdp socket %s",
			     safe_strerror(save_errno));
		return sock;
	};

	i = 1;
	ret = setsockopt(sock, IPPROTO_IP, IP_TTL, (void *)&i, sizeof(i));
	if (ret < 0) {
		flog_err_sys(EC_LIB_SOCKET, "IRDP: can't do irdp sockopt %s",
			     safe_strerror(errno));
		close(sock);
		return ret;
	};

	ret = setsockopt_ifindex(AF_INET, sock, 1);
	if (ret < 0) {
		flog_err_sys(EC_LIB_SOCKET, "IRDP: can't do irdp sockopt %s",
			     safe_strerror(errno));
		close(sock);
		return ret;
	};

	t_irdp_raw = NULL;
	thread_add_read(zebrad.master, irdp_read_raw, NULL, sock, &t_irdp_raw);

	return sock;
}


static int get_pref(struct irdp_interface *irdp, struct prefix *p)
{
	struct listnode *node;
	struct Adv *adv;

	/* Use default preference or use the override pref */

	if (irdp->AdvPrefList == NULL)
		return irdp->Preference;

	for (ALL_LIST_ELEMENTS_RO(irdp->AdvPrefList, node, adv))
		if (p->u.prefix4.s_addr == adv->ip.s_addr)
			return adv->pref;

	return irdp->Preference;
}

/* Make ICMP Router Advertisement Message. */
static int make_advertisement_packet(struct interface *ifp, struct prefix *p,
				     struct stream *s)
{
	struct zebra_if *zi = ifp->info;
	struct irdp_interface *irdp = zi->irdp;
	int size;
	int pref;
	uint16_t checksum;

	pref = get_pref(irdp, p);

	stream_putc(s, ICMP_ROUTERADVERT); /* Type. */
	stream_putc(s, 0);		   /* Code. */
	stream_putw(s, 0);		   /* Checksum. */
	stream_putc(s, 1);		   /* Num address. */
	stream_putc(s, 2);		   /* Address Entry Size. */

	if (irdp->flags & IF_SHUTDOWN)
		stream_putw(s, 0);
	else
		stream_putw(s, irdp->Lifetime);

	stream_putl(s, htonl(p->u.prefix4.s_addr)); /* Router address. */
	stream_putl(s, pref);

	/* in_cksum return network byte order value */
	size = 16;
	checksum = in_cksum(s->data, size);
	stream_putw_at(s, 2, htons(checksum));

	return size;
}

static void irdp_send(struct interface *ifp, struct prefix *p, struct stream *s)
{
	struct zebra_if *zi = ifp->info;
	struct irdp_interface *irdp = zi->irdp;
	char buf[PREFIX_STRLEN];
	uint32_t dst;
	uint32_t ttl = 1;

	if (!irdp)
		return;
	if (!(ifp->flags & IFF_UP))
		return;

	if (irdp->flags & IF_BROADCAST)
		dst = INADDR_BROADCAST;
	else
		dst = htonl(INADDR_ALLHOSTS_GROUP);

	if (irdp->flags & IF_DEBUG_MESSAGES)
		zlog_debug("IRDP: TX Advert on %s %s Holdtime=%d Preference=%d",
			   ifp->name, prefix2str(p, buf, sizeof buf),
			   irdp->flags & IF_SHUTDOWN ? 0 : irdp->Lifetime,
			   get_pref(irdp, p));

	send_packet(ifp, s, dst, p, ttl);
}

static void irdp_advertisement(struct interface *ifp, struct prefix *p)
{
	struct stream *s;
	s = stream_new(128);
	make_advertisement_packet(ifp, p, s);
	irdp_send(ifp, p, s);
	stream_free(s);
}

int irdp_send_thread(struct thread *t_advert)
{
	uint32_t timer, tmp;
	struct interface *ifp = THREAD_ARG(t_advert);
	struct zebra_if *zi = ifp->info;
	struct irdp_interface *irdp = zi->irdp;
	struct prefix *p;
	struct listnode *node, *nnode;
	struct connected *ifc;

	if (!irdp)
		return 0;

	irdp->flags &= ~IF_SOLICIT;

	if (ifp->connected)
		for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, ifc)) {
			p = ifc->address;

			if (p->family != AF_INET)
				continue;

			irdp_advertisement(ifp, p);
			irdp->irdp_sent++;
		}

	tmp = irdp->MaxAdvertInterval - irdp->MinAdvertInterval;
	timer = random() % (tmp + 1);
	timer = irdp->MinAdvertInterval + timer;

	if (irdp->irdp_sent < MAX_INITIAL_ADVERTISEMENTS
	    && timer > MAX_INITIAL_ADVERT_INTERVAL)
		timer = MAX_INITIAL_ADVERT_INTERVAL;

	if (irdp->flags & IF_DEBUG_MISC)
		zlog_debug("IRDP: New timer for %s set to %u\n", ifp->name,
			   timer);

	irdp->t_advertise = NULL;
	thread_add_timer(zebrad.master, irdp_send_thread, ifp, timer,
			 &irdp->t_advertise);
	return 0;
}

void irdp_advert_off(struct interface *ifp)
{
	struct zebra_if *zi = ifp->info;
	struct irdp_interface *irdp = zi->irdp;
	struct listnode *node, *nnode;
	int i;
	struct connected *ifc;
	struct prefix *p;

	if (!irdp)
		return;

	if (irdp->t_advertise)
		thread_cancel(irdp->t_advertise);
	irdp->t_advertise = NULL;

	if (ifp->connected)
		for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, ifc)) {
			p = ifc->address;

			/* Output some packets with Lifetime 0
			   we should add a wait...
			*/

			for (i = 0; i < IRDP_LAST_ADVERT_MESSAGES; i++) {
				irdp->irdp_sent++;
				irdp_advertisement(ifp, p);
			}
		}
}


void process_solicit(struct interface *ifp)
{
	struct zebra_if *zi = ifp->info;
	struct irdp_interface *irdp = zi->irdp;
	uint32_t timer;

	if (!irdp)
		return;

	/* When SOLICIT is active we reject further incoming solicits
	   this keeps down the answering rate so we don't have think
	   about DoS attacks here. */

	if (irdp->flags & IF_SOLICIT)
		return;

	irdp->flags |= IF_SOLICIT;
	if (irdp->t_advertise)
		thread_cancel(irdp->t_advertise);
	irdp->t_advertise = NULL;

	timer = (random() % MAX_RESPONSE_DELAY) + 1;

	irdp->t_advertise = NULL;
	thread_add_timer(zebrad.master, irdp_send_thread, ifp, timer,
			 &irdp->t_advertise);
}

static int irdp_finish(void)
{
	struct vrf *vrf;
	struct interface *ifp;
	struct zebra_if *zi;
	struct irdp_interface *irdp;

	zlog_info("IRDP: Received shutdown notification.");

	RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id)
		FOR_ALL_INTERFACES (vrf, ifp) {
			zi = ifp->info;

			if (!zi)
				continue;
			irdp = zi->irdp;
			if (!irdp)
				continue;

			if (irdp->flags & IF_ACTIVE) {
				irdp->flags |= IF_SHUTDOWN;
				irdp_advert_off(ifp);
			}
		}
	return 0;
}

static int irdp_init(struct thread_master *master)
{
	irdp_if_init();

	hook_register(frr_early_fini, irdp_finish);
	return 0;
}

static int irdp_module_init(void)
{
	hook_register(frr_late_init, irdp_init);
	return 0;
}

FRR_MODULE_SETUP(.name = "zebra_irdp", .version = FRR_VERSION,
		 .description = "zebra IRDP module", .init = irdp_module_init, )
Commit	Line	Data
ca776988	1	/*
	2	*
	3	* Copyright (C) 2000 Robert Olsson.
	4	* Swedish University of Agricultural Sciences
	5	*
	6	* This file is part of GNU Zebra.
	7	*
	8	* GNU Zebra is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License as published by the
	10	* Free Software Foundation; either version 2, or (at your option) any
	11	* later version.
	12	*
	13	* GNU Zebra is distributed in the hope that it will be useful, but
	14	* WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* General Public License for more details.
	17	*
896014f4 DL	18	* You should have received a copy of the GNU General Public License along
	19	* with this program; see the file COPYING; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
ca776988	21	*/
ca776988	22
d62a17ae	23	/*
ca776988	24	* This work includes work with the following copywrite:
	25	*
	26	* Copyright (C) 1997, 2000 Kunihiro Ishiguro
	27	*
	28	*/
	29
d62a17ae	30	/*
43e52561	31	* Thanks to Jens Laas at Swedish University of Agricultural Sciences
ca776988	32	* for reviewing and tests.
	33	*/
	34
	35
	36	#include <zebra.h>
	37
ca776988	38	#include "if.h"
	39	#include "vty.h"
	40	#include "sockunion.h"
c9e52be3	41	#include "sockopt.h"
ca776988	42	#include "prefix.h"
	43	#include "command.h"
	44	#include "memory.h"
4a1ab8e4	45	#include "zebra_memory.h"
ca776988	46	#include "stream.h"
	47	#include "ioctl.h"
	48	#include "connected.h"
	49	#include "log.h"
	50	#include "zclient.h"
	51	#include "thread.h"
25dac855	52	#include "privs.h"
ead4ee99	53	#include "libfrr.h"
43e52561	54	#include "lib_errors.h"
8dc1f7fc	55	#include "version.h"
ca776988	56	#include "zebra/interface.h"
	57	#include "zebra/rtadv.h"
	58	#include "zebra/rib.h"
	59	#include "zebra/zserv.h"
	60	#include "zebra/redistribute.h"
	61	#include "zebra/irdp.h"
364fed6b	62	#include "zebra/zebra_errors.h"
ca776988	63	#include <netinet/ip_icmp.h>
ca776988	64
ab0f6155	65	#include "checksum.h"
ca776988	66	#include "if.h"
	67	#include "sockunion.h"
	68	#include "log.h"
	69
	70	/* GLOBAL VARS */
	71
25dac855	72	extern struct zebra_privs_t zserv_privs;
25dac855	73
ca776988	74	struct thread *t_irdp_raw;
	75
	76	/* Timer interval of irdp. */
	77	int irdp_timer_interval = IRDP_DEFAULT_INTERVAL;
	78
d62a17ae	79	int irdp_sock_init(void)
ca776988	80	{
d62a17ae	81	int ret, i;
	82	int save_errno;
	83	int sock;
	84
01b9e3fd	85	frr_elevate_privs(&zserv_privs) {
d62a17ae	86
01b9e3fd DL	87	sock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
01b9e3fd DL	88	save_errno = errno;
d62a17ae	89
01b9e3fd	90	}
d62a17ae	91
d62a17ae	92	if (sock < 0) {
1c50c1c0	93	flog_err_sys(EC_LIB_SOCKET, "IRDP: can't create irdp socket %s",
9df414fe	94	safe_strerror(save_errno));
d62a17ae	95	return sock;
	96	};
	97
	98	i = 1;
	99	ret = setsockopt(sock, IPPROTO_IP, IP_TTL, (void *)&i, sizeof(i));
	100	if (ret < 0) {
450971aa	101	flog_err_sys(EC_LIB_SOCKET, "IRDP: can't do irdp sockopt %s",
9df414fe	102	safe_strerror(errno));
d62a17ae	103	close(sock);
	104	return ret;
	105	};
	106
	107	ret = setsockopt_ifindex(AF_INET, sock, 1);
	108	if (ret < 0) {
450971aa	109	flog_err_sys(EC_LIB_SOCKET, "IRDP: can't do irdp sockopt %s",
9df414fe	110	safe_strerror(errno));
d62a17ae	111	close(sock);
	112	return ret;
	113	};
	114
	115	t_irdp_raw = NULL;
	116	thread_add_read(zebrad.master, irdp_read_raw, NULL, sock, &t_irdp_raw);
	117
	118	return sock;
ca776988	119	}
	120
	121
d62a17ae	122	static int get_pref(struct irdp_interface irdp, struct prefix p)
ca776988	123	{
d62a17ae	124	struct listnode *node;
	125	struct Adv *adv;
	126
	127	/* Use default preference or use the override pref */
	128
	129	if (irdp->AdvPrefList == NULL)
	130	return irdp->Preference;
	131
	132	for (ALL_LIST_ELEMENTS_RO(irdp->AdvPrefList, node, adv))
	133	if (p->u.prefix4.s_addr == adv->ip.s_addr)
	134	return adv->pref;
	135
	136	return irdp->Preference;
ca776988	137	}
	138
	139	/* Make ICMP Router Advertisement Message. */
d62a17ae	140	static int make_advertisement_packet(struct interface ifp, struct prefix p,
d62a17ae	141	struct stream *s)
ca776988	142	{
d62a17ae	143	struct zebra_if *zi = ifp->info;
ead4ee99	144	struct irdp_interface *irdp = zi->irdp;
d62a17ae	145	int size;
d62a17ae	146	int pref;
d7c0a89a	147	uint16_t checksum;
d62a17ae	148
	149	pref = get_pref(irdp, p);
	150
	151	stream_putc(s, ICMP_ROUTERADVERT); /* Type. */
	152	stream_putc(s, 0); /* Code. */
	153	stream_putw(s, 0); /* Checksum. */
	154	stream_putc(s, 1); /* Num address. */
	155	stream_putc(s, 2); /* Address Entry Size. */
	156
	157	if (irdp->flags & IF_SHUTDOWN)
	158	stream_putw(s, 0);
	159	else
	160	stream_putw(s, irdp->Lifetime);
	161
	162	stream_putl(s, htonl(p->u.prefix4.s_addr)); /* Router address. */
	163	stream_putl(s, pref);
	164
	165	/* in_cksum return network byte order value */
	166	size = 16;
	167	checksum = in_cksum(s->data, size);
	168	stream_putw_at(s, 2, htons(checksum));
	169
	170	return size;
ca776988	171	}
ca776988	172
d62a17ae	173	static void irdp_send(struct interface ifp, struct prefix p, struct stream *s)
ca776988	174	{
d62a17ae	175	struct zebra_if *zi = ifp->info;
ead4ee99	176	struct irdp_interface *irdp = zi->irdp;
d62a17ae	177	char buf[PREFIX_STRLEN];
d7c0a89a QY	178	uint32_t dst;
d7c0a89a QY	179	uint32_t ttl = 1;
d62a17ae	180
ead4ee99 DL	181	if (!irdp)
ead4ee99 DL	182	return;
d62a17ae	183	if (!(ifp->flags & IFF_UP))
	184	return;
	185
	186	if (irdp->flags & IF_BROADCAST)
	187	dst = INADDR_BROADCAST;
	188	else
	189	dst = htonl(INADDR_ALLHOSTS_GROUP);
	190
	191	if (irdp->flags & IF_DEBUG_MESSAGES)
	192	zlog_debug("IRDP: TX Advert on %s %s Holdtime=%d Preference=%d",
	193	ifp->name, prefix2str(p, buf, sizeof buf),
	194	irdp->flags & IF_SHUTDOWN ? 0 : irdp->Lifetime,
	195	get_pref(irdp, p));
	196
	197	send_packet(ifp, s, dst, p, ttl);
ca776988	198	}
ca776988	199
d62a17ae	200	static void irdp_advertisement(struct interface ifp, struct prefix p)
ca776988	201	{
d62a17ae	202	struct stream *s;
	203	s = stream_new(128);
	204	make_advertisement_packet(ifp, p, s);
	205	irdp_send(ifp, p, s);
	206	stream_free(s);
ca776988	207	}
	208
	209	int irdp_send_thread(struct thread *t_advert)
	210	{
d7c0a89a	211	uint32_t timer, tmp;
d62a17ae	212	struct interface *ifp = THREAD_ARG(t_advert);
d62a17ae	213	struct zebra_if *zi = ifp->info;
ead4ee99	214	struct irdp_interface *irdp = zi->irdp;
d62a17ae	215	struct prefix *p;
	216	struct listnode node, nnode;
	217	struct connected *ifc;
	218
ead4ee99 DL	219	if (!irdp)
	220	return 0;
	221
d62a17ae	222	irdp->flags &= ~IF_SOLICIT;
	223
	224	if (ifp->connected)
	225	for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, ifc)) {
	226	p = ifc->address;
	227
	228	if (p->family != AF_INET)
	229	continue;
	230
	231	irdp_advertisement(ifp, p);
	232	irdp->irdp_sent++;
	233	}
	234
	235	tmp = irdp->MaxAdvertInterval - irdp->MinAdvertInterval;
	236	timer = random() % (tmp + 1);
	237	timer = irdp->MinAdvertInterval + timer;
	238
	239	if (irdp->irdp_sent < MAX_INITIAL_ADVERTISEMENTS
	240	&& timer > MAX_INITIAL_ADVERT_INTERVAL)
	241	timer = MAX_INITIAL_ADVERT_INTERVAL;
	242
	243	if (irdp->flags & IF_DEBUG_MISC)
	244	zlog_debug("IRDP: New timer for %s set to %u\n", ifp->name,
	245	timer);
	246
	247	irdp->t_advertise = NULL;
	248	thread_add_timer(zebrad.master, irdp_send_thread, ifp, timer,
	249	&irdp->t_advertise);
	250	return 0;
ca776988	251	}
	252
	253	void irdp_advert_off(struct interface *ifp)
	254	{
d62a17ae	255	struct zebra_if *zi = ifp->info;
ead4ee99	256	struct irdp_interface *irdp = zi->irdp;
d62a17ae	257	struct listnode node, nnode;
	258	int i;
	259	struct connected *ifc;
	260	struct prefix *p;
	261
ead4ee99 DL	262	if (!irdp)
	263	return;
	264
d62a17ae	265	if (irdp->t_advertise)
	266	thread_cancel(irdp->t_advertise);
	267	irdp->t_advertise = NULL;
	268
	269	if (ifp->connected)
	270	for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, ifc)) {
	271	p = ifc->address;
	272
	273	/* Output some packets with Lifetime 0
	274	we should add a wait...
	275	*/
	276
	277	for (i = 0; i < IRDP_LAST_ADVERT_MESSAGES; i++) {
	278	irdp->irdp_sent++;
	279	irdp_advertisement(ifp, p);
	280	}
	281	}
ca776988	282	}
	283
	284
d62a17ae	285	void process_solicit(struct interface *ifp)
ca776988	286	{
d62a17ae	287	struct zebra_if *zi = ifp->info;
ead4ee99	288	struct irdp_interface *irdp = zi->irdp;
d7c0a89a	289	uint32_t timer;
ca776988	290
ead4ee99 DL	291	if (!irdp)
	292	return;
	293
d62a17ae	294	/* When SOLICIT is active we reject further incoming solicits
	295	this keeps down the answering rate so we don't have think
	296	about DoS attacks here. */
ca776988	297
d62a17ae	298	if (irdp->flags & IF_SOLICIT)
d62a17ae	299	return;
ca776988	300
d62a17ae	301	irdp->flags \|= IF_SOLICIT;
	302	if (irdp->t_advertise)
	303	thread_cancel(irdp->t_advertise);
	304	irdp->t_advertise = NULL;
ca776988	305
d62a17ae	306	timer = (random() % MAX_RESPONSE_DELAY) + 1;
ca776988	307
d62a17ae	308	irdp->t_advertise = NULL;
	309	thread_add_timer(zebrad.master, irdp_send_thread, ifp, timer,
	310	&irdp->t_advertise);
ca776988	311	}
ca776988	312
2eb27eec	313	static int irdp_finish(void)
ca776988	314	{
d62a17ae	315	struct vrf *vrf;
d62a17ae	316	struct interface *ifp;
	317	struct zebra_if *zi;
	318	struct irdp_interface *irdp;
	319
	320	zlog_info("IRDP: Received shutdown notification.");
	321
a2addae8	322	RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id)
451fda4f	323	FOR_ALL_INTERFACES (vrf, ifp) {
a2addae8 RW	324	zi = ifp->info;
	325
	326	if (!zi)
	327	continue;
	328	irdp = zi->irdp;
	329	if (!irdp)
	330	continue;
	331
	332	if (irdp->flags & IF_ACTIVE) {
	333	irdp->flags \|= IF_SHUTDOWN;
	334	irdp_advert_off(ifp);
	335	}
d62a17ae	336	}
ead4ee99	337	return 0;
ca776988	338	}
ca776988	339
8dc1f7fc	340	static int irdp_init(struct thread_master *master)
2eb27eec DL	341	{
	342	irdp_if_init();
	343
	344	hook_register(frr_early_fini, irdp_finish);
8dc1f7fc DL	345	return 0;
	346	}
	347
	348	static int irdp_module_init(void)
	349	{
	350	hook_register(frr_late_init, irdp_init);
	351	return 0;
2eb27eec DL	352	}
2eb27eec DL	353
996c9314 LB	354	FRR_MODULE_SETUP(.name = "zebra_irdp", .version = FRR_VERSION,
996c9314 LB	355	.description = "zebra IRDP module", .init = irdp_module_init, )