1/*
2 * Copyright (c) 1983, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgment:
15 * This product includes software developed by the University of
16 * California, Berkeley and its contributors.
17 * 4. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 *
|
33 * $FreeBSD: head/sbin/routed/if.c 108533 2003-01-01 18:49:04Z schweikh $
|
| 33 * $FreeBSD: head/sbin/routed/if.c 126250 2004-02-25 23:45:57Z bms $ |
34 */
35
36#include "defs.h"
37#include "pathnames.h"
38
|
39#if !defined(sgi) && !defined(__NetBSD__)
40static char sccsid[] __attribute__((unused)) = "@(#)if.c 8.1 (Berkeley) 6/5/93";
41#elif defined(__NetBSD__)
42#include <sys/cdefs.h>
|
| 39#ifdef __NetBSD__ |
40__RCSID("$NetBSD$");
|
41#elif defined(__FreeBSD__)
42__RCSID("$FreeBSD: head/sbin/routed/if.c 126250 2004-02-25 23:45:57Z bms $");
43#else
44__RCSID("$Revision: 2.27 $");
45#ident "$Revision: 2.27 $" |
46#endif
|
45#ident "$FreeBSD: head/sbin/routed/if.c 108533 2003-01-01 18:49:04Z schweikh $"
46
|
| 47#ident "$FreeBSD: head/sbin/routed/if.c 126250 2004-02-25 23:45:57Z bms $" |
48struct 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]
57struct interface *ahash_tbl[AHASH_LEN];
58
59#define BHASH_LEN 211 /* must be prime */
60#define BHASH(a) &bhash_tbl[(a)%BHASH_LEN]
61struct interface *bhash_tbl[BHASH_LEN];
62
63struct 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
70struct interface *nhash_tbl[NHASH_LEN];
71
72int tot_interfaces; /* # of remote and local interfaces */
73int rip_interfaces; /* # of interfaces doing RIP */
74int foundloopback; /* valid flag for loopaddr */
75naddr loopaddr; /* our address on loopback */
76struct rt_spare loop_rts;
77
78struct timeval ifinit_timer;
79static 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
84int have_ripv1_out; /* have a RIPv1 interface */
85int have_ripv1_in;
86
87
88static struct interface**
89nhash(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 */
103void
104if_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 */
151struct interface *
152ifwithaddr(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 */
189struct interface *
190ifwithname(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
217struct interface *
|
217ifwithindex(u_short index,
|
| 218ifwithindex(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) {
|
224 if (ifp->int_index == index)
|
| 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 */
244struct interface *
245iflookup(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
|
270 if (maybe != 0
271 || IF_RESCAN_DELAY())
|
| 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 */
286naddr /* host byte order */
287std_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 */
305naddr
306ripv1_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
356naddr
357ripv1_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 an IP address looks reasonable as a destination.
373 */
374int /* 0=bad */
375check_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 */
393struct interface *
394check_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 */
|
409 if (ifp->int_addr == addr
|
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 */
426int /* 0=bad */
427check_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 */
456static void
457ifdel(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 */
546void
547if_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 */
561void
562if_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 */
593int /* 1=it was dead */
594if_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 */
634void
635rt_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#ifdef sgi
645#define ROUNDUP(a) ((a) > 0 ? (1 + (((a) - 1) | (sizeof(__uint64_t) - 1))) \
646 : sizeof(__uint64_t))
647#else
648#define ROUNDUP(a) ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) \
649 : sizeof(long))
650#endif
651
652
653 memset(info, 0, sizeof(*info));
654 info->rti_addrs = addrs;
655 for (i = 0; i < RTAX_MAX && sa < lim; i++) {
656 if ((addrs & (1 << i)) == 0)
657 continue;
658#ifdef _HAVE_SA_LEN
659 info->rti_info[i] = (sa->sa_len != 0) ? sa : &sa_zero;
660 sa = (struct sockaddr *)((char*)(sa)
661 + ROUNDUP(sa->sa_len));
662#else
663 info->rti_info[i] = sa;
664 sa = (struct sockaddr *)((char*)(sa)
665 + ROUNDUP(_FAKE_SA_LEN_DST(sa)));
666#endif
667 }
668}
669
670
671/* Find the network interfaces which have configured themselves.
672 * This must be done regularly, if only for extra addresses
673 * that come and go on interfaces.
674 */
675void
676ifinit(void)
677{
678 static char *sysctl_buf;
679 static size_t sysctl_buf_size = 0;
680 uint complaints = 0;
681 static u_int prev_complaints = 0;
682# define COMP_NOT_INET 0x001
683# define COMP_NOADDR 0x002
684# define COMP_BADADDR 0x004
685# define COMP_NODST 0x008
686# define COMP_NOBADR 0x010
687# define COMP_NOMASK 0x020
688# define COMP_DUP 0x040
689# define COMP_BAD_METRIC 0x080
690# define COMP_NETMASK 0x100
691
692 struct interface ifs, ifs0, *ifp, *ifp1;
693 struct rt_entry *rt;
694 size_t needed;
695 int mib[6];
696 struct if_msghdr *ifm;
697 struct ifa_msghdr *ifam, *ifam_lim, *ifam2;
698 int in, ierr, out, oerr;
699 struct intnet *intnetp;
700 struct rt_addrinfo info;
701#ifdef SIOCGIFMETRIC
702 struct ifreq ifr;
703#endif
704
705
706 last_ifinit = now;
707 ifinit_timer.tv_sec = now.tv_sec + (supplier
708 ? CHECK_ACT_INTERVAL
709 : CHECK_QUIET_INTERVAL);
710
711 /* mark all interfaces so we can get rid of those that disappear */
712 for (ifp = ifnet; 0 != ifp; ifp = ifp->int_next)
713 ifp->int_state &= ~(IS_CHECKED | IS_DUP);
714
715 /* Fetch the interface list, without too many system calls
716 * since we do it repeatedly.
717 */
718 mib[0] = CTL_NET;
719 mib[1] = PF_ROUTE;
720 mib[2] = 0;
721 mib[3] = AF_INET;
722 mib[4] = NET_RT_IFLIST;
723 mib[5] = 0;
724 for (;;) {
725 if ((needed = sysctl_buf_size) != 0) {
726 if (sysctl(mib, 6, sysctl_buf,&needed, 0, 0) >= 0)
727 break;
728 /* retry if the table grew */
729 if (errno != ENOMEM && errno != EFAULT)
730 BADERR(1, "ifinit: sysctl(RT_IFLIST)");
731 free(sysctl_buf);
732 needed = 0;
733 }
734 if (sysctl(mib, 6, 0, &needed, 0, 0) < 0)
735 BADERR(1,"ifinit: sysctl(RT_IFLIST) estimate");
736 sysctl_buf = rtmalloc(sysctl_buf_size = needed,
737 "ifinit sysctl");
738 }
739
740 ifam_lim = (struct ifa_msghdr *)(sysctl_buf + needed);
741 for (ifam = (struct ifa_msghdr *)sysctl_buf;
742 ifam < ifam_lim;
743 ifam = ifam2) {
744
745 ifam2 = (struct ifa_msghdr*)((char*)ifam + ifam->ifam_msglen);
746
|
747#ifdef RTM_OIFINFO
748 if (ifam->ifam_type == RTM_OIFINFO)
749 continue; /* just ignore compat message */
750#endif |
751 if (ifam->ifam_type == RTM_IFINFO) {
752 struct sockaddr_dl *sdl;
753
754 ifm = (struct if_msghdr *)ifam;
755 /* make prototype structure for the IP aliases
756 */
757 memset(&ifs0, 0, sizeof(ifs0));
758 ifs0.int_rip_sock = -1;
759 ifs0.int_index = ifm->ifm_index;
760 ifs0.int_if_flags = ifm->ifm_flags;
761 ifs0.int_state = IS_CHECKED;
762 ifs0.int_query_time = NEVER;
763 ifs0.int_act_time = now.tv_sec;
764 ifs0.int_data.ts = now.tv_sec;
765 ifs0.int_data.ipackets = ifm->ifm_data.ifi_ipackets;
766 ifs0.int_data.ierrors = ifm->ifm_data.ifi_ierrors;
767 ifs0.int_data.opackets = ifm->ifm_data.ifi_opackets;
768 ifs0.int_data.oerrors = ifm->ifm_data.ifi_oerrors;
769#ifdef sgi
770 ifs0.int_data.odrops = ifm->ifm_data.ifi_odrops;
771#endif
772 sdl = (struct sockaddr_dl *)(ifm + 1);
773 sdl->sdl_data[sdl->sdl_nlen] = 0;
774 strncpy(ifs0.int_name, sdl->sdl_data,
775 MIN(sizeof(ifs0.int_name), sdl->sdl_nlen));
776 continue;
777 }
778 if (ifam->ifam_type != RTM_NEWADDR) {
779 logbad(1,"ifinit: out of sync");
780 continue;
781 }
782 rt_xaddrs(&info, (struct sockaddr *)(ifam+1),
783 (struct sockaddr *)ifam2,
784 ifam->ifam_addrs);
785
786 /* Prepare for the next address of this interface, which
787 * will be an alias.
788 * Do not output RIP or Router-Discovery packets via aliases.
789 */
790 memcpy(&ifs, &ifs0, sizeof(ifs));
791 ifs0.int_state |= (IS_ALIAS | IS_NO_RIP_OUT | IS_NO_RDISC);
792
793 if (INFO_IFA(&info) == 0) {
794 if (iff_up(ifs.int_if_flags)) {
795 if (!(prev_complaints & COMP_NOADDR))
796 msglog("%s has no address",
797 ifs.int_name);
798 complaints |= COMP_NOADDR;
799 }
800 continue;
801 }
802 if (INFO_IFA(&info)->sa_family != AF_INET) {
803 if (iff_up(ifs.int_if_flags)) {
804 if (!(prev_complaints & COMP_NOT_INET))
805 trace_act("%s: not AF_INET",
806 ifs.int_name);
807 complaints |= COMP_NOT_INET;
808 }
809 continue;
810 }
811
812 ifs.int_addr = S_ADDR(INFO_IFA(&info));
813
814 if (ntohl(ifs.int_addr)>>24 == 0
815 || ntohl(ifs.int_addr)>>24 == 0xff) {
816 if (iff_up(ifs.int_if_flags)) {
817 if (!(prev_complaints & COMP_BADADDR))
818 msglog("%s has a bad address",
819 ifs.int_name);
820 complaints |= COMP_BADADDR;
821 }
822 continue;
823 }
824
825 if (ifs.int_if_flags & IFF_LOOPBACK) {
826 ifs.int_state |= IS_PASSIVE | IS_NO_RIP | IS_NO_RDISC;
827 ifs.int_dstaddr = ifs.int_addr;
828 ifs.int_mask = HOST_MASK;
829 ifs.int_ripv1_mask = HOST_MASK;
830 ifs.int_std_mask = std_mask(ifs.int_dstaddr);
831 ifs.int_net = ntohl(ifs.int_dstaddr);
832 if (!foundloopback) {
833 foundloopback = 1;
834 loopaddr = ifs.int_addr;
835 loop_rts.rts_gate = loopaddr;
836 loop_rts.rts_router = loopaddr;
837 }
838
839 } else if (ifs.int_if_flags & IFF_POINTOPOINT) {
840 if (INFO_BRD(&info) == 0
841 || INFO_BRD(&info)->sa_family != AF_INET) {
842 if (iff_up(ifs.int_if_flags)) {
843 if (!(prev_complaints & COMP_NODST))
844 msglog("%s has a bad"
845 " destination address",
846 ifs.int_name);
847 complaints |= COMP_NODST;
848 }
849 continue;
850 }
851 ifs.int_dstaddr = S_ADDR(INFO_BRD(&info));
852 if (ntohl(ifs.int_dstaddr)>>24 == 0
853 || ntohl(ifs.int_dstaddr)>>24 == 0xff) {
854 if (iff_up(ifs.int_if_flags)) {
855 if (!(prev_complaints & COMP_NODST))
856 msglog("%s has a bad"
857 " destination address",
858 ifs.int_name);
859 complaints |= COMP_NODST;
860 }
861 continue;
862 }
863 ifs.int_mask = HOST_MASK;
864 ifs.int_ripv1_mask = ntohl(S_ADDR(INFO_MASK(&info)));
865 ifs.int_std_mask = std_mask(ifs.int_dstaddr);
866 ifs.int_net = ntohl(ifs.int_dstaddr);
867
868 } else {
869 if (INFO_MASK(&info) == 0) {
870 if (iff_up(ifs.int_if_flags)) {
871 if (!(prev_complaints & COMP_NOMASK))
872 msglog("%s has no netmask",
873 ifs.int_name);
874 complaints |= COMP_NOMASK;
875 }
876 continue;
877 }
878 ifs.int_dstaddr = ifs.int_addr;
879 ifs.int_mask = ntohl(S_ADDR(INFO_MASK(&info)));
880 ifs.int_ripv1_mask = ifs.int_mask;
881 ifs.int_std_mask = std_mask(ifs.int_addr);
882 ifs.int_net = ntohl(ifs.int_addr) & ifs.int_mask;
883 if (ifs.int_mask != ifs.int_std_mask)
884 ifs.int_state |= IS_SUBNET;
885
886 if (ifs.int_if_flags & IFF_BROADCAST) {
887 if (INFO_BRD(&info) == 0) {
888 if (iff_up(ifs.int_if_flags)) {
889 if (!(prev_complaints
890 & COMP_NOBADR))
891 msglog("%s has"
892 "no broadcast address",
893 ifs.int_name);
894 complaints |= COMP_NOBADR;
895 }
896 continue;
897 }
898 ifs.int_brdaddr = S_ADDR(INFO_BRD(&info));
899 }
900 }
901 ifs.int_std_net = ifs.int_net & ifs.int_std_mask;
902 ifs.int_std_addr = htonl(ifs.int_std_net);
903
904 /* Use a minimum metric of one. Treat the interface metric
905 * (default 0) as an increment to the hop count of one.
906 *
907 * The metric obtained from the routing socket dump of
908 * interface addresses is wrong. It is not set by the
909 * SIOCSIFMETRIC ioctl.
910 */
911#ifdef SIOCGIFMETRIC
912 strncpy(ifr.ifr_name, ifs.int_name, sizeof(ifr.ifr_name));
913 if (ioctl(rt_sock, SIOCGIFMETRIC, &ifr) < 0) {
914 DBGERR(1, "ioctl(SIOCGIFMETRIC)");
915 ifs.int_metric = 0;
916 } else {
917 ifs.int_metric = ifr.ifr_metric;
918 }
919#else
920 ifs.int_metric = ifam->ifam_metric;
921#endif
922 if (ifs.int_metric > HOPCNT_INFINITY) {
923 ifs.int_metric = 0;
924 if (!(prev_complaints & COMP_BAD_METRIC)
925 && iff_up(ifs.int_if_flags)) {
926 complaints |= COMP_BAD_METRIC;
927 msglog("%s has a metric of %d",
928 ifs.int_name, ifs.int_metric);
929 }
930 }
931
932 /* See if this is a familiar interface.
933 * If so, stop worrying about it if it is the same.
934 * Start it over if it now is to somewhere else, as happens
935 * frequently with PPP and SLIP.
936 */
937 ifp = ifwithname(ifs.int_name, ((ifs.int_state & IS_ALIAS)
938 ? ifs.int_addr
939 : 0));
940 if (ifp != 0) {
941 ifp->int_state |= IS_CHECKED;
942
943 if (0 != ((ifp->int_if_flags ^ ifs.int_if_flags)
944 & (IFF_BROADCAST
945 | IFF_LOOPBACK
946 | IFF_POINTOPOINT
947 | IFF_MULTICAST))
948 || 0 != ((ifp->int_state ^ ifs.int_state)
949 & IS_ALIAS)
950 || ifp->int_addr != ifs.int_addr
951 || ifp->int_brdaddr != ifs.int_brdaddr
952 || ifp->int_dstaddr != ifs.int_dstaddr
953 || ifp->int_mask != ifs.int_mask
954 || ifp->int_metric != ifs.int_metric) {
955 /* Forget old information about
956 * a changed interface.
957 */
958 trace_act("interface %s has changed",
959 ifp->int_name);
960 ifdel(ifp);
961 ifp = 0;
962 }
963 }
964
965 if (ifp != 0) {
966 /* The primary representative of an alias worries
967 * about how things are working.
968 */
969 if (ifp->int_state & IS_ALIAS)
970 continue;
971
972 /* note interfaces that have been turned off
973 */
974 if (!iff_up(ifs.int_if_flags)) {
975 if (iff_up(ifp->int_if_flags)) {
976 msglog("interface %s to %s turned off",
977 ifp->int_name,
978 naddr_ntoa(ifp->int_dstaddr));
979 if_bad(ifp);
980 ifp->int_if_flags &= ~IFF_UP;
981 } else if (now.tv_sec>(ifp->int_data.ts
982 + CHECK_BAD_INTERVAL)) {
983 trace_act("interface %s has been off"
984 " %ld seconds; forget it",
985 ifp->int_name,
986 now.tv_sec-ifp->int_data.ts);
987 ifdel(ifp);
988 }
989 continue;
990 }
991 /* or that were off and are now ok */
992 if (!iff_up(ifp->int_if_flags)) {
993 ifp->int_if_flags |= IFF_UP;
994 (void)if_ok(ifp, "");
995 }
996
997 /* If it has been long enough,
998 * see if the interface is broken.
999 */
1000 if (now.tv_sec < ifp->int_data.ts+CHECK_BAD_INTERVAL)
1001 continue;
1002
1003 in = ifs.int_data.ipackets - ifp->int_data.ipackets;
1004 ierr = ifs.int_data.ierrors - ifp->int_data.ierrors;
1005 out = ifs.int_data.opackets - ifp->int_data.opackets;
1006 oerr = ifs.int_data.oerrors - ifp->int_data.oerrors;
1007#ifdef sgi
1008 /* Through at least IRIX 6.2, PPP and SLIP
1009 * count packets dropped by the filters.
1010 * But FDDI rings stuck non-operational count
1011 * dropped packets as they wait for improvement.
1012 */
1013 if (!(ifp->int_if_flags & IFF_POINTOPOINT))
1014 oerr += (ifs.int_data.odrops
1015 - ifp->int_data.odrops);
1016#endif
1017 /* If the interface just awoke, restart the counters.
1018 */
1019 if (ifp->int_data.ts == 0) {
1020 ifp->int_data = ifs.int_data;
1021 continue;
1022 }
1023 ifp->int_data = ifs.int_data;
1024
1025 /* Withhold judgment when the short error
1026 * counters wrap or the interface is reset.
1027 */
1028 if (ierr < 0 || in < 0 || oerr < 0 || out < 0) {
1029 LIM_SEC(ifinit_timer,
1030 now.tv_sec+CHECK_BAD_INTERVAL);
1031 continue;
1032 }
1033
1034 /* Withhold judgement when there is no traffic
1035 */
1036 if (in == 0 && out == 0 && ierr == 0 && oerr == 0)
1037 continue;
1038
1039 /* It is bad if input or output is not working.
1040 * Require presistent problems before marking it dead.
1041 */
1042 if ((in <= ierr && ierr > 0)
1043 || (out <= oerr && oerr > 0)) {
1044 if (!(ifp->int_state & IS_SICK)) {
1045 trace_act("interface %s to %s"
1046 " sick: in=%d ierr=%d"
1047 " out=%d oerr=%d",
1048 ifp->int_name,
1049 naddr_ntoa(ifp->int_dstaddr),
1050 in, ierr, out, oerr);
1051 if_sick(ifp);
1052 continue;
1053 }
1054 if (!(ifp->int_state & IS_BROKE)) {
1055 msglog("interface %s to %s broken:"
1056 " in=%d ierr=%d out=%d oerr=%d",
1057 ifp->int_name,
1058 naddr_ntoa(ifp->int_dstaddr),
1059 in, ierr, out, oerr);
1060 if_bad(ifp);
1061 }
1062 continue;
1063 }
1064
1065 /* otherwise, it is active and healthy
1066 */
1067 ifp->int_act_time = now.tv_sec;
1068 (void)if_ok(ifp, "");
1069 continue;
1070 }
1071
1072 /* This is a new interface.
1073 * If it is dead, forget it.
1074 */
1075 if (!iff_up(ifs.int_if_flags))
1076 continue;
1077
1078 /* If it duplicates an existing interface,
1079 * complain about it, mark the other one
1080 * duplicated, and forget this one.
1081 */
1082 ifp = check_dup(ifs.int_addr,ifs.int_dstaddr,ifs.int_mask,
1083 ifs.int_if_flags);
1084 if (ifp != 0) {
1085 /* Ignore duplicates of itself, caused by having
1086 * IP aliases on the same network.
1087 */
1088 if (!strcmp(ifp->int_name, ifs.int_name))
1089 continue;
1090
1091 if (!(prev_complaints & COMP_DUP)) {
1092 complaints |= COMP_DUP;
1093 msglog("%s (%s%s%s) is duplicated by"
1094 " %s (%s%s%s)",
1095 ifs.int_name,
1096 addrname(ifs.int_addr,ifs.int_mask,1),
1097 ((ifs.int_if_flags & IFF_POINTOPOINT)
1098 ? "-->" : ""),
1099 ((ifs.int_if_flags & IFF_POINTOPOINT)
1100 ? naddr_ntoa(ifs.int_dstaddr) : ""),
1101 ifp->int_name,
1102 addrname(ifp->int_addr,ifp->int_mask,1),
1103 ((ifp->int_if_flags & IFF_POINTOPOINT)
1104 ? "-->" : ""),
1105 ((ifp->int_if_flags & IFF_POINTOPOINT)
1106 ? naddr_ntoa(ifp->int_dstaddr) : ""));
1107 }
1108 ifp->int_state |= IS_DUP;
1109 continue;
1110 }
1111
1112 if (0 == (ifs.int_if_flags & (IFF_POINTOPOINT | IFF_BROADCAST))
1113 && !(ifs.int_state & IS_PASSIVE)) {
1114 trace_act("%s is neither broadcast, point-to-point,"
1115 " nor loopback",
1116 ifs.int_name);
1117 if (!(ifs.int_state & IFF_MULTICAST))
1118 ifs.int_state |= IS_NO_RDISC;
1119 }
1120
1121
1122 /* It is new and ok. Add it to the list of interfaces
1123 */
1124 ifp = (struct interface *)rtmalloc(sizeof(*ifp), "ifinit ifp");
1125 memcpy(ifp, &ifs, sizeof(*ifp));
1126 get_parms(ifp);
1127 if_link(ifp);
1128 trace_if("Add", ifp);
1129
1130 /* Notice likely bad netmask.
1131 */
1132 if (!(prev_complaints & COMP_NETMASK)
1133 && !(ifp->int_if_flags & IFF_POINTOPOINT)
1134 && ifp->int_addr != RIP_DEFAULT) {
1135 for (ifp1 = ifnet; 0 != ifp1; ifp1 = ifp1->int_next) {
1136 if (ifp1->int_mask == ifp->int_mask)
1137 continue;
1138 if (ifp1->int_if_flags & IFF_POINTOPOINT)
1139 continue;
1140 if (ifp1->int_dstaddr == RIP_DEFAULT)
1141 continue;
1142 /* ignore aliases on the right network */
1143 if (!strcmp(ifp->int_name, ifp1->int_name))
1144 continue;
1145 if (on_net(ifp->int_dstaddr,
1146 ifp1->int_net, ifp1->int_mask)
1147 || on_net(ifp1->int_dstaddr,
1148 ifp->int_net, ifp->int_mask)) {
1149 msglog("possible netmask problem"
1150 " between %s:%s and %s:%s",
1151 ifp->int_name,
1152 addrname(htonl(ifp->int_net),
1153 ifp->int_mask, 1),
1154 ifp1->int_name,
1155 addrname(htonl(ifp1->int_net),
1156 ifp1->int_mask, 1));
1157 complaints |= COMP_NETMASK;
1158 }
1159 }
1160 }
1161
1162 if (!(ifp->int_state & IS_ALIAS)) {
1163 /* Count the # of directly connected networks.
1164 */
1165 if (!(ifp->int_if_flags & IFF_LOOPBACK))
1166 tot_interfaces++;
1167 if (!IS_RIP_OFF(ifp->int_state))
1168 rip_interfaces++;
1169
1170 /* turn on router discovery and RIP If needed */
1171 if_ok_rdisc(ifp);
1172 rip_on(ifp);
1173 }
1174 }
1175
1176 /* If we are multi-homed and have at least two interfaces
1177 * listening to RIP, then output by default.
1178 */
1179 if (!supplier_set && rip_interfaces > 1)
1180 set_supplier();
1181
1182 /* If we are multi-homed, optionally advertise a route to
1183 * our main address.
1184 */
1185 if (advertise_mhome
1186 || (tot_interfaces > 1
1187 && mhome
1188 && (ifp = ifwithaddr(myaddr, 0, 0)) != 0
1189 && foundloopback)) {
1190 advertise_mhome = 1;
1191 rt = rtget(myaddr, HOST_MASK);
1192 if (rt != 0) {
1193 if (rt->rt_ifp != ifp
1194 || rt->rt_router != loopaddr) {
1195 rtdelete(rt);
1196 rt = 0;
1197 } else {
1198 loop_rts.rts_ifp = ifp;
1199 loop_rts.rts_metric = 0;
1200 loop_rts.rts_time = rt->rt_time;
1201 rtchange(rt, rt->rt_state | RS_MHOME,
1202 &loop_rts, 0);
1203 }
1204 }
1205 if (rt == 0) {
1206 loop_rts.rts_ifp = ifp;
1207 loop_rts.rts_metric = 0;
1208 rtadd(myaddr, HOST_MASK, RS_MHOME, &loop_rts);
1209 }
1210 }
1211
1212 for (ifp = ifnet; ifp != 0; ifp = ifp1) {
1213 ifp1 = ifp->int_next; /* because we may delete it */
1214
1215 /* Forget any interfaces that have disappeared.
1216 */
1217 if (!(ifp->int_state & (IS_CHECKED | IS_REMOTE))) {
1218 trace_act("interface %s has disappeared",
1219 ifp->int_name);
1220 ifdel(ifp);
1221 continue;
1222 }
1223
1224 if ((ifp->int_state & IS_BROKE)
1225 && !(ifp->int_state & IS_PASSIVE))
1226 LIM_SEC(ifinit_timer, now.tv_sec+CHECK_BAD_INTERVAL);
1227
1228 /* If we ever have a RIPv1 interface, assume we always will.
1229 * It might come back if it ever goes away.
1230 */
1231 if (!(ifp->int_state & IS_NO_RIPV1_OUT) && supplier)
1232 have_ripv1_out = 1;
1233 if (!(ifp->int_state & IS_NO_RIPV1_IN))
1234 have_ripv1_in = 1;
1235 }
1236
1237 for (ifp = ifnet; ifp != 0; ifp = ifp->int_next) {
1238 /* Ensure there is always a network route for interfaces,
1239 * after any dead interfaces have been deleted, which
1240 * might affect routes for point-to-point links.
1241 */
1242 if (!addrouteforif(ifp))
1243 continue;
1244
1245 /* Add routes to the local end of point-to-point interfaces
1246 * using loopback.
1247 */
1248 if ((ifp->int_if_flags & IFF_POINTOPOINT)
1249 && !(ifp->int_state & IS_REMOTE)
1250 && foundloopback) {
1251 /* Delete any routes to the network address through
1252 * foreign routers. Remove even static routes.
1253 */
1254 del_static(ifp->int_addr, HOST_MASK, 0, 0);
1255 rt = rtget(ifp->int_addr, HOST_MASK);
1256 if (rt != 0 && rt->rt_router != loopaddr) {
1257 rtdelete(rt);
1258 rt = 0;
1259 }
1260 if (rt != 0) {
1261 if (!(rt->rt_state & RS_LOCAL)
1262 || rt->rt_metric > ifp->int_metric) {
1263 ifp1 = ifp;
1264 } else {
1265 ifp1 = rt->rt_ifp;
1266 }
1267 loop_rts.rts_ifp = ifp1;
1268 loop_rts.rts_metric = 0;
1269 loop_rts.rts_time = rt->rt_time;
1270 rtchange(rt, ((rt->rt_state & ~RS_NET_SYN)
1271 | (RS_IF|RS_LOCAL)),
1272 &loop_rts, 0);
1273 } else {
1274 loop_rts.rts_ifp = ifp;
1275 loop_rts.rts_metric = 0;
1276 rtadd(ifp->int_addr, HOST_MASK,
1277 (RS_IF | RS_LOCAL), &loop_rts);
1278 }
1279 }
1280 }
1281
1282 /* add the authority routes */
1283 for (intnetp = intnets; intnetp!=0; intnetp = intnetp->intnet_next) {
1284 rt = rtget(intnetp->intnet_addr, intnetp->intnet_mask);
1285 if (rt != 0
1286 && !(rt->rt_state & RS_NO_NET_SYN)
1287 && !(rt->rt_state & RS_NET_INT)) {
1288 rtdelete(rt);
1289 rt = 0;
1290 }
1291 if (rt == 0) {
1292 loop_rts.rts_ifp = 0;
1293 loop_rts.rts_metric = intnetp->intnet_metric-1;
1294 rtadd(intnetp->intnet_addr, intnetp->intnet_mask,
1295 RS_NET_SYN | RS_NET_INT, &loop_rts);
1296 }
1297 }
1298
1299 prev_complaints = complaints;
1300}
1301
1302
1303static void
1304check_net_syn(struct interface *ifp)
1305{
1306 struct rt_entry *rt;
1307 static struct rt_spare new;
1308
1309
1310 /* Turn on the need to automatically synthesize a network route
1311 * for this interface only if we are running RIPv1 on some other
1312 * interface that is on a different class-A,B,or C network.
1313 */
1314 if (have_ripv1_out || have_ripv1_in) {
1315 ifp->int_state |= IS_NEED_NET_SYN;
1316 rt = rtget(ifp->int_std_addr, ifp->int_std_mask);
1317 if (rt != 0
1318 && 0 == (rt->rt_state & RS_NO_NET_SYN)
1319 && (!(rt->rt_state & RS_NET_SYN)
1320 || rt->rt_metric > ifp->int_metric)) {
1321 rtdelete(rt);
1322 rt = 0;
1323 }
1324 if (rt == 0) {
1325 new.rts_ifp = ifp;
1326 new.rts_gate = ifp->int_addr;
1327 new.rts_router = ifp->int_addr;
1328 new.rts_metric = ifp->int_metric;
1329 rtadd(ifp->int_std_addr, ifp->int_std_mask,
1330 RS_NET_SYN, &new);
1331 }
1332
1333 } else {
1334 ifp->int_state &= ~IS_NEED_NET_SYN;
1335
1336 rt = rtget(ifp->int_std_addr,
1337 ifp->int_std_mask);
1338 if (rt != 0
1339 && (rt->rt_state & RS_NET_SYN)
1340 && rt->rt_ifp == ifp)
1341 rtbad_sub(rt);
1342 }
1343}
1344
1345
1346/* Add route for interface if not currently installed.
1347 * Create route to other end if a point-to-point link,
1348 * otherwise a route to this (sub)network.
1349 */
1350int /* 0=bad interface */
1351addrouteforif(struct interface *ifp)
1352{
1353 struct rt_entry *rt;
1354 static struct rt_spare new;
1355 naddr dst;
1356
1357
1358 /* skip sick interfaces
1359 */
1360 if (ifp->int_state & IS_BROKE)
1361 return 0;
1362
1363 /* If the interface on a subnet, then install a RIPv1 route to
1364 * the network as well (unless it is sick).
1365 */
1366 if (ifp->int_state & IS_SUBNET)
1367 check_net_syn(ifp);
1368
1369 dst = (0 != (ifp->int_if_flags & (IFF_POINTOPOINT | IFF_LOOPBACK))
1370 ? ifp->int_dstaddr
1371 : htonl(ifp->int_net));
1372
1373 new.rts_ifp = ifp;
1374 new.rts_router = ifp->int_addr;
1375 new.rts_gate = ifp->int_addr;
1376 new.rts_metric = ifp->int_metric;
1377 new.rts_time = now.tv_sec;
1378
1379 /* If we are going to send packets to the gateway,
1380 * it must be reachable using our physical interfaces
1381 */
1382 if ((ifp->int_state & IS_REMOTE)
1383 && !(ifp->int_state & IS_EXTERNAL)
1384 && !check_remote(ifp))
1385 return 0;
1386
1387 /* We are finished if the correct main interface route exists.
1388 * The right route must be for the right interface, not synthesized
1389 * from a subnet, be a "gateway" or not as appropriate, and so forth.
1390 */
1391 del_static(dst, ifp->int_mask, 0, 0);
1392 rt = rtget(dst, ifp->int_mask);
1393 if (rt != 0) {
1394 if ((rt->rt_ifp != ifp
1395 || rt->rt_router != ifp->int_addr)
1396 && (!(ifp->int_state & IS_DUP)
1397 || rt->rt_ifp == 0
1398 || (rt->rt_ifp->int_state & IS_BROKE))) {
1399 rtdelete(rt);
1400 rt = 0;
1401 } else {
1402 rtchange(rt, ((rt->rt_state | RS_IF)
1403 & ~(RS_NET_SYN | RS_LOCAL)),
1404 &new, 0);
1405 }
1406 }
1407 if (rt == 0) {
1408 if (ifp->int_transitions++ > 0)
1409 trace_act("re-install interface %s",
1410 ifp->int_name);
1411
1412 rtadd(dst, ifp->int_mask, RS_IF, &new);
1413 }
1414
1415 return 1;
1416}
|