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