Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/dvmrpd/kroute.c	Lines:	0	162	0.0 %
Date:	2017-11-07	Branches:	0	276	0.0 %


/*	$OpenBSD: kroute.c,v 1.14 2017/07/24 11:00:01 friehm Exp $ */

/*
 * Copyright (c) 2004 Esben Norby <norby@openbsd.org>
 * Copyright (c) 2003, 2004 Henning Brauer <henning@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 <sys/socket.h>
#include <sys/sysctl.h>
#include <sys/tree.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_types.h>
#include <net/route.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "dvmrp.h"
#include "dvmrpd.h"
#include "log.h"

struct {
	u_int32_t		rtseq;
	pid_t			pid;
	struct event		ev;
} kr_state;

struct kif_node {
	RB_ENTRY(kif_node)	 entry;
	struct kif		 k;
};

int	kif_compare(struct kif_node *, struct kif_node *);

struct kif_node		*kif_find(int);
int			 kif_insert(struct kif_node *);
int			 kif_remove(struct kif_node *);
void			 kif_clear(void);

in_addr_t	prefixlen2mask(u_int8_t);
void		get_rtaddrs(int, struct sockaddr *, struct sockaddr **);
void		if_change(u_short, int, struct if_data *);
void		if_announce(void *);

int		fetchifs(int);

RB_HEAD(kif_tree, kif_node)		kit;
RB_PROTOTYPE(kif_tree, kif_node, entry, kif_compare)
RB_GENERATE(kif_tree, kif_node, entry, kif_compare)

int
kif_init(void)
{
	RB_INIT(&kit);

	if (fetchifs(0) == -1)
		return (-1);

	return (0);
}

int
kr_init(void)
{
	int opt, fd;

	if ((fd = socket(AF_ROUTE, SOCK_RAW | SOCK_CLOEXEC | SOCK_NONBLOCK,
	    0)) == -1) {
		log_warn("kr_init: socket");
		return (-1);
	}

	/* not interested in my own messages */
	if (setsockopt(fd, SOL_SOCKET, SO_USELOOPBACK, &opt, sizeof(opt)) == -1)
		log_warn("kr_init: setsockopt");	/* not fatal */

	kr_state.pid = getpid();
	kr_state.rtseq = 1;

	event_set(&kr_state.ev, fd, EV_READ | EV_PERSIST,
	    kr_dispatch_msg, NULL);
	event_add(&kr_state.ev, NULL);

	return (0);
}

void
kr_shutdown(void)
{
	kif_clear();
	close(EVENT_FD((&kr_state.ev)));
}

void
kr_ifinfo(char *ifname)
{
	struct kif_node	*kif;

	RB_FOREACH(kif, kif_tree, &kit)
		if (!strcmp(ifname, kif->k.ifname)) {
			main_imsg_compose_dvmrpe(IMSG_CTL_IFINFO, 0,
			    &kif->k, sizeof(kif->k));
			return;
		}
}

/* rb-tree compare */
int
kif_compare(struct kif_node *a, struct kif_node *b)
{
	return (b->k.ifindex - a->k.ifindex);
}

struct kif_node *
kif_find(int ifindex)
{
	struct kif_node	s;

	memset(&s, 0, sizeof(s));
	s.k.ifindex = ifindex;

	return (RB_FIND(kif_tree, &kit, &s));
}

struct kif *
kif_findname(char *ifname)
{
	struct kif_node	*kif;

	RB_FOREACH(kif, kif_tree, &kit)
		if (!strcmp(ifname, kif->k.ifname))
			return (&kif->k);

	return (NULL);
}

int
kif_insert(struct kif_node *kif)
{
	if (RB_INSERT(kif_tree, &kit, kif) != NULL) {
		log_warnx("RB_INSERT(kif_tree, &kit, kif)");
		free(kif);
		return (-1);
	}

	return (0);
}

int
kif_remove(struct kif_node *kif)
{
	if (RB_REMOVE(kif_tree, &kit, kif) == NULL) {
		log_warnx("RB_REMOVE(kif_tree, &kit, kif)");
		return (-1);
	}

	free(kif);
	return (0);
}

void
kif_clear(void)
{
	struct kif_node	*kif;

	while ((kif = RB_MIN(kif_tree, &kit)) != NULL)
		kif_remove(kif);
}

/* misc */
u_int8_t
prefixlen_classful(in_addr_t ina)
{
	/* it hurt to write this. */

	if (ina >= 0xf0000000U)		/* class E */
		return (32);
	else if (ina >= 0xe0000000U)	/* class D */
		return (4);
	else if (ina >= 0xc0000000U)	/* class C */
		return (24);
	else if (ina >= 0x80000000U)	/* class B */
		return (16);
	else				/* class A */
		return (8);
}

u_int8_t
mask2prefixlen(in_addr_t ina)
{
	if (ina == 0)
		return (0);
	else
		return (33 - ffs(ntohl(ina)));
}

in_addr_t
prefixlen2mask(u_int8_t prefixlen)
{
	if (prefixlen == 0)
		return (0);

	return (0xffffffff << (32 - prefixlen));
}

void
if_change(u_short ifindex, int flags, struct if_data *ifd)
{
	struct kif_node		*kif;
	u_int8_t		 reachable;

	if ((kif = kif_find(ifindex)) == NULL) {
		log_warnx("interface with index %u not found",
		    ifindex);
		return;
	}

	kif->k.flags = flags;
	kif->k.link_state = ifd->ifi_link_state;
	kif->k.if_type = ifd->ifi_type;
	kif->k.baudrate = ifd->ifi_baudrate;

	if ((reachable = (flags & IFF_UP) &&
	    LINK_STATE_IS_UP(ifd->ifi_link_state)) == kif->k.nh_reachable)
		return;		/* nothing changed wrt nexthop validity */

	kif->k.nh_reachable = reachable;
	main_imsg_compose_dvmrpe(IMSG_IFINFO, 0, &kif->k, sizeof(kif->k));
}

void
if_announce(void *msg)
{
	struct if_announcemsghdr	*ifan;
	struct kif_node			*kif;

	ifan = msg;

	switch (ifan->ifan_what) {
	case IFAN_ARRIVAL:
		if ((kif = calloc(1, sizeof(struct kif_node))) == NULL) {
			log_warn("if_announce");
			return;
		}

		kif->k.ifindex = ifan->ifan_index;
		strlcpy(kif->k.ifname, ifan->ifan_name, sizeof(kif->k.ifname));
		kif_insert(kif);
		break;
	case IFAN_DEPARTURE:
		kif = kif_find(ifan->ifan_index);
		kif_remove(kif);
		break;
	}
}

/* rtsock */
#define ROUNDUP(a) \
	((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))

void
get_rtaddrs(int addrs, struct sockaddr *sa, struct sockaddr **rti_info)
{
	int	i;

	for (i = 0; i < RTAX_MAX; i++) {
		if (addrs & (1 << i)) {
			rti_info[i] = sa;
			sa = (struct sockaddr *)((char *)(sa) +
			    ROUNDUP(sa->sa_len));
		} else
			rti_info[i] = NULL;
	}
}

int
fetchifs(int ifindex)
{
	size_t			 len;
	int			 mib[6];
	char			*buf, *next, *lim;
	struct if_msghdr	 ifm;
	struct kif_node		*kif;
	struct sockaddr		*sa, *rti_info[RTAX_MAX];
	struct sockaddr_dl	*sdl;

	mib[0] = CTL_NET;
	mib[1] = PF_ROUTE;
	mib[2] = 0;
	mib[3] = AF_INET;
	mib[4] = NET_RT_IFLIST;
	mib[5] = ifindex;

	if (sysctl(mib, 6, NULL, &len, NULL, 0) == -1) {
		log_warn("sysctl");
		return (-1);
	}
	if ((buf = malloc(len)) == NULL) {
		log_warn("fetchif");
		return (-1);
	}
	if (sysctl(mib, 6, buf, &len, NULL, 0) == -1) {
		log_warn("sysctl");
		free(buf);
		return (-1);
	}

	lim = buf + len;
	for (next = buf; next < lim; next += ifm.ifm_msglen) {
		memcpy(&ifm, next, sizeof(ifm));
		sa = (struct sockaddr *)(next + sizeof(ifm));
		get_rtaddrs(ifm.ifm_addrs, sa, rti_info);

		if (ifm.ifm_version != RTM_VERSION)
			continue;
		if (ifm.ifm_type != RTM_IFINFO)
			continue;

		if ((kif = calloc(1, sizeof(struct kif_node))) == NULL) {
			log_warn("fetchifs");
			free(buf);
			return (-1);
		}

		kif->k.ifindex = ifm.ifm_index;
		kif->k.flags = ifm.ifm_flags;
		kif->k.link_state = ifm.ifm_data.ifi_link_state;
		kif->k.if_type = ifm.ifm_data.ifi_type;
		kif->k.baudrate = ifm.ifm_data.ifi_baudrate;
		kif->k.mtu = ifm.ifm_data.ifi_mtu;
		kif->k.nh_reachable = (kif->k.flags & IFF_UP) &&
		    LINK_STATE_IS_UP(ifm.ifm_data.ifi_link_state);
		if ((sa = rti_info[RTAX_IFP]) != NULL)
			if (sa->sa_family == AF_LINK) {
				sdl = (struct sockaddr_dl *)sa;
				if (sdl->sdl_nlen >= sizeof(kif->k.ifname))
					memcpy(kif->k.ifname, sdl->sdl_data,
					    sizeof(kif->k.ifname) - 1);
				else if (sdl->sdl_nlen > 0)
					memcpy(kif->k.ifname, sdl->sdl_data,
					    sdl->sdl_nlen);
				/* string already terminated via calloc() */
			}

		kif_insert(kif);
	}
	free(buf);
	return (0);
}

void
kr_dispatch_msg(int fd, short event, void *bula)
{
	char			 buf[RT_BUF_SIZE];
	ssize_t			 n;
	char			*next, *lim;
	struct rt_msghdr	*rtm;
	struct if_msghdr	 ifm;

	if ((n = read(fd, &buf, sizeof(buf))) == -1) {
		if (errno == EAGAIN || errno == EINTR)
			return;
		fatal("dispatch_rtmsg: read error");
	}

	if (n == 0)
		fatalx("routing socket closed");

	lim = buf + n;
	for (next = buf; next < lim; next += rtm->rtm_msglen) {
		rtm = (struct rt_msghdr *)next;
		if (lim < next + sizeof(u_short) ||
		    lim < next + rtm->rtm_msglen)
			fatalx("dispatch_rtmsg: partial rtm in buffer");
		if (rtm->rtm_version != RTM_VERSION)
			continue;

		switch (rtm->rtm_type) {
		case RTM_IFINFO:
			memcpy(&ifm, next, sizeof(ifm));
			if_change(ifm.ifm_index, ifm.ifm_flags,
			    &ifm.ifm_data);
			break;
		case RTM_IFANNOUNCE:
			if_announce(next);
			break;
		default:
			/* ignore for now */
			break;
		}
	}
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: kroute.c,v 1.14 2017/07/24 11:00:01 friehm Exp $ */
2
3			/*
4			* Copyright (c) 2004 Esben Norby <norby@openbsd.org>
5			* Copyright (c) 2003, 2004 Henning Brauer <henning@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 <sys/socket.h>
22			#include <sys/sysctl.h>
23			#include <sys/tree.h>
24			#include <netinet/in.h>
25			#include <arpa/inet.h>
26			#include <net/if.h>
27			#include <net/if_dl.h>
28			#include <net/if_types.h>
29			#include <net/route.h>
30			#include <err.h>
31			#include <errno.h>
32			#include <fcntl.h>
33			#include <stdio.h>
34			#include <stdlib.h>
35			#include <string.h>
36			#include <unistd.h>
37
38			#include "dvmrp.h"
39			#include "dvmrpd.h"
40			#include "log.h"
41
42			struct {
43			u_int32_t rtseq;
44			pid_t pid;
45			struct event ev;
46			} kr_state;
47
48			struct kif_node {
49			RB_ENTRY(kif_node) entry;
50			struct kif k;
51			};
52
53			int kif_compare(struct kif_node , struct kif_node );
54
55			struct kif_node *kif_find(int);
56			int kif_insert(struct kif_node *);
57			int kif_remove(struct kif_node *);
58			void kif_clear(void);
59
60			in_addr_t prefixlen2mask(u_int8_t);
61			void get_rtaddrs(int, struct sockaddr , struct sockaddr *);
62			void if_change(u_short, int, struct if_data *);
63			void if_announce(void *);
64
65			int fetchifs(int);
66
67			RB_HEAD(kif_tree, kif_node) kit;
68			RB_PROTOTYPE(kif_tree, kif_node, entry, kif_compare)
69			RB_GENERATE(kif_tree, kif_node, entry, kif_compare)
70
71			int
72			kif_init(void)
73			{
74			RB_INIT(&kit);
75
76			if (fetchifs(0) == -1)
77			return (-1);
78
79			return (0);
80			}
81
82			int
83			kr_init(void)
84			{
85			int opt, fd;
86
87			if ((fd = socket(AF_ROUTE, SOCK_RAW \| SOCK_CLOEXEC \| SOCK_NONBLOCK,
88			0)) == -1) {
89			log_warn("kr_init: socket");
90			return (-1);
91			}
92
93			/* not interested in my own messages */
94			if (setsockopt(fd, SOL_SOCKET, SO_USELOOPBACK, &opt, sizeof(opt)) == -1)
95			log_warn("kr_init: setsockopt"); /* not fatal */
96
97			kr_state.pid = getpid();
98			kr_state.rtseq = 1;
99
100			event_set(&kr_state.ev, fd, EV_READ \| EV_PERSIST,
101			kr_dispatch_msg, NULL);
102			event_add(&kr_state.ev, NULL);
103
104			return (0);
105			}
106
107			void
108			kr_shutdown(void)
109			{
110			kif_clear();
111			close(EVENT_FD((&kr_state.ev)));
112			}
113
114			void
115			kr_ifinfo(char *ifname)
116			{
117			struct kif_node *kif;
118
119			RB_FOREACH(kif, kif_tree, &kit)
120			if (!strcmp(ifname, kif->k.ifname)) {
121			main_imsg_compose_dvmrpe(IMSG_CTL_IFINFO, 0,
122			&kif->k, sizeof(kif->k));
123			return;
124			}
125			}
126
127			/* rb-tree compare */
128			int
129			kif_compare(struct kif_node a, struct kif_node b)
130			{
131			return (b->k.ifindex - a->k.ifindex);
132			}
133
134			struct kif_node *
135			kif_find(int ifindex)
136			{
137			struct kif_node s;
138
139			memset(&s, 0, sizeof(s));
140			s.k.ifindex = ifindex;
141
142			return (RB_FIND(kif_tree, &kit, &s));
143			}
144
145			struct kif *
146			kif_findname(char *ifname)
147			{
148			struct kif_node *kif;
149
150			RB_FOREACH(kif, kif_tree, &kit)
151			if (!strcmp(ifname, kif->k.ifname))
152			return (&kif->k);
153
154			return (NULL);
155			}
156
157			int
158			kif_insert(struct kif_node *kif)
159			{
160			if (RB_INSERT(kif_tree, &kit, kif) != NULL) {
161			log_warnx("RB_INSERT(kif_tree, &kit, kif)");
162			free(kif);
163			return (-1);
164			}
165
166			return (0);
167			}
168
169			int
170			kif_remove(struct kif_node *kif)
171			{
172			if (RB_REMOVE(kif_tree, &kit, kif) == NULL) {
173			log_warnx("RB_REMOVE(kif_tree, &kit, kif)");
174			return (-1);
175			}
176
177			free(kif);
178			return (0);
179			}
180
181			void
182			kif_clear(void)
183			{
184			struct kif_node *kif;
185
186			while ((kif = RB_MIN(kif_tree, &kit)) != NULL)
187			kif_remove(kif);
188			}
189
190			/* misc */
191			u_int8_t
192			prefixlen_classful(in_addr_t ina)
193			{
194			/* it hurt to write this. */
195
196			if (ina >= 0xf0000000U) /* class E */
197			return (32);
198			else if (ina >= 0xe0000000U) /* class D */
199			return (4);
200			else if (ina >= 0xc0000000U) /* class C */
201			return (24);
202			else if (ina >= 0x80000000U) /* class B */
203			return (16);
204			else /* class A */
205			return (8);
206			}
207
208			u_int8_t
209			mask2prefixlen(in_addr_t ina)
210			{
211			if (ina == 0)
212			return (0);
213			else
214			return (33 - ffs(ntohl(ina)));
215			}
216
217			in_addr_t
218			prefixlen2mask(u_int8_t prefixlen)
219			{
220			if (prefixlen == 0)
221			return (0);
222
223			return (0xffffffff << (32 - prefixlen));
224			}
225
226			void
227			if_change(u_short ifindex, int flags, struct if_data *ifd)
228			{
229			struct kif_node *kif;
230			u_int8_t reachable;
231
232			if ((kif = kif_find(ifindex)) == NULL) {
233			log_warnx("interface with index %u not found",
234			ifindex);
235			return;
236			}
237
238			kif->k.flags = flags;
239			kif->k.link_state = ifd->ifi_link_state;
240			kif->k.if_type = ifd->ifi_type;
241			kif->k.baudrate = ifd->ifi_baudrate;
242
243			if ((reachable = (flags & IFF_UP) &&
244			LINK_STATE_IS_UP(ifd->ifi_link_state)) == kif->k.nh_reachable)
245			return; /* nothing changed wrt nexthop validity */
246
247			kif->k.nh_reachable = reachable;
248			main_imsg_compose_dvmrpe(IMSG_IFINFO, 0, &kif->k, sizeof(kif->k));
249			}
250
251			void
252			if_announce(void *msg)
253			{
254			struct if_announcemsghdr *ifan;
255			struct kif_node *kif;
256
257			ifan = msg;
258
259			switch (ifan->ifan_what) {
260			case IFAN_ARRIVAL:
261			if ((kif = calloc(1, sizeof(struct kif_node))) == NULL) {
262			log_warn("if_announce");
263			return;
264			}
265
266			kif->k.ifindex = ifan->ifan_index;
267			strlcpy(kif->k.ifname, ifan->ifan_name, sizeof(kif->k.ifname));
268			kif_insert(kif);
269			break;
270			case IFAN_DEPARTURE:
271			kif = kif_find(ifan->ifan_index);
272			kif_remove(kif);
273			break;
274			}
275			}
276
277			/* rtsock */
278			#define ROUNDUP(a) \
279			((a) > 0 ? (1 + (((a) - 1) \| (sizeof(long) - 1))) : sizeof(long))
280
281			void
282			get_rtaddrs(int addrs, struct sockaddr sa, struct sockaddr *rti_info)
283			{
284			int i;
285
286			for (i = 0; i < RTAX_MAX; i++) {
287			if (addrs & (1 << i)) {
288			rti_info[i] = sa;
289			sa = (struct sockaddr )((char )(sa) +
290			ROUNDUP(sa->sa_len));
291			} else
292			rti_info[i] = NULL;
293			}
294			}
295
296			int
297			fetchifs(int ifindex)
298			{
299			size_t len;
300			int mib[6];
301			char buf, next, *lim;
302			struct if_msghdr ifm;
303			struct kif_node *kif;
304			struct sockaddr sa, rti_info[RTAX_MAX];
305			struct sockaddr_dl *sdl;
306
307			mib[0] = CTL_NET;
308			mib[1] = PF_ROUTE;
309			mib[2] = 0;
310			mib[3] = AF_INET;
311			mib[4] = NET_RT_IFLIST;
312			mib[5] = ifindex;
313
314			if (sysctl(mib, 6, NULL, &len, NULL, 0) == -1) {
315			log_warn("sysctl");
316			return (-1);
317			}
318			if ((buf = malloc(len)) == NULL) {
319			log_warn("fetchif");
320			return (-1);
321			}
322			if (sysctl(mib, 6, buf, &len, NULL, 0) == -1) {
323			log_warn("sysctl");
324			free(buf);
325			return (-1);
326			}
327
328			lim = buf + len;
329			for (next = buf; next < lim; next += ifm.ifm_msglen) {
330			memcpy(&ifm, next, sizeof(ifm));
331			sa = (struct sockaddr *)(next + sizeof(ifm));
332			get_rtaddrs(ifm.ifm_addrs, sa, rti_info);
333
334			if (ifm.ifm_version != RTM_VERSION)
335			continue;
336			if (ifm.ifm_type != RTM_IFINFO)
337			continue;
338
339			if ((kif = calloc(1, sizeof(struct kif_node))) == NULL) {
340			log_warn("fetchifs");
341			free(buf);
342			return (-1);
343			}
344
345			kif->k.ifindex = ifm.ifm_index;
346			kif->k.flags = ifm.ifm_flags;
347			kif->k.link_state = ifm.ifm_data.ifi_link_state;
348			kif->k.if_type = ifm.ifm_data.ifi_type;
349			kif->k.baudrate = ifm.ifm_data.ifi_baudrate;
350			kif->k.mtu = ifm.ifm_data.ifi_mtu;
351			kif->k.nh_reachable = (kif->k.flags & IFF_UP) &&
352			LINK_STATE_IS_UP(ifm.ifm_data.ifi_link_state);
353			if ((sa = rti_info[RTAX_IFP]) != NULL)
354			if (sa->sa_family == AF_LINK) {
355			sdl = (struct sockaddr_dl *)sa;
356			if (sdl->sdl_nlen >= sizeof(kif->k.ifname))
357			memcpy(kif->k.ifname, sdl->sdl_data,
358			sizeof(kif->k.ifname) - 1);
359			else if (sdl->sdl_nlen > 0)
360			memcpy(kif->k.ifname, sdl->sdl_data,
361			sdl->sdl_nlen);
362			/* string already terminated via calloc() */
363			}
364
365			kif_insert(kif);
366			}
367			free(buf);
368			return (0);
369			}
370
371			void
372			kr_dispatch_msg(int fd, short event, void *bula)
373			{
374			char buf[RT_BUF_SIZE];
375			ssize_t n;
376			char next, lim;
377			struct rt_msghdr *rtm;
378			struct if_msghdr ifm;
379
380			if ((n = read(fd, &buf, sizeof(buf))) == -1) {
381			if (errno == EAGAIN \|\| errno == EINTR)
382			return;
383			fatal("dispatch_rtmsg: read error");
384			}
385
386			if (n == 0)
387			fatalx("routing socket closed");
388
389			lim = buf + n;
390			for (next = buf; next < lim; next += rtm->rtm_msglen) {
391			rtm = (struct rt_msghdr *)next;
392			if (lim < next + sizeof(u_short) \|\|
393			lim < next + rtm->rtm_msglen)
394			fatalx("dispatch_rtmsg: partial rtm in buffer");
395			if (rtm->rtm_version != RTM_VERSION)
396			continue;
397
398			switch (rtm->rtm_type) {
399			case RTM_IFINFO:
400			memcpy(&ifm, next, sizeof(ifm));
401			if_change(ifm.ifm_index, ifm.ifm_flags,
402			&ifm.ifm_data);
403			break;
404			case RTM_IFANNOUNCE:
405			if_announce(next);
406			break;
407			default:
408			/* ignore for now */
409			break;
410			}
411			}
412			}