1: /*
2: PIM for Quagga
3: Copyright (C) 2008 Everton da Silva Marques
4: This program is free software; you can redistribute it and/or modify
5: it under the terms of the GNU General Public License as published by
6: the Free Software Foundation; either version 2 of the License, or
7: (at your option) any later version.
8:
9: This program is distributed in the hope that it will be useful, but
10: WITHOUT ANY WARRANTY; without even the implied warranty of
11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12: General Public License for more details.
13:
14: You should have received a copy of the GNU General Public License
15: along with this program; see the file COPYING; if not, write to the
16: Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
17: MA 02110-1301 USA
18:
19: $QuaggaId: $Format:%an, %ai, %h$ $
20: */
21:
22: #include <zebra.h>
23:
24: #include "if.h"
25: #include "log.h"
26: #include "vty.h"
27: #include "memory.h"
28: #include "prefix.h"
29:
30: #include "pimd.h"
31: #include "pim_iface.h"
32: #include "pim_igmp.h"
33: #include "pim_mroute.h"
34: #include "pim_oil.h"
35: #include "pim_str.h"
36: #include "pim_pim.h"
37: #include "pim_neighbor.h"
38: #include "pim_ifchannel.h"
39: #include "pim_sock.h"
40: #include "pim_time.h"
41: #include "pim_ssmpingd.h"
42:
43: static void pim_if_igmp_join_del_all(struct interface *ifp);
44:
45: static void *if_list_clean(struct pim_interface *pim_ifp)
46: {
47: if (pim_ifp->igmp_join_list) {
48: list_delete(pim_ifp->igmp_join_list);
49: }
50:
51: if (pim_ifp->igmp_socket_list) {
52: list_delete(pim_ifp->igmp_socket_list);
53: }
54:
55: if (pim_ifp->pim_neighbor_list) {
56: list_delete(pim_ifp->pim_neighbor_list);
57: }
58:
59: if (pim_ifp->pim_ifchannel_list) {
60: list_delete(pim_ifp->pim_ifchannel_list);
61: }
62:
63: XFREE(MTYPE_PIM_INTERFACE, pim_ifp);
64:
65: return 0;
66: }
67:
68: struct pim_interface *pim_if_new(struct interface *ifp, int igmp, int pim)
69: {
70: struct pim_interface *pim_ifp;
71:
72: zassert(ifp);
73: zassert(!ifp->info);
74:
75: pim_ifp = XMALLOC(MTYPE_PIM_INTERFACE, sizeof(*pim_ifp));
76: if (!pim_ifp) {
77: zlog_err("PIM XMALLOC(%zu) failure", sizeof(*pim_ifp));
78: return 0;
79: }
80:
81: pim_ifp->options = 0;
82: pim_ifp->mroute_vif_index = -1;
83:
84: pim_ifp->igmp_default_robustness_variable = IGMP_DEFAULT_ROBUSTNESS_VARIABLE;
85: pim_ifp->igmp_default_query_interval = IGMP_GENERAL_QUERY_INTERVAL;
86: pim_ifp->igmp_query_max_response_time_dsec = IGMP_QUERY_MAX_RESPONSE_TIME_DSEC;
87: pim_ifp->igmp_specific_query_max_response_time_dsec = IGMP_SPECIFIC_QUERY_MAX_RESPONSE_TIME_DSEC;
88:
89: /*
90: RFC 3376: 8.3. Query Response Interval
91: The number of seconds represented by the [Query Response Interval]
92: must be less than the [Query Interval].
93: */
94: zassert(pim_ifp->igmp_query_max_response_time_dsec < pim_ifp->igmp_default_query_interval);
95:
96: if (pim)
97: PIM_IF_DO_PIM(pim_ifp->options);
98: if (igmp)
99: PIM_IF_DO_IGMP(pim_ifp->options);
100:
101: #if 0
102: /* FIXME: Should join? */
103: PIM_IF_DO_IGMP_LISTEN_ALLROUTERS(pim_ifp->options);
104: #endif
105:
106: pim_ifp->igmp_join_list = 0;
107: pim_ifp->igmp_socket_list = 0;
108: pim_ifp->pim_neighbor_list = 0;
109: pim_ifp->pim_ifchannel_list = 0;
110:
111: /* list of struct igmp_sock */
112: pim_ifp->igmp_socket_list = list_new();
113: if (!pim_ifp->igmp_socket_list) {
114: zlog_err("%s %s: failure: igmp_socket_list=list_new()",
115: __FILE__, __PRETTY_FUNCTION__);
116: return if_list_clean(pim_ifp);
117: }
118: pim_ifp->igmp_socket_list->del = (void (*)(void *)) igmp_sock_free;
119:
120: /* list of struct pim_neighbor */
121: pim_ifp->pim_neighbor_list = list_new();
122: if (!pim_ifp->pim_neighbor_list) {
123: zlog_err("%s %s: failure: pim_neighbor_list=list_new()",
124: __FILE__, __PRETTY_FUNCTION__);
125: return if_list_clean(pim_ifp);
126: }
127: pim_ifp->pim_neighbor_list->del = (void (*)(void *)) pim_neighbor_free;
128:
129: /* list of struct pim_ifchannel */
130: pim_ifp->pim_ifchannel_list = list_new();
131: if (!pim_ifp->pim_ifchannel_list) {
132: zlog_err("%s %s: failure: pim_ifchannel_list=list_new()",
133: __FILE__, __PRETTY_FUNCTION__);
134: return if_list_clean(pim_ifp);
135: }
136: pim_ifp->pim_ifchannel_list->del = (void (*)(void *)) pim_ifchannel_free;
137:
138: ifp->info = pim_ifp;
139:
140: pim_sock_reset(ifp);
141:
142: zassert(PIM_IF_TEST_PIM(pim_ifp->options) || PIM_IF_TEST_IGMP(pim_ifp->options));
143:
144: if (PIM_MROUTE_IS_ENABLED) {
145: pim_if_add_vif(ifp);
146: }
147:
148: return pim_ifp;
149: }
150:
151: void pim_if_delete(struct interface *ifp)
152: {
153: struct pim_interface *pim_ifp;
154:
155: zassert(ifp);
156: pim_ifp = ifp->info;
157: zassert(pim_ifp);
158:
159: if (pim_ifp->igmp_join_list) {
160: pim_if_igmp_join_del_all(ifp);
161: }
162: zassert(!pim_ifp->igmp_join_list);
163:
164: zassert(pim_ifp->igmp_socket_list);
165: zassert(!listcount(pim_ifp->igmp_socket_list));
166:
167: zassert(pim_ifp->pim_neighbor_list);
168: zassert(!listcount(pim_ifp->pim_neighbor_list));
169:
170: zassert(pim_ifp->pim_ifchannel_list);
171: zassert(!listcount(pim_ifp->pim_ifchannel_list));
172:
173: if (PIM_MROUTE_IS_ENABLED) {
174: pim_if_del_vif(ifp);
175: }
176:
177: list_delete(pim_ifp->igmp_socket_list);
178: list_delete(pim_ifp->pim_neighbor_list);
179: list_delete(pim_ifp->pim_ifchannel_list);
180:
181: XFREE(MTYPE_PIM_INTERFACE, pim_ifp);
182:
183: ifp->info = 0;
184: }
185:
186: void pim_if_update_could_assert(struct interface *ifp)
187: {
188: struct pim_interface *pim_ifp;
189: struct listnode *node;
190: struct listnode *next_node;
191: struct pim_ifchannel *ch;
192:
193: pim_ifp = ifp->info;
194: zassert(pim_ifp);
195:
196: for (ALL_LIST_ELEMENTS(pim_ifp->pim_ifchannel_list, node, next_node, ch)) {
197: pim_ifchannel_update_could_assert(ch);
198: }
199: }
200:
201: static void pim_if_update_my_assert_metric(struct interface *ifp)
202: {
203: struct pim_interface *pim_ifp;
204: struct listnode *node;
205: struct listnode *next_node;
206: struct pim_ifchannel *ch;
207:
208: pim_ifp = ifp->info;
209: zassert(pim_ifp);
210:
211: for (ALL_LIST_ELEMENTS(pim_ifp->pim_ifchannel_list, node, next_node, ch)) {
212: pim_ifchannel_update_my_assert_metric(ch);
213: }
214: }
215:
216: static void pim_addr_change(struct interface *ifp)
217: {
218: struct pim_interface *pim_ifp;
219:
220: pim_ifp = ifp->info;
221: zassert(pim_ifp);
222:
223: pim_if_dr_election(ifp); /* router's own DR Priority (addr) changes -- Done TODO T30 */
224: pim_if_update_join_desired(pim_ifp); /* depends on DR */
225: pim_if_update_could_assert(ifp); /* depends on DR */
226: pim_if_update_my_assert_metric(ifp); /* depends on could_assert */
227: pim_if_update_assert_tracking_desired(ifp); /* depends on DR, join_desired */
228:
229: /*
230: RFC 4601: 4.3.1. Sending Hello Messages
231:
232: 1) Before an interface goes down or changes primary IP address, a
233: Hello message with a zero HoldTime should be sent immediately
234: (with the old IP address if the IP address changed).
235: -- FIXME See CAVEAT C13
236:
237: 2) After an interface has changed its IP address, it MUST send a
238: Hello message with its new IP address.
239: -- DONE below
240:
241: 3) If an interface changes one of its secondary IP addresses, a
242: Hello message with an updated Address_List option and a non-zero
243: HoldTime should be sent immediately.
244: -- FIXME See TODO T31
245: */
246: pim_ifp->pim_ifstat_hello_sent = 0; /* reset hello counter */
247: if (pim_ifp->pim_sock_fd < 0)
248: return;
249: pim_hello_restart_now(ifp); /* send hello and restart timer */
250: }
251:
252: static int detect_primary_address_change(struct interface *ifp,
253: int force_prim_as_any,
254: const char *caller)
255: {
256: struct pim_interface *pim_ifp;
257: struct in_addr new_prim_addr;
258: int changed;
259:
260: pim_ifp = ifp->info;
261: if (!pim_ifp)
262: return 0;
263:
264: if (force_prim_as_any)
265: new_prim_addr = qpim_inaddr_any;
266: else
267: new_prim_addr = pim_find_primary_addr(ifp);
268:
269: changed = new_prim_addr.s_addr != pim_ifp->primary_address.s_addr;
270:
271: if (PIM_DEBUG_ZEBRA) {
272: char new_prim_str[100];
273: char old_prim_str[100];
274: pim_inet4_dump("<new?>", new_prim_addr, new_prim_str, sizeof(new_prim_str));
275: pim_inet4_dump("<old?>", pim_ifp->primary_address, old_prim_str, sizeof(old_prim_str));
276: zlog_debug("%s: old=%s new=%s on interface %s: %s",
277: __PRETTY_FUNCTION__,
278: old_prim_str, new_prim_str, ifp->name,
279: changed ? "changed" : "unchanged");
280: }
281:
282: if (changed) {
283: pim_ifp->primary_address = new_prim_addr;
284:
285: if (!PIM_IF_TEST_PIM(pim_ifp->options)) {
286: return changed;
287: }
288:
289: pim_addr_change(ifp);
290: }
291:
292: return changed;
293: }
294:
295: static void detect_secondary_address_change(struct interface *ifp,
296: const char *caller)
297: {
298: struct pim_interface *pim_ifp;
299: int changed;
300:
301: pim_ifp = ifp->info;
302: if (!pim_ifp)
303: return;
304:
305: changed = 1; /* true */
306: if (PIM_DEBUG_ZEBRA)
307: zlog_debug("FIXME T31 C15 %s: on interface %s: acting on any addr change",
308: __PRETTY_FUNCTION__, ifp->name);
309:
310: if (!changed) {
311: return;
312: }
313:
314: if (!PIM_IF_TEST_PIM(pim_ifp->options)) {
315: return;
316: }
317:
318: pim_addr_change(ifp);
319: }
320:
321: static void detect_address_change(struct interface *ifp,
322: int force_prim_as_any,
323: const char *caller)
324: {
325: int prim_changed;
326:
327: prim_changed = detect_primary_address_change(ifp, force_prim_as_any, caller);
328: if (prim_changed) {
329: /* no need to detect secondary change because
330: the reaction would be the same */
331: return;
332: }
333:
334: detect_secondary_address_change(ifp, caller);
335: }
336:
337: void pim_if_addr_add(struct connected *ifc)
338: {
339: struct pim_interface *pim_ifp;
340: struct interface *ifp;
341: struct in_addr ifaddr;
342:
343: zassert(ifc);
344:
345: ifp = ifc->ifp;
346: zassert(ifp);
347: pim_ifp = ifp->info;
348: if (!pim_ifp)
349: return;
350:
351: if (!if_is_operative(ifp))
352: return;
353:
354: if (PIM_DEBUG_ZEBRA) {
355: char buf[BUFSIZ];
356: prefix2str(ifc->address, buf, BUFSIZ);
357: zlog_debug("%s: %s ifindex=%d connected IP address %s %s",
358: __PRETTY_FUNCTION__,
359: ifp->name, ifp->ifindex, buf,
360: CHECK_FLAG(ifc->flags, ZEBRA_IFA_SECONDARY) ?
361: "secondary" : "primary");
362: }
363:
364: ifaddr = ifc->address->u.prefix4;
365:
366: detect_address_change(ifp, 0, __PRETTY_FUNCTION__);
367:
368: if (PIM_IF_TEST_IGMP(pim_ifp->options)) {
369: struct igmp_sock *igmp;
370:
371: /* lookup IGMP socket */
372: igmp = pim_igmp_sock_lookup_ifaddr(pim_ifp->igmp_socket_list,
373: ifaddr);
374: if (!igmp) {
375: /* if addr new, add IGMP socket */
376: pim_igmp_sock_add(pim_ifp->igmp_socket_list, ifaddr, ifp);
377: }
378: } /* igmp */
379:
380: if (PIM_IF_TEST_PIM(pim_ifp->options)) {
381:
382: /* Interface has a valid primary address ? */
383: if (PIM_INADDR_ISNOT_ANY(pim_ifp->primary_address)) {
384:
385: /* Interface has a valid socket ? */
386: if (pim_ifp->pim_sock_fd < 0) {
387: if (pim_sock_add(ifp)) {
388: zlog_warn("Failure creating PIM socket for interface %s",
389: ifp->name);
390: }
391: }
392:
393: }
394: } /* pim */
395:
396: if (PIM_MROUTE_IS_ENABLED) {
397: /*
398: PIM or IGMP is enabled on interface, and there is at least one
399: address assigned, then try to create a vif_index.
400: */
401: if (pim_ifp->mroute_vif_index < 0) {
402: pim_if_add_vif(ifp);
403: }
404: }
405: }
406:
407: static void pim_if_addr_del_igmp(struct connected *ifc)
408: {
409: struct pim_interface *pim_ifp = ifc->ifp->info;
410: struct igmp_sock *igmp;
411: struct in_addr ifaddr;
412:
413: if (ifc->address->family != AF_INET) {
414: /* non-IPv4 address */
415: return;
416: }
417:
418: if (!pim_ifp) {
419: /* IGMP not enabled on interface */
420: return;
421: }
422:
423: ifaddr = ifc->address->u.prefix4;
424:
425: /* lookup IGMP socket */
426: igmp = pim_igmp_sock_lookup_ifaddr(pim_ifp->igmp_socket_list,
427: ifaddr);
428: if (igmp) {
429: /* if addr found, del IGMP socket */
430: igmp_sock_delete(igmp);
431: }
432: }
433:
434: static void pim_if_addr_del_pim(struct connected *ifc)
435: {
436: struct pim_interface *pim_ifp = ifc->ifp->info;
437:
438: if (ifc->address->family != AF_INET) {
439: /* non-IPv4 address */
440: return;
441: }
442:
443: if (!pim_ifp) {
444: /* PIM not enabled on interface */
445: return;
446: }
447:
448: if (PIM_INADDR_ISNOT_ANY(pim_ifp->primary_address)) {
449: /* Interface keeps a valid primary address */
450: return;
451: }
452:
453: if (pim_ifp->pim_sock_fd < 0) {
454: /* Interface does not hold a valid socket any longer */
455: return;
456: }
457:
458: /*
459: pim_sock_delete() closes the socket, stops read and timer threads,
460: and kills all neighbors.
461: */
462: pim_sock_delete(ifc->ifp, "last address has been removed from interface");
463: }
464:
465: void pim_if_addr_del(struct connected *ifc, int force_prim_as_any)
466: {
467: struct interface *ifp;
468:
469: zassert(ifc);
470: ifp = ifc->ifp;
471: zassert(ifp);
472:
473: if (PIM_DEBUG_ZEBRA) {
474: char buf[BUFSIZ];
475: prefix2str(ifc->address, buf, BUFSIZ);
476: zlog_debug("%s: %s ifindex=%d disconnected IP address %s %s",
477: __PRETTY_FUNCTION__,
478: ifp->name, ifp->ifindex, buf,
479: CHECK_FLAG(ifc->flags, ZEBRA_IFA_SECONDARY) ?
480: "secondary" : "primary");
481: }
482:
483: detect_address_change(ifp, force_prim_as_any, __PRETTY_FUNCTION__);
484:
485: pim_if_addr_del_igmp(ifc);
486: pim_if_addr_del_pim(ifc);
487: }
488:
489: void pim_if_addr_add_all(struct interface *ifp)
490: {
491: struct connected *ifc;
492: struct listnode *node;
493: struct listnode *nextnode;
494:
495: /* PIM/IGMP enabled ? */
496: if (!ifp->info)
497: return;
498:
499: for (ALL_LIST_ELEMENTS(ifp->connected, node, nextnode, ifc)) {
500: struct prefix *p = ifc->address;
501:
502: if (p->family != AF_INET)
503: continue;
504:
505: pim_if_addr_add(ifc);
506: }
507: }
508:
509: void pim_if_addr_del_all(struct interface *ifp)
510: {
511: struct connected *ifc;
512: struct listnode *node;
513: struct listnode *nextnode;
514:
515: /* PIM/IGMP enabled ? */
516: if (!ifp->info)
517: return;
518:
519: for (ALL_LIST_ELEMENTS(ifp->connected, node, nextnode, ifc)) {
520: struct prefix *p = ifc->address;
521:
522: if (p->family != AF_INET)
523: continue;
524:
525: pim_if_addr_del(ifc, 1 /* force_prim_as_any=true */);
526: }
527: }
528:
529: void pim_if_addr_del_all_igmp(struct interface *ifp)
530: {
531: struct connected *ifc;
532: struct listnode *node;
533: struct listnode *nextnode;
534:
535: /* PIM/IGMP enabled ? */
536: if (!ifp->info)
537: return;
538:
539: for (ALL_LIST_ELEMENTS(ifp->connected, node, nextnode, ifc)) {
540: struct prefix *p = ifc->address;
541:
542: if (p->family != AF_INET)
543: continue;
544:
545: pim_if_addr_del_igmp(ifc);
546: }
547: }
548:
549: void pim_if_addr_del_all_pim(struct interface *ifp)
550: {
551: struct connected *ifc;
552: struct listnode *node;
553: struct listnode *nextnode;
554:
555: /* PIM/IGMP enabled ? */
556: if (!ifp->info)
557: return;
558:
559: for (ALL_LIST_ELEMENTS(ifp->connected, node, nextnode, ifc)) {
560: struct prefix *p = ifc->address;
561:
562: if (p->family != AF_INET)
563: continue;
564:
565: pim_if_addr_del_pim(ifc);
566: }
567: }
568:
569: static struct in_addr find_first_nonsec_addr(struct interface *ifp)
570: {
571: struct connected *ifc;
572: struct listnode *node;
573: struct in_addr addr;
574:
575: for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, ifc)) {
576: struct prefix *p = ifc->address;
577:
578: if (p->family != AF_INET)
579: continue;
580:
581: if (PIM_INADDR_IS_ANY(p->u.prefix4)) {
582: zlog_warn("%s: null IPv4 address connected to interface %s",
583: __PRETTY_FUNCTION__, ifp->name);
584: continue;
585: }
586:
587: if (CHECK_FLAG(ifc->flags, ZEBRA_IFA_SECONDARY))
588: continue;
589:
590: return p->u.prefix4;
591: }
592:
593: addr.s_addr = PIM_NET_INADDR_ANY;
594:
595: return addr;
596: }
597:
598: struct in_addr pim_find_primary_addr(struct interface *ifp)
599: {
600: return find_first_nonsec_addr(ifp);
601: }
602:
603: /*
604: pim_if_add_vif() uses ifindex as vif_index
605:
606: see also pim_if_find_vifindex_by_ifindex()
607: */
608: int pim_if_add_vif(struct interface *ifp)
609: {
610: struct pim_interface *pim_ifp = ifp->info;
611: struct in_addr ifaddr;
612:
613: zassert(pim_ifp);
614:
615: if (pim_ifp->mroute_vif_index > 0) {
616: zlog_warn("%s: vif_index=%d > 0 on interface %s ifindex=%d",
617: __PRETTY_FUNCTION__,
618: pim_ifp->mroute_vif_index, ifp->name, ifp->ifindex);
619: return -1;
620: }
621:
622: if (ifp->ifindex < 1) {
623: zlog_warn("%s: ifindex=%d < 1 on interface %s",
624: __PRETTY_FUNCTION__,
625: ifp->ifindex, ifp->name);
626: return -2;
627: }
628:
629: if (ifp->ifindex >= MAXVIFS) {
630: zlog_warn("%s: ifindex=%d >= MAXVIFS=%d on interface %s",
631: __PRETTY_FUNCTION__,
632: ifp->ifindex, MAXVIFS, ifp->name);
633: return -3;
634: }
635:
636: ifaddr = pim_ifp->primary_address;
637: if (PIM_INADDR_IS_ANY(ifaddr)) {
638: zlog_warn("%s: could not get address for interface %s ifindex=%d",
639: __PRETTY_FUNCTION__,
640: ifp->name, ifp->ifindex);
641: return -4;
642: }
643:
644: if (pim_mroute_add_vif(ifp->ifindex, ifaddr)) {
645: /* pim_mroute_add_vif reported error */
646: return -5;
647: }
648:
649: pim_ifp->mroute_vif_index = ifp->ifindex;
650:
651: /*
652: Update highest vif_index
653: */
654: if (pim_ifp->mroute_vif_index > qpim_mroute_oif_highest_vif_index) {
655: qpim_mroute_oif_highest_vif_index = pim_ifp->mroute_vif_index;
656: }
657:
658: return 0;
659: }
660:
661: static int iflist_find_highest_vif_index()
662: {
663: struct listnode *ifnode;
664: struct interface *ifp;
665: struct pim_interface *pim_ifp;
666: int highest_vif_index = -1;
667:
668: for (ALL_LIST_ELEMENTS_RO(iflist, ifnode, ifp)) {
669: pim_ifp = ifp->info;
670: if (!pim_ifp)
671: continue;
672:
673: if (pim_ifp->mroute_vif_index > highest_vif_index) {
674: highest_vif_index = pim_ifp->mroute_vif_index;
675: }
676: }
677:
678: return highest_vif_index;
679: }
680:
681: int pim_if_del_vif(struct interface *ifp)
682: {
683: struct pim_interface *pim_ifp = ifp->info;
684: int old_vif_index;
685:
686: if (pim_ifp->mroute_vif_index < 1) {
687: zlog_warn("%s: vif_index=%d < 1 on interface %s ifindex=%d",
688: __PRETTY_FUNCTION__,
689: pim_ifp->mroute_vif_index, ifp->name, ifp->ifindex);
690: return -1;
691: }
692:
693: if (pim_mroute_del_vif(pim_ifp->mroute_vif_index)) {
694: /* pim_mroute_del_vif reported error */
695: return -2;
696: }
697:
698: /*
699: Update highest vif_index
700: */
701:
702: /* save old vif_index in order to compare with highest below */
703: old_vif_index = pim_ifp->mroute_vif_index;
704:
705: pim_ifp->mroute_vif_index = -1;
706:
707: if (old_vif_index == qpim_mroute_oif_highest_vif_index) {
708: qpim_mroute_oif_highest_vif_index = iflist_find_highest_vif_index();
709: }
710:
711: return 0;
712: }
713:
714: void pim_if_add_vif_all()
715: {
716: struct listnode *ifnode;
717: struct listnode *ifnextnode;
718: struct interface *ifp;
719:
720: for (ALL_LIST_ELEMENTS(iflist, ifnode, ifnextnode, ifp)) {
721: if (!ifp->info)
722: continue;
723:
724: pim_if_add_vif(ifp);
725: }
726: }
727:
728: void pim_if_del_vif_all()
729: {
730: struct listnode *ifnode;
731: struct listnode *ifnextnode;
732: struct interface *ifp;
733:
734: for (ALL_LIST_ELEMENTS(iflist, ifnode, ifnextnode, ifp)) {
735: if (!ifp->info)
736: continue;
737:
738: pim_if_del_vif(ifp);
739: }
740: }
741:
742: struct interface *pim_if_find_by_vif_index(int vif_index)
743: {
744: struct listnode *ifnode;
745: struct interface *ifp;
746:
747: for (ALL_LIST_ELEMENTS_RO(iflist, ifnode, ifp)) {
748: if (ifp->info) {
749: struct pim_interface *pim_ifp;
750: pim_ifp = ifp->info;
751: if (vif_index == pim_ifp->mroute_vif_index)
752: return ifp;
753: }
754: }
755:
756: return 0;
757: }
758:
759: /*
760: pim_if_add_vif() uses ifindex as vif_index
761: */
762: int pim_if_find_vifindex_by_ifindex(ifindex_t ifindex)
763: {
764: return ifindex;
765: }
766:
767: int pim_if_lan_delay_enabled(struct interface *ifp)
768: {
769: struct pim_interface *pim_ifp;
770:
771: pim_ifp = ifp->info;
772: zassert(pim_ifp);
773: zassert(pim_ifp->pim_number_of_nonlandelay_neighbors >= 0);
774:
775: return pim_ifp->pim_number_of_nonlandelay_neighbors == 0;
776: }
777:
778: uint16_t pim_if_effective_propagation_delay_msec(struct interface *ifp)
779: {
780: if (pim_if_lan_delay_enabled(ifp)) {
781: struct pim_interface *pim_ifp;
782: pim_ifp = ifp->info;
783: return pim_ifp->pim_neighbors_highest_propagation_delay_msec;
784: }
785: else {
786: return PIM_DEFAULT_PROPAGATION_DELAY_MSEC;
787: }
788: }
789:
790: uint16_t pim_if_effective_override_interval_msec(struct interface *ifp)
791: {
792: if (pim_if_lan_delay_enabled(ifp)) {
793: struct pim_interface *pim_ifp;
794: pim_ifp = ifp->info;
795: return pim_ifp->pim_neighbors_highest_override_interval_msec;
796: }
797: else {
798: return PIM_DEFAULT_OVERRIDE_INTERVAL_MSEC;
799: }
800: }
801:
802: int pim_if_t_override_msec(struct interface *ifp)
803: {
804: int effective_override_interval_msec;
805: int t_override_msec;
806:
807: effective_override_interval_msec =
808: pim_if_effective_override_interval_msec(ifp);
809:
810: t_override_msec = random() % (effective_override_interval_msec + 1);
811:
812: return t_override_msec;
813: }
814:
815: uint16_t pim_if_jp_override_interval_msec(struct interface *ifp)
816: {
817: return pim_if_effective_propagation_delay_msec(ifp) +
818: pim_if_effective_override_interval_msec(ifp);
819: }
820:
821: /*
822: RFC 4601: 4.1.6. State Summarization Macros
823:
824: The function NBR( I, A ) uses information gathered through PIM Hello
825: messages to map the IP address A of a directly connected PIM
826: neighbor router on interface I to the primary IP address of the same
827: router (Section 4.3.4). The primary IP address of a neighbor is the
828: address that it uses as the source of its PIM Hello messages.
829: */
830: struct pim_neighbor *pim_if_find_neighbor(struct interface *ifp,
831: struct in_addr addr)
832: {
833: struct listnode *neighnode;
834: struct pim_neighbor *neigh;
835: struct pim_interface *pim_ifp;
836:
837: zassert(ifp);
838:
839: pim_ifp = ifp->info;
840: if (!pim_ifp) {
841: zlog_warn("%s: multicast not enabled on interface %s",
842: __PRETTY_FUNCTION__,
843: ifp->name);
844: return 0;
845: }
846:
847: for (ALL_LIST_ELEMENTS_RO(pim_ifp->pim_neighbor_list, neighnode, neigh)) {
848:
849: /* primary address ? */
850: if (neigh->source_addr.s_addr == addr.s_addr)
851: return neigh;
852:
853: /* secondary address ? */
854: if (pim_neighbor_find_secondary(neigh, addr))
855: return neigh;
856: }
857:
858: if (PIM_DEBUG_PIM_TRACE) {
859: char addr_str[100];
860: pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
861: zlog_debug("%s: neighbor not found for address %s on interface %s",
862: __PRETTY_FUNCTION__,
863: addr_str, ifp->name);
864: }
865:
866: return 0;
867: }
868:
869: long pim_if_t_suppressed_msec(struct interface *ifp)
870: {
871: struct pim_interface *pim_ifp;
872: long t_suppressed_msec;
873: uint32_t ramount = 0;
874:
875: pim_ifp = ifp->info;
876: zassert(pim_ifp);
877:
878: /* join suppression disabled ? */
879: if (PIM_IF_TEST_PIM_CAN_DISABLE_JOIN_SUPRESSION(pim_ifp->options))
880: return 0;
881:
882: /* t_suppressed = t_periodic * rand(1.1, 1.4) */
883: ramount = 1100 + (random() % (1400 - 1100 + 1));
884: t_suppressed_msec = qpim_t_periodic * ramount;
885:
886: return t_suppressed_msec;
887: }
888:
889: static void igmp_join_free(struct igmp_join *ij)
890: {
891: XFREE(MTYPE_PIM_IGMP_JOIN, ij);
892: }
893:
894: static struct igmp_join *igmp_join_find(struct list *join_list,
895: struct in_addr group_addr,
896: struct in_addr source_addr)
897: {
898: struct listnode *node;
899: struct igmp_join *ij;
900:
901: zassert(join_list);
902:
903: for (ALL_LIST_ELEMENTS_RO(join_list, node, ij)) {
904: if ((group_addr.s_addr == ij->group_addr.s_addr) &&
905: (source_addr.s_addr == ij->source_addr.s_addr))
906: return ij;
907: }
908:
909: return 0;
910: }
911:
912: static int igmp_join_sock(const char *ifname,
913: ifindex_t ifindex,
914: struct in_addr group_addr,
915: struct in_addr source_addr)
916: {
917: int join_fd;
918:
919: join_fd = pim_socket_raw(IPPROTO_IGMP);
920: if (join_fd < 0) {
921: return -1;
922: }
923:
924: if (pim_socket_join_source(join_fd, ifindex, group_addr, source_addr, ifname)) {
925: close(join_fd);
926: return -2;
927: }
928:
929: return join_fd;
930: }
931:
932: static struct igmp_join *igmp_join_new(struct interface *ifp,
933: struct in_addr group_addr,
934: struct in_addr source_addr)
935: {
936: struct pim_interface *pim_ifp;
937: struct igmp_join *ij;
938: int join_fd;
939:
940: pim_ifp = ifp->info;
941: zassert(pim_ifp);
942:
943: join_fd = igmp_join_sock(ifp->name, ifp->ifindex, group_addr, source_addr);
944: if (join_fd < 0) {
945: char group_str[100];
946: char source_str[100];
947: pim_inet4_dump("<grp?>", group_addr, group_str, sizeof(group_str));
948: pim_inet4_dump("<src?>", source_addr, source_str, sizeof(source_str));
949: zlog_warn("%s: igmp_join_sock() failure for IGMP group %s source %s on interface %s",
950: __PRETTY_FUNCTION__,
951: group_str, source_str, ifp->name);
952: return 0;
953: }
954:
955: ij = XMALLOC(MTYPE_PIM_IGMP_JOIN, sizeof(*ij));
956: if (!ij) {
957: char group_str[100];
958: char source_str[100];
959: pim_inet4_dump("<grp?>", group_addr, group_str, sizeof(group_str));
960: pim_inet4_dump("<src?>", source_addr, source_str, sizeof(source_str));
961: zlog_err("%s: XMALLOC(%zu) failure for IGMP group %s source %s on interface %s",
962: __PRETTY_FUNCTION__,
963: sizeof(*ij), group_str, source_str, ifp->name);
964: close(join_fd);
965: return 0;
966: }
967:
968: ij->sock_fd = join_fd;
969: ij->group_addr = group_addr;
970: ij->source_addr = source_addr;
971: ij->sock_creation = pim_time_monotonic_sec();
972:
973: listnode_add(pim_ifp->igmp_join_list, ij);
974:
975: return ij;
976: }
977:
978: int pim_if_igmp_join_add(struct interface *ifp,
979: struct in_addr group_addr,
980: struct in_addr source_addr)
981: {
982: struct pim_interface *pim_ifp;
983: struct igmp_join *ij;
984:
985: pim_ifp = ifp->info;
986: if (!pim_ifp) {
987: zlog_warn("%s: multicast not enabled on interface %s",
988: __PRETTY_FUNCTION__,
989: ifp->name);
990: return -1;
991: }
992:
993: if (!pim_ifp->igmp_join_list) {
994: pim_ifp->igmp_join_list = list_new();
995: if (!pim_ifp->igmp_join_list) {
996: zlog_err("%s %s: failure: igmp_join_list=list_new()",
997: __FILE__, __PRETTY_FUNCTION__);
998: return -2;
999: }
1000: pim_ifp->igmp_join_list->del = (void (*)(void *)) igmp_join_free;
1001: }
1002:
1003: ij = igmp_join_find(pim_ifp->igmp_join_list, group_addr, source_addr);
1004: if (ij) {
1005: char group_str[100];
1006: char source_str[100];
1007: pim_inet4_dump("<grp?>", group_addr, group_str, sizeof(group_str));
1008: pim_inet4_dump("<src?>", source_addr, source_str, sizeof(source_str));
1009: zlog_warn("%s: can't re-join existing IGMP group %s source %s on interface %s",
1010: __PRETTY_FUNCTION__,
1011: group_str, source_str, ifp->name);
1012: return -3;
1013: }
1014:
1015: ij = igmp_join_new(ifp, group_addr, source_addr);
1016: if (!ij) {
1017: char group_str[100];
1018: char source_str[100];
1019: pim_inet4_dump("<grp?>", group_addr, group_str, sizeof(group_str));
1020: pim_inet4_dump("<src?>", source_addr, source_str, sizeof(source_str));
1021: zlog_warn("%s: igmp_join_new() failure for IGMP group %s source %s on interface %s",
1022: __PRETTY_FUNCTION__,
1023: group_str, source_str, ifp->name);
1024: return -4;
1025: }
1026:
1027: if (PIM_DEBUG_IGMP_EVENTS) {
1028: char group_str[100];
1029: char source_str[100];
1030: pim_inet4_dump("<grp?>", group_addr, group_str, sizeof(group_str));
1031: pim_inet4_dump("<src?>", source_addr, source_str, sizeof(source_str));
1032: zlog_debug("%s: issued static igmp join for channel (S,G)=(%s,%s) on interface %s",
1033: __PRETTY_FUNCTION__,
1034: source_str, group_str, ifp->name);
1035: }
1036:
1037: return 0;
1038: }
1039:
1040:
1041:
1042: int pim_if_igmp_join_del(struct interface *ifp,
1043: struct in_addr group_addr,
1044: struct in_addr source_addr)
1045: {
1046: struct pim_interface *pim_ifp;
1047: struct igmp_join *ij;
1048:
1049: pim_ifp = ifp->info;
1050: if (!pim_ifp) {
1051: zlog_warn("%s: multicast not enabled on interface %s",
1052: __PRETTY_FUNCTION__,
1053: ifp->name);
1054: return -1;
1055: }
1056:
1057: if (!pim_ifp->igmp_join_list) {
1058: zlog_warn("%s: no IGMP join on interface %s",
1059: __PRETTY_FUNCTION__,
1060: ifp->name);
1061: return -2;
1062: }
1063:
1064: ij = igmp_join_find(pim_ifp->igmp_join_list, group_addr, source_addr);
1065: if (!ij) {
1066: char group_str[100];
1067: char source_str[100];
1068: pim_inet4_dump("<grp?>", group_addr, group_str, sizeof(group_str));
1069: pim_inet4_dump("<src?>", source_addr, source_str, sizeof(source_str));
1070: zlog_warn("%s: could not find IGMP group %s source %s on interface %s",
1071: __PRETTY_FUNCTION__,
1072: group_str, source_str, ifp->name);
1073: return -3;
1074: }
1075:
1076: if (close(ij->sock_fd)) {
1077: int e = errno;
1078: char group_str[100];
1079: char source_str[100];
1080: pim_inet4_dump("<grp?>", group_addr, group_str, sizeof(group_str));
1081: pim_inet4_dump("<src?>", source_addr, source_str, sizeof(source_str));
1082: zlog_warn("%s: failure closing sock_fd=%d for IGMP group %s source %s on interface %s: errno=%d: %s",
1083: __PRETTY_FUNCTION__,
1084: ij->sock_fd, group_str, source_str, ifp->name, e, safe_strerror(e));
1085: /* warning only */
1086: }
1087: listnode_delete(pim_ifp->igmp_join_list, ij);
1088: igmp_join_free(ij);
1089: if (listcount(pim_ifp->igmp_join_list) < 1) {
1090: list_delete(pim_ifp->igmp_join_list);
1091: pim_ifp->igmp_join_list = 0;
1092: }
1093:
1094: return 0;
1095: }
1096:
1097: static void pim_if_igmp_join_del_all(struct interface *ifp)
1098: {
1099: struct pim_interface *pim_ifp;
1100: struct listnode *node;
1101: struct listnode *nextnode;
1102: struct igmp_join *ij;
1103:
1104: pim_ifp = ifp->info;
1105: if (!pim_ifp) {
1106: zlog_warn("%s: multicast not enabled on interface %s",
1107: __PRETTY_FUNCTION__,
1108: ifp->name);
1109: return;
1110: }
1111:
1112: if (!pim_ifp->igmp_join_list)
1113: return;
1114:
1115: for (ALL_LIST_ELEMENTS(pim_ifp->igmp_join_list, node, nextnode, ij))
1116: pim_if_igmp_join_del(ifp, ij->group_addr, ij->source_addr);
1117: }
1118:
1119: /*
1120: RFC 4601
1121:
1122: Transitions from "I am Assert Loser" State
1123:
1124: Current Winner's GenID Changes or NLT Expires
1125:
1126: The Neighbor Liveness Timer associated with the current winner
1127: expires or we receive a Hello message from the current winner
1128: reporting a different GenID from the one it previously reported.
1129: This indicates that the current winner's interface or router has
1130: gone down (and may have come back up), and so we must assume it no
1131: longer knows it was the winner.
1132: */
1133: void pim_if_assert_on_neighbor_down(struct interface *ifp,
1134: struct in_addr neigh_addr)
1135: {
1136: struct pim_interface *pim_ifp;
1137: struct listnode *node;
1138: struct listnode *next_node;
1139: struct pim_ifchannel *ch;
1140:
1141: pim_ifp = ifp->info;
1142: zassert(pim_ifp);
1143:
1144: for (ALL_LIST_ELEMENTS(pim_ifp->pim_ifchannel_list, node, next_node, ch)) {
1145: /* Is (S,G,I) assert loser ? */
1146: if (ch->ifassert_state != PIM_IFASSERT_I_AM_LOSER)
1147: continue;
1148: /* Dead neighbor was winner ? */
1149: if (ch->ifassert_winner.s_addr != neigh_addr.s_addr)
1150: continue;
1151:
1152: assert_action_a5(ch);
1153: }
1154: }
1155:
1156: void pim_if_update_join_desired(struct pim_interface *pim_ifp)
1157: {
1158: struct listnode *ch_node;
1159: struct pim_ifchannel *ch;
1160:
1161: /* clear off flag from interface's upstreams */
1162: for (ALL_LIST_ELEMENTS_RO(pim_ifp->pim_ifchannel_list, ch_node, ch)) {
1163: PIM_UPSTREAM_FLAG_UNSET_DR_JOIN_DESIRED_UPDATED(ch->upstream->flags);
1164: }
1165:
1166: /* scan per-interface (S,G,I) state on this I interface */
1167: for (ALL_LIST_ELEMENTS_RO(pim_ifp->pim_ifchannel_list, ch_node, ch)) {
1168: struct pim_upstream *up = ch->upstream;
1169:
1170: if (PIM_UPSTREAM_FLAG_TEST_DR_JOIN_DESIRED_UPDATED(up->flags))
1171: continue;
1172:
1173: /* update join_desired for the global (S,G) state */
1174: pim_upstream_update_join_desired(up);
1175: PIM_UPSTREAM_FLAG_SET_DR_JOIN_DESIRED_UPDATED(up->flags);
1176: }
1177: }
1178:
1179: void pim_if_update_assert_tracking_desired(struct interface *ifp)
1180: {
1181: struct pim_interface *pim_ifp;
1182: struct listnode *node;
1183: struct listnode *next_node;
1184: struct pim_ifchannel *ch;
1185:
1186: pim_ifp = ifp->info;
1187: if (!pim_ifp)
1188: return;
1189:
1190: for (ALL_LIST_ELEMENTS(pim_ifp->pim_ifchannel_list, node, next_node, ch)) {
1191: pim_ifchannel_update_assert_tracking_desired(ch);
1192: }
1193: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pim_iface.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / pimd