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