/usr/src/usr.sbin/route6d/route6d.c

Bug Summary

File:	src/usr.sbin/route6d/route6d.c
Warning:	line 2944, column 27 Assigned value is garbage or undefined
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name route6d.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/usr.sbin/route6d/obj -resource-dir /usr/local/lib/clang/13.0.0 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/usr.sbin/route6d/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/usr.sbin/route6d/route6d.c
1/*	$OpenBSD: route6d.c,v 1.100 2020/12/29 19:48:27 benno Exp $	*/
2/*	$KAME: route6d.c,v 1.111 2006/10/25 06:38:13 jinmei Exp $	*/

4/*
* Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
* All rights reserved.
* 
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the project nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
* 
* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

33#include <sys/types.h>
34#include <sys/ioctl.h>
35#include <sys/socket.h>
36#include <sys/sysctl.h>
37#include <sys/uio.h>

39#include <net/if.h>
40#include <net/route.h>
41#include <netinet/in.h>
42#include <netinet/ip6.h>
43#include <netinet/udp.h>
44#include <netinet6/in6_var.h>

46#include <arpa/inet.h>
47#include <errno(*__errno()).h>
48#include <ifaddrs.h>
49#include <netdb.h>
50#include <poll.h>
51#include <signal.h>
52#include <stdarg.h>
53#include <stddef.h>
54#include <stdint.h>
55#include <stdio.h>
56#include <stdlib.h>
57#include <string.h>
58#include <time.h>
59#include <unistd.h>

61#include "route6d.h"
62#include "log.h"

64#define	MAXFILTER40	40

66#ifdef	DEBUG
67#define	INIT_INTERVAL610	6
68#else
69#define	INIT_INTERVAL610	10	/* Wait to submit a initial riprequest */
70#endif

72/* alignment constraint for routing socket */
73#define ROUNDUP(a)((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof
(long)) \
((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
75#define ADVANCE(x, n)(x += (((n)->sa_len) > 0 ? (1 + ((((n)->sa_len) - 1)
 | (sizeof(long) - 1))) : sizeof(long))) (x += ROUNDUP((n)->sa_len)(((n)->sa_len) > 0 ? (1 + ((((n)->sa_len) - 1) | (sizeof
(long) - 1))) : sizeof(long)))

77/*
* Following two macros are highly depending on KAME Release
*/
80#define	IN6_LINKLOCAL_IFINDEX(addr)((addr).__u6_addr.__u6_addr8[2] << 8 | (addr).__u6_addr
.__u6_addr8[3]) \
((addr).s6_addr__u6_addr.__u6_addr8[2] << 8 | (addr).s6_addr__u6_addr.__u6_addr8[3])

83#define	SET_IN6_LINKLOCAL_IFINDEX(addr, index)do { (addr).__u6_addr.__u6_addr8[2] = ((index) >> 8) &
 0xff; (addr).__u6_addr.__u6_addr8[3] = (index) & 0xff; }
 while (0) \
do { \
(addr).s6_addr__u6_addr.__u6_addr8[2] = ((index) >> 8) & 0xff; \
(addr).s6_addr__u6_addr.__u6_addr8[3] = (index) & 0xff; \
} while (0)

89struct	ifc {			/* Configuration of an interface */
char	*ifc_name;			/* if name */
struct	ifc *ifc_next;
int	ifc_index;			/* if index */
int	ifc_mtu;			/* if mtu */
int	ifc_metric;			/* if metric */
u_int	ifc_flags;			/* flags */
short	ifc_cflags;			/* IFC_XXX */
struct	in6_addr ifc_mylladdr;		/* my link-local address */
struct	sockaddr_in6 ifc_ripsin;	/* rip multicast address */
struct	iff *ifc_filter;		/* filter structure */
struct	ifac *ifc_addr;			/* list of AF_INET6 addresses */
int	ifc_joined;			/* joined to ff02::9 */
102};

104struct	ifac {			/* Address associated to an interface */ 
struct	ifc *ifa_conf;		/* back pointer */
struct	ifac *ifa_next;
struct	in6_addr ifa_addr;	/* address */
struct	in6_addr ifa_raddr;	/* remote address, valid in p2p */
int	ifa_plen;		/* prefix length */
110};

112struct	iff {
int	iff_type;
struct	in6_addr iff_addr;
int	iff_plen;
struct	iff *iff_next;
117};

119struct	ifc *ifc;
120int	nifc;		/* number of valid ifc's */
121struct	ifc **index2ifc;
122int	nindex2ifc;
123struct	ifc *loopifcp = NULL((void*)0);	/* pointing to loopback */
124struct	pollfd pfd[2];
125int	rtsock;		/* the routing socket */
126int	ripsock;	/* socket to send/receive RIP datagram */

128struct	rip6 *ripbuf;	/* packet buffer for sending */

130/*
* Maintain the routes in a linked list.  When the number of the routes
* grows, somebody would like to introduce a hash based or a radix tree
* based structure.  I believe the number of routes handled by RIP is
* limited and I don't have to manage a complex data structure, however.
*
* One of the major drawbacks of the linear linked list is the difficulty
* of representing the relationship between a couple of routes.  This may
* be a significant problem when we have to support route aggregation with
* suppressing the specifics covered by the aggregate.
*/

142struct	riprt {
struct	riprt *rrt_next;	/* next destination */
struct	netinfo6 rrt_info;	/* network info */
struct	in6_addr rrt_gw;	/* gateway */
u_long	rrt_flags;		/* kernel routing table flags */
u_long	rrt_rflags;		/* route6d routing table flags */
time_t	rrt_t;			/* when the route validated */
int	rrt_index;		/* ifindex from which this route got */
150};

152struct	riprt *riprt = 0;

154int	dflag = 0;	/* debug flag */
155int	qflag = 0;	/* quiet flag */
156int	nflag = 0;	/* don't update kernel routing table */
157int	aflag = 0;	/* age out even the statically defined routes */
158int	hflag = 0;	/* don't split horizon */
159int	lflag = 0;	/* exchange site local routes */
160int	sflag = 0;	/* announce static routes w/ split horizon */
161int	Sflag = 0;	/* announce static routes to every interface */
162int	uflag = 0;	/* always log route updates (additions/deletions) */
163unsigned long routetag = 0;	/* route tag attached on originating case */

165char	*filter[MAXFILTER40];
166int	filtertype[MAXFILTER40];
167int	nfilter = 0;

169pid_t	pid;

171struct	sockaddr_storage ripsin;

173time_t	nextalarm = 0;
174time_t	sup_trig_update = 0;

176static	int	seq = 0;

178volatile sig_atomic_t seenalrm;
179volatile sig_atomic_t seenquit;
180volatile sig_atomic_t seenusr1;

182#define	RRTF_AGGREGATE0x08000000		0x08000000
183#define	RRTF_NOADVERTISE0x10000000	0x10000000
184#define	RRTF_NH_NOT_LLADDR0x20000000	0x20000000
185#define RRTF_SENDANYWAY0x40000000		0x40000000
186#define	RRTF_CHANGED0x80000000		0x80000000

188void sighandler(int);
189void ripalarm(void);
190void riprecv(void);
191void ripsend(struct ifc *, struct sockaddr_in6 *, int);
192int out_filter(struct riprt *, struct ifc *);
193void init(void);
194void sockopt(struct ifc *);
195void ifconfig(void);
196void ifconfig1(const char *, const struct sockaddr *, struct ifc *, int);
197void rtrecv(void);
198int rt_del(const struct sockaddr_in6 *, const struct sockaddr_in6 *,
  const struct sockaddr_in6 *);
200int rt_deladdr(struct ifc *, const struct sockaddr_in6 *,
  const struct sockaddr_in6 *);
202void filterconfig(void);
203int getifmtu(int);
204const char *rttypes(struct rt_msghdr *);
205const char *rtflags(struct rt_msghdr *);
206const char *ifflags(int);
207int ifrt(struct ifc *, int);
208void ifrt_p2p(struct ifc *, int);
209void applyplen(struct in6_addr *, int);
210void ifrtdump(int);
211void ifdump(int);
212void ifdump0(const struct ifc *);
213void rtdump(int);
214void rt_entry(struct rt_msghdr *, int);
215__dead__attribute__((__noreturn__)) void rtdexit(void);
216void riprequest(struct ifc *, struct netinfo6 *, int, struct sockaddr_in6 *);
217void ripflush(struct ifc *, struct sockaddr_in6 *);
218void sendrequest(struct ifc *);
219int sin6mask2len(const struct sockaddr_in6 *);
220int mask2len(const struct in6_addr *, int);
221int sendpacket(struct sockaddr_in6 *, int);
222int addroute(struct riprt *, const struct in6_addr *, struct ifc *);
223int delroute(struct netinfo6 *, struct in6_addr *);
224struct in6_addr *getroute(struct netinfo6 *, struct in6_addr *);
225void krtread(int);
226int tobeadv(struct riprt *, struct ifc *);
227char *xstrdup(const char *);
228const char *hms(void);
229const char *inet6_n2p(const struct in6_addr *);
230struct ifac *ifa_match(const struct ifc *, const struct in6_addr *, int);
231struct in6_addr *plen2mask(int);
232struct riprt *rtsearch(struct netinfo6 *, struct riprt **);
233int ripinterval(int);
234time_t ripsuptrig(void);
235unsigned int if_maxindex(void);
236struct ifc *ifc_find(char *);
237struct iff *iff_find(struct ifc *, int);
238void setindex2ifc(int, struct ifc *);

240int
241main(int argc, char *argv[])
242{
int	ch;
int	error = 0;
struct	ifc *ifcp;
sigset_t mask, omask;
char *ep;

log_init(1); /* log to stderr until daemonized */

while ((ch = getopt(argc, argv, "A:N:O:T:L:t:adDhlnqsSu")) != -1) {
1
Assuming the condition is false→
2
←
Loop condition is false. Execution continues on line 290→
switch (ch) {
case 'A':
case 'N':
case 'O':
case 'T':
case 'L':
	if (nfilter >= MAXFILTER40) {
		fatalx("Exceeds MAXFILTER");
		/*NOTREACHED*/
	}
	filtertype[nfilter] = ch;
	filter[nfilter++] = xstrdup(optarg);
	break;
case 't':
	ep = NULL((void*)0);
	routetag = strtoul(optarg, &ep, 0);
	if (!ep || *ep != '\0' || (routetag & ~0xffff) != 0) {
		fatalx("invalid route tag");
		/*NOTREACHED*/
	}
	break;
273#define	FLAG(c, flag, n)	case c: do { flag = n; break; } while(0)
FLAG('a', aflag, 1); break;
FLAG('d', dflag, 1); break;
FLAG('D', dflag, 2); break;
FLAG('h', hflag, 1); break;
FLAG('l', lflag, 1); break;
FLAG('n', nflag, 1); break;
FLAG('q', qflag, 1); break;
FLAG('s', sflag, 1); break;
FLAG('S', Sflag, 1); break;
FLAG('u', uflag, 1); break;
284#undef	FLAG
default:
	fatalx("Invalid option specified, terminating");
	/*NOTREACHED*/
}
}
argc -= optind;
argv += optind;
if (argc > 0) {
3
←
Assuming 'argc' is <= 0→
4
←
Taking false branch→
fatalx("bogus extra arguments");
/*NOTREACHED*/
}

if (geteuid()) {
5
←
Assuming the condition is false→
6
←
Taking false branch→
nflag = 1;
log_warn("No kernel update is allowed");
}

if (dflag6.1
'dflag' is equal to 0
 == 0) {
7
←
Taking true branch→
if (daemon(0, 0) == -1) {
8
←
Assuming the condition is false→
9
←
Taking false branch→
	fatal("daemon");
	/*NOTREACHED*/
}
}

log_init(dflag);

pid = getpid();

if ((ripbuf = calloc(RIP6_MAXMTU1500, 1)) == NULL((void*)0))
10
←
Assuming the condition is false→
11
←
Taking false branch→
fatal(NULL((void*)0));
ripbuf->rip6_cmd = RIP6_RESPONSE2;
ripbuf->rip6_vers = RIP6_VERSION1;
ripbuf->rip6_res1[0] = 0;
ripbuf->rip6_res1[1] = 0;

init();

if (pledge("stdio inet route mcast", NULL((void*)0)) == -1)
12
←
Assuming the condition is false→
13
←
Taking false branch→
fatal("pledge");

ifconfig();

for (ifcp = ifc; ifcp; ifcp = ifcp->ifc_next) {
14
←
Loop condition is false. Execution continues on line 335→
if (ifcp->ifc_index < 0) {
	log_warn(
330"No ifindex found at %s (no link-local address?)",
		ifcp->ifc_name);
	error++;
}
}
if (error14.1
'error' is 0
)
15
←
Taking false branch→
exit(1);
if (loopifcp == NULL((void*)0)) {
16
←
Assuming 'loopifcp' is not equal to NULL→
17
←
Taking false branch→
fatalx("No loopback found");
/*NOTREACHED*/
}
for (ifcp = ifc; ifcp; ifcp = ifcp->ifc_next)
18
←
Loop condition is false. Execution continues on line 343→
ifrt(ifcp, 0);
filterconfig();
19
←
Calling 'filterconfig'→
krtread(0);
if (dflag)
ifrtdump(0);

if (signal(SIGALRM14, sighandler) == SIG_ERR(void (*)(int))-1 ||
   signal(SIGQUIT3, sighandler) == SIG_ERR(void (*)(int))-1 ||
   signal(SIGTERM15, sighandler) == SIG_ERR(void (*)(int))-1 ||
   signal(SIGUSR130, sighandler) == SIG_ERR(void (*)(int))-1 ||
   signal(SIGHUP1, sighandler) == SIG_ERR(void (*)(int))-1 ||
   signal(SIGINT2, sighandler) == SIG_ERR(void (*)(int))-1) {
fatal("signal");
/*NOTREACHED*/
}
/*
* To avoid rip packet congestion (not on a cable but in this
* process), wait for a moment to send the first RIP6_RESPONSE
* packets.
*/
alarm(ripinterval(INIT_INTERVAL610));

for (ifcp = ifc; ifcp; ifcp = ifcp->ifc_next) {
if (iff_find(ifcp, 'N'))
	continue;
if (ifcp->ifc_index > 0 && (ifcp->ifc_flags & IFF_UP0x1))
	sendrequest(ifcp);
}

log_info("**** Started ****");
sigemptyset(&mask);
sigaddset(&mask, SIGALRM14);
while (1) {
if (seenalrm) {
	ripalarm();
	seenalrm = 0;
	continue;
}
if (seenquit) {
	rtdexit();
	seenquit = 0;
	continue;
}
if (seenusr1) {
	ifrtdump(SIGUSR130);
	seenusr1 = 0;
	continue;
}

switch (poll(pfd, 2, INFTIM(-1)))
{
case -1:
	if (errno(*__errno()) != EINTR4) {
		fatal("poll");
		/*NOTREACHED*/
	}
	continue;
case 0:
	continue;
default:
	if (pfd[0].revents & POLLIN0x0001) {
		sigprocmask(SIG_BLOCK1, &mask, &omask);
		riprecv();
		sigprocmask(SIG_SETMASK3, &omask, NULL((void*)0));
	}
	if (pfd[1].revents & POLLIN0x0001) {
		sigprocmask(SIG_BLOCK1, &mask, &omask);
		rtrecv();
		sigprocmask(SIG_SETMASK3, &omask, NULL((void*)0));
	}
}
}
414}

416void
417sighandler(int signo)
418{

switch (signo) {
case SIGALRM14:
seenalrm++;
break;
case SIGQUIT3:
case SIGTERM15:
seenquit++;
break;
case SIGUSR130:
case SIGHUP1:
case SIGINT2:
seenusr1++;
break;
}
434}

436/*
* gracefully exits after resetting sockopts.
*/
439void
440rtdexit(void)
441{
struct	riprt *rrt;

alarm(0);
for (rrt = riprt; rrt; rrt = rrt->rrt_next) {
if (rrt->rrt_rflags & RRTF_AGGREGATE0x08000000) {
	delroute(&rrt->rrt_info, &rrt->rrt_gw);
}
}
close(ripsock);
close(rtsock);
log_info("**** Terminated ****");
exit(1);
454}

456/*
* Called periodically:
*	1. age out the learned route. remove it if necessary.
*	2. submit RIP6_RESPONSE packets.
* Invoked in every SUPPLY_INTERVAL6 (30) seconds.  I believe we don't have
* to invoke this function in every 1 or 5 or 10 seconds only to age the
* routes more precisely.
*/
464void
465ripalarm(void)
466{
struct	ifc *ifcp;
struct	riprt *rrt, *rrt_prev, *rrt_next;
time_t	t_lifetime, t_holddown;

/* age the RIP routes */
rrt_prev = 0;
t_lifetime = time(NULL((void*)0)) - RIP_LIFETIME180;
t_holddown = t_lifetime - RIP_HOLDDOWN120;
for (rrt = riprt; rrt; rrt = rrt_next) {
rrt_next = rrt->rrt_next;

if (rrt->rrt_t == 0) {
	rrt_prev = rrt;
	continue;
}
if (rrt->rrt_t < t_holddown) {
	if (rrt_prev) {
		rrt_prev->rrt_next = rrt->rrt_next;
	} else {
		riprt = rrt->rrt_next;
	}
	delroute(&rrt->rrt_info, &rrt->rrt_gw);
	free(rrt);
	continue;
}
if (rrt->rrt_t < t_lifetime)
	rrt->rrt_info.rip6_metric = HOPCNT_INFINITY616;
rrt_prev = rrt;
}
/* Supply updates */
for (ifcp = ifc; ifcp; ifcp = ifcp->ifc_next) {
if (ifcp->ifc_index > 0 && (ifcp->ifc_flags & IFF_UP0x1))
	ripsend(ifcp, &ifcp->ifc_ripsin, 0);
}
alarm(ripinterval(SUPPLY_INTERVAL630));
502}

504void
505init(void)
506{
int	i, error;
const int int0 = 0, int1 = 1, int255 = 255;
struct	addrinfo hints, *res;
char	port[NI_MAXSERV32];

ifc = (struct ifc *)NULL((void*)0);
nifc = 0;
nindex2ifc = 0;	/*initial guess*/
index2ifc = NULL((void*)0);
snprintf(port, sizeof(port), "%u", RIP6_PORT521);

memset(&hints, 0, sizeof(hints));
hints.ai_family = PF_INET624;
hints.ai_socktype = SOCK_DGRAM2;
hints.ai_flags = AI_PASSIVE1;
error = getaddrinfo(NULL((void*)0), port, &hints, &res);
if (error) {
fatalx(gai_strerror(error));
/*NOTREACHED*/
}
if (res->ai_next) {
fatalx(":: resolved to multiple address");
/*NOTREACHED*/
}

ripsock = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
if (ripsock == -1) {
fatal("rip socket");
/*NOTREACHED*/
}
if (setsockopt(ripsock, IPPROTO_IPV641, IPV6_V6ONLY27,
   &int1, sizeof(int1)) == -1) {
fatal("rip IPV6_V6ONLY");
/*NOTREACHED*/
}
if (bind(ripsock, res->ai_addr, res->ai_addrlen) == -1) {
fatal("rip bind");
/*NOTREACHED*/
}
if (setsockopt(ripsock, IPPROTO_IPV641, IPV6_MULTICAST_HOPS10,
   &int255, sizeof(int255)) == -1) {
fatal("rip IPV6_MULTICAST_HOPS");
/*NOTREACHED*/
}
if (setsockopt(ripsock, IPPROTO_IPV641, IPV6_MULTICAST_LOOP11,
   &int0, sizeof(int0)) == -1) {
fatal("rip IPV6_MULTICAST_LOOP");
/*NOTREACHED*/
}

i = 1;
if (setsockopt(ripsock, IPPROTO_IPV641, IPV6_RECVPKTINFO36, &i,
   sizeof(i)) == -1) {
fatal("rip IPV6_RECVPKTINFO");
/*NOTREACHED*/
}

if (setsockopt(ripsock, IPPROTO_IPV641, IPV6_RECVHOPLIMIT37,
   &int1, sizeof(int1)) == -1) {
fatal("rip IPV6_RECVHOPLIMIT");
/*NOTREACHED*/
}

freeaddrinfo(res);
memset(&hints, 0, sizeof(hints));
hints.ai_family = PF_INET624;
hints.ai_socktype = SOCK_DGRAM2;
error = getaddrinfo(RIP6_DEST"ff02::9", port, &hints, &res);
if (error) {
fatalx(gai_strerror(error));
/*NOTREACHED*/
}
if (res->ai_next) {
fatalx(RIP6_DEST"ff02::9" " resolved to multiple address");
/*NOTREACHED*/
}
memcpy(&ripsin, res->ai_addr, res->ai_addrlen);
freeaddrinfo(res);

pfd[0].fd = ripsock;
pfd[0].events = POLLIN0x0001;

if (nflag == 0) {
if ((rtsock = socket(AF_ROUTE17, SOCK_RAW3, 0)) == -1) {
	fatal("route socket");
	/*NOTREACHED*/
}
pfd[1].fd = rtsock;
pfd[1].events = POLLIN0x0001;
} else
pfd[1].fd = -1;

599}

601#define	RIPSIZE(n)(sizeof(struct rip6) + ((n)-1) * sizeof(struct netinfo6)) \
(sizeof(struct rip6) + ((n)-1) * sizeof(struct netinfo6))

604/*
* ripflush flushes the rip datagram stored in the rip buffer
*/
607static int nrt;
608static struct netinfo6 *np;

610void
611ripflush(struct ifc *ifcp, struct sockaddr_in6 *sin6)
612{
int i;
int error;

if (ifcp)
log_debug("Send(%s): info(%d) to %s.%d",
	ifcp->ifc_name, nrt,
	inet6_n2p(&sin6->sin6_addr), ntohs(sin6->sin6_port)(__uint16_t)(__builtin_constant_p(sin6->sin6_port) ? (__uint16_t
)(((__uint16_t)(sin6->sin6_port) & 0xffU) << 8 |
 ((__uint16_t)(sin6->sin6_port) & 0xff00U) >> 8)
 : __swap16md(sin6->sin6_port)));
else
log_debug("Send: info(%d) to %s.%d",
	nrt, inet6_n2p(&sin6->sin6_addr), ntohs(sin6->sin6_port)(__uint16_t)(__builtin_constant_p(sin6->sin6_port) ? (__uint16_t
)(((__uint16_t)(sin6->sin6_port) & 0xffU) << 8 |
 ((__uint16_t)(sin6->sin6_port) & 0xff00U) >> 8)
 : __swap16md(sin6->sin6_port)));
if (dflag >= 2) {
np = ripbuf->rip6_netsrip6un.ru6_nets;
for (i = 0; i < nrt; i++, np++) {
	if (np->rip6_metric == NEXTHOP_METRIC0xff) {
		if (IN6_IS_ADDR_UNSPECIFIED(&np->rip6_dest)((*(const u_int32_t *)(const void *)(&(&np->rip6_dest
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&np->rip6_dest)->__u6_addr.
__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void
 *)(&(&np->rip6_dest)->__u6_addr.__u6_addr8[8])
 == 0) && (*(const u_int32_t *)(const void *)(&(&
np->rip6_dest)->__u6_addr.__u6_addr8[12]) == 0)))
			log_enqueue("    NextHop reset");
		else {
			log_enqueue("    NextHop %s",
				inet6_n2p(&np->rip6_dest));
		}
	} else {
		log_enqueue("    %s/%d[%d]",
			inet6_n2p(&np->rip6_dest),
			np->rip6_plen, np->rip6_metric);
	}
	if (np->rip6_tag) {
		log_enqueue("  tag=0x%04x",
			ntohs(np->rip6_tag)(__uint16_t)(__builtin_constant_p(np->rip6_tag) ? (__uint16_t
)(((__uint16_t)(np->rip6_tag) & 0xffU) << 8 | ((
__uint16_t)(np->rip6_tag) & 0xff00U) >> 8) : __swap16md
(np->rip6_tag)) & 0xffff);
	}
	log_debug("");
}
}
error = sendpacket(sin6, RIPSIZE(nrt)(sizeof(struct rip6) + ((nrt)-1) * sizeof(struct netinfo6)));
if (error == EAFNOSUPPORT47) {
/* Protocol not supported */
log_debug("Could not send info to %s (%s): "
	"set IFF_UP to 0",
	ifcp->ifc_name, inet6_n2p(&ifcp->ifc_ripsin.sin6_addr));
ifcp->ifc_flags &= ~IFF_UP0x1;	/* As if down for AF_INET6 */
}
nrt = 0; np = ripbuf->rip6_netsrip6un.ru6_nets;
654}

656/*
* Generate RIP6_RESPONSE packets and send them.
*/
659void
660ripsend(struct ifc *ifcp, struct sockaddr_in6 *sin6, int flag)
661{
struct	riprt *rrt;
struct	in6_addr *nh;	/* next hop */
int	maxrte;

if (qflag)
return;

if (ifcp == NULL((void*)0)) {
/*
 * Request from non-link local address is not
 * a regular route6d update.
 */
maxrte = (IFMINMTU576 - sizeof(struct ip6_hdr) - 
		sizeof(struct udphdr) - 
		sizeof(struct rip6) + sizeof(struct netinfo6)) /
		sizeof(struct netinfo6);
nrt = 0; np = ripbuf->rip6_netsrip6un.ru6_nets; nh = NULL((void*)0);
for (rrt = riprt; rrt; rrt = rrt->rrt_next) {
	if (rrt->rrt_rflags & RRTF_NOADVERTISE0x10000000)
		continue;
	/* Put the route to the buffer */
	*np = rrt->rrt_info;
	np++; nrt++;
	if (nrt == maxrte) {
		ripflush(NULL((void*)0), sin6);
		nh = NULL((void*)0);
	}
}
if (nrt)	/* Send last packet */
	ripflush(NULL((void*)0), sin6);
return;
}

if ((flag & RRTF_SENDANYWAY0x40000000) == 0 &&
   (qflag || (ifcp->ifc_flags & IFF_LOOPBACK0x8)))
return;

/* -N: no use */
if (iff_find(ifcp, 'N') != NULL((void*)0))
return;

/* -T: generate default route only */
if (iff_find(ifcp, 'T') != NULL((void*)0)) {
struct netinfo6 rrt_info;
memset(&rrt_info, 0, sizeof(struct netinfo6));
rrt_info.rip6_dest = in6addr_any;
rrt_info.rip6_plen = 0;
rrt_info.rip6_metric = 1;
rrt_info.rip6_metric += ifcp->ifc_metric;
rrt_info.rip6_tag = htons(routetag & 0xffff)(__uint16_t)(__builtin_constant_p(routetag & 0xffff) ? (__uint16_t
)(((__uint16_t)(routetag & 0xffff) & 0xffU) << 8
 | ((__uint16_t)(routetag & 0xffff) & 0xff00U) >>
 8) : __swap16md(routetag & 0xffff));
np = ripbuf->rip6_netsrip6un.ru6_nets;
*np = rrt_info;
nrt = 1;
ripflush(ifcp, sin6);
return;
}

maxrte = (ifcp->ifc_mtu - sizeof(struct ip6_hdr) - 
	sizeof(struct udphdr) - 
	sizeof(struct rip6) + sizeof(struct netinfo6)) /
	sizeof(struct netinfo6);

nrt = 0; np = ripbuf->rip6_netsrip6un.ru6_nets; nh = NULL((void*)0);
for (rrt = riprt; rrt; rrt = rrt->rrt_next) {
if (rrt->rrt_rflags & RRTF_NOADVERTISE0x10000000)
	continue;

/* Need to check filter here */
if (out_filter(rrt, ifcp) == 0)
	continue;

/* Check split horizon and other conditions */
if (tobeadv(rrt, ifcp) == 0)
	continue;

/* Only considers the routes with flag if specified */
if ((flag & RRTF_CHANGED0x80000000) &&
    (rrt->rrt_rflags & RRTF_CHANGED0x80000000) == 0)
	continue;

/* Check nexthop */
if (rrt->rrt_index == ifcp->ifc_index &&
    !IN6_IS_ADDR_UNSPECIFIED(&rrt->rrt_gw)((*(const u_int32_t *)(const void *)(&(&rrt->rrt_gw
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&rrt->rrt_gw)->__u6_addr.__u6_addr8
[4]) == 0) && (*(const u_int32_t *)(const void *)(&
(&rrt->rrt_gw)->__u6_addr.__u6_addr8[8]) == 0) &&
 (*(const u_int32_t *)(const void *)(&(&rrt->rrt_gw
)->__u6_addr.__u6_addr8[12]) == 0)) &&
    (rrt->rrt_rflags & RRTF_NH_NOT_LLADDR0x20000000) == 0) {
	if (nh == NULL((void*)0) || !IN6_ARE_ADDR_EQUAL(nh, &rrt->rrt_gw)(memcmp(&(nh)->__u6_addr.__u6_addr8[0], &(&rrt
->rrt_gw)->__u6_addr.__u6_addr8[0], sizeof(struct in6_addr
)) == 0)) {
		if (nrt == maxrte - 2)
			ripflush(ifcp, sin6);
		np->rip6_dest = rrt->rrt_gw;
		if (IN6_IS_ADDR_LINKLOCAL(&np->rip6_dest)(((&np->rip6_dest)->__u6_addr.__u6_addr8[0] == 0xfe
) && (((&np->rip6_dest)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0x80)))
			SET_IN6_LINKLOCAL_IFINDEX(np->rip6_dest, 0)do { (np->rip6_dest).__u6_addr.__u6_addr8[2] = ((0) >>
 8) & 0xff; (np->rip6_dest).__u6_addr.__u6_addr8[3] = (
0) & 0xff; } while (0);
		np->rip6_plen = 0;
		np->rip6_tag = 0;
		np->rip6_metric = NEXTHOP_METRIC0xff;
		nh = &rrt->rrt_gw;
		np++; nrt++;
	}
} else if (nh && (rrt->rrt_index != ifcp->ifc_index ||
	          !IN6_ARE_ADDR_EQUAL(nh, &rrt->rrt_gw)(memcmp(&(nh)->__u6_addr.__u6_addr8[0], &(&rrt
->rrt_gw)->__u6_addr.__u6_addr8[0], sizeof(struct in6_addr
)) == 0) ||
		  rrt->rrt_rflags & RRTF_NH_NOT_LLADDR0x20000000)) {
	/* Reset nexthop */
	if (nrt == maxrte - 2)
		ripflush(ifcp, sin6);
	memset(np, 0, sizeof(struct netinfo6));
	np->rip6_metric = NEXTHOP_METRIC0xff;
	nh = NULL((void*)0);
	np++; nrt++;
}

/* Put the route to the buffer */
*np = rrt->rrt_info;
np++; nrt++;
if (nrt == maxrte) {
	ripflush(ifcp, sin6);
	nh = NULL((void*)0);
}
}
if (nrt)	/* Send last packet */
ripflush(ifcp, sin6);
780}

782/*
* outbound filter logic, per-route/interface.
*/
785int
786out_filter(struct riprt *rrt, struct ifc *ifcp)
787{
struct iff *iffp;
struct in6_addr ia;
int ok;

/*
* -A: filter out less specific routes, if we have aggregated
* route configured.
*/ 
for (iffp = ifcp->ifc_filter; iffp; iffp = iffp->iff_next) {
if (iffp->iff_type != 'A')
	continue;
if (rrt->rrt_info.rip6_plen <= iffp->iff_plen)
	continue;
ia = rrt->rrt_info.rip6_dest; 
applyplen(&ia, iffp->iff_plen);
if (IN6_ARE_ADDR_EQUAL(&ia, &iffp->iff_addr)(memcmp(&(&ia)->__u6_addr.__u6_addr8[0], &(&
iffp->iff_addr)->__u6_addr.__u6_addr8[0], sizeof(struct
 in6_addr)) == 0))
	return 0;
}

/*
* if it is an aggregated route, advertise it only to the
* interfaces specified on -A.
*/
if ((rrt->rrt_rflags & RRTF_AGGREGATE0x08000000) != 0) {
ok = 0;
for (iffp = ifcp->ifc_filter; iffp; iffp = iffp->iff_next) {
	if (iffp->iff_type != 'A')
		continue;
	if (rrt->rrt_info.rip6_plen == iffp->iff_plen &&
	    IN6_ARE_ADDR_EQUAL(&rrt->rrt_info.rip6_dest,(memcmp(&(&rrt->rrt_info.rip6_dest)->__u6_addr.
__u6_addr8[0], &(&iffp->iff_addr)->__u6_addr.__u6_addr8
[0], sizeof(struct in6_addr)) == 0)
	    &iffp->iff_addr)(memcmp(&(&rrt->rrt_info.rip6_dest)->__u6_addr.
__u6_addr8[0], &(&iffp->iff_addr)->__u6_addr.__u6_addr8
[0], sizeof(struct in6_addr)) == 0)) {
		ok = 1;
		break;
	}
}
if (!ok)
	return 0;
}

/*
* -O: advertise only if prefix matches the configured prefix.
*/
if (iff_find(ifcp, 'O')) {
ok = 0;
for (iffp = ifcp->ifc_filter; iffp; iffp = iffp->iff_next) {
	if (iffp->iff_type != 'O')
		continue;
	if (rrt->rrt_info.rip6_plen < iffp->iff_plen)
		continue;
	ia = rrt->rrt_info.rip6_dest; 
	applyplen(&ia, iffp->iff_plen);
	if (IN6_ARE_ADDR_EQUAL(&ia, &iffp->iff_addr)(memcmp(&(&ia)->__u6_addr.__u6_addr8[0], &(&
iffp->iff_addr)->__u6_addr.__u6_addr8[0], sizeof(struct
 in6_addr)) == 0)) {
		ok = 1;
		break;
	}
}
if (!ok)
	return 0;
}

/* the prefix should be advertised */
return 1;
850}

852/*
* Determine if the route is to be advertised on the specified interface.
* It checks options specified in the arguments and the split horizon rule.
*/
856int
857tobeadv(struct riprt *rrt, struct ifc *ifcp)
858{

/* Special care for static routes */
if (rrt->rrt_flags & RTF_STATIC0x800) {
/* XXX don't advertise reject/blackhole routes */
if (rrt->rrt_flags & (RTF_REJECT0x8 | RTF_BLACKHOLE0x1000))
	return 0;

if (Sflag)	/* Yes, advertise it anyway */
	return 1;
if (sflag && rrt->rrt_index != ifcp->ifc_index)
	return 1;
return 0;
}
/* Regular split horizon */
if (hflag == 0 && rrt->rrt_index == ifcp->ifc_index)
return 0;
return 1;
876}

878/*
* Send a rip packet actually.
*/
881int
882sendpacket(struct sockaddr_in6 *sin6, int len)
883{
struct msghdr m;
struct cmsghdr *cm;
struct iovec iov[2];
union {
struct cmsghdr hdr;
u_char buf[CMSG_SPACE(sizeof(struct in6_pktinfo))((((unsigned long)(sizeof(struct cmsghdr)) + (sizeof(long) - 1
)) &~(sizeof(long) - 1)) + (((unsigned long)(sizeof(struct
 in6_pktinfo)) + (sizeof(long) - 1)) &~(sizeof(long) - 1)
))];
} cmsgbuf;
struct in6_pktinfo *pi;
int idx;
struct sockaddr_in6 sincopy;

/* do not overwrite the given sin */
sincopy = *sin6;
sin6 = &sincopy;

if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)(((&sin6->sin6_addr)->__u6_addr.__u6_addr8[0] == 0xfe
) && (((&sin6->sin6_addr)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0x80)) ||
   IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr)((&sin6->sin6_addr)->__u6_addr.__u6_addr8[0] == 0xff
)) {
/* XXX: do not mix the interface index and link index */
idx = IN6_LINKLOCAL_IFINDEX(sin6->sin6_addr)((sin6->sin6_addr).__u6_addr.__u6_addr8[2] << 8 | (sin6
->sin6_addr).__u6_addr.__u6_addr8[3]);
SET_IN6_LINKLOCAL_IFINDEX(sin6->sin6_addr, 0)do { (sin6->sin6_addr).__u6_addr.__u6_addr8[2] = ((0) >>
 8) & 0xff; (sin6->sin6_addr).__u6_addr.__u6_addr8[3] =
 (0) & 0xff; } while (0);
sin6->sin6_scope_id = idx;
} else
idx = 0;

m.msg_name = (caddr_t)sin6;
m.msg_namelen = sizeof(*sin6);
iov[0].iov_base = (caddr_t)ripbuf;
iov[0].iov_len = len;
m.msg_iov = iov;
m.msg_iovlen = 1;
if (!idx) {
m.msg_control = NULL((void*)0);
m.msg_controllen = 0;
} else {
memset(&cmsgbuf, 0, sizeof(cmsgbuf));
m.msg_control = (caddr_t)&cmsgbuf.buf;
m.msg_controllen = sizeof(cmsgbuf.buf);
cm = CMSG_FIRSTHDR(&m)((&m)->msg_controllen >= sizeof(struct cmsghdr) ? (
struct cmsghdr *)(&m)->msg_control : (struct cmsghdr *
)((void*)0));
cm->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo))((((unsigned long)(sizeof(struct cmsghdr)) + (sizeof(long) - 1
)) &~(sizeof(long) - 1)) + (sizeof(struct in6_pktinfo)));
cm->cmsg_level = IPPROTO_IPV641;
cm->cmsg_type = IPV6_PKTINFO46;
pi = (struct in6_pktinfo *)CMSG_DATA(cm)((unsigned char *)(cm) + (((unsigned long)(sizeof(struct cmsghdr
)) + (sizeof(long) - 1)) &~(sizeof(long) - 1)));
memset(&pi->ipi6_addr, 0, sizeof(pi->ipi6_addr)); /*::*/
pi->ipi6_ifindex = idx;
}

if (sendmsg(ripsock, &m, 0) == -1) {
log_debug("sendmsg: %s", strerror(errno(*__errno())));
return errno(*__errno());
}

return 0;
936}

938/*
* Receive and process RIP packets.  Update the routes/kernel forwarding
* table if necessary.
*/
942void
943riprecv(void)
944{
struct	ifc *ifcp, *ic;
struct	sockaddr_in6 fsock;
struct	in6_addr nh;	/* next hop */
struct	rip6 *rp;
struct	netinfo6 *np, *nq;
struct	riprt *rrt;
ssize_t	len, nn;
unsigned int need_trigger, idx;
char	buf[4 * RIP6_MAXMTU1500];
time_t	t;
struct msghdr m;
struct cmsghdr *cm;
struct iovec iov[2];
union {
struct cmsghdr hdr;
u_char buf[CMSG_SPACE(sizeof(struct in6_pktinfo))((((unsigned long)(sizeof(struct cmsghdr)) + (sizeof(long) - 1
)) &~(sizeof(long) - 1)) + (((unsigned long)(sizeof(struct
 in6_pktinfo)) + (sizeof(long) - 1)) &~(sizeof(long) - 1)
)) +
    CMSG_SPACE(sizeof(int))((((unsigned long)(sizeof(struct cmsghdr)) + (sizeof(long) - 1
)) &~(sizeof(long) - 1)) + (((unsigned long)(sizeof(int))
 + (sizeof(long) - 1)) &~(sizeof(long) - 1)))];
} cmsgbuf;
struct in6_pktinfo *pi = NULL((void*)0);
int *hlimp = NULL((void*)0);
struct iff *iffp;
struct in6_addr ia;
int ok;
time_t t_half_lifetime;

need_trigger = 0;

m.msg_name = (caddr_t)&fsock;
m.msg_namelen = sizeof(fsock);
iov[0].iov_base = (caddr_t)buf;
iov[0].iov_len = sizeof(buf);
m.msg_iov = iov;
m.msg_iovlen = 1;
m.msg_control = (caddr_t)&cmsgbuf.buf;
m.msg_controllen = sizeof(cmsgbuf.buf);
if ((len = recvmsg(ripsock, &m, 0)) == -1) {
fatal("recvmsg");
/*NOTREACHED*/
}
idx = 0;
for (cm = (struct cmsghdr *)CMSG_FIRSTHDR(&m)((&m)->msg_controllen >= sizeof(struct cmsghdr) ? (
struct cmsghdr *)(&m)->msg_control : (struct cmsghdr *
)((void*)0));
    cm;
    cm = (struct cmsghdr *)CMSG_NXTHDR(&m, cm)(((char *)(cm) + (((unsigned long)((cm)->cmsg_len) + (sizeof
(long) - 1)) &~(sizeof(long) - 1)) + (((unsigned long)(sizeof
(struct cmsghdr)) + (sizeof(long) - 1)) &~(sizeof(long) -
 1)) > ((char *)(&m)->msg_control) + (&m)->msg_controllen
) ? (struct cmsghdr *)((void*)0) : (struct cmsghdr *)((char *
)(cm) + (((unsigned long)((cm)->cmsg_len) + (sizeof(long) -
 1)) &~(sizeof(long) - 1))))) {
if (cm->cmsg_level != IPPROTO_IPV641)
	continue;
switch (cm->cmsg_type) {
case IPV6_PKTINFO46:
	if (cm->cmsg_len != CMSG_LEN(sizeof(*pi))((((unsigned long)(sizeof(struct cmsghdr)) + (sizeof(long) - 1
)) &~(sizeof(long) - 1)) + (sizeof(*pi)))) {
		log_debug(
		    "invalid cmsg length for IPV6_PKTINFO");
		return;
	}
	pi = (struct in6_pktinfo *)(CMSG_DATA(cm)((unsigned char *)(cm) + (((unsigned long)(sizeof(struct cmsghdr
)) + (sizeof(long) - 1)) &~(sizeof(long) - 1))));
	idx = pi->ipi6_ifindex;
	break;
case IPV6_HOPLIMIT47:
	if (cm->cmsg_len != CMSG_LEN(sizeof(int))((((unsigned long)(sizeof(struct cmsghdr)) + (sizeof(long) - 1
)) &~(sizeof(long) - 1)) + (sizeof(int)))) {
		log_debug(
		    "invalid cmsg length for IPV6_HOPLIMIT");
		return;
	}
	hlimp = (int *)CMSG_DATA(cm)((unsigned char *)(cm) + (((unsigned long)(sizeof(struct cmsghdr
)) + (sizeof(long) - 1)) &~(sizeof(long) - 1)));
	break;
}
}
if (idx && IN6_IS_ADDR_LINKLOCAL(&fsock.sin6_addr)(((&fsock.sin6_addr)->__u6_addr.__u6_addr8[0] == 0xfe)
 && (((&fsock.sin6_addr)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0x80)))
SET_IN6_LINKLOCAL_IFINDEX(fsock.sin6_addr, idx)do { (fsock.sin6_addr).__u6_addr.__u6_addr8[2] = ((idx) >>
 8) & 0xff; (fsock.sin6_addr).__u6_addr.__u6_addr8[3] = (
idx) & 0xff; } while (0);

if (len < sizeof(struct rip6)) {
log_debug("Packet too short");
return;
}

if (pi == NULL((void*)0) || hlimp == NULL((void*)0)) {
/*
 * This can happen when the kernel failed to allocate memory
 * for the ancillary data.  Although we might be able to handle
 * some cases without this info, those are minor and not so
 * important, so it's better to discard the packet for safer
 * operation.
 */
log_debug("IPv6 packet information cannot be retrieved");
return;
}

nh = fsock.sin6_addr;
nn = (len - sizeof(struct rip6) + sizeof(struct netinfo6)) /
sizeof(struct netinfo6);
rp = (struct rip6 *)buf;
np = rp->rip6_netsrip6un.ru6_nets;

if (rp->rip6_vers != RIP6_VERSION1) {
log_debug("Incorrect RIP version %d", rp->rip6_vers);
return;
}
if (rp->rip6_cmd == RIP6_REQUEST1) {
if (idx && idx < nindex2ifc) {
	ifcp = index2ifc[idx];
	riprequest(ifcp, np, nn, &fsock);
} else {
	riprequest(NULL((void*)0), np, nn, &fsock);
}
return; 
} 

if (!IN6_IS_ADDR_LINKLOCAL(&fsock.sin6_addr)(((&fsock.sin6_addr)->__u6_addr.__u6_addr8[0] == 0xfe)
 && (((&fsock.sin6_addr)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0x80))) {
log_debug("Response from non-ll addr: %s",
    inet6_n2p(&fsock.sin6_addr));
return;		/* Ignore packets from non-link-local addr */
}
if (ntohs(fsock.sin6_port)(__uint16_t)(__builtin_constant_p(fsock.sin6_port) ? (__uint16_t
)(((__uint16_t)(fsock.sin6_port) & 0xffU) << 8 | ((
__uint16_t)(fsock.sin6_port) & 0xff00U) >> 8) : __swap16md
(fsock.sin6_port)) != RIP6_PORT521) {
log_debug("Response from non-rip port from %s",
    inet6_n2p(&fsock.sin6_addr));
return;
}
if (IN6_IS_ADDR_MULTICAST(&pi->ipi6_addr)((&pi->ipi6_addr)->__u6_addr.__u6_addr8[0] == 0xff) && *hlimp != 255) {
log_debug(
    "Response packet with a smaller hop limit (%d) from %s",
    *hlimp, inet6_n2p(&fsock.sin6_addr));
return;
}
/*
* Further validation: since this program does not send off-link
* requests, an incoming response must always come from an on-link
* node.  Although this is normally ensured by the source address
* check above, it may not 100% be safe because there are router
* implementations that (invalidly) allow a packet with a link-local
* source address to be forwarded to a different link.
* So we also check whether the destination address is a link-local
* address or the hop limit is 255.  Note that RFC2080 does not require
* the specific hop limit for a unicast response, so we cannot assume
* the limitation.
*/
if (!IN6_IS_ADDR_LINKLOCAL(&pi->ipi6_addr)(((&pi->ipi6_addr)->__u6_addr.__u6_addr8[0] == 0xfe
) && (((&pi->ipi6_addr)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0x80)) && *hlimp != 255) {
log_debug(
    "Response packet possibly from an off-link node: "
    "from %s to %s hlim=%d",
    inet6_n2p(&fsock.sin6_addr), inet6_n2p(&pi->ipi6_addr),
    *hlimp);
return;
}

idx = IN6_LINKLOCAL_IFINDEX(fsock.sin6_addr)((fsock.sin6_addr).__u6_addr.__u6_addr8[2] << 8 | (fsock
.sin6_addr).__u6_addr.__u6_addr8[3]);
ifcp = (idx < nindex2ifc) ? index2ifc[idx] : NULL((void*)0);
if (!ifcp) {
log_debug("Packets to unknown interface index %d", idx);
return;		/* Ignore it */
}
if (IN6_ARE_ADDR_EQUAL(&ifcp->ifc_mylladdr, &fsock.sin6_addr)(memcmp(&(&ifcp->ifc_mylladdr)->__u6_addr.__u6_addr8
[0], &(&fsock.sin6_addr)->__u6_addr.__u6_addr8[0],
 sizeof(struct in6_addr)) == 0))
return;		/* The packet is from me; ignore */
if (rp->rip6_cmd != RIP6_RESPONSE2) {
log_debug("Invalid command %d", rp->rip6_cmd);
return; 
}

/* -N: no use */
if (iff_find(ifcp, 'N') != NULL((void*)0))
return;

log_debug("Recv(%s): from %s.%d info(%zd)",
   ifcp->ifc_name, inet6_n2p(&nh), ntohs(fsock.sin6_port)(__uint16_t)(__builtin_constant_p(fsock.sin6_port) ? (__uint16_t
)(((__uint16_t)(fsock.sin6_port) & 0xffU) << 8 | ((
__uint16_t)(fsock.sin6_port) & 0xff00U) >> 8) : __swap16md
(fsock.sin6_port)), nn);

t = time(NULL((void*)0));
t_half_lifetime = t - (RIP_LIFETIME180/2);
for (; nn; nn--, np++) {
if (np->rip6_metric == NEXTHOP_METRIC0xff) {
	/* modify neighbor address */
	if (IN6_IS_ADDR_LINKLOCAL(&np->rip6_dest)(((&np->rip6_dest)->__u6_addr.__u6_addr8[0] == 0xfe
) && (((&np->rip6_dest)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0x80))) {
		nh = np->rip6_dest;
		SET_IN6_LINKLOCAL_IFINDEX(nh, idx)do { (nh).__u6_addr.__u6_addr8[2] = ((idx) >> 8) & 0xff
; (nh).__u6_addr.__u6_addr8[3] = (idx) & 0xff; } while (0
);
		log_debug("\tNexthop: %s", inet6_n2p(&nh));
	} else if (IN6_IS_ADDR_UNSPECIFIED(&np->rip6_dest)((*(const u_int32_t *)(const void *)(&(&np->rip6_dest
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&np->rip6_dest)->__u6_addr.
__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void
 *)(&(&np->rip6_dest)->__u6_addr.__u6_addr8[8])
 == 0) && (*(const u_int32_t *)(const void *)(&(&
np->rip6_dest)->__u6_addr.__u6_addr8[12]) == 0))) {
		nh = fsock.sin6_addr;
		log_debug("\tNexthop: %s", inet6_n2p(&nh));
	} else {
		nh = fsock.sin6_addr;
		log_debug("\tInvalid Nexthop: %s",
		    inet6_n2p(&np->rip6_dest));
	}
	continue;
}
if (IN6_IS_ADDR_MULTICAST(&np->rip6_dest)((&np->rip6_dest)->__u6_addr.__u6_addr8[0] == 0xff)) {
	log_debug("\tMulticast netinfo6: %s/%d [%d]",
		inet6_n2p(&np->rip6_dest),
		np->rip6_plen, np->rip6_metric);
	continue;
}
if (IN6_IS_ADDR_LOOPBACK(&np->rip6_dest)((*(const u_int32_t *)(const void *)(&(&np->rip6_dest
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&np->rip6_dest)->__u6_addr.
__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void
 *)(&(&np->rip6_dest)->__u6_addr.__u6_addr8[8])
 == 0) && (*(const u_int32_t *)(const void *)(&(&
np->rip6_dest)->__u6_addr.__u6_addr8[12]) == (__uint32_t
)(__builtin_constant_p(1) ? (__uint32_t)(((__uint32_t)(1) &
 0xff) << 24 | ((__uint32_t)(1) & 0xff00) << 8
 | ((__uint32_t)(1) & 0xff0000) >> 8 | ((__uint32_t
)(1) & 0xff000000) >> 24) : __swap32md(1))))) {
	log_debug("\tLoopback netinfo6: %s/%d [%d]",
		inet6_n2p(&np->rip6_dest),
		np->rip6_plen, np->rip6_metric);
	continue;
}
if (IN6_IS_ADDR_LINKLOCAL(&np->rip6_dest)(((&np->rip6_dest)->__u6_addr.__u6_addr8[0] == 0xfe
) && (((&np->rip6_dest)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0x80))) {
	log_debug("\tLink Local netinfo6: %s/%d [%d]",
		inet6_n2p(&np->rip6_dest),
		np->rip6_plen, np->rip6_metric);
	continue;
}
/* may need to pass sitelocal prefix in some case, however*/
if (IN6_IS_ADDR_SITELOCAL(&np->rip6_dest)(((&np->rip6_dest)->__u6_addr.__u6_addr8[0] == 0xfe
) && (((&np->rip6_dest)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0xc0)) && !lflag) {
	log_debug("\tSite Local netinfo6: %s/%d [%d]",
		inet6_n2p(&np->rip6_dest),
		np->rip6_plen, np->rip6_metric);
	continue;
}
if (dflag >= 2) {
	log_enqueue("\tnetinfo6: %s/%d [%d]",
	    inet6_n2p(&np->rip6_dest),
	    np->rip6_plen, np->rip6_metric);
	if (np->rip6_tag)
		log_enqueue("  tag=0x%04x",
		    ntohs(np->rip6_tag)(__uint16_t)(__builtin_constant_p(np->rip6_tag) ? (__uint16_t
)(((__uint16_t)(np->rip6_tag) & 0xffU) << 8 | ((
__uint16_t)(np->rip6_tag) & 0xff00U) >> 8) : __swap16md
(np->rip6_tag)) & 0xffff);
	ia = np->rip6_dest;
	applyplen(&ia, np->rip6_plen);
	if (!IN6_ARE_ADDR_EQUAL(&ia, &np->rip6_dest)(memcmp(&(&ia)->__u6_addr.__u6_addr8[0], &(&
np->rip6_dest)->__u6_addr.__u6_addr8[0], sizeof(struct in6_addr
)) == 0))
		log_enqueue(" [junk outside prefix]");
}

/*
 * -L: listen only if the prefix matches the configuration
 */
ok = 1;		/* if there's no L filter, it is ok */
for (iffp = ifcp->ifc_filter; iffp; iffp = iffp->iff_next) {
	if (iffp->iff_type != 'L')
		continue;
	ok = 0;
	if (np->rip6_plen < iffp->iff_plen)
		continue;
	/* special rule: ::/0 means default, not "in /0" */
	if (iffp->iff_plen == 0 && np->rip6_plen > 0)
		continue;
	ia = np->rip6_dest; 
	applyplen(&ia, iffp->iff_plen);
	if (IN6_ARE_ADDR_EQUAL(&ia, &iffp->iff_addr)(memcmp(&(&ia)->__u6_addr.__u6_addr8[0], &(&
iffp->iff_addr)->__u6_addr.__u6_addr8[0], sizeof(struct
 in6_addr)) == 0)) {
		ok = 1;
		break;
	}
}

if (!ok) {
	if (dflag >= 2)
		log_debug("  (filtered)");
	continue;
}

if (dflag >= 2)
	log_debug("");

np->rip6_metric++;
np->rip6_metric += ifcp->ifc_metric;
if (np->rip6_metric > HOPCNT_INFINITY616)
	np->rip6_metric = HOPCNT_INFINITY616;

applyplen(&np->rip6_dest, np->rip6_plen);
if ((rrt = rtsearch(np, NULL((void*)0))) != NULL((void*)0)) {
	if (rrt->rrt_t == 0)
		continue;	/* Intf route has priority */
	nq = &rrt->rrt_info;
	if (nq->rip6_metric > np->rip6_metric) {
		if (rrt->rrt_index == ifcp->ifc_index &&
		    IN6_ARE_ADDR_EQUAL(&nh, &rrt->rrt_gw)(memcmp(&(&nh)->__u6_addr.__u6_addr8[0], &(&
rrt->rrt_gw)->__u6_addr.__u6_addr8[0], sizeof(struct in6_addr
)) == 0)) {
			/* Small metric from the same gateway */
			nq->rip6_metric = np->rip6_metric;
		} else {
			/* Better route found */
			rrt->rrt_index = ifcp->ifc_index;
			/* Update routing table */
			delroute(nq, &rrt->rrt_gw);
			rrt->rrt_gw = nh;
			*nq = *np;
			addroute(rrt, &nh, ifcp);
		}
		rrt->rrt_rflags |= RRTF_CHANGED0x80000000;
		rrt->rrt_t = t;
		need_trigger = 1;
	} else if (nq->rip6_metric < np->rip6_metric &&
		   rrt->rrt_index == ifcp->ifc_index &&
		   IN6_ARE_ADDR_EQUAL(&nh, &rrt->rrt_gw)(memcmp(&(&nh)->__u6_addr.__u6_addr8[0], &(&
rrt->rrt_gw)->__u6_addr.__u6_addr8[0], sizeof(struct in6_addr
)) == 0)) {
		/* Got worse route from same gw */
		nq->rip6_metric = np->rip6_metric;
		rrt->rrt_t = t;
		rrt->rrt_rflags |= RRTF_CHANGED0x80000000;
		need_trigger = 1;
	} else if (nq->rip6_metric == np->rip6_metric &&
		   np->rip6_metric < HOPCNT_INFINITY616) {
		if (rrt->rrt_index == ifcp->ifc_index &&
		   IN6_ARE_ADDR_EQUAL(&nh, &rrt->rrt_gw)(memcmp(&(&nh)->__u6_addr.__u6_addr8[0], &(&
rrt->rrt_gw)->__u6_addr.__u6_addr8[0], sizeof(struct in6_addr
)) == 0)) { 
			/* same metric, same route from same gw */
			rrt->rrt_t = t;
		} else if (rrt->rrt_t < t_half_lifetime) {
			/* Better route found */
			rrt->rrt_index = ifcp->ifc_index;
			/* Update routing table */
			delroute(nq, &rrt->rrt_gw);
			rrt->rrt_gw = nh;
			*nq = *np;
			addroute(rrt, &nh, ifcp);
			rrt->rrt_rflags |= RRTF_CHANGED0x80000000;
			rrt->rrt_t = t;
		}
	}
	/* 
	 * if nq->rip6_metric == HOPCNT_INFINITY6 then
	 * do not update age value.  Do nothing.
	 */
} else if (np->rip6_metric < HOPCNT_INFINITY616) {
	/* Got a new valid route */
	if ((rrt = calloc(1, sizeof(struct riprt))) == NULL((void*)0)) {
		fatal("calloc: struct riprt");
		/*NOTREACHED*/
	}
	nq = &rrt->rrt_info;

	rrt->rrt_index = ifcp->ifc_index;
	rrt->rrt_flags = RTF_UP0x1|RTF_GATEWAY0x2;
	rrt->rrt_gw = nh;
	*nq = *np;
	applyplen(&nq->rip6_dest, nq->rip6_plen);
	if (nq->rip6_plen == sizeof(struct in6_addr) * 8)
		rrt->rrt_flags |= RTF_HOST0x4;

	/* Put the route to the list */
	rrt->rrt_next = riprt;
	riprt = rrt;
	/* Update routing table */
	addroute(rrt, &nh, ifcp);
	rrt->rrt_rflags |= RRTF_CHANGED0x80000000;
	need_trigger = 1;
	rrt->rrt_t = t;
}
}
/* XXX need to care the interval between triggered updates */
if (need_trigger) {
if (nextalarm > time(NULL((void*)0)) + RIP_TRIG_INT6_MAX5) {
	for (ic = ifc; ic; ic = ic->ifc_next) {
		if (ifcp->ifc_index == ic->ifc_index)
			continue;
		if (ic->ifc_flags & IFF_UP0x1)
			ripsend(ic, &ic->ifc_ripsin,
				RRTF_CHANGED0x80000000);
	}
}
/* Reset the flag */
for (rrt = riprt; rrt; rrt = rrt->rrt_next)
	rrt->rrt_rflags &= ~RRTF_CHANGED0x80000000;
}
1292}

1294/*
* Send all routes request packet to the specified interface.
*/
1297void
1298sendrequest(struct ifc *ifcp)
1299{
struct netinfo6 *np;
int error;

if (ifcp->ifc_flags & IFF_LOOPBACK0x8)
return;
ripbuf->rip6_cmd = RIP6_REQUEST1;
np = ripbuf->rip6_netsrip6un.ru6_nets;
memset(np, 0, sizeof(struct netinfo6));
np->rip6_metric = HOPCNT_INFINITY616;
log_debug("Send rtdump Request to %s (%s)",
ifcp->ifc_name, inet6_n2p(&ifcp->ifc_ripsin.sin6_addr));
error = sendpacket(&ifcp->ifc_ripsin, RIPSIZE(1)(sizeof(struct rip6) + ((1)-1) * sizeof(struct netinfo6)));
if (error == EAFNOSUPPORT47) {
/* Protocol not supported */
log_debug("Could not send rtdump Request to %s (%s): "
	"set IFF_UP to 0",
	ifcp->ifc_name, inet6_n2p(&ifcp->ifc_ripsin.sin6_addr));
ifcp->ifc_flags &= ~IFF_UP0x1;	/* As if down for AF_INET6 */
}
ripbuf->rip6_cmd = RIP6_RESPONSE2;
1320}

1322/*
* Process a RIP6_REQUEST packet.
*/
1325void
1326riprequest(struct ifc *ifcp, struct netinfo6 *np, int nn,
  struct sockaddr_in6 *sin6)
1328{
int i;
struct riprt *rrt;

if (!(nn == 1 && IN6_IS_ADDR_UNSPECIFIED(&np->rip6_dest)((*(const u_int32_t *)(const void *)(&(&np->rip6_dest
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&np->rip6_dest)->__u6_addr.
__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void
 *)(&(&np->rip6_dest)->__u6_addr.__u6_addr8[8])
 == 0) && (*(const u_int32_t *)(const void *)(&(&
np->rip6_dest)->__u6_addr.__u6_addr8[12]) == 0)) &&
     np->rip6_plen == 0 && np->rip6_metric == HOPCNT_INFINITY616)) {
/* Specific response, don't split-horizon */
log_debug("\tRIP Request");
for (i = 0; i < nn; i++, np++) {
	rrt = rtsearch(np, NULL((void*)0));
	if (rrt)
		np->rip6_metric = rrt->rrt_info.rip6_metric;
	else
		np->rip6_metric = HOPCNT_INFINITY616;
}
(void)sendpacket(sin6, RIPSIZE(nn)(sizeof(struct rip6) + ((nn)-1) * sizeof(struct netinfo6)));
return;
}
/* Whole routing table dump */
log_debug("\tRIP Request -- whole routing table");
ripsend(ifcp, sin6, RRTF_SENDANYWAY0x40000000);
1349}

1351/*
* Get information of each interface.
*/
1354void
1355ifconfig(void)
1356{
struct ifaddrs *ifap, *ifa;
struct ifc *ifcp;
struct ipv6_mreq mreq;
int s;

if ((s = socket(AF_INET624, SOCK_DGRAM2, 0)) == -1) {
fatal("socket");
/*NOTREACHED*/
}

if (getifaddrs(&ifap) != 0) {
fatal("getifaddrs");
/*NOTREACHED*/
}

for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
if (ifa->ifa_addr == NULL((void*)0) ||
    ifa->ifa_addr->sa_family != AF_INET624)
	continue;
ifcp = ifc_find(ifa->ifa_name);
/* we are interested in multicast-capable interfaces */
if ((ifa->ifa_flags & IFF_MULTICAST0x8000) == 0)
	continue;
if (!ifcp) {
	/* new interface */
	if ((ifcp = calloc(1, sizeof(struct ifc))) == NULL((void*)0)) {
		fatal("calloc: struct ifc");
		/*NOTREACHED*/
	}
	ifcp->ifc_index = -1;
	ifcp->ifc_next = ifc;
	ifc = ifcp;
	nifc++;
	ifcp->ifc_name = xstrdup(ifa->ifa_name);
	ifcp->ifc_addr = 0;
	ifcp->ifc_filter = 0;
	ifcp->ifc_flags = ifa->ifa_flags;
	log_debug("newif %s <%s>", ifcp->ifc_name,
		ifflags(ifcp->ifc_flags));
	if (!strcmp(ifcp->ifc_name, LOOPBACK_IF"lo0"))
		loopifcp = ifcp;
} else {
	/* update flag, this may be up again */
	if (ifcp->ifc_flags != ifa->ifa_flags) {
		log_enqueue("%s: <%s> -> ", ifcp->ifc_name,
			ifflags(ifcp->ifc_flags));
		log_debug("<%s>", ifflags(ifa->ifa_flags));
		ifcp->ifc_cflags |= IFC_CHANGED1;
	}
	ifcp->ifc_flags = ifa->ifa_flags;
}
ifconfig1(ifa->ifa_name, ifa->ifa_addr, ifcp, s);
if ((ifcp->ifc_flags & (IFF_LOOPBACK0x8 | IFF_UP0x1)) == IFF_UP0x1
 && 0 < ifcp->ifc_index && !ifcp->ifc_joined) {
	mreq.ipv6mr_multiaddr = ifcp->ifc_ripsin.sin6_addr;
	mreq.ipv6mr_interface = ifcp->ifc_index;
	if (setsockopt(ripsock, IPPROTO_IPV641, IPV6_JOIN_GROUP12,
	    &mreq, sizeof(mreq)) == -1) {
		fatalx("IPV6_JOIN_GROUP");
		/*NOTREACHED*/
	}
	log_debug("join %s %s", ifcp->ifc_name, RIP6_DEST"ff02::9");
	ifcp->ifc_joined++;
}
}
close(s);
freeifaddrs(ifap);
1424}

1426void
1427ifconfig1(const char *name, const struct sockaddr *sa, struct ifc *ifcp, int s)
1428{
struct	in6_ifreq ifr;
const struct sockaddr_in6 *sin6;
struct	ifac *ifa;
int	plen;
char	buf[BUFSIZ1024];

sin6 = (const struct sockaddr_in6 *)sa;
if (IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr)(((&sin6->sin6_addr)->__u6_addr.__u6_addr8[0] == 0xfe
) && (((&sin6->sin6_addr)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0xc0)) && !lflag)
return;
ifr.ifr_addrifr_ifru.ifru_addr = *sin6;
strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
if (ioctl(s, SIOCGIFNETMASK_IN6(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct in6_ifreq) & 0x1fff) << 16) | ((('i')) <<
 8) | ((37))), (char *)&ifr) == -1) {
fatal("ioctl: SIOCGIFNETMASK_IN6");
/*NOTREACHED*/
}
plen = sin6mask2len(&ifr.ifr_addrifr_ifru.ifru_addr);
if ((ifa = ifa_match(ifcp, &sin6->sin6_addr, plen)) != NULL((void*)0)) {
/* same interface found */
/* need check if something changed */
/* XXX not yet implemented */
return;
}
/*
* New address is found
*/
if ((ifa = calloc(1, sizeof(struct ifac))) == NULL((void*)0)) {
fatal("calloc: struct ifac");
/*NOTREACHED*/
}
ifa->ifa_conf = ifcp;
ifa->ifa_next = ifcp->ifc_addr;
ifcp->ifc_addr = ifa;
ifa->ifa_addr = sin6->sin6_addr;
ifa->ifa_plen = plen;
if (ifcp->ifc_flags & IFF_POINTOPOINT0x10) {
ifr.ifr_addrifr_ifru.ifru_addr = *sin6;
if (ioctl(s, SIOCGIFDSTADDR_IN6(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct in6_ifreq) & 0x1fff) << 16) | ((('i')) <<
 8) | ((34))), (char *)&ifr) == -1) {
	fatal("ioctl: SIOCGIFDSTADDR_IN6");
	/*NOTREACHED*/
}
ifa->ifa_raddr = ifr.ifr_dstaddrifr_ifru.ifru_dstaddr.sin6_addr;
inet_ntop(AF_INET624, (void *)&ifa->ifa_raddr, buf, sizeof(buf));
log_debug("found address %s/%d -- %s",
	inet6_n2p(&ifa->ifa_addr), ifa->ifa_plen, buf);
} else {
log_debug("found address %s/%d",
	inet6_n2p(&ifa->ifa_addr), ifa->ifa_plen);
}
if (ifcp->ifc_index < 0 && IN6_IS_ADDR_LINKLOCAL(&ifa->ifa_addr)(((&ifa->ifa_addr)->__u6_addr.__u6_addr8[0] == 0xfe
) && (((&ifa->ifa_addr)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0x80))) {
ifcp->ifc_mylladdr = ifa->ifa_addr;
ifcp->ifc_index = IN6_LINKLOCAL_IFINDEX(ifa->ifa_addr)((ifa->ifa_addr).__u6_addr.__u6_addr8[2] << 8 | (ifa
->ifa_addr).__u6_addr.__u6_addr8[3]);
memcpy(&ifcp->ifc_ripsin, &ripsin, ripsin.ss_len);
SET_IN6_LINKLOCAL_IFINDEX(ifcp->ifc_ripsin.sin6_addr,do { (ifcp->ifc_ripsin.sin6_addr).__u6_addr.__u6_addr8[2] =
 ((ifcp->ifc_index) >> 8) & 0xff; (ifcp->ifc_ripsin
.sin6_addr).__u6_addr.__u6_addr8[3] = (ifcp->ifc_index) &
 0xff; } while (0)
	ifcp->ifc_index)do { (ifcp->ifc_ripsin.sin6_addr).__u6_addr.__u6_addr8[2] =
 ((ifcp->ifc_index) >> 8) & 0xff; (ifcp->ifc_ripsin
.sin6_addr).__u6_addr.__u6_addr8[3] = (ifcp->ifc_index) &
 0xff; } while (0);
setindex2ifc(ifcp->ifc_index, ifcp);
ifcp->ifc_mtu = getifmtu(ifcp->ifc_index);
if (ifcp->ifc_mtu > RIP6_MAXMTU1500)
	ifcp->ifc_mtu = RIP6_MAXMTU1500;
if (ioctl(s, SIOCGIFMETRIC(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct ifreq) & 0x1fff) << 16) | ((('i')) <<
 8) | ((23))), (char *)&ifr) == -1) {
	fatal("ioctl: SIOCGIFMETRIC");
	/*NOTREACHED*/
}
ifcp->ifc_metric = ifr.ifr_metricifr_ifru.ifru_metric;
log_debug("\tindex: %d, mtu: %d, metric: %d",
	ifcp->ifc_index, ifcp->ifc_mtu, ifcp->ifc_metric);
} else
ifcp->ifc_cflags |= IFC_CHANGED1;
1496}

1498/*
* Receive and process routing messages.
* Update interface information as necesssary.
*/
1502void
1503rtrecv(void)
1504{
char buf[BUFSIZ1024];
char *p, *q;
struct rt_msghdr *rtm;
struct ifa_msghdr *ifam;
struct if_msghdr *ifm;
int len;
struct ifc *ifcp, *ic;
int iface = 0, rtable = 0;
struct sockaddr_in6 *rta[RTAX_MAX15];
struct sockaddr_in6 mask;
int i, addrs;
struct riprt *rrt;

if ((len = read(rtsock, buf, sizeof(buf))) == -1) {
perror("read from rtsock");
exit(1);
}
if (len < sizeof(*rtm)) {
log_debug("short read from rtsock: %d (should be > %zu)",
	len, sizeof(*rtm));
return;
}
if (dflag >= 2) {
log_debug("rtmsg:");
for (i = 0; i < len; i++) {
	log_enqueue("%02x ", buf[i] & 0xff);
	if (i % 16 == 15)
		log_debug("");
}
log_debug("");
}

p = buf;
/* safety against bogus message */
if (((struct rt_msghdr *)p)->rtm_msglen <= 0) {
log_debug("bogus rtmsg: length=%d",
    ((struct rt_msghdr *)p)->rtm_msglen);
return;
}
if (((struct rt_msghdr *)p)->rtm_version != RTM_VERSION5)
return;

rtm = NULL((void*)0);
ifam = NULL((void*)0);
ifm = NULL((void*)0);
switch (((struct rt_msghdr *)p)->rtm_type) {
case RTM_NEWADDR0xc:
case RTM_DELADDR0xd:
ifam = (struct ifa_msghdr *)p;
addrs = ifam->ifam_addrs;
q = (char *)(ifam + 1);
break;
case RTM_IFINFO0xe:
ifm = (struct if_msghdr *)p;
addrs = ifm->ifm_addrs;
q = (char *)(ifm + 1);
break;
default:
rtm = (struct rt_msghdr *)p;
addrs = rtm->rtm_addrs;
q = (char *)(p + rtm->rtm_hdrlen);
if (rtm->rtm_pid == pid) {
1567#if 0
	log_debug("rtmsg looped back to me, ignored");
1569#endif
	return;
}
break;
}
memset(&rta, 0, sizeof(rta));
for (i = 0; i < RTAX_MAX15; i++) {
if (addrs & (1 << i)) {
	rta[i] = (struct sockaddr_in6 *)q;
	q += ROUNDUP(rta[i]->sin6_len)((rta[i]->sin6_len) > 0 ? (1 + (((rta[i]->sin6_len) -
 1) | (sizeof(long) - 1))) : sizeof(long));
}
}

log_debug("rtsock: %s (addrs=%x)",
   rttypes((struct rt_msghdr *)p), addrs);
if (dflag >= 2) {
for (i = 0;
     i < ((struct rt_msghdr *)p)->rtm_msglen;
     i++) {
	log_enqueue("%02x ", p[i] & 0xff);
	if (i % 16 == 15)
		log_debug("");
}
log_debug("");
}
/*
* Easy ones first.
*
* We may be able to optimize by using ifm->ifm_index or
* ifam->ifam_index.  For simplicity we don't do that here.
*/
switch (((struct rt_msghdr *)p)->rtm_type) {
case RTM_NEWADDR0xc:
case RTM_IFINFO0xe:
iface++;
return;
case RTM_ADD0x1:
rtable++;
return;
case RTM_MISS0x7:
case RTM_RESOLVE0xb:
case RTM_GET0x4:
/* nothing to be done here */
log_debug("\tnothing to be done, ignored");
return;
}

1616#if 0
if (rta[RTAX_DST0] == NULL((void*)0)) {
log_debug("\tno destination, ignored");
return;
}
if (rta[RTAX_DST0]->sin6_family != AF_INET624) {
log_debug("\taf mismatch, ignored");
return;
}
if (IN6_IS_ADDR_LINKLOCAL(&rta[RTAX_DST]->sin6_addr)(((&rta[0]->sin6_addr)->__u6_addr.__u6_addr8[0] == 0xfe
) && (((&rta[0]->sin6_addr)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0x80))) {
log_debug("\tlinklocal destination, ignored");
return;
}
if (IN6_ARE_ADDR_EQUAL(&rta[RTAX_DST]->sin6_addr, &in6addr_loopback)(memcmp(&(&rta[0]->sin6_addr)->__u6_addr.__u6_addr8
[0], &(&in6addr_loopback)->__u6_addr.__u6_addr8[0]
, sizeof(struct in6_addr)) == 0)) {
log_debug("\tloopback destination, ignored");
return;		/* Loopback */
}
if (IN6_IS_ADDR_MULTICAST(&rta[RTAX_DST]->sin6_addr)((&rta[0]->sin6_addr)->__u6_addr.__u6_addr8[0] == 0xff
)) {
log_debug("\tmulticast destination, ignored");
return;
}
1637#endif

/* hard ones */
switch (((struct rt_msghdr *)p)->rtm_type) {
case RTM_NEWADDR0xc:
case RTM_IFINFO0xe:
case RTM_ADD0x1:
case RTM_MISS0x7:
case RTM_RESOLVE0xb:
case RTM_GET0x4:
/* should already be handled */
fatalx("rtrecv: never reach here");
/*NOTREACHED*/
case RTM_DELETE0x2:
if (!rta[RTAX_DST0] || !rta[RTAX_GATEWAY1]) {
	log_debug("\tsome of dst/gw/netmask are "
	    "unavailable, ignored");
	break;
}
if ((rtm->rtm_flags & RTF_HOST0x4) != 0) {
	mask.sin6_len = sizeof(mask);
	memset(&mask.sin6_addr, 0xff,
	    sizeof(mask.sin6_addr));
	rta[RTAX_NETMASK2] = &mask;
} else if (!rta[RTAX_NETMASK2]) {
	log_debug("\tsome of dst/gw/netmask are "
	    "unavailable, ignored");
	break;
}
if (rt_del(rta[RTAX_DST0], rta[RTAX_GATEWAY1],
	rta[RTAX_NETMASK2]) == 0) {
	rtable++;	/*just to be sure*/
}
break;
case RTM_CHANGE0x3:
case RTM_REDIRECT0x6:
log_debug("\tnot supported yet, ignored");
break;
case RTM_DELADDR0xd:
if (!rta[RTAX_NETMASK2] || !rta[RTAX_IFA5]) {
	log_debug("\tno netmask or ifa given, ignored");
	break;
}
if (ifam->ifam_index < nindex2ifc)
	ifcp = index2ifc[ifam->ifam_index];
else
	ifcp = NULL((void*)0);
if (!ifcp) {
	log_debug("\tinvalid ifam_index %d, ignored",
	    ifam->ifam_index);
	break;
}
if (!rt_deladdr(ifcp, rta[RTAX_IFA5], rta[RTAX_NETMASK2]))
	iface++;
break;
}

if (iface) {
log_debug("rtsock: reconfigure interfaces, refresh interface routes");
ifconfig();
for (ifcp = ifc; ifcp; ifcp = ifcp->ifc_next)
	if (ifcp->ifc_cflags & IFC_CHANGED1) {
		if (ifrt(ifcp, 1)) {
			for (ic = ifc; ic; ic = ic->ifc_next) {
				if (ifcp->ifc_index == ic->ifc_index)
					continue;
				if (ic->ifc_flags & IFF_UP0x1)
					ripsend(ic, &ic->ifc_ripsin,
					RRTF_CHANGED0x80000000);
			}
			/* Reset the flag */
			for (rrt = riprt; rrt; rrt = rrt->rrt_next)
				rrt->rrt_rflags &= ~RRTF_CHANGED0x80000000;
		}
		ifcp->ifc_cflags &= ~IFC_CHANGED1;
	}
}
if (rtable) {
log_debug("rtsock: read routing table again");
krtread(1);
}
1718}

1720/*
* remove specified route from the internal routing table.
*/
1723int
1724rt_del(const struct sockaddr_in6 *sdst, const struct sockaddr_in6 *sgw,
  const struct sockaddr_in6 *smask)
1726{
const struct in6_addr *dst = NULL((void*)0);
const struct in6_addr *gw = NULL((void*)0);
int prefix;
struct netinfo6 ni6;
struct riprt *rrt = NULL((void*)0);
time_t t_lifetime;

if (sdst->sin6_family != AF_INET624) {
log_debug("\tother AF, ignored");
return -1;
}
if (IN6_IS_ADDR_LINKLOCAL(&sdst->sin6_addr)(((&sdst->sin6_addr)->__u6_addr.__u6_addr8[0] == 0xfe
) && (((&sdst->sin6_addr)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0x80))
|| IN6_ARE_ADDR_EQUAL(&sdst->sin6_addr, &in6addr_loopback)(memcmp(&(&sdst->sin6_addr)->__u6_addr.__u6_addr8
[0], &(&in6addr_loopback)->__u6_addr.__u6_addr8[0]
, sizeof(struct in6_addr)) == 0)
|| IN6_IS_ADDR_MULTICAST(&sdst->sin6_addr)((&sdst->sin6_addr)->__u6_addr.__u6_addr8[0] == 0xff
)) {
log_debug("\taddress %s not interesting, ignored",
	inet6_n2p(&sdst->sin6_addr));
return -1;
}
dst = &sdst->sin6_addr;
if (sgw->sin6_family == AF_INET624) {
/* easy case */
gw = &sgw->sin6_addr;
prefix = sin6mask2len(smask);
} else if (sgw->sin6_family == AF_LINK18) {
/*
 * Interface route... a hard case.  We need to get the prefix
 * length from the kernel, but we now are parsing rtmsg.
 * We'll purge matching routes from my list, then get the
 * fresh list.
 */
struct riprt *longest;
log_debug("\t%s is a interface route, guessing prefixlen",
	inet6_n2p(dst));
longest = NULL((void*)0);
for (rrt = riprt; rrt; rrt = rrt->rrt_next) {
	if (IN6_ARE_ADDR_EQUAL(&rrt->rrt_info.rip6_dest,(memcmp(&(&rrt->rrt_info.rip6_dest)->__u6_addr.
__u6_addr8[0], &(&sdst->sin6_addr)->__u6_addr.__u6_addr8
[0], sizeof(struct in6_addr)) == 0)
			&sdst->sin6_addr)(memcmp(&(&rrt->rrt_info.rip6_dest)->__u6_addr.
__u6_addr8[0], &(&sdst->sin6_addr)->__u6_addr.__u6_addr8
[0], sizeof(struct in6_addr)) == 0)
	 && IN6_IS_ADDR_LOOPBACK(&rrt->rrt_gw)((*(const u_int32_t *)(const void *)(&(&rrt->rrt_gw
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&rrt->rrt_gw)->__u6_addr.__u6_addr8
[4]) == 0) && (*(const u_int32_t *)(const void *)(&
(&rrt->rrt_gw)->__u6_addr.__u6_addr8[8]) == 0) &&
 (*(const u_int32_t *)(const void *)(&(&rrt->rrt_gw
)->__u6_addr.__u6_addr8[12]) == (__uint32_t)(__builtin_constant_p
(1) ? (__uint32_t)(((__uint32_t)(1) & 0xff) << 24 |
 ((__uint32_t)(1) & 0xff00) << 8 | ((__uint32_t)(1)
 & 0xff0000) >> 8 | ((__uint32_t)(1) & 0xff000000
) >> 24) : __swap32md(1))))) {
		if (!longest
		 || longest->rrt_info.rip6_plen <
				 rrt->rrt_info.rip6_plen) {
			longest = rrt;
		}
	}
}
rrt = longest;
if (!rrt) {
	log_debug("\tno matching interface route found");
	return -1;
}
gw = &in6addr_loopback;
prefix = rrt->rrt_info.rip6_plen;
} else {
log_debug("\tunsupported af: (gw=%d)", sgw->sin6_family);
return -1;
}

log_enqueue("\tdeleting %s/%d ", inet6_n2p(dst), prefix);
log_debug("gw %s", inet6_n2p(gw));
t_lifetime = time(NULL((void*)0)) - RIP_LIFETIME180;
/* age route for interface address */
memset(&ni6, 0, sizeof(ni6));
ni6.rip6_dest = *dst;
ni6.rip6_plen = prefix;
applyplen(&ni6.rip6_dest, ni6.rip6_plen);	/*to be sure*/
log_debug("\tfind route %s/%d", inet6_n2p(&ni6.rip6_dest),
ni6.rip6_plen);
if (!rrt && (rrt = rtsearch(&ni6, NULL((void*)0))) == NULL((void*)0)) {
log_debug("\tno route found");
return -1;
}
1798#if 0
if ((rrt->rrt_flags & RTF_STATIC0x800) == 0) {
log_debug("\tyou can delete static routes only");
} else
1802#endif
if (!IN6_ARE_ADDR_EQUAL(&rrt->rrt_gw, gw)(memcmp(&(&rrt->rrt_gw)->__u6_addr.__u6_addr8[0
], &(gw)->__u6_addr.__u6_addr8[0], sizeof(struct in6_addr
)) == 0)) {
log_enqueue("\tgw mismatch: %s <-> ",
	inet6_n2p(&rrt->rrt_gw));
log_debug("%s", inet6_n2p(gw));
} else {
log_debug("\troute found, age it");
if (rrt->rrt_t == 0 || rrt->rrt_t > t_lifetime) {
	rrt->rrt_t = t_lifetime;
	rrt->rrt_info.rip6_metric = HOPCNT_INFINITY616;
}
}
return 0;
1815}

1817/*
* remove specified address from internal interface/routing table.
*/
1820int
1821rt_deladdr(struct ifc *ifcp, const struct sockaddr_in6 *sifa,
  const struct sockaddr_in6 *smask)
1823{
const struct in6_addr *addr = NULL((void*)0);
int prefix;
struct ifac *ifa = NULL((void*)0);
struct netinfo6 ni6;
struct riprt *rrt = NULL((void*)0);
time_t t_lifetime;
int updated = 0;

if (sifa->sin6_family != AF_INET624) {
log_debug("\tother AF, ignored");
return -1;
}
addr = &sifa->sin6_addr;
prefix = sin6mask2len(smask);

log_debug("\tdeleting %s/%d from %s",
inet6_n2p(addr), prefix, ifcp->ifc_name);
ifa = ifa_match(ifcp, addr, prefix);
if (!ifa) {
log_debug("\tno matching ifa found for %s/%d on %s",
	inet6_n2p(addr), prefix, ifcp->ifc_name);
return -1;
}
if (ifa->ifa_conf != ifcp) {
log_debug("\taddress table corrupt: back pointer does not match "
	"(%s != %s)",
	ifcp->ifc_name, ifa->ifa_conf->ifc_name);
return -1;
}
/* remove ifa from interface */
if (ifcp->ifc_addr == ifa)
ifcp->ifc_addr = ifa->ifa_next;
else {
struct ifac *p;
for (p = ifcp->ifc_addr; p; p = p->ifa_next) {
	if (p->ifa_next == ifa) {
		p->ifa_next = ifa->ifa_next;
		break;
	}
}
}
ifa->ifa_next = NULL((void*)0);
ifa->ifa_conf = NULL((void*)0);
t_lifetime = time(NULL((void*)0)) - RIP_LIFETIME180;
/* age route for interface address */
memset(&ni6, 0, sizeof(ni6));
ni6.rip6_dest = ifa->ifa_addr;
ni6.rip6_plen = ifa->ifa_plen;
applyplen(&ni6.rip6_dest, ni6.rip6_plen);
log_debug("\tfind interface route %s/%d on %d",
inet6_n2p(&ni6.rip6_dest), ni6.rip6_plen, ifcp->ifc_index);
if ((rrt = rtsearch(&ni6, NULL((void*)0))) != NULL((void*)0)) {
struct in6_addr none;
memset(&none, 0, sizeof(none));
if (rrt->rrt_index == ifcp->ifc_index &&
    (IN6_ARE_ADDR_EQUAL(&rrt->rrt_gw, &none)(memcmp(&(&rrt->rrt_gw)->__u6_addr.__u6_addr8[0
], &(&none)->__u6_addr.__u6_addr8[0], sizeof(struct
 in6_addr)) == 0) ||
     IN6_IS_ADDR_LOOPBACK(&rrt->rrt_gw)((*(const u_int32_t *)(const void *)(&(&rrt->rrt_gw
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&rrt->rrt_gw)->__u6_addr.__u6_addr8
[4]) == 0) && (*(const u_int32_t *)(const void *)(&
(&rrt->rrt_gw)->__u6_addr.__u6_addr8[8]) == 0) &&
 (*(const u_int32_t *)(const void *)(&(&rrt->rrt_gw
)->__u6_addr.__u6_addr8[12]) == (__uint32_t)(__builtin_constant_p
(1) ? (__uint32_t)(((__uint32_t)(1) & 0xff) << 24 |
 ((__uint32_t)(1) & 0xff00) << 8 | ((__uint32_t)(1)
 & 0xff0000) >> 8 | ((__uint32_t)(1) & 0xff000000
) >> 24) : __swap32md(1)))))) {
	log_debug("\troute found, age it");
	if (rrt->rrt_t == 0 || rrt->rrt_t > t_lifetime) {
		rrt->rrt_t = t_lifetime;
		rrt->rrt_info.rip6_metric = HOPCNT_INFINITY616;
	}
	updated++;
} else {
	log_debug("\tnon-interface route found: %s/%d on %d",
		inet6_n2p(&rrt->rrt_info.rip6_dest),
		rrt->rrt_info.rip6_plen,
		rrt->rrt_index);
}
} else
log_debug("\tno interface route found");
/* age route for p2p destination */
if (ifcp->ifc_flags & IFF_POINTOPOINT0x10) {
memset(&ni6, 0, sizeof(ni6));
ni6.rip6_dest = ifa->ifa_raddr;
ni6.rip6_plen = 128;
applyplen(&ni6.rip6_dest, ni6.rip6_plen);	/*to be sure*/
log_debug("\tfind p2p route %s/%d on %d",
	inet6_n2p(&ni6.rip6_dest), ni6.rip6_plen,
	ifcp->ifc_index);
if ((rrt = rtsearch(&ni6, NULL((void*)0))) != NULL((void*)0)) {
	if (rrt->rrt_index == ifcp->ifc_index &&
	    IN6_ARE_ADDR_EQUAL(&rrt->rrt_gw, &ifa->ifa_addr)(memcmp(&(&rrt->rrt_gw)->__u6_addr.__u6_addr8[0
], &(&ifa->ifa_addr)->__u6_addr.__u6_addr8[0], sizeof
(struct in6_addr)) == 0)) {
		log_debug("\troute found, age it");
		if (rrt->rrt_t == 0 || rrt->rrt_t > t_lifetime) {
			rrt->rrt_t = t_lifetime;
			rrt->rrt_info.rip6_metric =
			    HOPCNT_INFINITY616;
			updated++;
		}
	} else {
		log_debug("\tnon-p2p route found: %s/%d on %d",
			inet6_n2p(&rrt->rrt_info.rip6_dest),
			rrt->rrt_info.rip6_plen,
			rrt->rrt_index);
	}
} else
	log_debug("\tno p2p route found");
}
return updated ? 0 : -1;
1924}

1926/*
* Get each interface address and put those interface routes to the route
* list.
*/
1930int
1931ifrt(struct ifc *ifcp, int again)
1932{
struct ifac *ifa;
struct riprt *rrt = NULL((void*)0), *search_rrt, *prev_rrt, *loop_rrt;
struct netinfo6 *np;
time_t t_lifetime;
int need_trigger = 0;

1939#if 0
if (ifcp->ifc_flags & IFF_LOOPBACK0x8)
return 0;			/* ignore loopback */
1942#endif

if (ifcp->ifc_flags & IFF_POINTOPOINT0x10) {
ifrt_p2p(ifcp, again);
return 0;
}

for (ifa = ifcp->ifc_addr; ifa; ifa = ifa->ifa_next) {
if (IN6_IS_ADDR_LINKLOCAL(&ifa->ifa_addr)(((&ifa->ifa_addr)->__u6_addr.__u6_addr8[0] == 0xfe
) && (((&ifa->ifa_addr)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0x80))) {
1951#if 0
	log_debug("route: %s on %s: "
	    "skip linklocal interface address",
	    inet6_n2p(&ifa->ifa_addr), ifcp->ifc_name);
1955#endif
	continue;
}
if (IN6_IS_ADDR_UNSPECIFIED(&ifa->ifa_addr)((*(const u_int32_t *)(const void *)(&(&ifa->ifa_addr
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&ifa->ifa_addr)->__u6_addr.
__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void
 *)(&(&ifa->ifa_addr)->__u6_addr.__u6_addr8[8])
 == 0) && (*(const u_int32_t *)(const void *)(&(&
ifa->ifa_addr)->__u6_addr.__u6_addr8[12]) == 0))) {
1959#if 0
	log_debug("route: %s: skip unspec interface address",
	    ifcp->ifc_name);
1962#endif
	continue;
}
if (IN6_IS_ADDR_LOOPBACK(&ifa->ifa_addr)((*(const u_int32_t *)(const void *)(&(&ifa->ifa_addr
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&ifa->ifa_addr)->__u6_addr.
__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void
 *)(&(&ifa->ifa_addr)->__u6_addr.__u6_addr8[8])
 == 0) && (*(const u_int32_t *)(const void *)(&(&
ifa->ifa_addr)->__u6_addr.__u6_addr8[12]) == (__uint32_t
)(__builtin_constant_p(1) ? (__uint32_t)(((__uint32_t)(1) &
 0xff) << 24 | ((__uint32_t)(1) & 0xff00) << 8
 | ((__uint32_t)(1) & 0xff0000) >> 8 | ((__uint32_t
)(1) & 0xff000000) >> 24) : __swap32md(1))))) {
1966#if 0
	log_debug("route: %s: skip loopback address",
	    ifcp->ifc_name);
1969#endif
	continue;
}
if (ifcp->ifc_flags & IFF_UP0x1) {
	if ((rrt = calloc(1, sizeof(struct riprt))) == NULL((void*)0))
		fatal("calloc: struct riprt");
	rrt->rrt_index = ifcp->ifc_index;
	rrt->rrt_t = 0;	/* don't age */
	rrt->rrt_info.rip6_dest = ifa->ifa_addr;
	rrt->rrt_info.rip6_tag = htons(routetag & 0xffff)(__uint16_t)(__builtin_constant_p(routetag & 0xffff) ? (__uint16_t
)(((__uint16_t)(routetag & 0xffff) & 0xffU) << 8
 | ((__uint16_t)(routetag & 0xffff) & 0xff00U) >>
 8) : __swap16md(routetag & 0xffff));
	rrt->rrt_info.rip6_metric = 1 + ifcp->ifc_metric;
	rrt->rrt_info.rip6_plen = ifa->ifa_plen;
	if (ifa->ifa_plen == 128)
		rrt->rrt_flags = RTF_HOST0x4;
	else
		rrt->rrt_flags = RTF_CLONING0x100;
	rrt->rrt_rflags |= RRTF_CHANGED0x80000000;
	applyplen(&rrt->rrt_info.rip6_dest, ifa->ifa_plen);
	memset(&rrt->rrt_gw, 0, sizeof(struct in6_addr));
	rrt->rrt_gw = ifa->ifa_addr;
	np = &rrt->rrt_info;
	search_rrt = rtsearch(np, &prev_rrt);
	if (search_rrt != NULL((void*)0)) {
		if (search_rrt->rrt_info.rip6_metric <=
		    rrt->rrt_info.rip6_metric) {
			/* Already have better route */
			if (!again) {
				log_debug("route: %s/%d: "
				    "already registered (%s)",
				    inet6_n2p(&np->rip6_dest), np->rip6_plen,
				    ifcp->ifc_name);
			}
			goto next;
		}

		if (prev_rrt)
			prev_rrt->rrt_next = rrt->rrt_next;
		else
			riprt = rrt->rrt_next;
		delroute(&rrt->rrt_info, &rrt->rrt_gw);
	}
	/* Attach the route to the list */
	log_debug("route: %s/%d: register route (%s)",
	    inet6_n2p(&np->rip6_dest), np->rip6_plen,
	    ifcp->ifc_name);
	rrt->rrt_next = riprt;
	riprt = rrt;
	addroute(rrt, &rrt->rrt_gw, ifcp);
	rrt = NULL((void*)0);
	sendrequest(ifcp);
	ripsend(ifcp, &ifcp->ifc_ripsin, 0);
	need_trigger = 1;
} else {
	for (loop_rrt = riprt; loop_rrt; loop_rrt = loop_rrt->rrt_next) {
		if (loop_rrt->rrt_index == ifcp->ifc_index) {
			t_lifetime = time(NULL((void*)0)) - RIP_LIFETIME180;
			if (loop_rrt->rrt_t == 0 || loop_rrt->rrt_t > t_lifetime) {
				loop_rrt->rrt_t = t_lifetime;
				loop_rrt->rrt_info.rip6_metric = HOPCNT_INFINITY616;
				loop_rrt->rrt_rflags |= RRTF_CHANGED0x80000000;
				need_trigger = 1;
			}
		}
	}
              }
next:
free(rrt);
}
return need_trigger;
2038}

2040/*
* there are couple of p2p interface routing models.  "behavior" lets
* you pick one.  it looks that gated behavior fits best with BSDs,
* since BSD kernels do not look at prefix length on p2p interfaces.
*/
2045void
2046ifrt_p2p(struct ifc *ifcp, int again)
2047{
struct ifac *ifa;
struct riprt *rrt, *orrt, *prevrrt;
struct netinfo6 *np;
struct in6_addr addr, dest;
int advert, ignore, i;
2053#define P2PADVERT_NETWORK	1
2054#define P2PADVERT_ADDR		2
2055#define P2PADVERT_DEST		4
2056#define P2PADVERT_MAX		4
const enum { CISCO, GATED, ROUTE6D } behavior = GATED;
const char *category = "";
const char *noadv;

for (ifa = ifcp->ifc_addr; ifa; ifa = ifa->ifa_next) {
addr = ifa->ifa_addr;
dest = ifa->ifa_raddr;
applyplen(&addr, ifa->ifa_plen);
applyplen(&dest, ifa->ifa_plen);
advert = ignore = 0;
switch (behavior) {
case CISCO:
	/*
	 * honor addr/plen, just like normal shared medium
	 * interface.  this may cause trouble if you reuse
	 * addr/plen on other interfaces.
	 *
	 * advertise addr/plen.
	 */
	advert |= P2PADVERT_NETWORK;
	break;
case GATED:
	/*
	 * prefixlen on p2p interface is meaningless.
	 * advertise addr/128 and dest/128.
	 *
	 * do not install network route to route6d routing
	 * table (if we do, it would prevent route installation
	 * for other p2p interface that shares addr/plen).
	 *
	 * XXX what should we do if dest is ::?  it will not
	 * get announced anyways (see following filter),
	 * but we need to think.
	 */
	advert |= P2PADVERT_ADDR;
	advert |= P2PADVERT_DEST;
	ignore |= P2PADVERT_NETWORK;
	break;
case ROUTE6D:
	/*
	 * just for testing.  actually the code is redundant
	 * given the current p2p interface address assignment
	 * rule for kame kernel.
	 *
	 * intent:
	 *	A/n -> announce A/n
	 *	A B/n, A and B share prefix -> A/n (= B/n)
	 *	A B/n, do not share prefix -> A/128 and B/128
	 * actually, A/64 and A B/128 are the only cases
	 * permitted by the kernel:
	 *	A/64 -> A/64
	 *	A B/128 -> A/128 and B/128
	 */
	if (!IN6_IS_ADDR_UNSPECIFIED(&ifa->ifa_raddr)((*(const u_int32_t *)(const void *)(&(&ifa->ifa_raddr
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&ifa->ifa_raddr)->__u6_addr
.__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void
 *)(&(&ifa->ifa_raddr)->__u6_addr.__u6_addr8[8]
) == 0) && (*(const u_int32_t *)(const void *)(&(
&ifa->ifa_raddr)->__u6_addr.__u6_addr8[12]) == 0))) {
		if (IN6_ARE_ADDR_EQUAL(&addr, &dest)(memcmp(&(&addr)->__u6_addr.__u6_addr8[0], &(&
dest)->__u6_addr.__u6_addr8[0], sizeof(struct in6_addr)) ==
 0))
			advert |= P2PADVERT_NETWORK;
		else {
			advert |= P2PADVERT_ADDR;
			advert |= P2PADVERT_DEST;
			ignore |= P2PADVERT_NETWORK;
		}
	} else
		advert |= P2PADVERT_NETWORK;
	break;
}

for (i = 1; i <= P2PADVERT_MAX; i *= 2) {
	if ((ignore & i) != 0)
		continue;
	if ((rrt = calloc(1, sizeof(struct riprt))) == NULL((void*)0)) {
		fatal("calloc: struct riprt");
		/*NOTREACHED*/
	}
	rrt->rrt_index = ifcp->ifc_index;
	rrt->rrt_t = 0;	/* don't age */
	switch (i) {
	case P2PADVERT_NETWORK:
		rrt->rrt_info.rip6_dest = ifa->ifa_addr;
		rrt->rrt_info.rip6_plen = ifa->ifa_plen;
		applyplen(&rrt->rrt_info.rip6_dest,
		    ifa->ifa_plen);
		category = "network";
		break;
	case P2PADVERT_ADDR:
		rrt->rrt_info.rip6_dest = ifa->ifa_addr;
		rrt->rrt_info.rip6_plen = 128;
		rrt->rrt_gw = in6addr_loopback;
		category = "addr";
		break;
	case P2PADVERT_DEST:
		rrt->rrt_info.rip6_dest = ifa->ifa_raddr;
		rrt->rrt_info.rip6_plen = 128;
		rrt->rrt_gw = ifa->ifa_addr;
		category = "dest";
		break;
	}
	if (IN6_IS_ADDR_UNSPECIFIED(&rrt->rrt_info.rip6_dest)((*(const u_int32_t *)(const void *)(&(&rrt->rrt_info
.rip6_dest)->__u6_addr.__u6_addr8[0]) == 0) && (*(
const u_int32_t *)(const void *)(&(&rrt->rrt_info.
rip6_dest)->__u6_addr.__u6_addr8[4]) == 0) && (*(const
 u_int32_t *)(const void *)(&(&rrt->rrt_info.rip6_dest
)->__u6_addr.__u6_addr8[8]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&rrt->rrt_info.rip6_dest)->
__u6_addr.__u6_addr8[12]) == 0)) ||
	    IN6_IS_ADDR_LINKLOCAL(&rrt->rrt_info.rip6_dest)(((&rrt->rrt_info.rip6_dest)->__u6_addr.__u6_addr8[
0] == 0xfe) && (((&rrt->rrt_info.rip6_dest)->
__u6_addr.__u6_addr8[1] & 0xc0) == 0x80))) {
2155#if 0
		log_debug("route: %s: skip unspec/linklocal "
		    "(%s on %s)", category, ifcp->ifc_name);
2158#endif
		free(rrt);
		continue;
	}
	if ((advert & i) == 0) {
		rrt->rrt_rflags |= RRTF_NOADVERTISE0x10000000;
		noadv = ", NO-ADV";
	} else
		noadv = "";
	rrt->rrt_info.rip6_tag = htons(routetag & 0xffff)(__uint16_t)(__builtin_constant_p(routetag & 0xffff) ? (__uint16_t
)(((__uint16_t)(routetag & 0xffff) & 0xffU) << 8
 | ((__uint16_t)(routetag & 0xffff) & 0xff00U) >>
 8) : __swap16md(routetag & 0xffff));
	rrt->rrt_info.rip6_metric = 1 + ifcp->ifc_metric;
	np = &rrt->rrt_info;
	orrt = rtsearch(np, &prevrrt);
	if (!orrt) {
		/* Attach the route to the list */
		log_debug("route: %s/%d: register route "
		    "(%s on %s%s)",
		    inet6_n2p(&np->rip6_dest), np->rip6_plen,
		    category, ifcp->ifc_name, noadv);
		rrt->rrt_next = riprt;
		riprt = rrt;
	} else if (rrt->rrt_index != orrt->rrt_index ||
	    rrt->rrt_info.rip6_metric != orrt->rrt_info.rip6_metric) {
		/* swap route */
		rrt->rrt_next = orrt->rrt_next;
		if (prevrrt)
			prevrrt->rrt_next = rrt;
		else
			riprt = rrt;
		free(orrt);

		log_debug("route: %s/%d: update (%s on %s%s)",
		    inet6_n2p(&np->rip6_dest), np->rip6_plen,
		    category, ifcp->ifc_name, noadv);
	} else {
		/* Already found */
		if (!again) {
			log_debug("route: %s/%d: "
			    "already registered (%s on %s%s)",
			    inet6_n2p(&np->rip6_dest),
			    np->rip6_plen, category,
			    ifcp->ifc_name, noadv);
		}
		free(rrt);
	}
}
}
2205#undef P2PADVERT_NETWORK
2206#undef P2PADVERT_ADDR
2207#undef P2PADVERT_DEST
2208#undef P2PADVERT_MAX
2209}

2211int
2212getifmtu(int ifindex)
2213{
int	mib[6];
char	*buf = NULL((void*)0);
size_t	needed;
struct	if_msghdr *ifm;
int	mtu;

mib[0] = CTL_NET4;
mib[1] = PF_ROUTE17;
mib[2] = 0;
mib[3] = AF_INET624;
mib[4] = NET_RT_IFLIST3;
mib[5] = ifindex;
while (1) {
if (sysctl(mib, 6, NULL((void*)0), &needed, NULL((void*)0), 0) == -1)
	fatal("sysctl estimate NET_RT_IFLIST");
if (needed == 0)
	break;
if ((buf = realloc(buf, needed)) == NULL((void*)0))
	fatal(NULL((void*)0));
if (sysctl(mib, 6, buf, &needed, NULL((void*)0), 0) == -1) {
	if (errno(*__errno()) == ENOMEM12)
		continue;
	fatal("sysctl NET_RT_IFLIST");
}
break;
}
ifm = (struct if_msghdr *)buf;
mtu = ifm->ifm_data.ifi_mtu;
free(buf);
return mtu;
2244}

2246const char *
2247rttypes(struct rt_msghdr *rtm)
2248{
2249#define	RTTYPE(s, f) \
2250do { \
if (rtm->rtm_type == (f)) \
return (s); \
2253} while (0)
RTTYPE("ADD", RTM_ADD0x1);
RTTYPE("DELETE", RTM_DELETE0x2);
RTTYPE("CHANGE", RTM_CHANGE0x3);
RTTYPE("GET", RTM_GET0x4);
RTTYPE("REDIRECT", RTM_REDIRECT0x6);
RTTYPE("MISS", RTM_MISS0x7);
RTTYPE("RESOLVE", RTM_RESOLVE0xb);
RTTYPE("NEWADDR", RTM_NEWADDR0xc);
RTTYPE("DELADDR", RTM_DELADDR0xd);
RTTYPE("IFINFO", RTM_IFINFO0xe);
2264#ifdef RTM_OIFINFO
RTTYPE("OIFINFO", RTM_OIFINFO);
2266#endif
2267#ifdef RTM_IFANNOUNCE0xf
RTTYPE("IFANNOUNCE", RTM_IFANNOUNCE0xf);
2269#endif
2270#ifdef RTM_NEWMADDR
RTTYPE("NEWMADDR", RTM_NEWMADDR);
2272#endif
2273#ifdef RTM_DELMADDR
RTTYPE("DELMADDR", RTM_DELMADDR);
2275#endif
2276#undef RTTYPE
return NULL((void*)0);
2278}

2280const char *
2281rtflags(struct rt_msghdr *rtm)
2282{
static char buf[BUFSIZ1024];

/*
* letter conflict should be okay.  painful when *BSD diverges...
*/
strlcpy(buf, "", sizeof(buf));
2289#define	RTFLAG(s, f) \
2290do { \
if (rtm->rtm_flags & (f)) \
strlcat(buf, (s), sizeof(buf)); \
2293} while (0)
RTFLAG("U", RTF_UP0x1);
RTFLAG("G", RTF_GATEWAY0x2);
RTFLAG("H", RTF_HOST0x4);
RTFLAG("R", RTF_REJECT0x8);
RTFLAG("D", RTF_DYNAMIC0x10);
RTFLAG("M", RTF_MODIFIED0x20);
RTFLAG("d", RTF_DONE0x40);
RTFLAG("m", RTF_MULTICAST0x200);
RTFLAG("C", RTF_CLONING0x100);
RTFLAG("c", RTF_CLONED0x10000);
RTFLAG("L", RTF_LLINFO0x400);
RTFLAG("S", RTF_STATIC0x800);
RTFLAG("B", RTF_BLACKHOLE0x1000);
RTFLAG("3", RTF_PROTO30x2000);
RTFLAG("2", RTF_PROTO20x4000);
RTFLAG("1", RTF_PROTO10x8000);
RTFLAG("b", RTF_BROADCAST0x400000);
2311#undef RTFLAG
return buf;
2313}

2315const char *
2316ifflags(int flags)
2317{
static char buf[BUFSIZ1024];

strlcpy(buf, "", sizeof(buf));
2321#define	IFFLAG(s, f) \
2322do { \
if (flags & (f)) { \
if (buf[0]) \
	strlcat(buf, ",", sizeof(buf)); \
strlcat(buf, (s), sizeof(buf)); \
} \
2328} while (0)
IFFLAG("UP", IFF_UP0x1);
IFFLAG("BROADCAST", IFF_BROADCAST0x2);
IFFLAG("DEBUG", IFF_DEBUG0x4);
IFFLAG("LOOPBACK", IFF_LOOPBACK0x8);
IFFLAG("POINTOPOINT", IFF_POINTOPOINT0x10);
IFFLAG("STATICARP", IFF_STATICARP0x20);
IFFLAG("RUNNING", IFF_RUNNING0x40);
IFFLAG("NOARP", IFF_NOARP0x80);
IFFLAG("PROMISC", IFF_PROMISC0x100);
IFFLAG("ALLMULTI", IFF_ALLMULTI0x200);
IFFLAG("OACTIVE", IFF_OACTIVE0x400);
IFFLAG("SIMPLEX", IFF_SIMPLEX0x800);
IFFLAG("LINK0", IFF_LINK00x1000);
IFFLAG("LINK1", IFF_LINK10x2000);
IFFLAG("LINK2", IFF_LINK20x4000);
IFFLAG("MULTICAST", IFF_MULTICAST0x8000);
2345#undef IFFLAG
return buf;
2347}

2349void
2350krtread(int again)
2351{
int mib[6];
size_t msize;
char *buf, *p, *lim;
struct rt_msghdr *rtm;
int retry;
const char *errmsg;

retry = 0;
buf = NULL((void*)0);
mib[0] = CTL_NET4;
mib[1] = PF_ROUTE17;
mib[2] = 0;
mib[3] = AF_INET624;	/* Address family */
mib[4] = NET_RT_DUMP1;	/* Dump the kernel routing table */
mib[5] = 0;		/* No flags */
do {
retry++;
free(buf);
buf = NULL((void*)0);
errmsg = NULL((void*)0);
if (sysctl(mib, 6, NULL((void*)0), &msize, NULL((void*)0), 0) == -1) {
	errmsg = "sysctl estimate";
	continue;
}
if ((buf = malloc(msize)) == NULL((void*)0)) {
	errmsg = "malloc";
	continue;
}
if (sysctl(mib, 6, buf, &msize, NULL((void*)0), 0) == -1) {
	errmsg = "sysctl NET_RT_DUMP";
	continue;
}
} while (retry < 5 && errmsg != NULL((void*)0));
if (errmsg) {
fatal(errmsg);
/*NOTREACHED*/
} else if (1 < retry)
log_info("NET_RT_DUMP %d retries", retry);

lim = buf + msize;
for (p = buf; p < lim; p += rtm->rtm_msglen) {
rtm = (struct rt_msghdr *)p;
if (rtm->rtm_version != RTM_VERSION5)
	continue;
rt_entry(rtm, again);
}
free(buf);
2399}

2401void
2402rt_entry(struct rt_msghdr *rtm, int again)
2403{
struct	sockaddr_in6 *sin6_dst, *sin6_gw, *sin6_mask;
struct	sockaddr_in6 *sin6_ifp;
char	*rtmp, *ifname = NULL((void*)0);
struct	riprt *rrt, *orrt;
struct	netinfo6 *np;
int	s;

sin6_dst = sin6_gw = sin6_mask = sin6_ifp = 0;
if ((rtm->rtm_flags & RTF_UP0x1) == 0 || rtm->rtm_flags &
(RTF_CLONING0x100|RTF_LLINFO0x400|RTF_BLACKHOLE0x1000)) {
return;		/* not interested in the link route */
}
/* do not look at cloned routes */
2417#ifdef RTF_WASCLONED
if (rtm->rtm_flags & RTF_WASCLONED)
return;
2420#endif
2421#ifdef RTF_CLONED0x10000
if (rtm->rtm_flags & RTF_CLONED0x10000)
return;
2424#endif
/*
* do not look at dynamic routes.
* netbsd/openbsd cloned routes have UGHD.
*/
if (rtm->rtm_flags & RTF_DYNAMIC0x10)
return;
rtmp = (char *)((char *)rtm + rtm->rtm_hdrlen);
/* Destination */
if ((rtm->rtm_addrs & RTA_DST0x1) == 0)
return;		/* ignore routes without destination address */
sin6_dst = (struct sockaddr_in6 *)rtmp;
rtmp += ROUNDUP(sin6_dst->sin6_len)((sin6_dst->sin6_len) > 0 ? (1 + (((sin6_dst->sin6_len
) - 1) | (sizeof(long) - 1))) : sizeof(long));
if (rtm->rtm_addrs & RTA_GATEWAY0x2) {
sin6_gw = (struct sockaddr_in6 *)rtmp;
rtmp += ROUNDUP(sin6_gw->sin6_len)((sin6_gw->sin6_len) > 0 ? (1 + (((sin6_gw->sin6_len
) - 1) | (sizeof(long) - 1))) : sizeof(long));
}
if (rtm->rtm_addrs & RTA_NETMASK0x4) {
sin6_mask = (struct sockaddr_in6 *)rtmp;
rtmp += ROUNDUP(sin6_mask->sin6_len)((sin6_mask->sin6_len) > 0 ? (1 + (((sin6_mask->sin6_len
) - 1) | (sizeof(long) - 1))) : sizeof(long));
}
if (rtm->rtm_addrs & RTA_IFP0x10) {
sin6_ifp = (struct sockaddr_in6 *)rtmp;
rtmp += ROUNDUP(sin6_ifp->sin6_len)((sin6_ifp->sin6_len) > 0 ? (1 + (((sin6_ifp->sin6_len
) - 1) | (sizeof(long) - 1))) : sizeof(long));
}

/* Destination */
if (sin6_dst->sin6_family != AF_INET624)
return;
if (IN6_IS_ADDR_LINKLOCAL(&sin6_dst->sin6_addr)(((&sin6_dst->sin6_addr)->__u6_addr.__u6_addr8[0] ==
 0xfe) && (((&sin6_dst->sin6_addr)->__u6_addr
.__u6_addr8[1] & 0xc0) == 0x80)))
return;		/* Link-local */
if (IN6_ARE_ADDR_EQUAL(&sin6_dst->sin6_addr, &in6addr_loopback)(memcmp(&(&sin6_dst->sin6_addr)->__u6_addr.__u6_addr8
[0], &(&in6addr_loopback)->__u6_addr.__u6_addr8[0]
, sizeof(struct in6_addr)) == 0))
return;		/* Loopback */
if (IN6_IS_ADDR_MULTICAST(&sin6_dst->sin6_addr)((&sin6_dst->sin6_addr)->__u6_addr.__u6_addr8[0] ==
 0xff))
return;

if ((rrt = calloc(1, sizeof(struct riprt))) == NULL((void*)0)) {
fatal("calloc: struct riprt");
/*NOTREACHED*/
}
np = &rrt->rrt_info;
rrt->rrt_t = time(NULL((void*)0));
if (aflag == 0 && (rtm->rtm_flags & RTF_STATIC0x800))
rrt->rrt_t = 0;	/* Don't age static routes */
if ((rtm->rtm_flags & (RTF_HOST0x4|RTF_GATEWAY0x2)) == RTF_HOST0x4)
rrt->rrt_t = 0;	/* Don't age non-gateway host routes */
np->rip6_tag = 0;
np->rip6_metric = 1;
rrt->rrt_flags = rtm->rtm_flags;
np->rip6_dest = sin6_dst->sin6_addr;

/* Mask or plen */
if (rtm->rtm_flags & RTF_HOST0x4)
np->rip6_plen = 128;	/* Host route */
else if (sin6_mask)
np->rip6_plen = sin6mask2len(sin6_mask);
else
np->rip6_plen = 0;

orrt = rtsearch(np, NULL((void*)0));
if (orrt && orrt->rrt_info.rip6_metric != HOPCNT_INFINITY616) {
/* Already found */
if (!again) {
	log_debug("route: %s/%d flags %s: already registered",
		inet6_n2p(&np->rip6_dest), np->rip6_plen,
		rtflags(rtm));
}
free(rrt);
return;
}
/* Gateway */
if (!sin6_gw)
memset(&rrt->rrt_gw, 0, sizeof(struct in6_addr));
else {
if (sin6_gw->sin6_family == AF_INET624)
	rrt->rrt_gw = sin6_gw->sin6_addr;
else if (sin6_gw->sin6_family == AF_LINK18) {
	/* XXX in case ppp link? */
	rrt->rrt_gw = in6addr_loopback;
} else
	memset(&rrt->rrt_gw, 0, sizeof(struct in6_addr));
}
log_enqueue("route: %s/%d flags %s",
inet6_n2p(&np->rip6_dest), np->rip6_plen, rtflags(rtm));
log_enqueue(" gw %s", inet6_n2p(&rrt->rrt_gw));

/* Interface */
s = rtm->rtm_index;
if (s < nindex2ifc && index2ifc[s])
ifname = index2ifc[s]->ifc_name;
else {
log_debug(" not configured");
free(rrt);
return;
}
log_debug(" if %s sock %d", ifname, s);
rrt->rrt_index = s;

/* Check gateway */
if (!IN6_IS_ADDR_LINKLOCAL(&rrt->rrt_gw)(((&rrt->rrt_gw)->__u6_addr.__u6_addr8[0] == 0xfe) &&
 (((&rrt->rrt_gw)->__u6_addr.__u6_addr8[1] & 0xc0
) == 0x80)) &&
   !IN6_IS_ADDR_LOOPBACK(&rrt->rrt_gw)((*(const u_int32_t *)(const void *)(&(&rrt->rrt_gw
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&rrt->rrt_gw)->__u6_addr.__u6_addr8
[4]) == 0) && (*(const u_int32_t *)(const void *)(&
(&rrt->rrt_gw)->__u6_addr.__u6_addr8[8]) == 0) &&
 (*(const u_int32_t *)(const void *)(&(&rrt->rrt_gw
)->__u6_addr.__u6_addr8[12]) == (__uint32_t)(__builtin_constant_p
(1) ? (__uint32_t)(((__uint32_t)(1) & 0xff) << 24 |
 ((__uint32_t)(1) & 0xff00) << 8 | ((__uint32_t)(1)
 & 0xff0000) >> 8 | ((__uint32_t)(1) & 0xff000000
) >> 24) : __swap32md(1))))) {
log_warnx("***** Gateway %s is not a link-local address.",
	inet6_n2p(&rrt->rrt_gw));
log_warnx("*****     dest(%s) if(%s) -- Not optimized.",
	inet6_n2p(&rrt->rrt_info.rip6_dest), ifname);
rrt->rrt_rflags |= RRTF_NH_NOT_LLADDR0x20000000;
}

/* Put it to the route list */
if (orrt && orrt->rrt_info.rip6_metric == HOPCNT_INFINITY616) {
/* replace route list */
rrt->rrt_next = orrt->rrt_next;
*orrt = *rrt;
log_debug("route: %s/%d flags %s: replace new route",
    inet6_n2p(&np->rip6_dest), np->rip6_plen,
    rtflags(rtm));
free(rrt);
} else {
rrt->rrt_next = riprt;
riprt = rrt;
}
2545}

2547int
2548addroute(struct riprt *rrt, const struct in6_addr *gw, struct ifc *ifcp)
2549{
struct	netinfo6 *np;
u_char	buf[BUFSIZ1024], buf1[BUFSIZ1024], buf2[BUFSIZ1024];
struct	rt_msghdr	*rtm;
struct	sockaddr_in6	*sin6;
int	len;

np = &rrt->rrt_info;
inet_ntop(AF_INET624, (const void *)gw, (char *)buf1, sizeof(buf1));
inet_ntop(AF_INET624, (void *)&ifcp->ifc_mylladdr, (char *)buf2, sizeof(buf2));
if (uflag)
log_info("RTADD: %s/%d gw %s [%d] ifa %s",
    inet6_n2p(&np->rip6_dest), np->rip6_plen, buf1,
    np->rip6_metric - 1, buf2);
else
log_debug("RTADD: %s/%d gw %s [%d] ifa %s",
    inet6_n2p(&np->rip6_dest), np->rip6_plen, buf1,
    np->rip6_metric - 1, buf2);

if (nflag)
return 0;

memset(buf, 0, sizeof(buf));
rtm = (struct rt_msghdr *)buf;
rtm->rtm_type = RTM_ADD0x1;
rtm->rtm_version = RTM_VERSION5;
rtm->rtm_seq = ++seq;
rtm->rtm_flags = rrt->rrt_flags;
rtm->rtm_addrs = RTA_DST0x1 | RTA_GATEWAY0x2 | RTA_NETMASK0x4;
rtm->rtm_inits = RTV_HOPCOUNT0x2;
sin6 = (struct sockaddr_in6 *)&buf[sizeof(struct rt_msghdr)];
/* Destination */
sin6->sin6_len = sizeof(struct sockaddr_in6);
sin6->sin6_family = AF_INET624;
sin6->sin6_addr = np->rip6_dest;
sin6 = (struct sockaddr_in6 *)((char *)sin6 + ROUNDUP(sin6->sin6_len)((sin6->sin6_len) > 0 ? (1 + (((sin6->sin6_len) - 1)
 | (sizeof(long) - 1))) : sizeof(long)));
/* Gateway */
sin6->sin6_len = sizeof(struct sockaddr_in6);
sin6->sin6_family = AF_INET624;
sin6->sin6_addr = *gw;
sin6 = (struct sockaddr_in6 *)((char *)sin6 + ROUNDUP(sin6->sin6_len)((sin6->sin6_len) > 0 ? (1 + (((sin6->sin6_len) - 1)
 | (sizeof(long) - 1))) : sizeof(long)));
/* Netmask */
sin6->sin6_len = sizeof(struct sockaddr_in6);
sin6->sin6_family = AF_INET624;
sin6->sin6_addr = *(plen2mask(np->rip6_plen));
sin6 = (struct sockaddr_in6 *)((char *)sin6 + ROUNDUP(sin6->sin6_len)((sin6->sin6_len) > 0 ? (1 + (((sin6->sin6_len) - 1)
 | (sizeof(long) - 1))) : sizeof(long)));

len = (char *)sin6 - (char *)buf;
rtm->rtm_msglen = len;
if (write(rtsock, buf, len) > 0)
return 0;

if (errno(*__errno()) == EEXIST17) {
log_warnx("RTADD: Route already exists %s/%d gw %s",
    inet6_n2p(&np->rip6_dest), np->rip6_plen, buf1);
} else {
log_warnx("RTADD: Can not write to rtsock (addroute): %s",
    strerror(errno(*__errno())));
}
return -1;
2609}

2611int
2612delroute(struct netinfo6 *np, struct in6_addr *gw)
2613{
u_char	buf[BUFSIZ1024], buf2[BUFSIZ1024];
struct	rt_msghdr	*rtm;
struct	sockaddr_in6	*sin6;
int	len;

inet_ntop(AF_INET624, (void *)gw, (char *)buf2, sizeof(buf2));
if (uflag)
log_info("RTDEL: %s/%d gw %s", inet6_n2p(&np->rip6_dest),
    np->rip6_plen, buf2);
else
log_debug("RTDEL: %s/%d gw %s", inet6_n2p(&np->rip6_dest),
    np->rip6_plen, buf2);

if (nflag)
return 0;

memset(buf, 0, sizeof(buf));
rtm = (struct rt_msghdr *)buf;
rtm->rtm_type = RTM_DELETE0x2;
rtm->rtm_version = RTM_VERSION5;
rtm->rtm_seq = ++seq;
rtm->rtm_flags = RTF_UP0x1 | RTF_GATEWAY0x2;
if (np->rip6_plen == sizeof(struct in6_addr) * 8)
rtm->rtm_flags |= RTF_HOST0x4;
rtm->rtm_addrs = RTA_DST0x1 | RTA_GATEWAY0x2 | RTA_NETMASK0x4;
sin6 = (struct sockaddr_in6 *)&buf[sizeof(struct rt_msghdr)];
/* Destination */
sin6->sin6_len = sizeof(struct sockaddr_in6);
sin6->sin6_family = AF_INET624;
sin6->sin6_addr = np->rip6_dest;
sin6 = (struct sockaddr_in6 *)((char *)sin6 + ROUNDUP(sin6->sin6_len)((sin6->sin6_len) > 0 ? (1 + (((sin6->sin6_len) - 1)
 | (sizeof(long) - 1))) : sizeof(long)));
/* Gateway */
sin6->sin6_len = sizeof(struct sockaddr_in6);
sin6->sin6_family = AF_INET624;
sin6->sin6_addr = *gw;
sin6 = (struct sockaddr_in6 *)((char *)sin6 + ROUNDUP(sin6->sin6_len)((sin6->sin6_len) > 0 ? (1 + (((sin6->sin6_len) - 1)
 | (sizeof(long) - 1))) : sizeof(long)));
/* Netmask */
sin6->sin6_len = sizeof(struct sockaddr_in6);
sin6->sin6_family = AF_INET624;
sin6->sin6_addr = *(plen2mask(np->rip6_plen));
sin6 = (struct sockaddr_in6 *)((char *)sin6 + ROUNDUP(sin6->sin6_len)((sin6->sin6_len) > 0 ? (1 + (((sin6->sin6_len) - 1)
 | (sizeof(long) - 1))) : sizeof(long)));

len = (char *)sin6 - (char *)buf;
rtm->rtm_msglen = len;
if (write(rtsock, buf, len) >= 0)
return 0;

if (errno(*__errno()) == ESRCH3) {
log_warnx("RTDEL: Route does not exist: %s/%d gw %s",
    inet6_n2p(&np->rip6_dest), np->rip6_plen, buf2);
} else {
log_warnx("RTDEL: Can not write to rtsock (delroute): %s",
    strerror(errno(*__errno())));
}
return -1;
2669}

2671struct in6_addr *
2672getroute(struct netinfo6 *np, struct in6_addr *gw)
2673{
u_char buf[BUFSIZ1024];
int len;
struct rt_msghdr *rtm;
struct sockaddr_in6 *sin6;

rtm = (struct rt_msghdr *)buf;
len = sizeof(struct rt_msghdr) + sizeof(struct sockaddr_in6);
memset(rtm, 0, len);
rtm->rtm_type = RTM_GET0x4;
rtm->rtm_version = RTM_VERSION5;
rtm->rtm_seq = ++seq;
rtm->rtm_addrs = RTA_DST0x1;
rtm->rtm_msglen = len;
sin6 = (struct sockaddr_in6 *)&buf[sizeof(struct rt_msghdr)];
sin6->sin6_len = sizeof(struct sockaddr_in6);
sin6->sin6_family = AF_INET624;
sin6->sin6_addr = np->rip6_dest;
if (write(rtsock, buf, len) == -1) {
if (errno(*__errno()) == ESRCH3)	/* No such route found */
	return NULL((void*)0);
perror("write to rtsock");
exit(1);
}
do {
if ((len = read(rtsock, buf, sizeof(buf))) == -1) {
	perror("read from rtsock");
	exit(1);
}
rtm = (struct rt_msghdr *)buf;
} while (rtm->rtm_version != RTM_VERSION5 ||
   rtm->rtm_seq != seq || rtm->rtm_pid != pid);
sin6 = (struct sockaddr_in6 *)&buf[sizeof(struct rt_msghdr)];
if (rtm->rtm_addrs & RTA_DST0x1) {
sin6 = (struct sockaddr_in6 *)
	((char *)sin6 + ROUNDUP(sin6->sin6_len)((sin6->sin6_len) > 0 ? (1 + (((sin6->sin6_len) - 1)
 | (sizeof(long) - 1))) : sizeof(long)));
}
if (rtm->rtm_addrs & RTA_GATEWAY0x2) {
*gw = sin6->sin6_addr;
return gw;
}
return NULL((void*)0);
2715}

2717const char *
2718inet6_n2p(const struct in6_addr *p)
2719{
static char buf[BUFSIZ1024];

return inet_ntop(AF_INET624, (const void *)p, buf, sizeof(buf));
2723}

2725void
2726ifrtdump(int sig)
2727{

ifdump(sig);
rtdump(sig);
2731}

2733void
2734ifdump(int sig)
2735{
struct ifc *ifcp;
int i;

log_info("%s: Interface Table Dump", hms());
log_info("  Number of interfaces: %d", nifc);
for (i = 0; i < 2; i++) {
log_info("  %sadvertising interfaces:", i ? "non-" : "");
for (ifcp = ifc; ifcp; ifcp = ifcp->ifc_next) {
	if (i == 0) {
		if ((ifcp->ifc_flags & IFF_UP0x1) == 0)
			continue;
		if (iff_find(ifcp, 'N') != NULL((void*)0))
			continue;
	} else {
		if (ifcp->ifc_flags & IFF_UP0x1)
			continue;
	}
	ifdump0(ifcp);
}
}
log_info("");
2757}

2759void
2760ifdump0(const struct ifc *ifcp)
2761{
struct ifac *ifa;
struct iff *iffp;
char buf[BUFSIZ1024];
const char *ft;
int addr;

log_info("    %s: index(%d) flags(%s) addr(%s) mtu(%d) metric(%d)",
ifcp->ifc_name, ifcp->ifc_index, ifflags(ifcp->ifc_flags),
inet6_n2p(&ifcp->ifc_mylladdr),
ifcp->ifc_mtu, ifcp->ifc_metric);
for (ifa = ifcp->ifc_addr; ifa; ifa = ifa->ifa_next) {
if (ifcp->ifc_flags & IFF_POINTOPOINT0x10) {
	inet_ntop(AF_INET624, (void *)&ifa->ifa_raddr,
		buf, sizeof(buf));
	log_info("\t%s/%d -- %s",
		inet6_n2p(&ifa->ifa_addr),
		ifa->ifa_plen, buf);
} else {
	log_info("\t%s/%d",
		inet6_n2p(&ifa->ifa_addr),
		ifa->ifa_plen);
}
}
if (ifcp->ifc_filter) {
log_enqueue("\tFilter:");
for (iffp = ifcp->ifc_filter; iffp; iffp = iffp->iff_next) {
	addr = 0;
	switch (iffp->iff_type) {
	case 'A':
		ft = "Aggregate"; addr++; break;
	case 'N':
		ft = "No-use"; break;
	case 'O':
		ft = "Advertise-only"; addr++; break;
	case 'T':
		ft = "Default-only"; break;
	case 'L':
		ft = "Listen-only"; addr++; break;
	default:
		snprintf(buf, sizeof(buf), "Unknown-%c", iffp->iff_type);
		ft = buf;
		addr++;
		break;
	}
	log_enqueue(" %s", ft);
	if (addr) {
		log_enqueue("(%s/%d)",
		    inet6_n2p(&iffp->iff_addr), iffp->iff_plen);
	}
}
log_info("");
}
2814}

2816void
2817rtdump(int sig)
2818{
struct	riprt *rrt;
char	buf[BUFSIZ1024];
time_t	t, age;

t = time(NULL((void*)0));
log_info("%s: Routing Table Dump", hms());
for (rrt = riprt; rrt; rrt = rrt->rrt_next) {
if (rrt->rrt_t == 0)
	age = 0;
else
	age = t - rrt->rrt_t;
inet_ntop(AF_INET624, (void *)&rrt->rrt_info.rip6_dest,
	buf, sizeof(buf));
log_enqueue("    %s/%d if(%d:%s) gw(%s) [%d] age(%lld)",
	buf, rrt->rrt_info.rip6_plen, rrt->rrt_index,
	index2ifc[rrt->rrt_index]->ifc_name,
	inet6_n2p(&rrt->rrt_gw),
	rrt->rrt_info.rip6_metric, (long long)age);
if (rrt->rrt_info.rip6_tag) {
	log_enqueue(" tag(0x%04x)",
		ntohs(rrt->rrt_info.rip6_tag)(__uint16_t)(__builtin_constant_p(rrt->rrt_info.rip6_tag) ?
 (__uint16_t)(((__uint16_t)(rrt->rrt_info.rip6_tag) & 0xffU
) << 8 | ((__uint16_t)(rrt->rrt_info.rip6_tag) &
 0xff00U) >> 8) : __swap16md(rrt->rrt_info.rip6_tag)
) & 0xffff);
}
if (rrt->rrt_rflags & RRTF_NH_NOT_LLADDR0x20000000)
	log_enqueue(" NOT-LL");
if (rrt->rrt_rflags & RRTF_NOADVERTISE0x10000000)
	log_enqueue(" NO-ADV");
log_info("");
}
2847}

2849/*
* Parse the -A (and -O) options and put corresponding filter object to the
* specified interface structures.  Each of the -A/O option has the following
* syntax:	-A 5f09:c400::/32,ef0,ef1  (aggregate)
* 		-O 5f09:c400::/32,ef0,ef1  (only when match)
*/
2855void
2856filterconfig(void)
2857{
int i;
char *p, *ap, *iflp, *ifname, *ep;
struct iff ftmp, *iff_obj;
struct ifc *ifcp;
struct riprt *rrt;
2863#if 0
struct in6_addr gw;
2865#endif
u_long plen;

for (i = 0; i < nfilter; i++) {
20
←
Assuming 'i' is < 'nfilter'→
21
←
Loop condition is true.  Entering loop body→
ap = filter[i];
iflp = NULL((void*)0);
ifcp = NULL((void*)0);
if (filtertype[i] == 'N' || filtertype[i] == 'T') {
22
←
Assuming the condition is true→
	iflp = ap;
	goto ifonly;
23
←
Control jumps to line 2903→
}
if ((p = strchr(ap, ',')) != NULL((void*)0)) {
	*p++ = '\0';
	iflp = p;
}
if ((p = strchr(ap, '/')) == NULL((void*)0)) {
	log_warnx("no prefixlen specified for '%s'", ap);
	fatalx("exiting");
	/*NOTREACHED*/
}
*p++ = '\0';
if (inet_pton(AF_INET624, ap, &ftmp.iff_addr) != 1) {
	log_warnx("invalid prefix specified for '%s'", ap);
	fatalx("exiting");
	/*NOTREACHED*/
}
errno(*__errno()) = 0;
ep = NULL((void*)0);
plen = strtoul(p, &ep, 10);
if (errno(*__errno()) || !*p || *ep || plen > sizeof(ftmp.iff_addr) * 8) {
	log_warnx("invalid prefix length specified for '%s'", ap);
	fatalx("exiting");
	/*NOTREACHED*/
}
ftmp.iff_plen = plen;
ftmp.iff_next = NULL((void*)0);
applyplen(&ftmp.iff_addr, ftmp.iff_plen);
2902ifonly:
ftmp.iff_type = filtertype[i];
if (iflp == NULL((void*)0) || *iflp == '\0') {
24
←
Assuming 'iflp' is not equal to NULL→
25
←
Assuming the condition is false→
26
←
Taking false branch→
	log_warnx("no interface specified for '%s'", ap);
	fatal("exiting");
	/*NOTREACHED*/
}
/* parse the interface listing portion */
while (iflp) {
27
←
Loop condition is true.  Entering loop body→
34
←
Loop condition is true.  Entering loop body→
41
←
Loop condition is false. Execution continues on line 2935→
	ifname = iflp;
	if ((iflp = strchr(iflp, ',')) != NULL((void*)0))
28
←
Assuming the condition is true→
29
←
Taking true branch→
35
←
Assuming pointer value is null→
36
←
Taking false branch→
		*iflp++ = '\0';
	ifcp = ifc_find(ifname);
	if (ifcp == NULL((void*)0)) {
30
←
Assuming 'ifcp' is not equal to NULL→
31
←
Taking false branch→
37
←
Assuming 'ifcp' is not equal to NULL→
38
←
Taking false branch→
		log_warnx("no interface %s exists", ifname);
		fatalx("exiting");
		/*NOTREACHED*/
	}
	iff_obj = malloc(sizeof(struct iff));
	if (iff_obj == NULL((void*)0)) {
32
←
Assuming 'iff_obj' is not equal to NULL→
33
←
Taking false branch→
39
←
Assuming 'iff_obj' is not equal to NULL→
40
←
Taking false branch→
		fatal("malloc of iff_obj");
		/*NOTREACHED*/
	}
	memcpy((void *)iff_obj, (void *)&ftmp,
	    sizeof(struct iff));
	/* link it to the interface filter */
	iff_obj->iff_next = ifcp->ifc_filter;
	ifcp->ifc_filter = iff_obj;
}

/*
 * -A: aggregate configuration.
 */
if (filtertype[i] != 'A')
42
←
Assuming the condition is false→
43
←
Taking false branch→
	continue;
/* put the aggregate to the kernel routing table */
rrt = calloc(1, sizeof(struct riprt));
if (rrt == NULL((void*)0)) {
44
←
Assuming 'rrt' is not equal to NULL→
45
←
Taking false branch→
	fatal("calloc: rrt");
	/*NOTREACHED*/
}
rrt->rrt_info.rip6_dest = ftmp.iff_addr;
rrt->rrt_info.rip6_plen = ftmp.iff_plen;
46
←
Assigned value is garbage or undefined
rrt->rrt_info.rip6_metric = 1;
rrt->rrt_info.rip6_tag = htons(routetag & 0xffff)(__uint16_t)(__builtin_constant_p(routetag & 0xffff) ? (__uint16_t
)(((__uint16_t)(routetag & 0xffff) & 0xffU) << 8
 | ((__uint16_t)(routetag & 0xffff) & 0xff00U) >>
 8) : __swap16md(routetag & 0xffff));
rrt->rrt_gw = in6addr_loopback;
rrt->rrt_flags = RTF_UP0x1 | RTF_REJECT0x8;
rrt->rrt_rflags = RRTF_AGGREGATE0x08000000;
rrt->rrt_t = 0;
rrt->rrt_index = loopifcp->ifc_index;
2952#if 0
if (getroute(&rrt->rrt_info, &gw)) {
2954#if 0
	/*
	 * When the address has already been registered in the
	 * kernel routing table, it should be removed 
	 */
	delroute(&rrt->rrt_info, &gw);
2960#else
	/* it is safer behavior */
	errno(*__errno()) = EINVAL22;
	fatal("%s/%u already in routing table, "
	    "cannot aggregate",
	    inet6_n2p(&rrt->rrt_info.rip6_dest),
	    rrt->rrt_info.rip6_plen);
	/*NOTREACHED*/
2968#endif
}
2970#endif
/* Put the route to the list */
rrt->rrt_next = riprt;
riprt = rrt;
log_debug("Aggregate: %s/%d for %s",
	inet6_n2p(&ftmp.iff_addr), ftmp.iff_plen,
	ifcp->ifc_name);
/* Add this route to the kernel */
if (nflag) 	/* do not modify kernel routing table */
	continue;
addroute(rrt, &in6addr_loopback, loopifcp);
}
2982}

2984/***************** utility functions *****************/

2986/*
* Returns a pointer to ifac whose address and prefix length matches
* with the address and prefix length specified in the arguments.
*/
2990struct ifac *
2991ifa_match(const struct ifc *ifcp, const struct in6_addr *ia, int plen)
2992{
struct ifac *ifa;

for (ifa = ifcp->ifc_addr; ifa; ifa = ifa->ifa_next) {
if (IN6_ARE_ADDR_EQUAL(&ifa->ifa_addr, ia)(memcmp(&(&ifa->ifa_addr)->__u6_addr.__u6_addr8
[0], &(ia)->__u6_addr.__u6_addr8[0], sizeof(struct in6_addr
)) == 0) &&
    ifa->ifa_plen == plen)
	break;
}
return ifa;
3001}

3003/*
* Return a pointer to riprt structure whose address and prefix length
* matches with the address and prefix length found in the argument.
* Note: This is not a rtalloc().  Therefore exact match is necessary.
*/
3008struct riprt *
3009rtsearch(struct	netinfo6 *np, struct riprt **prev_rrt)
3010{
struct	riprt	*rrt;

if (prev_rrt)
*prev_rrt = NULL((void*)0);
for (rrt = riprt; rrt; rrt = rrt->rrt_next) {
if (rrt->rrt_info.rip6_plen == np->rip6_plen &&
    IN6_ARE_ADDR_EQUAL(&rrt->rrt_info.rip6_dest,(memcmp(&(&rrt->rrt_info.rip6_dest)->__u6_addr.
__u6_addr8[0], &(&np->rip6_dest)->__u6_addr.__u6_addr8
[0], sizeof(struct in6_addr)) == 0)
		       &np->rip6_dest)(memcmp(&(&rrt->rrt_info.rip6_dest)->__u6_addr.
__u6_addr8[0], &(&np->rip6_dest)->__u6_addr.__u6_addr8
[0], sizeof(struct in6_addr)) == 0))
	return rrt;
if (prev_rrt)
	*prev_rrt = rrt;
}
if (prev_rrt)
*prev_rrt = NULL((void*)0);
return 0;
3026}

3028int
3029sin6mask2len(const struct sockaddr_in6 *sin6)
3030{

return mask2len(&sin6->sin6_addr,
   sin6->sin6_len - offsetof(struct sockaddr_in6, sin6_addr)__builtin_offsetof(struct sockaddr_in6, sin6_addr));
3034}

3036int
3037mask2len(const struct in6_addr *addr, int lenlim)
3038{
int i = 0, j;
const u_char *p = (const u_char *)addr;

for (j = 0; j < lenlim; j++, p++) {
if (*p != 0xff)
	break;
i += 8;
}
if (j < lenlim) {
switch (*p) {
3049#define	MASKLEN(m, l)	case m: do { i += l; break; } while (0)
MASKLEN(0xfe, 7); break;
MASKLEN(0xfc, 6); break;
MASKLEN(0xf8, 5); break;
MASKLEN(0xf0, 4); break;
MASKLEN(0xe0, 3); break;
MASKLEN(0xc0, 2); break;
MASKLEN(0x80, 1); break;
3057#undef	MASKLEN
}
}
return i;
3061}

3063void
3064applyplen(struct in6_addr *ia, int plen)
3065{
static const u_char plent[8] = {
0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe
};
u_char	*p;
int	i;

p = ia->s6_addr__u6_addr.__u6_addr8;
for (i = 0; i < 16; i++) {
if (plen <= 0)
	*p = 0;
else if (plen < 8)
	*p &= plent[plen];
p++, plen -= 8;
}
3080}

3082struct in6_addr *
3083plen2mask(int n)
3084{
static const int pl2m[9] = {
0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff
};
static struct in6_addr ia;
u_char	*p;
int	i;

memset(&ia, 0, sizeof(struct in6_addr));
p = (u_char *)&ia;
for (i = 0; i < 16; i++, p++, n -= 8) {
if (n >= 8) {
	*p = 0xff;
	continue;
}
*p = pl2m[n];
break;
}
return &ia;
3103}

3105char *
3106xstrdup(const char *p)
3107{
char *q;

q = strdup(p);
if (q == NULL((void*)0)) {
fatal("strdup");
/*NOTREACHED*/
}
return q;
3116}

3118const char *
3119hms(void)
3120{
static char buf[BUFSIZ1024];
time_t t;
struct	tm *tm;

t = time(NULL((void*)0));
if ((tm = localtime(&t)) == 0) {
fatal("localtime");
/*NOTREACHED*/
}
snprintf(buf, sizeof(buf), "%02d:%02d:%02d", tm->tm_hour, tm->tm_min,
   tm->tm_sec);
return buf;
3133}

3135#define	RIPRANDDEV1.0	1.0	/* 30 +- 15, max - min = 30 */

3137int
3138ripinterval(int timer)
3139{
double r = arc4random();
int interval;

interval = (int)(timer + timer * RIPRANDDEV1.0 * (r / UINT32_MAX0xffffffffU - 0.5));
nextalarm = time(NULL((void*)0)) + interval;
return interval;
3146}

3148time_t
3149ripsuptrig(void)
3150{
time_t t;

double r = arc4random();
t  = (int)(RIP_TRIG_INT6_MIN1 + 
(RIP_TRIG_INT6_MAX5 - RIP_TRIG_INT6_MIN1) * (r / UINT32_MAX0xffffffffU));
sup_trig_update = time(NULL((void*)0)) + t;
return t;
3158}

3160unsigned int
3161if_maxindex(void)
3162{
struct if_nameindex *p, *p0;
unsigned int max = 0;

p0 = if_nameindex();
for (p = p0; p && p->if_index && p->if_name; p++) {
if (max < p->if_index)
	max = p->if_index;
}
if_freenameindex(p0);
return max;
3173}

3175struct ifc *
3176ifc_find(char *name)
3177{
struct ifc *ifcp;

for (ifcp = ifc; ifcp; ifcp = ifcp->ifc_next) {
if (strcmp(name, ifcp->ifc_name) == 0)
	return ifcp;
}
return (struct ifc *)NULL((void*)0);
3185}

3187struct iff *
3188iff_find(struct ifc *ifcp, int type)
3189{
struct iff *iffp;

for (iffp = ifcp->ifc_filter; iffp; iffp = iffp->iff_next) {
if (iffp->iff_type == type)
	return iffp;
}
return NULL((void*)0);
3197}

3199void
3200setindex2ifc(int idx, struct ifc *ifcp)
3201{
int n;
struct ifc **p;

if (!index2ifc) {
nindex2ifc = 5;	/*initial guess*/
index2ifc = calloc(nindex2ifc, sizeof(*index2ifc));
if (index2ifc == NULL((void*)0)) {
	fatal("calloc");
	/*NOTREACHED*/
}
}
n = nindex2ifc;
while (nindex2ifc <= idx)
nindex2ifc *= 2;
if (n != nindex2ifc) {
p = reallocarray(index2ifc, nindex2ifc, sizeof(*index2ifc));
if (p == NULL((void*)0)) {
	fatal("reallocarray");
	/*NOTREACHED*/
}
memset(p + n, 0, (nindex2ifc - n) * sizeof(*index2ifc));
index2ifc = p;
}
index2ifc[idx] = ifcp;
3226}