1 /*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1983, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32 #include <stdint.h>
33
34 #include "defs.h"
35 #include "pathnames.h"
36 struct ifhead ifnet = LIST_HEAD_INITIALIZER(ifnet); /* all interfaces */
37 struct ifhead remote_if = LIST_HEAD_INITIALIZER(remote_if); /* remote interfaces */
38
39 /* hash table for all interfaces, big enough to tolerate ridiculous
40 * numbers of IP aliases. Crazy numbers of aliases such as 7000
41 * still will not do well, but not just in looking up interfaces
42 * by name or address.
43 */
44 #define AHASH_LEN 211 /* must be prime */
45 #define AHASH(a) &ahash_tbl[(a)%AHASH_LEN]
46 static struct interface *ahash_tbl[AHASH_LEN];
47
48 #define BHASH_LEN 211 /* must be prime */
49 #define BHASH(a) &bhash_tbl[(a)%BHASH_LEN]
50 static struct interface *bhash_tbl[BHASH_LEN];
51
52
53 /* hash for physical interface names.
54 * Assume there are never more 100 or 200 real interfaces, and that
55 * aliases are put on the end of the hash chains.
56 */
57 #define NHASH_LEN 97
58 static struct interface *nhash_tbl[NHASH_LEN];
59
60 int tot_interfaces; /* # of remote and local interfaces */
61 int rip_interfaces; /* # of interfaces doing RIP */
62 static int foundloopback; /* valid flag for loopaddr */
63 naddr loopaddr; /* our address on loopback */
64 static struct rt_spare loop_rts;
65
66 struct timeval ifinit_timer;
67 static struct timeval last_ifinit;
68 #define IF_RESCAN_DELAY() (last_ifinit.tv_sec == now.tv_sec \
69 && last_ifinit.tv_usec == now.tv_usec \
70 && timercmp(&ifinit_timer, &now, >))
71
72 int have_ripv1_out; /* have a RIPv1 interface */
73 static int have_ripv1_in;
74
75
76 static void if_bad(struct interface *);
77 static int addrouteforif(struct interface *);
78
79 static struct interface**
nhash(char * p)80 nhash(char *p)
81 {
82 u_int i;
83
84 for (i = 0; *p != '\0'; p++) {
85 i = ((i<<1) & 0x7fffffff) | ((i>>31) & 1);
86 i ^= *p;
87 }
88 return &nhash_tbl[i % NHASH_LEN];
89 }
90
91
92 /* Link a new interface into the lists and hash tables.
93 */
94 void
if_link(struct interface * ifp)95 if_link(struct interface *ifp)
96 {
97 struct interface **hifp;
98
99 LIST_INSERT_HEAD(&ifnet, ifp, int_list);
100
101 hifp = AHASH(ifp->int_addr);
102 ifp->int_ahash_prev = hifp;
103 if ((ifp->int_ahash = *hifp) != NULL)
104 (*hifp)->int_ahash_prev = &ifp->int_ahash;
105 *hifp = ifp;
106
107 if (ifp->int_if_flags & IFF_BROADCAST) {
108 hifp = BHASH(ifp->int_brdaddr);
109 ifp->int_bhash_prev = hifp;
110 if ((ifp->int_bhash = *hifp) != NULL)
111 (*hifp)->int_bhash_prev = &ifp->int_bhash;
112 *hifp = ifp;
113 }
114
115 if (ifp->int_state & IS_REMOTE)
116 LIST_INSERT_HEAD(&remote_if, ifp, remote_list);
117
118 hifp = nhash(ifp->int_name);
119 if (ifp->int_state & IS_ALIAS) {
120 /* put aliases on the end of the hash chain */
121 while (*hifp != NULL)
122 hifp = &(*hifp)->int_nhash;
123 }
124 ifp->int_nhash_prev = hifp;
125 if ((ifp->int_nhash = *hifp) != NULL)
126 (*hifp)->int_nhash_prev = &ifp->int_nhash;
127 *hifp = ifp;
128 }
129
130
131 /* Find the interface with an address
132 */
133 struct interface *
ifwithaddr(naddr addr,int bcast,int remote)134 ifwithaddr(naddr addr,
135 int bcast, /* notice IFF_BROADCAST address */
136 int remote) /* include IS_REMOTE interfaces */
137 {
138 struct interface *ifp, *possible = NULL;
139
140 remote = (remote == 0) ? IS_REMOTE : 0;
141
142 for (ifp = *AHASH(addr); ifp; ifp = ifp->int_ahash) {
143 if (ifp->int_addr != addr)
144 continue;
145 if ((ifp->int_state & remote) != 0)
146 continue;
147 if ((ifp->int_state & (IS_BROKE | IS_PASSIVE)) == 0)
148 return ifp;
149 possible = ifp;
150 }
151
152 if (possible || !bcast)
153 return possible;
154
155 for (ifp = *BHASH(addr); ifp; ifp = ifp->int_bhash) {
156 if (ifp->int_brdaddr != addr)
157 continue;
158 if ((ifp->int_state & remote) != 0)
159 continue;
160 if ((ifp->int_state & (IS_BROKE | IS_PASSIVE)) == 0)
161 return ifp;
162 possible = ifp;
163 }
164
165 return possible;
166 }
167
168
169 /* find the interface with a name
170 */
171 static struct interface *
ifwithname(char * name,naddr addr)172 ifwithname(char *name, /* "ec0" or whatever */
173 naddr addr) /* 0 or network address */
174 {
175 struct interface *ifp;
176
177 for (;;) {
178 for (ifp = *nhash(name); ifp != NULL; ifp = ifp->int_nhash) {
179 /* If the network address is not specified,
180 * ignore any alias interfaces. Otherwise, look
181 * for the interface with the target name and address.
182 */
183 if (!strcmp(ifp->int_name, name)
184 && ((addr == 0 && !(ifp->int_state & IS_ALIAS))
185 || (ifp->int_addr == addr)))
186 return ifp;
187 }
188
189 /* If there is no known interface, maybe there is a
190 * new interface. So just once look for new interfaces.
191 */
192 if (IF_RESCAN_DELAY())
193 return 0;
194 ifinit();
195 }
196 }
197
198
199 struct interface *
ifwithindex(u_short ifindex,int rescan_ok)200 ifwithindex(u_short ifindex,
201 int rescan_ok)
202 {
203 struct interface *ifp;
204
205 for (;;) {
206 LIST_FOREACH(ifp, &ifnet, int_list) {
207 if (ifp->int_index == ifindex)
208 return ifp;
209 }
210
211 /* If there is no known interface, maybe there is a
212 * new interface. So just once look for new interfaces.
213 */
214 if (!rescan_ok
215 || IF_RESCAN_DELAY())
216 return 0;
217 ifinit();
218 }
219 }
220
221
222 /* Find an interface from which the specified address
223 * should have come from. Used for figuring out which
224 * interface a packet came in on.
225 */
226 struct interface *
iflookup(naddr addr)227 iflookup(naddr addr)
228 {
229 struct interface *ifp, *maybe;
230 int once = 0;
231
232 maybe = NULL;
233 for (;;) {
234 LIST_FOREACH(ifp, &ifnet, int_list) {
235 if (ifp->int_if_flags & IFF_POINTOPOINT) {
236 /* finished with a match */
237 if (ifp->int_dstaddr == addr)
238 return ifp;
239
240 } else {
241 /* finished with an exact match */
242 if (ifp->int_addr == addr)
243 return ifp;
244
245 /* Look for the longest approximate match.
246 */
247 if (on_net(addr, ifp->int_net, ifp->int_mask)
248 && (maybe == NULL
249 || ifp->int_mask > maybe->int_mask))
250 maybe = ifp;
251 }
252 }
253
254 if (maybe != NULL || once || IF_RESCAN_DELAY())
255 return maybe;
256 once = 1;
257
258 /* If there is no known interface, maybe there is a
259 * new interface. So just once look for new interfaces.
260 */
261 ifinit();
262 }
263 }
264
265
266 /* Return the classical netmask for an IP address.
267 */
268 naddr /* host byte order */
std_mask(naddr addr)269 std_mask(naddr addr) /* network byte order */
270 {
271 addr = ntohl(addr); /* was a host, not a network */
272
273 if (addr == 0) /* default route has mask 0 */
274 return 0;
275 if (IN_CLASSA(addr))
276 return IN_CLASSA_NET;
277 if (IN_CLASSB(addr))
278 return IN_CLASSB_NET;
279 return IN_CLASSC_NET;
280 }
281
282
283 /* Find the netmask that would be inferred by RIPv1 listeners
284 * on the given interface for a given network.
285 * If no interface is specified, look for the best fitting interface.
286 */
287 naddr
ripv1_mask_net(naddr addr,struct interface * ifp)288 ripv1_mask_net(naddr addr, /* in network byte order */
289 struct interface *ifp) /* as seen on this interface */
290 {
291 struct r1net *r1p;
292 naddr mask = 0;
293
294 if (addr == 0) /* default always has 0 mask */
295 return mask;
296
297 if (ifp != NULL && ifp->int_ripv1_mask != HOST_MASK) {
298 /* If the target network is that of the associated interface
299 * on which it arrived, then use the netmask of the interface.
300 */
301 if (on_net(addr, ifp->int_net, ifp->int_std_mask))
302 mask = ifp->int_ripv1_mask;
303
304 } else {
305 /* Examine all interfaces, and if it the target seems
306 * to have the same network number of an interface, use the
307 * netmask of that interface. If there is more than one
308 * such interface, prefer the interface with the longest
309 * match.
310 */
311 LIST_FOREACH(ifp, &ifnet, int_list) {
312 if (on_net(addr, ifp->int_std_net, ifp->int_std_mask)
313 && ifp->int_ripv1_mask > mask
314 && ifp->int_ripv1_mask != HOST_MASK)
315 mask = ifp->int_ripv1_mask;
316 }
317
318 }
319
320 /* check special definitions */
321 if (mask == 0) {
322 for (r1p = r1nets; r1p != NULL; r1p = r1p->r1net_next) {
323 if (on_net(addr, r1p->r1net_net, r1p->r1net_match)
324 && r1p->r1net_mask > mask)
325 mask = r1p->r1net_mask;
326 }
327
328 /* Otherwise, make the classic A/B/C guess.
329 */
330 if (mask == 0)
331 mask = std_mask(addr);
332 }
333
334 return mask;
335 }
336
337
338 naddr
ripv1_mask_host(naddr addr,struct interface * ifp)339 ripv1_mask_host(naddr addr, /* in network byte order */
340 struct interface *ifp) /* as seen on this interface */
341 {
342 naddr mask = ripv1_mask_net(addr, ifp);
343
344
345 /* If the computed netmask does not mask the address,
346 * then assume it is a host address
347 */
348 if ((ntohl(addr) & ~mask) != 0)
349 mask = HOST_MASK;
350 return mask;
351 }
352
353
354 /* See if an IP address looks reasonable as a destination.
355 */
356 int /* 0=bad */
check_dst(naddr addr)357 check_dst(naddr addr)
358 {
359 addr = ntohl(addr);
360
361 if (IN_CLASSA(addr)) {
362 if (addr == 0)
363 return 1; /* default */
364
365 addr >>= IN_CLASSA_NSHIFT;
366 return (addr != 0 && addr != IN_LOOPBACKNET);
367 }
368
369 return (IN_CLASSB(addr) || IN_CLASSC(addr));
370 }
371
372
373 /* See a new interface duplicates an existing interface.
374 */
375 struct interface *
check_dup(naddr addr,naddr dstaddr,naddr mask,int if_flags)376 check_dup(naddr addr, /* IP address, so network byte order */
377 naddr dstaddr, /* ditto */
378 naddr mask, /* mask, so host byte order */
379 int if_flags)
380 {
381 struct interface *ifp;
382
383 LIST_FOREACH(ifp, &ifnet, int_list) {
384 if (ifp->int_mask != mask)
385 continue;
386
387 if (!iff_up(ifp->int_if_flags))
388 continue;
389
390 /* The local address can only be shared with a point-to-point
391 * link.
392 */
393 if ((!(ifp->int_state & IS_REMOTE) || !(if_flags & IS_REMOTE))
394 && ifp->int_addr == addr
395 && (((if_flags|ifp->int_if_flags) & IFF_POINTOPOINT) == 0))
396 return ifp;
397
398 if (on_net(ifp->int_dstaddr, ntohl(dstaddr),mask))
399 return ifp;
400 }
401 return 0;
402 }
403
404
405 /* See that a remote gateway is reachable.
406 * Note that the answer can change as real interfaces come and go.
407 */
408 int /* 0=bad */
check_remote(struct interface * ifp)409 check_remote(struct interface *ifp)
410 {
411 struct rt_entry *rt;
412
413 /* do not worry about other kinds */
414 if (!(ifp->int_state & IS_REMOTE))
415 return 1;
416
417 rt = rtfind(ifp->int_addr);
418 if (rt != NULL
419 && rt->rt_ifp != 0
420 &&on_net(ifp->int_addr,
421 rt->rt_ifp->int_net, rt->rt_ifp->int_mask))
422 return 1;
423
424 /* the gateway cannot be reached directly from one of our
425 * interfaces
426 */
427 if (!(ifp->int_state & IS_BROKE)) {
428 msglog("unreachable gateway %s in "_PATH_GATEWAYS,
429 naddr_ntoa(ifp->int_addr));
430 if_bad(ifp);
431 }
432 return 0;
433 }
434
435
436 /* Delete an interface.
437 */
438 static void
ifdel(struct interface * ifp)439 ifdel(struct interface *ifp)
440 {
441 struct interface *ifp1;
442
443
444 trace_if("Del", ifp);
445
446 ifp->int_state |= IS_BROKE;
447
448 LIST_REMOVE(ifp, int_list);
449 *ifp->int_ahash_prev = ifp->int_ahash;
450 if (ifp->int_ahash != 0)
451 ifp->int_ahash->int_ahash_prev = ifp->int_ahash_prev;
452 *ifp->int_nhash_prev = ifp->int_nhash;
453 if (ifp->int_nhash != 0)
454 ifp->int_nhash->int_nhash_prev = ifp->int_nhash_prev;
455 if (ifp->int_if_flags & IFF_BROADCAST) {
456 *ifp->int_bhash_prev = ifp->int_bhash;
457 if (ifp->int_bhash != 0)
458 ifp->int_bhash->int_bhash_prev = ifp->int_bhash_prev;
459 }
460 if (ifp->int_state & IS_REMOTE)
461 LIST_REMOVE(ifp, remote_list);
462
463 if (!(ifp->int_state & IS_ALIAS)) {
464 /* delete aliases when the main interface dies
465 */
466 LIST_FOREACH(ifp1, &ifnet, int_list) {
467 if (ifp1 != ifp
468 && !strcmp(ifp->int_name, ifp1->int_name))
469 ifdel(ifp1);
470 }
471
472 if ((ifp->int_if_flags & IFF_MULTICAST) && rip_sock >= 0) {
473 struct group_req gr;
474 struct sockaddr_in *sin;
475
476 memset(&gr, 0, sizeof(gr));
477 gr.gr_interface = ifp->int_index;
478 sin = (struct sockaddr_in *)&gr.gr_group;
479 sin->sin_family = AF_INET;
480 #ifdef _HAVE_SIN_LEN
481 sin->sin_len = sizeof(struct sockaddr_in);
482 #endif
483 sin->sin_addr.s_addr = htonl(INADDR_RIP_GROUP);
484 if (setsockopt(rip_sock, IPPROTO_IP, MCAST_LEAVE_GROUP,
485 &gr, sizeof(gr)) < 0
486 && errno != EADDRNOTAVAIL
487 && !TRACEACTIONS)
488 LOGERR("setsockopt(MCAST_LEAVE_GROUP RIP)");
489 if (rip_sock_mcast == ifp)
490 rip_sock_mcast = NULL;
491 }
492 if (ifp->int_rip_sock >= 0) {
493 (void)close(ifp->int_rip_sock);
494 ifp->int_rip_sock = -1;
495 fix_select();
496 }
497
498 tot_interfaces--;
499 if (!IS_RIP_OFF(ifp->int_state))
500 rip_interfaces--;
501
502 /* Zap all routes associated with this interface.
503 * Assume routes just using gateways beyond this interface
504 * will timeout naturally, and have probably already died.
505 */
506 (void)rn_walktree(rhead, walk_bad, 0);
507
508 set_rdisc_mg(ifp, 0);
509 if_bad_rdisc(ifp);
510 }
511
512 free(ifp);
513 }
514
515
516 /* Mark an interface ill.
517 */
518 void
if_sick(struct interface * ifp)519 if_sick(struct interface *ifp)
520 {
521 if (0 == (ifp->int_state & (IS_SICK | IS_BROKE))) {
522 ifp->int_state |= IS_SICK;
523 ifp->int_act_time = NEVER;
524 trace_if("Chg", ifp);
525
526 LIM_SEC(ifinit_timer, now.tv_sec+CHECK_BAD_INTERVAL);
527 }
528 }
529
530
531 /* Mark an interface dead.
532 */
533 static void
if_bad(struct interface * ifp)534 if_bad(struct interface *ifp)
535 {
536 struct interface *ifp1;
537
538
539 if (ifp->int_state & IS_BROKE)
540 return;
541
542 LIM_SEC(ifinit_timer, now.tv_sec+CHECK_BAD_INTERVAL);
543
544 ifp->int_state |= (IS_BROKE | IS_SICK);
545 ifp->int_act_time = NEVER;
546 ifp->int_query_time = NEVER;
547 ifp->int_data.ts = now.tv_sec;
548
549 trace_if("Chg", ifp);
550
551 if (!(ifp->int_state & IS_ALIAS)) {
552 LIST_FOREACH(ifp1, &ifnet, int_list) {
553 if (ifp1 != ifp
554 && !strcmp(ifp->int_name, ifp1->int_name))
555 if_bad(ifp1);
556 }
557 (void)rn_walktree(rhead, walk_bad, 0);
558 if_bad_rdisc(ifp);
559 }
560 }
561
562
563 /* Mark an interface alive
564 */
565 int /* 1=it was dead */
if_ok(struct interface * ifp,const char * type)566 if_ok(struct interface *ifp,
567 const char *type)
568 {
569 struct interface *ifp1;
570
571
572 if (!(ifp->int_state & IS_BROKE)) {
573 if (ifp->int_state & IS_SICK) {
574 trace_act("%sinterface %s to %s working better",
575 type,
576 ifp->int_name, naddr_ntoa(ifp->int_dstaddr));
577 ifp->int_state &= ~IS_SICK;
578 }
579 return 0;
580 }
581
582 msglog("%sinterface %s to %s restored",
583 type, ifp->int_name, naddr_ntoa(ifp->int_dstaddr));
584 ifp->int_state &= ~(IS_BROKE | IS_SICK);
585 ifp->int_data.ts = 0;
586
587 if (!(ifp->int_state & IS_ALIAS)) {
588 LIST_FOREACH(ifp1, &ifnet, int_list) {
589 if (ifp1 != ifp
590 && !strcmp(ifp->int_name, ifp1->int_name))
591 if_ok(ifp1, type);
592 }
593 if_ok_rdisc(ifp);
594 }
595
596 if (ifp->int_state & IS_REMOTE) {
597 if (!addrouteforif(ifp))
598 return 0;
599 }
600 return 1;
601 }
602
603
604 /* disassemble routing message
605 */
606 void
rt_xaddrs(struct rt_addrinfo * info,struct sockaddr * sa,struct sockaddr * lim,int addrs)607 rt_xaddrs(struct rt_addrinfo *info,
608 struct sockaddr *sa,
609 struct sockaddr *lim,
610 int addrs)
611 {
612 int i;
613 #ifdef _HAVE_SA_LEN
614 static struct sockaddr sa_zero;
615 #endif
616
617 memset(info, 0, sizeof(*info));
618 info->rti_addrs = addrs;
619 for (i = 0; i < RTAX_MAX && sa < lim; i++) {
620 if ((addrs & (1 << i)) == 0)
621 continue;
622 info->rti_info[i] = (sa->sa_len != 0) ? sa : &sa_zero;
623 sa = (struct sockaddr *)((char*)(sa) + SA_SIZE(sa));
624 }
625 }
626
627
628 /* Find the network interfaces which have configured themselves.
629 * This must be done regularly, if only for extra addresses
630 * that come and go on interfaces.
631 */
632 void
ifinit(void)633 ifinit(void)
634 {
635 static struct ifa_msghdr *sysctl_buf;
636 static size_t sysctl_buf_size = 0;
637 uint complaints = 0;
638 static u_int prev_complaints = 0;
639 # define COMP_NOT_INET 0x001
640 # define COMP_NOADDR 0x002
641 # define COMP_BADADDR 0x004
642 # define COMP_NODST 0x008
643 # define COMP_NOBADR 0x010
644 # define COMP_NOMASK 0x020
645 # define COMP_DUP 0x040
646 # define COMP_BAD_METRIC 0x080
647 # define COMP_NETMASK 0x100
648
649 struct interface ifs, ifs0, *ifp, *ifp1;
650 struct rt_entry *rt;
651 size_t needed;
652 int mib[6];
653 struct if_msghdr *ifm;
654 void *ifam_lim;
655 struct ifa_msghdr *ifam, *ifam2;
656 int in, ierr, out, oerr;
657 struct intnet *intnetp;
658 struct rt_addrinfo info;
659 #ifdef SIOCGIFMETRIC
660 struct ifreq ifr;
661 #endif
662
663
664 last_ifinit = now;
665 ifinit_timer.tv_sec = now.tv_sec + (supplier
666 ? CHECK_ACT_INTERVAL
667 : CHECK_QUIET_INTERVAL);
668
669 /* mark all interfaces so we can get rid of those that disappear */
670 LIST_FOREACH(ifp, &ifnet, int_list)
671 ifp->int_state &= ~(IS_CHECKED | IS_DUP);
672
673 /* Fetch the interface list, without too many system calls
674 * since we do it repeatedly.
675 */
676 mib[0] = CTL_NET;
677 mib[1] = PF_ROUTE;
678 mib[2] = 0;
679 mib[3] = AF_INET;
680 mib[4] = NET_RT_IFLIST;
681 mib[5] = 0;
682 for (;;) {
683 if ((needed = sysctl_buf_size) != 0) {
684 if (sysctl(mib, 6, sysctl_buf,&needed, 0, 0) >= 0)
685 break;
686 /* retry if the table grew */
687 if (errno != ENOMEM && errno != EFAULT)
688 BADERR(1, "ifinit: sysctl(RT_IFLIST)");
689 free(sysctl_buf);
690 needed = 0;
691 }
692 if (sysctl(mib, 6, 0, &needed, 0, 0) < 0)
693 BADERR(1,"ifinit: sysctl(RT_IFLIST) estimate");
694 sysctl_buf = rtmalloc(sysctl_buf_size = needed,
695 "ifinit sysctl");
696 }
697
698 /* XXX: thanks to malloc(3), alignment can be presumed OK */
699 ifam_lim = (char *)sysctl_buf + needed;
700 for (ifam = sysctl_buf; (void *)ifam < ifam_lim; ifam = ifam2) {
701
702 ifam2 = (struct ifa_msghdr*)((char*)ifam + ifam->ifam_msglen);
703
704 #ifdef RTM_OIFINFO
705 if (ifam->ifam_type == RTM_OIFINFO)
706 continue; /* just ignore compat message */
707 #endif
708 if (ifam->ifam_type == RTM_IFINFO) {
709 struct sockaddr_dl *sdl;
710
711 ifm = (struct if_msghdr *)ifam;
712 /* make prototype structure for the IP aliases
713 */
714 memset(&ifs0, 0, sizeof(ifs0));
715 ifs0.int_rip_sock = -1;
716 ifs0.int_index = ifm->ifm_index;
717 ifs0.int_if_flags = ifm->ifm_flags;
718 ifs0.int_state = IS_CHECKED;
719 ifs0.int_query_time = NEVER;
720 ifs0.int_act_time = now.tv_sec;
721 ifs0.int_data.ts = now.tv_sec;
722 ifs0.int_data.ipackets = ifm->ifm_data.ifi_ipackets;
723 ifs0.int_data.ierrors = ifm->ifm_data.ifi_ierrors;
724 ifs0.int_data.opackets = ifm->ifm_data.ifi_opackets;
725 ifs0.int_data.oerrors = ifm->ifm_data.ifi_oerrors;
726 sdl = (struct sockaddr_dl *)(ifm + 1);
727 sdl->sdl_data[sdl->sdl_nlen] = 0;
728 strncpy(ifs0.int_name, sdl->sdl_data,
729 MIN(sizeof(ifs0.int_name), sdl->sdl_nlen));
730 continue;
731 }
732 if (ifam->ifam_type != RTM_NEWADDR) {
733 logbad(1,"ifinit: out of sync");
734 continue;
735 }
736 rt_xaddrs(&info, (struct sockaddr *)(ifam+1),
737 (struct sockaddr *)ifam2,
738 ifam->ifam_addrs);
739
740 /* Prepare for the next address of this interface, which
741 * will be an alias.
742 * Do not output RIP or Router-Discovery packets via aliases.
743 */
744 memcpy(&ifs, &ifs0, sizeof(ifs));
745 ifs0.int_state |= (IS_ALIAS | IS_NO_RIP_OUT | IS_NO_RDISC);
746
747 if (INFO_IFA(&info) == 0) {
748 if (iff_up(ifs.int_if_flags)) {
749 if (!(prev_complaints & COMP_NOADDR))
750 msglog("%s has no address",
751 ifs.int_name);
752 complaints |= COMP_NOADDR;
753 }
754 continue;
755 }
756 if (INFO_IFA(&info)->sa_family != AF_INET) {
757 if (iff_up(ifs.int_if_flags)) {
758 if (!(prev_complaints & COMP_NOT_INET))
759 trace_act("%s: not AF_INET",
760 ifs.int_name);
761 complaints |= COMP_NOT_INET;
762 }
763 continue;
764 }
765
766 ifs.int_addr = S_ADDR(INFO_IFA(&info));
767
768 if (ntohl(ifs.int_addr)>>24 == 0
769 || ntohl(ifs.int_addr)>>24 == 0xff) {
770 if (iff_up(ifs.int_if_flags)) {
771 if (!(prev_complaints & COMP_BADADDR))
772 msglog("%s has a bad address",
773 ifs.int_name);
774 complaints |= COMP_BADADDR;
775 }
776 continue;
777 }
778
779 if (ifs.int_if_flags & IFF_LOOPBACK) {
780 ifs.int_state |= IS_NO_RIP | IS_NO_RDISC;
781 if (ifs.int_addr == htonl(INADDR_LOOPBACK))
782 ifs.int_state |= IS_PASSIVE;
783 ifs.int_dstaddr = ifs.int_addr;
784 ifs.int_mask = HOST_MASK;
785 ifs.int_ripv1_mask = HOST_MASK;
786 ifs.int_std_mask = std_mask(ifs.int_dstaddr);
787 ifs.int_net = ntohl(ifs.int_dstaddr);
788 if (!foundloopback) {
789 foundloopback = 1;
790 loopaddr = ifs.int_addr;
791 loop_rts.rts_gate = loopaddr;
792 loop_rts.rts_router = loopaddr;
793 }
794
795 } else if (ifs.int_if_flags & IFF_POINTOPOINT) {
796 if (INFO_BRD(&info) == 0
797 || INFO_BRD(&info)->sa_family != AF_INET) {
798 if (iff_up(ifs.int_if_flags)) {
799 if (!(prev_complaints & COMP_NODST))
800 msglog("%s has a bad"
801 " destination address",
802 ifs.int_name);
803 complaints |= COMP_NODST;
804 }
805 continue;
806 }
807 ifs.int_dstaddr = S_ADDR(INFO_BRD(&info));
808 if (ntohl(ifs.int_dstaddr)>>24 == 0
809 || ntohl(ifs.int_dstaddr)>>24 == 0xff) {
810 if (iff_up(ifs.int_if_flags)) {
811 if (!(prev_complaints & COMP_NODST))
812 msglog("%s has a bad"
813 " destination address",
814 ifs.int_name);
815 complaints |= COMP_NODST;
816 }
817 continue;
818 }
819 ifs.int_mask = HOST_MASK;
820 ifs.int_ripv1_mask = ntohl(S_ADDR(INFO_MASK(&info)));
821 ifs.int_std_mask = std_mask(ifs.int_dstaddr);
822 ifs.int_net = ntohl(ifs.int_dstaddr);
823
824 } else {
825 if (INFO_MASK(&info) == 0) {
826 if (iff_up(ifs.int_if_flags)) {
827 if (!(prev_complaints & COMP_NOMASK))
828 msglog("%s has no netmask",
829 ifs.int_name);
830 complaints |= COMP_NOMASK;
831 }
832 continue;
833 }
834 ifs.int_dstaddr = ifs.int_addr;
835 ifs.int_mask = ntohl(S_ADDR(INFO_MASK(&info)));
836 ifs.int_ripv1_mask = ifs.int_mask;
837 ifs.int_std_mask = std_mask(ifs.int_addr);
838 ifs.int_net = ntohl(ifs.int_addr) & ifs.int_mask;
839 if (ifs.int_mask != ifs.int_std_mask)
840 ifs.int_state |= IS_SUBNET;
841
842 if (ifs.int_if_flags & IFF_BROADCAST) {
843 if (INFO_BRD(&info) == 0) {
844 if (iff_up(ifs.int_if_flags)) {
845 if (!(prev_complaints
846 & COMP_NOBADR))
847 msglog("%s has"
848 "no broadcast address",
849 ifs.int_name);
850 complaints |= COMP_NOBADR;
851 }
852 continue;
853 }
854 ifs.int_brdaddr = S_ADDR(INFO_BRD(&info));
855 }
856 }
857 ifs.int_std_net = ifs.int_net & ifs.int_std_mask;
858 ifs.int_std_addr = htonl(ifs.int_std_net);
859
860 /* Use a minimum metric of one. Treat the interface metric
861 * (default 0) as an increment to the hop count of one.
862 *
863 * The metric obtained from the routing socket dump of
864 * interface addresses is wrong. It is not set by the
865 * SIOCSIFMETRIC ioctl.
866 */
867 #ifdef SIOCGIFMETRIC
868 strncpy(ifr.ifr_name, ifs.int_name, sizeof(ifr.ifr_name));
869 if (ioctl(rt_sock, SIOCGIFMETRIC, &ifr) < 0) {
870 DBGERR(1, "ioctl(SIOCGIFMETRIC)");
871 ifs.int_metric = 0;
872 } else {
873 ifs.int_metric = ifr.ifr_metric;
874 }
875 #else
876 ifs.int_metric = ifam->ifam_metric;
877 #endif
878 if (ifs.int_metric > HOPCNT_INFINITY) {
879 ifs.int_metric = 0;
880 if (!(prev_complaints & COMP_BAD_METRIC)
881 && iff_up(ifs.int_if_flags)) {
882 complaints |= COMP_BAD_METRIC;
883 msglog("%s has a metric of %d",
884 ifs.int_name, ifs.int_metric);
885 }
886 }
887
888 /* See if this is a familiar interface.
889 * If so, stop worrying about it if it is the same.
890 * Start it over if it now is to somewhere else, as happens
891 * frequently with PPP and SLIP.
892 */
893 ifp = ifwithname(ifs.int_name, ((ifs.int_state & IS_ALIAS)
894 ? ifs.int_addr
895 : 0));
896 if (ifp != NULL) {
897 ifp->int_state |= IS_CHECKED;
898
899 if (0 != ((ifp->int_if_flags ^ ifs.int_if_flags)
900 & (IFF_BROADCAST
901 | IFF_LOOPBACK
902 | IFF_POINTOPOINT
903 | IFF_MULTICAST))
904 || 0 != ((ifp->int_state ^ ifs.int_state)
905 & IS_ALIAS)
906 || ifp->int_addr != ifs.int_addr
907 || ifp->int_brdaddr != ifs.int_brdaddr
908 || ifp->int_dstaddr != ifs.int_dstaddr
909 || ifp->int_mask != ifs.int_mask
910 || ifp->int_metric != ifs.int_metric) {
911 /* Forget old information about
912 * a changed interface.
913 */
914 trace_act("interface %s has changed",
915 ifp->int_name);
916 ifdel(ifp);
917 ifp = NULL;
918 }
919 }
920
921 if (ifp != NULL) {
922 /* The primary representative of an alias worries
923 * about how things are working.
924 */
925 if (ifp->int_state & IS_ALIAS)
926 continue;
927
928 /* note interfaces that have been turned off
929 */
930 if (!iff_up(ifs.int_if_flags)) {
931 if (iff_up(ifp->int_if_flags)) {
932 msglog("interface %s to %s turned off",
933 ifp->int_name,
934 naddr_ntoa(ifp->int_dstaddr));
935 if_bad(ifp);
936 ifp->int_if_flags &= ~IFF_UP;
937 } else if (now.tv_sec>(ifp->int_data.ts
938 + CHECK_BAD_INTERVAL)) {
939 trace_act("interface %s has been off"
940 " %jd seconds; forget it",
941 ifp->int_name,
942 (intmax_t)now.tv_sec -
943 ifp->int_data.ts);
944 ifdel(ifp);
945 ifp = NULL;
946 }
947 continue;
948 }
949 /* or that were off and are now ok */
950 if (!iff_up(ifp->int_if_flags)) {
951 ifp->int_if_flags |= IFF_UP;
952 (void)if_ok(ifp, "");
953 }
954
955 /* If it has been long enough,
956 * see if the interface is broken.
957 */
958 if (now.tv_sec < ifp->int_data.ts+CHECK_BAD_INTERVAL)
959 continue;
960
961 in = ifs.int_data.ipackets - ifp->int_data.ipackets;
962 ierr = ifs.int_data.ierrors - ifp->int_data.ierrors;
963 out = ifs.int_data.opackets - ifp->int_data.opackets;
964 oerr = ifs.int_data.oerrors - ifp->int_data.oerrors;
965 /* If the interface just awoke, restart the counters.
966 */
967 if (ifp->int_data.ts == 0) {
968 ifp->int_data = ifs.int_data;
969 continue;
970 }
971 ifp->int_data = ifs.int_data;
972
973 /* Withhold judgment when the short error
974 * counters wrap or the interface is reset.
975 */
976 if (ierr < 0 || in < 0 || oerr < 0 || out < 0) {
977 LIM_SEC(ifinit_timer,
978 now.tv_sec+CHECK_BAD_INTERVAL);
979 continue;
980 }
981
982 /* Withhold judgement when there is no traffic
983 */
984 if (in == 0 && out == 0 && ierr == 0 && oerr == 0)
985 continue;
986
987 /* It is bad if input or output is not working.
988 * Require presistent problems before marking it dead.
989 */
990 if ((in <= ierr && ierr > 0)
991 || (out <= oerr && oerr > 0)) {
992 if (!(ifp->int_state & IS_SICK)) {
993 trace_act("interface %s to %s"
994 " sick: in=%d ierr=%d"
995 " out=%d oerr=%d",
996 ifp->int_name,
997 naddr_ntoa(ifp->int_dstaddr),
998 in, ierr, out, oerr);
999 if_sick(ifp);
1000 continue;
1001 }
1002 if (!(ifp->int_state & IS_BROKE)) {
1003 msglog("interface %s to %s broken:"
1004 " in=%d ierr=%d out=%d oerr=%d",
1005 ifp->int_name,
1006 naddr_ntoa(ifp->int_dstaddr),
1007 in, ierr, out, oerr);
1008 if_bad(ifp);
1009 }
1010 continue;
1011 }
1012
1013 /* otherwise, it is active and healthy
1014 */
1015 ifp->int_act_time = now.tv_sec;
1016 (void)if_ok(ifp, "");
1017 continue;
1018 }
1019
1020 /* This is a new interface.
1021 * If it is dead, forget it.
1022 */
1023 if (!iff_up(ifs.int_if_flags))
1024 continue;
1025
1026 /* If it duplicates an existing interface,
1027 * complain about it, mark the other one
1028 * duplicated, and forget this one.
1029 */
1030 ifp = check_dup(ifs.int_addr,ifs.int_dstaddr,ifs.int_mask,
1031 ifs.int_if_flags);
1032 if (ifp != NULL) {
1033 /* Ignore duplicates of itself, caused by having
1034 * IP aliases on the same network.
1035 */
1036 if (!strcmp(ifp->int_name, ifs.int_name))
1037 continue;
1038
1039 if (!(prev_complaints & COMP_DUP)) {
1040 complaints |= COMP_DUP;
1041 msglog("%s (%s%s%s) is duplicated by"
1042 " %s (%s%s%s)",
1043 ifs.int_name,
1044 addrname(ifs.int_addr,ifs.int_mask,1),
1045 ((ifs.int_if_flags & IFF_POINTOPOINT)
1046 ? "-->" : ""),
1047 ((ifs.int_if_flags & IFF_POINTOPOINT)
1048 ? naddr_ntoa(ifs.int_dstaddr) : ""),
1049 ifp->int_name,
1050 addrname(ifp->int_addr,ifp->int_mask,1),
1051 ((ifp->int_if_flags & IFF_POINTOPOINT)
1052 ? "-->" : ""),
1053 ((ifp->int_if_flags & IFF_POINTOPOINT)
1054 ? naddr_ntoa(ifp->int_dstaddr) : ""));
1055 }
1056 ifp->int_state |= IS_DUP;
1057 continue;
1058 }
1059
1060 if (0 == (ifs.int_if_flags & (IFF_POINTOPOINT | IFF_BROADCAST | IFF_LOOPBACK))) {
1061 trace_act("%s is neither broadcast, point-to-point,"
1062 " nor loopback",
1063 ifs.int_name);
1064 if (!(ifs.int_state & IFF_MULTICAST))
1065 ifs.int_state |= IS_NO_RDISC;
1066 }
1067
1068
1069 /* It is new and ok. Add it to the list of interfaces
1070 */
1071 ifp = (struct interface *)rtmalloc(sizeof(*ifp), "ifinit ifp");
1072 memcpy(ifp, &ifs, sizeof(*ifp));
1073 get_parms(ifp);
1074 if_link(ifp);
1075 trace_if("Add", ifp);
1076
1077 /* Notice likely bad netmask.
1078 */
1079 if (!(prev_complaints & COMP_NETMASK)
1080 && !(ifp->int_if_flags & IFF_POINTOPOINT)
1081 && ifp->int_addr != RIP_DEFAULT) {
1082 LIST_FOREACH(ifp1, &ifnet, int_list) {
1083 if (ifp1->int_mask == ifp->int_mask)
1084 continue;
1085 if (ifp1->int_if_flags & IFF_POINTOPOINT)
1086 continue;
1087 if (ifp1->int_dstaddr == RIP_DEFAULT)
1088 continue;
1089 /* ignore aliases on the right network */
1090 if (!strcmp(ifp->int_name, ifp1->int_name))
1091 continue;
1092 if (on_net(ifp->int_dstaddr,
1093 ifp1->int_net, ifp1->int_mask)
1094 || on_net(ifp1->int_dstaddr,
1095 ifp->int_net, ifp->int_mask)) {
1096 msglog("possible netmask problem"
1097 " between %s:%s and %s:%s",
1098 ifp->int_name,
1099 addrname(htonl(ifp->int_net),
1100 ifp->int_mask, 1),
1101 ifp1->int_name,
1102 addrname(htonl(ifp1->int_net),
1103 ifp1->int_mask, 1));
1104 complaints |= COMP_NETMASK;
1105 }
1106 }
1107 }
1108
1109 if (!(ifp->int_state & IS_ALIAS)) {
1110 /* Count the # of directly connected networks.
1111 */
1112 if (!(ifp->int_if_flags & IFF_LOOPBACK))
1113 tot_interfaces++;
1114 if (!IS_RIP_OFF(ifp->int_state))
1115 rip_interfaces++;
1116
1117 /* turn on router discovery and RIP If needed */
1118 if_ok_rdisc(ifp);
1119 rip_on(ifp);
1120 }
1121 }
1122
1123 /* If we are multi-homed and have at least two interfaces
1124 * listening to RIP, then output by default.
1125 */
1126 if (!supplier_set && rip_interfaces > 1)
1127 set_supplier();
1128
1129 /* If we are multi-homed, optionally advertise a route to
1130 * our main address.
1131 */
1132 if ((advertise_mhome && ifp)
1133 || (tot_interfaces > 1
1134 && mhome
1135 && (ifp = ifwithaddr(myaddr, 0, 0)) != NULL
1136 && foundloopback)) {
1137 advertise_mhome = 1;
1138 rt = rtget(myaddr, HOST_MASK);
1139 if (rt != NULL) {
1140 if (rt->rt_ifp != ifp
1141 || rt->rt_router != loopaddr) {
1142 rtdelete(rt);
1143 rt = NULL;
1144 } else {
1145 loop_rts.rts_ifp = ifp;
1146 loop_rts.rts_metric = 0;
1147 loop_rts.rts_time = rt->rt_time;
1148 rtchange(rt, rt->rt_state | RS_MHOME,
1149 &loop_rts, 0);
1150 }
1151 }
1152 if (rt == NULL) {
1153 loop_rts.rts_ifp = ifp;
1154 loop_rts.rts_metric = 0;
1155 rtadd(myaddr, HOST_MASK, RS_MHOME, &loop_rts);
1156 }
1157 }
1158
1159 LIST_FOREACH_SAFE(ifp, &ifnet, int_list, ifp1) {
1160 /* Forget any interfaces that have disappeared.
1161 */
1162 if (!(ifp->int_state & (IS_CHECKED | IS_REMOTE))) {
1163 trace_act("interface %s has disappeared",
1164 ifp->int_name);
1165 ifdel(ifp);
1166 continue;
1167 }
1168
1169 if ((ifp->int_state & IS_BROKE)
1170 && !(ifp->int_state & IS_PASSIVE))
1171 LIM_SEC(ifinit_timer, now.tv_sec+CHECK_BAD_INTERVAL);
1172
1173 /* If we ever have a RIPv1 interface, assume we always will.
1174 * It might come back if it ever goes away.
1175 */
1176 if (!(ifp->int_state & IS_NO_RIPV1_OUT) && supplier)
1177 have_ripv1_out = 1;
1178 if (!(ifp->int_state & IS_NO_RIPV1_IN))
1179 have_ripv1_in = 1;
1180 }
1181
1182 LIST_FOREACH(ifp, &ifnet, int_list) {
1183 /* Ensure there is always a network route for interfaces,
1184 * after any dead interfaces have been deleted, which
1185 * might affect routes for point-to-point links.
1186 */
1187 if (!addrouteforif(ifp))
1188 continue;
1189
1190 /* Add routes to the local end of point-to-point interfaces
1191 * using loopback.
1192 */
1193 if ((ifp->int_if_flags & IFF_POINTOPOINT)
1194 && !(ifp->int_state & IS_REMOTE)
1195 && foundloopback) {
1196 /* Delete any routes to the network address through
1197 * foreign routers. Remove even static routes.
1198 */
1199 del_static(ifp->int_addr, HOST_MASK, 0, 0);
1200 rt = rtget(ifp->int_addr, HOST_MASK);
1201 if (rt != NULL && rt->rt_router != loopaddr) {
1202 rtdelete(rt);
1203 rt = NULL;
1204 }
1205 if (rt != NULL) {
1206 if (!(rt->rt_state & RS_LOCAL)
1207 || rt->rt_metric > ifp->int_metric) {
1208 ifp1 = ifp;
1209 } else {
1210 ifp1 = rt->rt_ifp;
1211 }
1212 loop_rts.rts_ifp = ifp1;
1213 loop_rts.rts_metric = 0;
1214 loop_rts.rts_time = rt->rt_time;
1215 rtchange(rt, ((rt->rt_state & ~RS_NET_SYN)
1216 | (RS_IF|RS_LOCAL)),
1217 &loop_rts, 0);
1218 } else {
1219 loop_rts.rts_ifp = ifp;
1220 loop_rts.rts_metric = 0;
1221 rtadd(ifp->int_addr, HOST_MASK,
1222 (RS_IF | RS_LOCAL), &loop_rts);
1223 }
1224 }
1225 }
1226
1227 /* add the authority routes */
1228 for (intnetp = intnets; intnetp != NULL;
1229 intnetp = intnetp->intnet_next) {
1230 rt = rtget(intnetp->intnet_addr, intnetp->intnet_mask);
1231 if (rt != NULL
1232 && !(rt->rt_state & RS_NO_NET_SYN)
1233 && !(rt->rt_state & RS_NET_INT)) {
1234 rtdelete(rt);
1235 rt = NULL;
1236 }
1237 if (rt == NULL) {
1238 loop_rts.rts_ifp = NULL;
1239 loop_rts.rts_metric = intnetp->intnet_metric-1;
1240 rtadd(intnetp->intnet_addr, intnetp->intnet_mask,
1241 RS_NET_SYN | RS_NET_INT, &loop_rts);
1242 }
1243 }
1244
1245 prev_complaints = complaints;
1246 }
1247
1248
1249 static void
check_net_syn(struct interface * ifp)1250 check_net_syn(struct interface *ifp)
1251 {
1252 struct rt_entry *rt;
1253 static struct rt_spare new;
1254
1255
1256 /* Turn on the need to automatically synthesize a network route
1257 * for this interface only if we are running RIPv1 on some other
1258 * interface that is on a different class-A,B,or C network.
1259 */
1260 if (have_ripv1_out || have_ripv1_in) {
1261 ifp->int_state |= IS_NEED_NET_SYN;
1262 rt = rtget(ifp->int_std_addr, ifp->int_std_mask);
1263 if (rt != NULL
1264 && 0 == (rt->rt_state & RS_NO_NET_SYN)
1265 && (!(rt->rt_state & RS_NET_SYN)
1266 || rt->rt_metric > ifp->int_metric)) {
1267 rtdelete(rt);
1268 rt = NULL;
1269 }
1270 if (rt == NULL) {
1271 new.rts_ifp = ifp;
1272 new.rts_gate = ifp->int_addr;
1273 new.rts_router = ifp->int_addr;
1274 new.rts_metric = ifp->int_metric;
1275 rtadd(ifp->int_std_addr, ifp->int_std_mask,
1276 RS_NET_SYN, &new);
1277 }
1278
1279 } else {
1280 ifp->int_state &= ~IS_NEED_NET_SYN;
1281
1282 rt = rtget(ifp->int_std_addr,
1283 ifp->int_std_mask);
1284 if (rt != NULL
1285 && (rt->rt_state & RS_NET_SYN)
1286 && rt->rt_ifp == ifp)
1287 rtbad_sub(rt);
1288 }
1289 }
1290
1291
1292 /* Add route for interface if not currently installed.
1293 * Create route to other end if a point-to-point link,
1294 * otherwise a route to this (sub)network.
1295 */
1296 static int /* 0=bad interface */
addrouteforif(struct interface * ifp)1297 addrouteforif(struct interface *ifp)
1298 {
1299 struct rt_entry *rt;
1300 static struct rt_spare new;
1301 naddr dst;
1302
1303
1304 /* skip sick interfaces
1305 */
1306 if (ifp->int_state & IS_BROKE)
1307 return 0;
1308
1309 /* If the interface on a subnet, then install a RIPv1 route to
1310 * the network as well (unless it is sick).
1311 */
1312 if (ifp->int_state & IS_SUBNET)
1313 check_net_syn(ifp);
1314
1315 dst = (0 != (ifp->int_if_flags & (IFF_POINTOPOINT | IFF_LOOPBACK))
1316 ? ifp->int_dstaddr
1317 : htonl(ifp->int_net));
1318
1319 new.rts_ifp = ifp;
1320 new.rts_router = ifp->int_addr;
1321 new.rts_gate = ifp->int_addr;
1322 new.rts_metric = ifp->int_metric;
1323 new.rts_time = now.tv_sec;
1324
1325 /* If we are going to send packets to the gateway,
1326 * it must be reachable using our physical interfaces
1327 */
1328 if ((ifp->int_state & IS_REMOTE)
1329 && !(ifp->int_state & IS_EXTERNAL)
1330 && !check_remote(ifp))
1331 return 0;
1332
1333 /* We are finished if the correct main interface route exists.
1334 * The right route must be for the right interface, not synthesized
1335 * from a subnet, be a "gateway" or not as appropriate, and so forth.
1336 */
1337 del_static(dst, ifp->int_mask, 0, 0);
1338 rt = rtget(dst, ifp->int_mask);
1339 if (rt != NULL) {
1340 if ((rt->rt_ifp != ifp
1341 || rt->rt_router != ifp->int_addr)
1342 && (!(ifp->int_state & IS_DUP)
1343 || rt->rt_ifp == 0
1344 || (rt->rt_ifp->int_state & IS_BROKE))) {
1345 rtdelete(rt);
1346 rt = NULL;
1347 } else {
1348 rtchange(rt, ((rt->rt_state | RS_IF)
1349 & ~(RS_NET_SYN | RS_LOCAL)),
1350 &new, 0);
1351 }
1352 }
1353 if (rt == NULL) {
1354 if (ifp->int_transitions++ > 0)
1355 trace_act("re-install interface %s",
1356 ifp->int_name);
1357
1358 rtadd(dst, ifp->int_mask, RS_IF, &new);
1359 }
1360
1361 return 1;
1362 }
1363