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