1 /* $NetBSD: vif.c,v 1.19 2015/02/05 16:50:19 gdt Exp $ */
2
3 /*
4 * The mrouted program is covered by the license in the accompanying file
5 * named "LICENSE". Use of the mrouted program represents acceptance of
6 * the terms and conditions listed in that file.
7 *
8 * The mrouted program is COPYRIGHT 1989 by The Board of Trustees of
9 * Leland Stanford Junior University.
10 */
11
12
13 #include "defs.h"
14 #include <fcntl.h>
15
16 /*
17 * Exported variables.
18 */
19 struct uvif uvifs[MAXVIFS]; /* array of virtual interfaces */
20 vifi_t numvifs; /* number of vifs in use */
21 int vifs_down; /* 1=>some interfaces are down */
22 int phys_vif; /* An enabled vif */
23 int udp_socket; /* Since the honkin' kernel doesn't support */
24 /* ioctls on raw IP sockets, we need a UDP */
25 /* socket as well as our IGMP (raw) socket. */
26 /* How dumb. */
27 int vifs_with_neighbors; /* == 1 if I am a leaf */
28
29 typedef struct {
30 vifi_t vifi;
31 struct listaddr *g;
32 int q_time;
33 } cbk_t;
34
35 /*
36 * Forward declarations.
37 */
38 static void start_vif(vifi_t vifi);
39 static void start_vif2(vifi_t vifi);
40 static void stop_vif(vifi_t vifi);
41 static void age_old_hosts(void);
42 static void send_probe_on_vif(struct uvif *v);
43 static int info_version(char *p, size_t);
44 static void DelVif(void *arg);
45 static int SetTimer(vifi_t vifi, struct listaddr *g);
46 static int DeleteTimer(int id);
47 static void SendQuery(void *arg);
48 static int SetQueryTimer(struct listaddr *g, vifi_t vifi, int to_expire,
49 int q_time);
50
51
52 /*
53 * Initialize the virtual interfaces, but do not install
54 * them in the kernel. Start routing on all vifs that are
55 * not down or disabled.
56 */
57 void
init_vifs(void)58 init_vifs(void)
59 {
60 vifi_t vifi;
61 struct uvif *v;
62 int enabled_vifs, enabled_phyints;
63 extern char *configfilename;
64
65 numvifs = 0;
66 vifs_with_neighbors = 0;
67 vifs_down = FALSE;
68
69 /*
70 * Configure the vifs based on the interface configuration of the
71 * the kernel and the contents of the configuration file.
72 * (Open a UDP socket for ioctl use in the config procedures.)
73 */
74 if ((udp_socket = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
75 logit(LOG_ERR, errno, "UDP socket");
76 logit(LOG_INFO,0,"Getting vifs from kernel interfaces");
77 config_vifs_from_kernel();
78 logit(LOG_INFO,0,"Getting vifs from %s",configfilename);
79 config_vifs_from_file();
80
81 /*
82 * Quit if there are fewer than two enabled vifs.
83 */
84 enabled_vifs = 0;
85 enabled_phyints = 0;
86 phys_vif = -1;
87 for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) {
88 if (!(v->uv_flags & VIFF_DISABLED)) {
89 ++enabled_vifs;
90 if (!(v->uv_flags & VIFF_TUNNEL)) {
91 if (phys_vif == -1)
92 phys_vif = vifi;
93 ++enabled_phyints;
94 }
95 }
96 }
97 if (enabled_vifs < 2)
98 logit(LOG_ERR, 0, "can't forward: %s",
99 enabled_vifs == 0 ? "no enabled vifs" : "only one enabled vif");
100
101 if (enabled_phyints == 0)
102 logit(LOG_WARNING, 0,
103 "no enabled interfaces, forwarding via tunnels only");
104
105 logit(LOG_INFO, 0, "Installing vifs in mrouted...");
106 for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) {
107 if (!(v->uv_flags & VIFF_DISABLED)) {
108 if (!(v->uv_flags & VIFF_DOWN)) {
109 if (v->uv_flags & VIFF_TUNNEL)
110 logit(LOG_INFO, 0, "vif #%d, tunnel %s -> %s", vifi,
111 inet_fmt(v->uv_lcl_addr),
112 inet_fmt(v->uv_rmt_addr));
113 else
114 logit(LOG_INFO, 0, "vif #%d, phyint %s", vifi,
115 inet_fmt(v->uv_lcl_addr));
116 start_vif2(vifi);
117 } else logit(LOG_INFO, 0,
118 "%s is not yet up; vif #%u not in service",
119 v->uv_name, vifi);
120 }
121 }
122 }
123
124 /*
125 * Start routing on all virtual interfaces that are not down or
126 * administratively disabled.
127 */
128 void
init_installvifs(void)129 init_installvifs(void)
130 {
131 vifi_t vifi;
132 struct uvif *v;
133
134 logit(LOG_INFO, 0, "Installing vifs in kernel...");
135 for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) {
136 if (!(v->uv_flags & VIFF_DISABLED)) {
137 if (!(v->uv_flags & VIFF_DOWN)) {
138 if (v->uv_flags & VIFF_TUNNEL)
139 logit(LOG_INFO, 0, "vif #%d, tunnel %s -> %s", vifi,
140 inet_fmt(v->uv_lcl_addr),
141 inet_fmt(v->uv_rmt_addr));
142 else
143 logit(LOG_INFO, 0, "vif #%d, phyint %s", vifi,
144 inet_fmt(v->uv_lcl_addr));
145 k_add_vif(vifi, &uvifs[vifi]);
146 } else logit(LOG_INFO, 0,
147 "%s is not yet up; vif #%u not in service",
148 v->uv_name, vifi);
149 }
150 }
151 }
152
153 /*
154 * See if any interfaces have changed from up state to down, or vice versa,
155 * including any non-multicast-capable interfaces that are in use as local
156 * tunnel end-points. Ignore interfaces that have been administratively
157 * disabled.
158 */
159 void
check_vif_state(void)160 check_vif_state(void)
161 {
162 vifi_t vifi;
163 struct uvif *v;
164 struct ifreq ifr;
165
166 vifs_down = FALSE;
167 for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) {
168
169 if (v->uv_flags & VIFF_DISABLED) continue;
170
171 strncpy(ifr.ifr_name, v->uv_name, IFNAMSIZ);
172 if (ioctl(udp_socket, SIOCGIFFLAGS, (char *)&ifr) < 0)
173 logit(LOG_ERR, errno,
174 "ioctl SIOCGIFFLAGS for %s", ifr.ifr_name);
175
176 if (v->uv_flags & VIFF_DOWN) {
177 if (ifr.ifr_flags & IFF_UP) {
178 v->uv_flags &= ~VIFF_DOWN;
179 start_vif(vifi);
180 logit(LOG_INFO, 0,
181 "%s has come up; vif #%u now in service",
182 v->uv_name, vifi);
183 }
184 else vifs_down = TRUE;
185 }
186 else {
187 if (!(ifr.ifr_flags & IFF_UP)) {
188 stop_vif(vifi);
189 v->uv_flags |= VIFF_DOWN;
190 logit(LOG_INFO, 0,
191 "%s has gone down; vif #%u taken out of service",
192 v->uv_name, vifi);
193 vifs_down = TRUE;
194 }
195 }
196 }
197 }
198
199 /*
200 * Send a probe message on vif v
201 */
202 static void
send_probe_on_vif(struct uvif * v)203 send_probe_on_vif(struct uvif *v)
204 {
205 char *p;
206 int datalen = 0;
207 struct listaddr *nbr;
208 int i;
209
210 p = send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN;
211
212 for (i = 0; i < 4; i++)
213 *p++ = ((char *)&(dvmrp_genid))[i];
214 datalen += 4;
215
216 /*
217 * add the neighbor list on the interface to the message
218 */
219 nbr = v->uv_neighbors;
220
221 while (nbr) {
222 for (i = 0; i < 4; i++)
223 *p++ = ((char *)&nbr->al_addr)[i];
224 datalen +=4;
225 nbr = nbr->al_next;
226 }
227
228 send_igmp(v->uv_lcl_addr,
229 (v->uv_flags & VIFF_TUNNEL) ? v->uv_rmt_addr
230 : dvmrp_group,
231 IGMP_DVMRP, DVMRP_PROBE,
232 htonl(MROUTED_LEVEL |
233 ((v->uv_flags & VIFF_LEAF) ? 0 : LEAF_FLAGS)),
234 datalen);
235 }
236
237 /*
238 * Add a vifi to the kernel and start routing on it.
239 */
240 static void
start_vif(vifi_t vifi)241 start_vif(vifi_t vifi)
242 {
243 /*
244 * Install the interface in the kernel's vif structure.
245 */
246 k_add_vif(vifi, &uvifs[vifi]);
247
248 start_vif2(vifi);
249 }
250
251 /*
252 * Add a vifi to all the user-level data structures but don't add
253 * it to the kernel yet.
254 */
255 static void
start_vif2(vifi_t vifi)256 start_vif2(vifi_t vifi)
257 {
258 struct uvif *v;
259 u_int32_t src;
260 struct phaddr *p;
261
262 v = &uvifs[vifi];
263 src = v->uv_lcl_addr;
264
265 /*
266 * Update the existing route entries to take into account the new vif.
267 */
268 add_vif_to_routes(vifi);
269
270 if (!(v->uv_flags & VIFF_TUNNEL)) {
271 /*
272 * Join the DVMRP multicast group on the interface.
273 * (This is not strictly necessary, since the kernel promiscuously
274 * receives IGMP packets addressed to ANY IP multicast group while
275 * multicast routing is enabled. However, joining the group allows
276 * this host to receive non-IGMP packets as well, such as 'pings'.)
277 */
278 k_join(dvmrp_group, src);
279
280 /*
281 * Join the ALL-ROUTERS multicast group on the interface.
282 * This allows mtrace requests to loop back if they are run
283 * on the multicast router.
284 */
285 k_join(allrtrs_group, src);
286
287 /*
288 * Install an entry in the routing table for the subnet to which
289 * the interface is connected.
290 */
291 start_route_updates();
292 update_route(v->uv_subnet, v->uv_subnetmask, 0, 0, vifi);
293 for (p = v->uv_addrs; p; p = p->pa_next) {
294 start_route_updates();
295 update_route(p->pa_subnet, p->pa_subnetmask, 0, 0, vifi);
296 }
297
298 /*
299 * Until neighbors are discovered, assume responsibility for sending
300 * periodic group membership queries to the subnet. Send the first
301 * query.
302 */
303 v->uv_flags |= VIFF_QUERIER;
304 send_igmp(src, allhosts_group, IGMP_HOST_MEMBERSHIP_QUERY,
305 (v->uv_flags & VIFF_IGMPV1) ? 0 :
306 IGMP_MAX_HOST_REPORT_DELAY * IGMP_TIMER_SCALE, 0, 0);
307 age_old_hosts();
308 }
309
310 v->uv_leaf_timer = LEAF_CONFIRMATION_TIME;
311
312 /*
313 * Send a probe via the new vif to look for neighbors.
314 */
315 send_probe_on_vif(v);
316 }
317
318 /*
319 * Stop routing on the specified virtual interface.
320 */
321 static void
stop_vif(vifi_t vifi)322 stop_vif(vifi_t vifi)
323 {
324 struct uvif *v;
325 struct listaddr *a;
326 struct phaddr *p;
327
328 v = &uvifs[vifi];
329
330 if (!(v->uv_flags & VIFF_TUNNEL)) {
331 /*
332 * Depart from the DVMRP multicast group on the interface.
333 */
334 k_leave(dvmrp_group, v->uv_lcl_addr);
335
336 /*
337 * Depart from the ALL-ROUTERS multicast group on the interface.
338 */
339 k_leave(allrtrs_group, v->uv_lcl_addr);
340
341 /*
342 * Update the entry in the routing table for the subnet to which
343 * the interface is connected, to take into account the interface
344 * failure.
345 */
346 start_route_updates();
347 update_route(v->uv_subnet, v->uv_subnetmask, UNREACHABLE, 0, vifi);
348 for (p = v->uv_addrs; p; p = p->pa_next) {
349 start_route_updates();
350 update_route(p->pa_subnet, p->pa_subnetmask, UNREACHABLE, 0, vifi);
351 }
352
353 /*
354 * Discard all group addresses. (No need to tell kernel;
355 * the k_del_vif() call, below, will clean up kernel state.)
356 */
357 while (v->uv_groups != NULL) {
358 a = v->uv_groups;
359 v->uv_groups = a->al_next;
360 free((char *)a);
361 }
362
363 v->uv_flags &= ~VIFF_QUERIER;
364 }
365
366 /*
367 * Update the existing route entries to take into account the vif failure.
368 */
369 delete_vif_from_routes(vifi);
370
371 /*
372 * Delete the interface from the kernel's vif structure.
373 */
374 k_del_vif(vifi);
375
376 /*
377 * Discard all neighbor addresses.
378 */
379 if (v->uv_neighbors)
380 vifs_with_neighbors--;
381
382 while (v->uv_neighbors != NULL) {
383 a = v->uv_neighbors;
384 v->uv_neighbors = a->al_next;
385 free((char *)a);
386 }
387 }
388
389
390 /*
391 * stop routing on all vifs
392 */
393 void
stop_all_vifs(void)394 stop_all_vifs(void)
395 {
396 vifi_t vifi;
397 struct uvif *v;
398 struct listaddr *a;
399 struct vif_acl *acl;
400
401 for (vifi = 0; vifi < numvifs; vifi++) {
402 v = &uvifs[vifi];
403 while (v->uv_groups != NULL) {
404 a = v->uv_groups;
405 v->uv_groups = a->al_next;
406 free((char *)a);
407 }
408 while (v->uv_neighbors != NULL) {
409 a = v->uv_neighbors;
410 v->uv_neighbors = a->al_next;
411 free((char *)a);
412 }
413 while (v->uv_acl != NULL) {
414 acl = v->uv_acl;
415 v->uv_acl = acl->acl_next;
416 free((char *)acl);
417 }
418 }
419 }
420
421
422 /*
423 * Find the virtual interface from which an incoming packet arrived,
424 * based on the packet's source and destination IP addresses.
425 */
426 vifi_t
find_vif(u_int32_t src,u_int32_t dst)427 find_vif(u_int32_t src, u_int32_t dst)
428 {
429 vifi_t vifi;
430 struct uvif *v;
431 struct phaddr *p;
432
433 for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) {
434 if (!(v->uv_flags & (VIFF_DOWN|VIFF_DISABLED))) {
435 if (v->uv_flags & VIFF_TUNNEL) {
436 if (src == v->uv_rmt_addr && dst == v->uv_lcl_addr)
437 return(vifi);
438 }
439 else {
440 if ((src & v->uv_subnetmask) == v->uv_subnet &&
441 ((v->uv_subnetmask == 0xffffffff) ||
442 (src != v->uv_subnetbcast)))
443 return(vifi);
444 for (p=v->uv_addrs; p; p=p->pa_next) {
445 if ((src & p->pa_subnetmask) == p->pa_subnet &&
446 ((p->pa_subnetmask == 0xffffffff) ||
447 (src != p->pa_subnetbcast)))
448 return(vifi);
449 }
450 }
451 }
452 }
453 return (NO_VIF);
454 }
455
456 static void
age_old_hosts(void)457 age_old_hosts(void)
458 {
459 vifi_t vifi;
460 struct uvif *v;
461 struct listaddr *g;
462
463 /*
464 * Decrement the old-hosts-present timer for each
465 * active group on each vif.
466 */
467 for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++)
468 for (g = v->uv_groups; g != NULL; g = g->al_next)
469 if (g->al_old)
470 g->al_old--;
471 }
472
473
474 /*
475 * Send group membership queries to all subnets for which I am querier.
476 */
477 void
query_groups(void)478 query_groups(void)
479 {
480 vifi_t vifi;
481 struct uvif *v;
482
483 for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) {
484 if (v->uv_flags & VIFF_QUERIER) {
485 send_igmp(v->uv_lcl_addr, allhosts_group,
486 IGMP_HOST_MEMBERSHIP_QUERY,
487 (v->uv_flags & VIFF_IGMPV1) ? 0 :
488 IGMP_MAX_HOST_REPORT_DELAY * IGMP_TIMER_SCALE, 0, 0);
489 }
490 }
491 age_old_hosts();
492 }
493
494 /*
495 * Process an incoming host membership query
496 */
497 void
accept_membership_query(u_int32_t src,u_int32_t dst,u_int32_t group,int tmo)498 accept_membership_query(u_int32_t src, u_int32_t dst, u_int32_t group, int tmo)
499 {
500 vifi_t vifi;
501 struct uvif *v;
502
503 if ((vifi = find_vif(src, dst)) == NO_VIF ||
504 (uvifs[vifi].uv_flags & VIFF_TUNNEL)) {
505 logit(LOG_INFO, 0,
506 "ignoring group membership query from non-adjacent host %s",
507 inet_fmt(src));
508 return;
509 }
510
511 v = &uvifs[vifi];
512
513 /*
514 * If we consider ourselves the querier for this vif, but hear a
515 * query from a router with a lower IP address, yield to them.
516 *
517 * This is done here as well as in the neighbor discovery in case
518 * there is a querier that doesn't speak DVMRP.
519 *
520 * XXX If this neighbor doesn't speak DVMRP, then we need to create
521 * some neighbor state for him so that we can time him out!
522 */
523 if ((v->uv_flags & VIFF_QUERIER) &&
524 (ntohl(src) < ntohl(v->uv_lcl_addr))) {
525 v->uv_flags &= ~VIFF_QUERIER;
526
527 }
528 }
529
530 /*
531 * Process an incoming group membership report.
532 */
533 void
accept_group_report(u_int32_t src,u_int32_t dst,u_int32_t group,int r_type)534 accept_group_report(u_int32_t src, u_int32_t dst, u_int32_t group, int r_type)
535 {
536 vifi_t vifi;
537 struct uvif *v;
538 struct listaddr *g;
539
540 if ((vifi = find_vif(src, dst)) == NO_VIF ||
541 (uvifs[vifi].uv_flags & VIFF_TUNNEL)) {
542 logit(LOG_INFO, 0,
543 "ignoring group membership report from non-adjacent host %s",
544 inet_fmt(src));
545 return;
546 }
547
548 v = &uvifs[vifi];
549
550 /*
551 * Look for the group in our group list; if found, reset its timer.
552 */
553 for (g = v->uv_groups; g != NULL; g = g->al_next) {
554 if (group == g->al_addr) {
555 if (r_type == IGMP_v1_HOST_MEMBERSHIP_REPORT)
556 g->al_old = OLD_AGE_THRESHOLD;
557 #ifdef SNMP
558 g->al_genid = src;
559 #endif /* SNMP */
560
561 /** delete old timers, set a timer for expiration **/
562 g->al_timer = GROUP_EXPIRE_TIME;
563 if (g->al_query)
564 g->al_query = DeleteTimer(g->al_query);
565 if (g->al_timerid)
566 g->al_timerid = DeleteTimer(g->al_timerid);
567 g->al_timerid = SetTimer(vifi, g);
568 break;
569 }
570 }
571
572 /*
573 * If not found, add it to the list and update kernel cache.
574 */
575 if (g == NULL) {
576 g = (struct listaddr *)malloc(sizeof(struct listaddr));
577 if (g == NULL) {
578 logit(LOG_ERR, 0, "ran out of memory"); /* fatal */
579 return;
580 }
581
582 g->al_addr = group;
583 if (r_type == IGMP_v2_HOST_MEMBERSHIP_REPORT)
584 g->al_old = 0;
585 else
586 g->al_old = OLD_AGE_THRESHOLD;
587 #ifdef SNMP
588 g->al_genid = src;
589 #endif
590
591 /** set a timer for expiration **/
592 g->al_query = 0;
593 g->al_timer = GROUP_EXPIRE_TIME;
594 time(&g->al_ctime);
595 g->al_timerid = SetTimer(vifi, g);
596 g->al_next = v->uv_groups;
597 v->uv_groups = g;
598
599 update_lclgrp(vifi, group);
600 }
601
602 /*
603 * Check if a graft is necessary for this group
604 */
605 chkgrp_graft(vifi, group);
606 }
607
608
609 void
accept_leave_message(u_int32_t src,u_int32_t dst,u_int32_t group)610 accept_leave_message(u_int32_t src, u_int32_t dst, u_int32_t group)
611 {
612 vifi_t vifi;
613 struct uvif *v;
614 struct listaddr *g;
615
616 if ((vifi = find_vif(src, dst)) == NO_VIF ||
617 (uvifs[vifi].uv_flags & VIFF_TUNNEL)) {
618 logit(LOG_INFO, 0,
619 "ignoring group leave report from non-adjacent host %s",
620 inet_fmt(src));
621 return;
622 }
623
624 v = &uvifs[vifi];
625
626 if (!(v->uv_flags & VIFF_QUERIER) || (v->uv_flags & VIFF_IGMPV1))
627 return;
628
629 /*
630 * Look for the group in our group list in order to set up a short-timeout
631 * query.
632 */
633 for (g = v->uv_groups; g != NULL; g = g->al_next) {
634 if (group == g->al_addr) {
635 logit(LOG_DEBUG, 0,
636 "[vif.c, _accept_leave_message] %d %ld\n",
637 g->al_old, g->al_query);
638
639 /* Ignore the leave message if there are old hosts present */
640 if (g->al_old)
641 return;
642
643 /* still waiting for a reply to a query, ignore the leave */
644 if (g->al_query)
645 return;
646
647 /** delete old timer set a timer for expiration **/
648 if (g->al_timerid)
649 g->al_timerid = DeleteTimer(g->al_timerid);
650
651 /** send a group specific querry **/
652 g->al_timer = LEAVE_EXPIRE_TIME;
653 send_igmp(v->uv_lcl_addr, g->al_addr,
654 IGMP_HOST_MEMBERSHIP_QUERY,
655 LEAVE_EXPIRE_TIME / 3 * IGMP_TIMER_SCALE,
656 g->al_addr, 0);
657 g->al_query = SetQueryTimer(g, vifi, g->al_timer / 3,
658 LEAVE_EXPIRE_TIME / 3 * IGMP_TIMER_SCALE);
659 g->al_timerid = SetTimer(vifi, g);
660 break;
661 }
662 }
663 }
664
665
666 /*
667 * Send a periodic probe on all vifs.
668 * Useful to determine one-way interfaces.
669 * Detect neighbor loss faster.
670 */
671 void
probe_for_neighbors(void)672 probe_for_neighbors(void)
673 {
674 vifi_t vifi;
675 struct uvif *v;
676
677 for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) {
678 if (!(v->uv_flags & (VIFF_DOWN|VIFF_DISABLED))) {
679 send_probe_on_vif(v);
680 }
681 }
682 }
683
684
685 /*
686 * Send a list of all of our neighbors to the requestor, `src'.
687 */
688 void
accept_neighbor_request(u_int32_t src,u_int32_t dst)689 accept_neighbor_request(u_int32_t src, u_int32_t dst)
690 {
691 vifi_t vifi;
692 struct uvif *v;
693 u_char *p, *ncount;
694 struct listaddr *la;
695 int datalen;
696 u_int32_t temp_addr, us, them = src;
697
698 /* Determine which of our addresses to use as the source of our response
699 * to this query.
700 */
701 if (IN_MULTICAST(ntohl(dst))) { /* query sent to a multicast group */
702 int udp; /* find best interface to reply on */
703 struct sockaddr_in addr;
704 socklen_t addrlen = sizeof(addr);
705
706 memset(&addr, 0, sizeof(addr));
707 addr.sin_family = AF_INET;
708 #if (defined(BSD) && (BSD >= 199103))
709 addr.sin_len = sizeof addr;
710 #endif
711 addr.sin_addr.s_addr = dst;
712 addr.sin_port = htons(2000); /* any port over 1024 will do... */
713 if ((udp = socket(AF_INET, SOCK_DGRAM, 0)) < 0
714 || connect(udp, (struct sockaddr *) &addr, sizeof(addr)) < 0
715 || getsockname(udp, (struct sockaddr *) &addr, &addrlen) < 0) {
716 logit(LOG_WARNING, errno, "Determining local address");
717 close(udp);
718 return;
719 }
720 close(udp);
721 us = addr.sin_addr.s_addr;
722 } else /* query sent to us alone */
723 us = dst;
724
725 #define PUT_ADDR(a) temp_addr = ntohl(a); \
726 *p++ = temp_addr >> 24; \
727 *p++ = (temp_addr >> 16) & 0xFF; \
728 *p++ = (temp_addr >> 8) & 0xFF; \
729 *p++ = temp_addr & 0xFF;
730
731 p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN);
732 datalen = 0;
733
734 for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) {
735 if (v->uv_flags & VIFF_DISABLED)
736 continue;
737
738 ncount = 0;
739
740 for (la = v->uv_neighbors; la; la = la->al_next) {
741
742 /* Make sure that there's room for this neighbor... */
743 if (datalen + (ncount == 0 ? 4 + 3 + 4 : 4) > MAX_DVMRP_DATA_LEN) {
744 send_igmp(us, them, IGMP_DVMRP, DVMRP_NEIGHBORS,
745 htonl(MROUTED_LEVEL), datalen);
746 p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN);
747 datalen = 0;
748 ncount = 0;
749 }
750
751 /* Put out the header for this neighbor list... */
752 if (ncount == 0) {
753 PUT_ADDR(v->uv_lcl_addr);
754 *p++ = v->uv_metric;
755 *p++ = v->uv_threshold;
756 ncount = p;
757 *p++ = 0;
758 datalen += 4 + 3;
759 }
760
761 PUT_ADDR(la->al_addr);
762 datalen += 4;
763 (*ncount)++;
764 }
765 }
766
767 if (datalen != 0)
768 send_igmp(us, them, IGMP_DVMRP, DVMRP_NEIGHBORS, htonl(MROUTED_LEVEL),
769 datalen);
770 }
771
772 /*
773 * Send a list of all of our neighbors to the requestor, `src'.
774 */
775 void
accept_neighbor_request2(u_int32_t src,u_int32_t dst)776 accept_neighbor_request2(u_int32_t src, u_int32_t dst)
777 {
778 vifi_t vifi;
779 struct uvif *v;
780 u_char *p, *ncount;
781 struct listaddr *la;
782 int datalen;
783 u_int32_t us, them = src;
784
785 /* Determine which of our addresses to use as the source of our response
786 * to this query.
787 */
788 if (IN_MULTICAST(ntohl(dst))) { /* query sent to a multicast group */
789 int udp; /* find best interface to reply on */
790 struct sockaddr_in addr;
791 socklen_t addrlen = sizeof(addr);
792
793 memset(&addr, 0, sizeof(addr));
794 addr.sin_family = AF_INET;
795 #if (defined(BSD) && (BSD >= 199103))
796 addr.sin_len = sizeof addr;
797 #endif
798 addr.sin_addr.s_addr = dst;
799 addr.sin_port = htons(2000); /* any port over 1024 will do... */
800 if ((udp = socket(AF_INET, SOCK_DGRAM, 0)) < 0
801 || connect(udp, (struct sockaddr *) &addr, sizeof(addr)) < 0
802 || getsockname(udp, (struct sockaddr *) &addr, &addrlen) < 0) {
803 logit(LOG_WARNING, errno, "Determining local address");
804 close(udp);
805 return;
806 }
807 close(udp);
808 us = addr.sin_addr.s_addr;
809 } else /* query sent to us alone */
810 us = dst;
811
812 p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN);
813 datalen = 0;
814
815 for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) {
816 u_short vflags = v->uv_flags;
817 u_char rflags = 0;
818 if (vflags & VIFF_TUNNEL)
819 rflags |= DVMRP_NF_TUNNEL;
820 if (vflags & VIFF_SRCRT)
821 rflags |= DVMRP_NF_SRCRT;
822 if (vflags & VIFF_DOWN)
823 rflags |= DVMRP_NF_DOWN;
824 if (vflags & VIFF_DISABLED)
825 rflags |= DVMRP_NF_DISABLED;
826 if (vflags & VIFF_QUERIER)
827 rflags |= DVMRP_NF_QUERIER;
828 if (vflags & VIFF_LEAF)
829 rflags |= DVMRP_NF_LEAF;
830 ncount = 0;
831 la = v->uv_neighbors;
832 if (la == NULL) {
833 /*
834 * include down & disabled interfaces and interfaces on
835 * leaf nets.
836 */
837 if (rflags & DVMRP_NF_TUNNEL)
838 rflags |= DVMRP_NF_DOWN;
839 if (datalen > MAX_DVMRP_DATA_LEN - 12) {
840 send_igmp(us, them, IGMP_DVMRP, DVMRP_NEIGHBORS2,
841 htonl(MROUTED_LEVEL), datalen);
842 p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN);
843 datalen = 0;
844 }
845 *(u_int*)p = v->uv_lcl_addr;
846 p += 4;
847 *p++ = v->uv_metric;
848 *p++ = v->uv_threshold;
849 *p++ = rflags;
850 *p++ = 1;
851 *(u_int*)p = v->uv_rmt_addr;
852 p += 4;
853 datalen += 12;
854 } else {
855 for ( ; la; la = la->al_next) {
856 /* Make sure that there's room for this neighbor... */
857 if (datalen + (ncount == 0 ? 4+4+4 : 4) > MAX_DVMRP_DATA_LEN) {
858 send_igmp(us, them, IGMP_DVMRP, DVMRP_NEIGHBORS2,
859 htonl(MROUTED_LEVEL), datalen);
860 p = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN);
861 datalen = 0;
862 ncount = 0;
863 }
864 /* Put out the header for this neighbor list... */
865 if (ncount == 0) {
866 *(u_int*)p = v->uv_lcl_addr;
867 p += 4;
868 *p++ = v->uv_metric;
869 *p++ = v->uv_threshold;
870 *p++ = rflags;
871 ncount = p;
872 *p++ = 0;
873 datalen += 4 + 4;
874 }
875 *(u_int*)p = la->al_addr;
876 p += 4;
877 datalen += 4;
878 (*ncount)++;
879 }
880 }
881 }
882 if (datalen != 0)
883 send_igmp(us, them, IGMP_DVMRP, DVMRP_NEIGHBORS2, htonl(MROUTED_LEVEL),
884 datalen);
885 }
886
887 void
accept_info_request(u_int32_t src,u_int32_t dst,u_char * p,int datalen)888 accept_info_request(u_int32_t src, u_int32_t dst, u_char *p, int datalen)
889 {
890 u_char *q;
891 int len;
892 int outlen = 0;
893
894 q = (u_char *) (send_buf + MIN_IP_HEADER_LEN + IGMP_MINLEN);
895
896 /* To be general, this must deal properly with breaking up over-sized
897 * packets. That implies passing a length to each function, and
898 * allowing each function to request to be called again. Right now,
899 * we're only implementing the one thing we are positive will fit into
900 * a single packet, so we wimp out.
901 */
902 while (datalen > 0) {
903 len = 0;
904 switch (*p) {
905 case DVMRP_INFO_VERSION:
906 len = info_version((char *)q,
907 send_buflen - MIN_IP_HEADER_LEN - IGMP_MINLEN);
908 break;
909
910 case DVMRP_INFO_NEIGHBORS:
911 default:
912 logit(LOG_INFO, 0, "ignoring unknown info type %d", *p);
913 break;
914 }
915 *(q+1) = len++;
916 outlen += len * 4;
917 q += len * 4;
918 len = (*(p+1) + 1) * 4;
919 p += len;
920 datalen -= len;
921 }
922
923 if (outlen != 0)
924 send_igmp(INADDR_ANY, src, IGMP_DVMRP, DVMRP_INFO_REPLY,
925 htonl(MROUTED_LEVEL), outlen);
926 }
927
928 /*
929 * Information response -- return version string
930 */
931 static int
info_version(char * p,size_t l)932 info_version(char *p, size_t l)
933 {
934 int len;
935 extern char versionstring[];
936
937 if (l < 4 + strlen(versionstring) + 1)
938 return -1;
939 p[0] = DVMRP_INFO_VERSION;
940 /* skip over length */
941 p[2] = 0; /* zero out */
942 p[3] = 0; /* reserved fields */
943 strlcpy(p + 4, versionstring, l - 4);
944
945 len = strlen(versionstring);
946 return ((len + 3) / 4);
947 }
948
949 /*
950 * Process an incoming neighbor-list message.
951 */
952 void
accept_neighbors(u_int32_t src,u_int32_t dst,u_char * p,int datalen,u_int32_t level)953 accept_neighbors(u_int32_t src, u_int32_t dst, u_char *p, int datalen,
954 u_int32_t level)
955 {
956 logit(LOG_INFO, 0, "ignoring spurious DVMRP neighbor list from %s to %s",
957 inet_fmt(src), inet_fmt(dst));
958 }
959
960
961 /*
962 * Process an incoming neighbor-list message.
963 */
964 void
accept_neighbors2(u_int32_t src,u_int32_t dst,u_char * p,int datalen,u_int32_t level)965 accept_neighbors2(u_int32_t src, u_int32_t dst, u_char *p, int datalen,
966 u_int32_t level)
967 {
968 logit(LOG_INFO, 0, "ignoring spurious DVMRP neighbor list2 from %s to %s",
969 inet_fmt(src), inet_fmt(dst));
970 }
971
972 /*
973 * Process an incoming info reply message.
974 */
975 void
accept_info_reply(u_int32_t src,u_int32_t dst,u_char * p,int datalen)976 accept_info_reply(u_int32_t src, u_int32_t dst, u_char *p, int datalen)
977 {
978 logit(LOG_INFO, 0, "ignoring spurious DVMRP info reply from %s to %s",
979 inet_fmt(src), inet_fmt(dst));
980 }
981
982
983 /*
984 * Update the neighbor entry for neighbor 'addr' on vif 'vifi'.
985 * 'msgtype' is the type of DVMRP message received from the neighbor.
986 * Return TRUE if 'addr' is a valid neighbor, FALSE otherwise.
987 */
988 int
update_neighbor(vifi_t vifi,u_int32_t addr,int msgtype,char * p,int datalen,u_int32_t level)989 update_neighbor(vifi_t vifi, u_int32_t addr, int msgtype, char *p, int datalen, u_int32_t level)
990 {
991 struct uvif *v;
992 struct listaddr *n;
993 u_int32_t genid = 0;
994 u_int32_t router;
995 u_int32_t send_tables = 0;
996 int do_reset = FALSE;
997 int nflags;
998
999 v = &uvifs[vifi];
1000 nflags = (level >> 16) & 0xff;
1001
1002 /*
1003 * Confirm that 'addr' is a valid neighbor address on vif 'vifi'.
1004 * IT IS ASSUMED that this was preceded by a call to find_vif(), which
1005 * checks that 'addr' is either a valid remote tunnel endpoint or a
1006 * non-broadcast address belonging to a directly-connected subnet.
1007 * Therefore, here we check only that 'addr' is not our own address
1008 * (due to an impostor or erroneous loopback) or an address of the form
1009 * {subnet,0} ("the unknown host"). These checks are not performed in
1010 * find_vif() because those types of address are acceptable for some
1011 * types of IGMP message (such as group membership reports).
1012 */
1013 if (!(v->uv_flags & VIFF_TUNNEL) &&
1014 (addr == v->uv_lcl_addr ||
1015 addr == v->uv_subnet )) {
1016 logit(LOG_WARNING, 0,
1017 "received DVMRP message from 'the unknown host' or self: %s",
1018 inet_fmt(addr));
1019 return (FALSE);
1020 }
1021
1022 /*
1023 * Look for addr in list of neighbors.
1024 */
1025 for (n = v->uv_neighbors; n != NULL; n = n->al_next) {
1026 if (addr == n->al_addr) {
1027 break;
1028 }
1029 }
1030
1031 /*
1032 * Found it. Reset its timer, and check for a version change
1033 */
1034 if (n) {
1035 n->al_timer = 0;
1036
1037 /*
1038 * update the neighbors version and protocol number
1039 * if changed => router went down and came up,
1040 * so take action immediately.
1041 */
1042 if ((n->al_pv != (level & 0xff)) ||
1043 (n->al_mv != ((level >> 8) & 0xff))) {
1044
1045 do_reset = TRUE;
1046 logit(LOG_DEBUG, 0,
1047 "version change neighbor %s [old:%d.%d, new:%d.%d]",
1048 inet_fmt(addr),
1049 n->al_pv, n->al_mv, level&0xff, (level >> 8) & 0xff);
1050
1051 n->al_pv = level & 0xff;
1052 n->al_mv = (level >> 8) & 0xff;
1053 }
1054 } else {
1055 /*
1056 * If not found, add it to the list. If the neighbor has a lower
1057 * IP address than me, yield querier duties to it.
1058 */
1059 logit(LOG_DEBUG, 0, "New neighbor %s on vif %d v%d.%d nf 0x%02x",
1060 inet_fmt(addr), vifi,
1061 level & 0xff, (level >> 8) & 0xff, (level >> 16) & 0xff);
1062
1063 n = (struct listaddr *)malloc(sizeof(struct listaddr));
1064 if (n == NULL) {
1065 logit(LOG_ERR, 0, "ran out of memory"); /* fatal */
1066 return FALSE;
1067 }
1068
1069 n->al_addr = addr;
1070 n->al_pv = level & 0xff;
1071 n->al_mv = (level >> 8) & 0xff;
1072 n->al_genid = 0;
1073
1074 time(&n->al_ctime);
1075 n->al_timer = 0;
1076 n->al_next = v->uv_neighbors;
1077
1078 /*
1079 * If we thought that we had no neighbors on this vif, send a route
1080 * report to the vif. If this is just a new neighbor on the same
1081 * vif, send the route report just to the new neighbor.
1082 */
1083 if (v->uv_neighbors == NULL) {
1084 send_tables = (v->uv_flags & VIFF_TUNNEL) ? addr : dvmrp_group;
1085 vifs_with_neighbors++;
1086 } else {
1087 send_tables = addr;
1088 }
1089
1090 v->uv_neighbors = n;
1091
1092 if (!(v->uv_flags & VIFF_TUNNEL) &&
1093 ntohl(addr) < ntohl(v->uv_lcl_addr))
1094 v->uv_flags &= ~VIFF_QUERIER;
1095 }
1096
1097 /*
1098 * Check if the router gen-ids are the same.
1099 * Need to reset the prune state of the router if not.
1100 * Also check for one-way interfaces by seeing if we are in our
1101 * neighbor's list of known routers.
1102 */
1103 if (msgtype == DVMRP_PROBE) {
1104
1105 /* Check genid neighbor flag. Also check version number; 3.3 and
1106 * 3.4 didn't set this flag. */
1107 if ((((level >> 16) & 0xff) & NF_GENID) ||
1108 (((level & 0xff) == 3) && (((level >> 8) & 0xff) > 2))) {
1109
1110 int i;
1111
1112 if (datalen < 4) {
1113 logit(LOG_WARNING, 0,
1114 "received truncated probe message from %s (len %d)",
1115 inet_fmt(addr), datalen);
1116 return (FALSE);
1117 }
1118
1119 for (i = 0; i < 4; i++)
1120 ((char *)&genid)[i] = *p++;
1121 datalen -= 4;
1122
1123 if (n->al_genid == 0)
1124 n->al_genid = genid;
1125 else if (n->al_genid != genid) {
1126 logit(LOG_DEBUG, 0,
1127 "new genid neigbor %s on vif %d [old:%x, new:%x]",
1128 inet_fmt(addr), vifi, n->al_genid, genid);
1129
1130 n->al_genid = genid;
1131 do_reset = TRUE;
1132 }
1133
1134 /*
1135 * loop through router list and check for one-way ifs.
1136 */
1137
1138 v->uv_flags |= VIFF_ONEWAY;
1139
1140 while (datalen > 0) {
1141 if (datalen < 4) {
1142 logit(LOG_WARNING, 0,
1143 "received truncated probe message from %s (len %d)",
1144 inet_fmt(addr), datalen);
1145 return (FALSE);
1146 }
1147 for (i = 0; i < 4; i++)
1148 ((char *)&router)[i] = *p++;
1149 datalen -= 4;
1150 if (router == v->uv_lcl_addr) {
1151 v->uv_flags &= ~VIFF_ONEWAY;
1152 break;
1153 }
1154 }
1155 }
1156 }
1157 if (n->al_flags != nflags) {
1158 n->al_flags = nflags;
1159
1160 if (n->al_flags & NF_LEAF) {
1161 /*XXX If we have non-leaf neighbors then we know we shouldn't
1162 * mark this vif as a leaf. For now we just count on other
1163 * probes and/or reports resetting the timer. */
1164 if (!v->uv_leaf_timer)
1165 v->uv_leaf_timer = LEAF_CONFIRMATION_TIME;
1166 } else {
1167 /* If we get a leaf to non-leaf transition, we *must* update
1168 * the routing table. */
1169 if (v->uv_flags & VIFF_LEAF && send_tables == 0)
1170 send_tables = addr;
1171 v->uv_flags &= ~VIFF_LEAF;
1172 v->uv_leaf_timer = 0;
1173 }
1174 }
1175 if (do_reset) {
1176 reset_neighbor_state(vifi, addr);
1177 if (!send_tables)
1178 send_tables = addr;
1179 }
1180 if (send_tables)
1181 report(ALL_ROUTES, vifi, send_tables);
1182
1183 return (TRUE);
1184 }
1185
1186
1187 /*
1188 * On every timer interrupt, advance the timer in each neighbor and
1189 * group entry on every vif.
1190 */
1191 void
age_vifs(void)1192 age_vifs(void)
1193 {
1194 vifi_t vifi;
1195 struct uvif *v;
1196 struct listaddr *a, *prev_a, *n;
1197 u_int32_t addr;
1198
1199 for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v ) {
1200 if (v->uv_leaf_timer && (v->uv_leaf_timer -= TIMER_INTERVAL == 0)) {
1201 v->uv_flags |= VIFF_LEAF;
1202 }
1203
1204 for (prev_a = NULL, a = v->uv_neighbors; a != NULL;) {
1205
1206 if ((a->al_timer += TIMER_INTERVAL) < NEIGHBOR_EXPIRE_TIME) {
1207 prev_a = a;
1208 a = a->al_next;
1209 continue;
1210 }
1211
1212 /*
1213 * Neighbor has expired; delete it from the neighbor list,
1214 * delete it from the 'dominants' and 'subordinates arrays of
1215 * any route entries and assume querier duties unless there is
1216 * another neighbor with a lower IP address than mine.
1217 */
1218 addr = a->al_addr;
1219 if (a == v->uv_neighbors) { /* implies prev_a == NULL */
1220 v->uv_neighbors = a->al_next;
1221 free((char *)a);
1222 a = v->uv_neighbors; /* prev_a stays NULL */
1223 } else {
1224 prev_a->al_next = a->al_next;
1225 free((char *)a);
1226 a = prev_a->al_next; /* prev_a stays the same */
1227 }
1228
1229 delete_neighbor_from_routes(addr, vifi);
1230
1231 if (v->uv_neighbors == NULL)
1232 vifs_with_neighbors--;
1233
1234 v->uv_leaf_timer = LEAF_CONFIRMATION_TIME;
1235
1236 if (!(v->uv_flags & VIFF_TUNNEL)) {
1237 v->uv_flags |= VIFF_QUERIER;
1238 for (n = v->uv_neighbors; n != NULL; n = n->al_next) {
1239 if (ntohl(n->al_addr) < ntohl(v->uv_lcl_addr)) {
1240 v->uv_flags &= ~VIFF_QUERIER;
1241 }
1242 if (!(n->al_flags & NF_LEAF)) {
1243 v->uv_leaf_timer = 0;
1244 }
1245 }
1246 }
1247 }
1248 }
1249 }
1250
1251 /*
1252 * Returns the neighbor info struct for a given neighbor
1253 */
1254 struct listaddr *
neighbor_info(vifi_t vifi,u_int32_t addr)1255 neighbor_info(vifi_t vifi, u_int32_t addr)
1256 {
1257 struct listaddr *u;
1258
1259 for (u = uvifs[vifi].uv_neighbors; u; u = u->al_next)
1260 if (u->al_addr == addr)
1261 return u;
1262
1263 return NULL;
1264 }
1265
1266 /*
1267 * Print the contents of the uvifs array on file 'fp'.
1268 */
1269 void
dump_vifs(FILE * fp)1270 dump_vifs(FILE *fp)
1271 {
1272 vifi_t vifi;
1273 struct uvif *v;
1274 struct listaddr *a;
1275 struct phaddr *p;
1276 struct sioc_vif_req v_req;
1277
1278 fprintf(fp, "vifs_with_neighbors = %d\n", vifs_with_neighbors);
1279
1280 if (vifs_with_neighbors == 1)
1281 fprintf(fp,"[This host is a leaf]\n\n");
1282
1283 fprintf(fp,
1284 "\nVirtual Interface Table\n%s",
1285 "Vif Name Local-Address ");
1286 fprintf(fp,
1287 "M Thr Rate Flags\n");
1288
1289 for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) {
1290
1291 fprintf(fp, "%2u %6s %-15s %6s: %-18s %2u %3u %5u ",
1292 vifi,
1293 v->uv_name,
1294 inet_fmt(v->uv_lcl_addr),
1295 (v->uv_flags & VIFF_TUNNEL) ?
1296 "tunnel":
1297 "subnet",
1298 (v->uv_flags & VIFF_TUNNEL) ?
1299 inet_fmt(v->uv_rmt_addr) :
1300 inet_fmts(v->uv_subnet, v->uv_subnetmask),
1301 v->uv_metric,
1302 v->uv_threshold,
1303 v->uv_rate_limit);
1304
1305 if (v->uv_flags & VIFF_ONEWAY) fprintf(fp, " one-way");
1306 if (v->uv_flags & VIFF_DOWN) fprintf(fp, " down");
1307 if (v->uv_flags & VIFF_DISABLED) fprintf(fp, " disabled");
1308 if (v->uv_flags & VIFF_QUERIER) fprintf(fp, " querier");
1309 if (v->uv_flags & VIFF_SRCRT) fprintf(fp, " src-rt");
1310 if (v->uv_flags & VIFF_LEAF) fprintf(fp, " leaf");
1311 if (v->uv_flags & VIFF_IGMPV1) fprintf(fp, " IGMPv1");
1312 fprintf(fp, "\n");
1313
1314 if (v->uv_addrs != NULL) {
1315 fprintf(fp, " alternate subnets: %s\n",
1316 inet_fmts(v->uv_addrs->pa_subnet,
1317 v->uv_addrs->pa_subnetmask));
1318 for (p = v->uv_addrs->pa_next; p; p = p->pa_next) {
1319 fprintf(fp, " %s\n",
1320 inet_fmts(p->pa_subnet, p->pa_subnetmask));
1321 }
1322 }
1323
1324 if (v->uv_neighbors != NULL) {
1325 fprintf(fp, " peers: %s (%d.%d) (0x%x)\n",
1326 inet_fmt(v->uv_neighbors->al_addr),
1327 v->uv_neighbors->al_pv, v->uv_neighbors->al_mv,
1328 v->uv_neighbors->al_flags);
1329 for (a = v->uv_neighbors->al_next; a != NULL; a = a->al_next) {
1330 fprintf(fp, " %s (%d.%d) (0x%x)\n",
1331 inet_fmt(a->al_addr), a->al_pv,
1332 a->al_mv, a->al_flags);
1333 }
1334 }
1335
1336 if (v->uv_groups != NULL) {
1337 fprintf(fp, " groups: %-15s\n",
1338 inet_fmt(v->uv_groups->al_addr));
1339 for (a = v->uv_groups->al_next; a != NULL; a = a->al_next) {
1340 fprintf(fp, " %-15s\n",
1341 inet_fmt(a->al_addr));
1342 }
1343 }
1344 if (v->uv_acl != NULL) {
1345 struct vif_acl *acl;
1346
1347 fprintf(fp, " boundaries: %-18s\n",
1348 inet_fmts(v->uv_acl->acl_addr, v->uv_acl->acl_mask));
1349 for (acl = v->uv_acl->acl_next; acl != NULL; acl = acl->acl_next) {
1350 fprintf(fp, " : %-18s\n",
1351 inet_fmts(acl->acl_addr, acl->acl_mask));
1352 }
1353 }
1354 v_req.vifi = vifi;
1355 if (ioctl(igmp_socket, SIOCGETVIFCNT, (char *)&v_req) < 0) {
1356 logit(LOG_WARNING, 0,
1357 "SIOCGETVIFCNT fails");
1358 }
1359 else {
1360 fprintf(fp, " pkts in : %ld\n",
1361 v_req.icount);
1362 fprintf(fp, " pkts out: %ld\n",
1363 v_req.ocount);
1364 }
1365 fprintf(fp, "\n");
1366 }
1367 fprintf(fp, "\n");
1368 }
1369
1370 /*
1371 * Time out record of a group membership on a vif
1372 */
1373 static void
DelVif(void * arg)1374 DelVif(void *arg)
1375 {
1376 cbk_t *cbk = (cbk_t *)arg;
1377 vifi_t vifi = cbk->vifi;
1378 struct uvif *v = &uvifs[vifi];
1379 struct listaddr *a, **anp, *g = cbk->g;
1380
1381 /*
1382 * Group has expired
1383 * delete all kernel cache entries with this group
1384 */
1385 if (g->al_query)
1386 DeleteTimer(g->al_query);
1387
1388 delete_lclgrp(vifi, g->al_addr);
1389
1390 anp = &(v->uv_groups);
1391 while ((a = *anp) != NULL) {
1392 if (a == g) {
1393 *anp = a->al_next;
1394 free((char *)a);
1395 } else {
1396 anp = &a->al_next;
1397 }
1398 }
1399
1400 free(cbk);
1401 }
1402
1403 /*
1404 * Set a timer to delete the record of a group membership on a vif.
1405 */
1406 static int
SetTimer(vifi_t vifi,struct listaddr * g)1407 SetTimer(vifi_t vifi, struct listaddr *g)
1408 {
1409 cbk_t *cbk;
1410
1411 cbk = (cbk_t *) malloc(sizeof(cbk_t));
1412 cbk->g = g;
1413 cbk->vifi = vifi;
1414 return timer_setTimer(g->al_timer, (cfunc_t)DelVif, (void *)cbk);
1415 }
1416
1417 /*
1418 * Delete a timer that was set above.
1419 */
1420 static int
DeleteTimer(int id)1421 DeleteTimer(int id)
1422 {
1423 timer_clearTimer(id);
1424 return 0;
1425 }
1426
1427 /*
1428 * Send a group-specific query.
1429 */
1430 static void
SendQuery(void * arg)1431 SendQuery(void *arg)
1432 {
1433 cbk_t *cbk = (cbk_t *)arg;
1434 struct uvif *v = &uvifs[cbk->vifi];
1435
1436 send_igmp(v->uv_lcl_addr, cbk->g->al_addr,
1437 IGMP_HOST_MEMBERSHIP_QUERY,
1438 cbk->q_time, cbk->g->al_addr, 0);
1439 cbk->g->al_query = 0;
1440 free(cbk);
1441 }
1442
1443 /*
1444 * Set a timer to send a group-specific query.
1445 */
1446 static int
SetQueryTimer(struct listaddr * g,vifi_t vifi,int to_expire,int q_time)1447 SetQueryTimer(struct listaddr *g, vifi_t vifi, int to_expire, int q_time)
1448 {
1449 cbk_t *cbk;
1450
1451 cbk = (cbk_t *) malloc(sizeof(cbk_t));
1452 cbk->g = g;
1453 cbk->q_time = q_time;
1454 cbk->vifi = vifi;
1455 return timer_setTimer(to_expire, (cfunc_t)SendQuery, (void *)cbk);
1456 }
1457