Annotation of embedaddon/pimd/mrt.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Copyright (c) 1998-2001
3: * University of Southern California/Information Sciences Institute.
4: * All rights reserved.
5: *
6: * Redistribution and use in source and binary forms, with or without
7: * modification, are permitted provided that the following conditions
8: * are met:
9: * 1. Redistributions of source code must retain the above copyright
10: * notice, this list of conditions and the following disclaimer.
11: * 2. Redistributions in binary form must reproduce the above copyright
12: * notice, this list of conditions and the following disclaimer in the
13: * documentation and/or other materials provided with the distribution.
14: * 3. Neither the name of the project nor the names of its contributors
15: * may be used to endorse or promote products derived from this software
16: * without specific prior written permission.
17: *
18: * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
19: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21: * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
22: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28: * SUCH DAMAGE.
29: */
30: /*
31: * $Id: mrt.c,v 1.27 2001/09/10 20:31:36 pavlin Exp $
32: */
33:
34:
35: #include "defs.h"
36:
37:
38: srcentry_t *srclist;
39: grpentry_t *grplist;
40:
41: /*
42: * Local functions definition
43: */
44: static srcentry_t *create_srcentry (uint32_t);
45: static int search_srclist (uint32_t, srcentry_t **);
46: static int search_srcmrtlink (srcentry_t *, uint32_t, mrtentry_t **);
47: static void insert_srcmrtlink (mrtentry_t *, mrtentry_t *, srcentry_t *);
48:
49: static grpentry_t *create_grpentry (uint32_t);
50: static int search_grplist (uint32_t, grpentry_t **);
51: static int search_grpmrtlink (grpentry_t *, uint32_t, mrtentry_t **);
52: static void insert_grpmrtlink (mrtentry_t *, mrtentry_t *, grpentry_t *);
53:
54: static mrtentry_t *alloc_mrtentry (srcentry_t *, grpentry_t *);
55: static mrtentry_t *create_mrtentry (srcentry_t *, grpentry_t *, uint16_t);
56:
57: static void move_kernel_cache (mrtentry_t *, uint16_t);
58:
59:
60: void init_pim_mrt(void)
61: {
62: /* TODO: delete any existing routing table */
63:
64: /* Initialize the source list */
65: /* The first entry has address 'INADDR_ANY' and is not used */
66: /* The order is the smallest address first. */
67: srclist = (srcentry_t *)calloc(1, sizeof(srcentry_t));
68: if (!srclist)
69: logit(LOG_ERR, 0, "Ran out of memory in init_pim_mrt()");
70: srclist->next = NULL;
71: srclist->prev = NULL;
72: srclist->address = INADDR_ANY_N;
73: srclist->mrtlink = NULL;
74: srclist->incoming = NO_VIF;
75: srclist->upstream = NULL;
76: srclist->metric = 0;
77: srclist->preference = 0;
78: RESET_TIMER(srclist->timer);
79: srclist->cand_rp = NULL;
80:
81: /* Initialize the group list */
82: /* The first entry has address 'INADDR_ANY' and is not used */
83: /* The order is the smallest address first. */
84: grplist = (grpentry_t *)calloc(1, sizeof(grpentry_t));
85: if (!grplist)
86: logit(LOG_ERR, 0, "Ran out of memory in init_pim_mrt()");
87: grplist->next = NULL;
88: grplist->prev = NULL;
89: grplist->rpnext = NULL;
90: grplist->rpprev = NULL;
91: grplist->group = INADDR_ANY_N;
92: grplist->rpaddr = INADDR_ANY_N;
93: grplist->mrtlink = NULL;
94: grplist->active_rp_grp = NULL;
95: grplist->grp_route = NULL;
96: }
97:
98:
99: grpentry_t *find_group(uint32_t group)
100: {
101: grpentry_t *grp;
102:
103: if (!IN_MULTICAST(ntohl(group)))
104: return NULL;
105:
106: if (search_grplist(group, &grp) == TRUE)
107: return grp; /* Group found! */
108:
109: return NULL;
110: }
111:
112:
113: srcentry_t *find_source(uint32_t source)
114: {
115: srcentry_t *src;
116:
117: if (!inet_valid_host(source))
118: return NULL;
119:
120: if (search_srclist(source, &src) == TRUE)
121: return src; /* Source found! */
122:
123: return NULL;
124: }
125:
126:
127: mrtentry_t *find_route(uint32_t source, uint32_t group, uint16_t flags, char create)
128: {
129: srcentry_t *src = NULL;
130: grpentry_t *grp = NULL;
131: mrtentry_t *mrt = NULL;
132: mrtentry_t *mrt_wc = NULL;
133: mrtentry_t *mrt_pmbr = NULL;
134: mrtentry_t *mrt2 = NULL;
135: rpentry_t *rp = NULL;
136: rp_grp_entry_t *rp_grp = NULL;
137:
138: if (flags & (MRTF_SG | MRTF_WC)) {
139: if (!IN_MULTICAST(ntohl(group))) {
140: logit(LOG_WARNING, 0, "find_route: Not a multicast group address (%s) ...",
141: inet_fmt(group, s1, sizeof(s1)));
142: return NULL;
143: }
144: }
145:
146: if (flags & MRTF_SG) {
147: if (!inet_valid_host(source) && !IN_PIM_SSM_RANGE(group)) {
148: logit(LOG_WARNING, 0, "find_route: Not a valid host (%s) ...",
149: inet_fmt(source, s1, sizeof(s1)));
150: return NULL;
151: }
152: }
153:
154: if (create == DONT_CREATE) {
155: if (flags & (MRTF_SG | MRTF_WC)) {
156: if (search_grplist(group, &grp) == FALSE) {
157: /* Group not found. Return the (*,*,RP) entry */
158: if (flags & MRTF_PMBR) {
159: rp = rp_match(group);
160: if (rp) {
161: logit(LOG_DEBUG, 0 , "find_route: Group not found. Return the (*,*,RP) entry");
162: return rp->mrtlink;
163: }
164: }
165:
166: logit(LOG_DEBUG, 0 , "find_route: Not PMBR, return NULL");
167: return NULL;
168: }
169:
170: /* Search for the source */
171: if (flags & MRTF_SG) {
172: if (search_grpmrtlink(grp, source, &mrt) == TRUE) {
173: /* Exact (S,G) entry found */
174: logit(LOG_DEBUG, 0 , "find_route: exact (S,G) entry found");
175: return mrt;
176: }
177:
178: logit(LOG_DEBUG, 0 , "find_route:(S,G) entry not found");
179: }
180:
181: /* No (S,G) entry. Return the (*,G) entry (if exist) */
182: if ((flags & MRTF_WC) && grp->grp_route) {
183: logit(LOG_DEBUG, 0 , "find_route: No (S,G) entry. Return the (*,G) entry");
184: return grp->grp_route;
185: }
186: }
187:
188: /* Return the (*,*,RP) entry */
189: if (flags & MRTF_PMBR) {
190: rp = NULL;
191: if (group != INADDR_ANY_N)
192: rp = rp_match(group);
193: else if (source != INADDR_ANY_N)
194: rp = rp_find(source);
195:
196: if (rp) {
197: logit(LOG_DEBUG, 0 , "find_route: Return the (*,*,RP) entry");
198: return rp->mrtlink;
199: }
200: }
201:
202: logit(LOG_DEBUG, 0 , "find_route: No SG|WC, return NULL");
203: return NULL;
204: }
205:
206:
207: /* Creation allowed */
208:
209: if (flags & (MRTF_SG | MRTF_WC)) {
210: grp = create_grpentry(group);
211: if (!grp)
212: return NULL;
213:
214: if (IN_PIM_SSM_RANGE(group)) {
215: if (rp_match(group) == (rpentry_t *) NULL) {
216: /* For SSM, virtual RP entry has to be created. RP is at local link 169.254.0.1
217: to be sure not to send any register messages outside, although sending them
218: has been disabled for SSM also in PIM protocol.
219: The address does not need to be really configured in any interface.
220: TODO: Avoid need for virtual RP by implementing SSM-specific state structures */
221: add_rp_grp_entry(&cand_rp_list, &grp_mask_list, 0x0100fea9, 20, 90, group,
222: 0xffffffff, curr_bsr_hash_mask, curr_bsr_fragment_tag);
223: }
224: }
225:
226: if (!grp->active_rp_grp) {
227: rp_grp = rp_grp_match(group);
228: if (!rp_grp) {
229: if (!grp->mrtlink && !grp->grp_route)
230: /* New created grpentry. Delete it. */
231: delete_grpentry(grp);
232:
233: return NULL;
234: }
235:
236: rp = rp_grp->rp->rpentry;
237: grp->active_rp_grp = rp_grp;
238: grp->rpaddr = rp->address;
239:
240: /* Link to the top of the rp_grp_chain */
241: grp->rpnext = rp_grp->grplink;
242: rp_grp->grplink = grp;
243: if (grp->rpnext)
244: grp->rpnext->rpprev = grp;
245: } else {
246: rp = grp->active_rp_grp->rp->rpentry;
247: }
248: }
249:
250: mrt_wc = mrt_pmbr = NULL;
251:
252: if (flags & MRTF_WC) {
253: /* Setup the (*,G) routing entry */
254: mrt_wc = create_mrtentry(NULL, grp, MRTF_WC);
255: if (!mrt_wc) {
256: if (!grp->mrtlink)
257: /* New created grpentry. Delete it. */
258: delete_grpentry(grp);
259:
260: return NULL;
261: }
262:
263: if (mrt_wc->flags & MRTF_NEW) {
264: mrt_pmbr = rp->mrtlink;
265:
266: /* Copy the oif list from the (*,*,RP) entry */
267: if (mrt_pmbr)
268: VOIF_COPY(mrt_pmbr, mrt_wc);
269:
270: mrt_wc->incoming = rp->incoming;
271: mrt_wc->upstream = rp->upstream;
272: mrt_wc->metric = rp->metric;
273: mrt_wc->preference = rp->preference;
274: move_kernel_cache(mrt_wc, 0);
275: #ifdef RSRR
276: rsrr_cache_bring_up(mrt_wc);
277: #endif /* RSRR */
278: }
279:
280: if (!(flags & MRTF_SG))
281: return mrt_wc;
282: }
283:
284: if (flags & MRTF_SG) {
285: /* Setup the (S,G) routing entry */
286: src = create_srcentry(source);
287: if (!src) {
288: /* TODO: XXX: The MRTF_NEW flag check may be misleading?? check */
289: if ((!grp->grp_route || (grp->grp_route && (grp->grp_route->flags & MRTF_NEW)))
290: && !grp->mrtlink) {
291: /* New created grpentry. Delete it. */
292: delete_grpentry(grp);
293: }
294:
295: return NULL;
296: }
297:
298: mrt = create_mrtentry(src, grp, MRTF_SG);
299: if (!mrt) {
300: if ((!grp->grp_route
301: || (grp->grp_route && (grp->grp_route->flags & MRTF_NEW)))
302: && !grp->mrtlink) {
303: /* New created grpentry. Delete it. */
304: delete_grpentry(grp);
305: }
306:
307: if (!src->mrtlink)
308: /* New created srcentry. Delete it. */
309: delete_srcentry(src);
310:
311: return NULL;
312: }
313:
314: if (mrt->flags & MRTF_NEW) {
315: mrt2 = grp->grp_route;
316: if (!mrt2)
317: mrt2 = rp->mrtlink;
318:
319: /* Copy the oif list from the existing (*,G) or (*,*,RP) entry */
320: if (mrt2) {
321: VOIF_COPY(mrt2, mrt);
322: if (flags & MRTF_RP) {
323: /* ~(S,G) prune entry */
324: mrt->incoming = mrt2->incoming;
325: mrt->upstream = mrt2->upstream;
326: mrt->metric = mrt2->metric;
327: mrt->preference = mrt2->preference;
328: mrt->flags |= MRTF_RP;
329: }
330: }
331:
332: if (!(mrt->flags & MRTF_RP)) {
333: mrt->incoming = src->incoming;
334: mrt->upstream = src->upstream;
335: mrt->metric = src->metric;
336: mrt->preference = src->preference;
337: }
338: move_kernel_cache(mrt, 0);
339: #ifdef RSRR
340: rsrr_cache_bring_up(mrt);
341: #endif /* RSRR */
342: }
343:
344: return mrt;
345: }
346:
347: if (flags & MRTF_PMBR) {
348: /* Get/return the (*,*,RP) routing entry */
349: if (group != INADDR_ANY_N)
350: rp = rp_match(group);
351: else if (source != INADDR_ANY_N)
352: rp = rp_find(source);
353: else
354: return NULL; /* source == group == INADDR_ANY */
355:
356: if (!rp)
357: return NULL;
358:
359: if (rp->mrtlink)
360: return rp->mrtlink;
361:
362: mrt = create_mrtentry(rp, NULL, MRTF_PMBR);
363: if (!mrt)
364: return NULL;
365:
366: mrt->incoming = rp->incoming;
367: mrt->upstream = rp->upstream;
368: mrt->metric = rp->metric;
369: mrt->preference = rp->preference;
370:
371: return mrt;
372: }
373:
374: return NULL;
375: }
376:
377:
378: void delete_srcentry(srcentry_t *src)
379: {
380: mrtentry_t *node;
381: mrtentry_t *next;
382:
383: if (!src)
384: return;
385:
386: /* TODO: XXX: the first entry is unused and always there */
387: src->prev->next = src->next;
388: if (src->next)
389: src->next->prev = src->prev;
390:
391: for (node = src->mrtlink; node; node = next) {
392: next = node->srcnext;
393: if (node->flags & MRTF_KERNEL_CACHE)
394: /* Delete the kernel cache first */
395: delete_mrtentry_all_kernel_cache(node);
396:
397: if (node->grpprev) {
398: node->grpprev->grpnext = node->grpnext;
399: } else {
400: node->group->mrtlink = node->grpnext;
401: if (!node->grpnext && !node->group->grp_route)
402: /* Delete the group entry if it has no (*,G) routing entry */
403: delete_grpentry(node->group);
404: }
405:
406: if (node->grpnext)
407: node->grpnext->grpprev = node->grpprev;
408:
409: FREE_MRTENTRY(node);
410: }
411:
412: free(src);
413: }
414:
415:
416: void delete_grpentry(grpentry_t *grp)
417: {
418: mrtentry_t *node;
419: mrtentry_t *next;
420:
421: if (!grp)
422: return;
423:
424: /* TODO: XXX: the first entry is unused and always there */
425: grp->prev->next = grp->next;
426: if (grp->next)
427: grp->next->prev = grp->prev;
428:
429: if (grp->grp_route) {
430: if (grp->grp_route->flags & MRTF_KERNEL_CACHE)
431: delete_mrtentry_all_kernel_cache(grp->grp_route);
432: FREE_MRTENTRY(grp->grp_route);
433: }
434:
435: /* Delete from the rp_grp_entry chain */
436: if (grp->active_rp_grp) {
437: if (grp->rpnext)
438: grp->rpnext->rpprev = grp->rpprev;
439:
440: if (grp->rpprev)
441: grp->rpprev->rpnext = grp->rpnext;
442: else
443: grp->active_rp_grp->grplink = grp->rpnext;
444: }
445:
446: for (node = grp->mrtlink; node; node = next) {
447: next = node->grpnext;
448: if (node->flags & MRTF_KERNEL_CACHE)
449: /* Delete the kernel cache first */
450: delete_mrtentry_all_kernel_cache(node);
451:
452: if (node->srcprev) {
453: node->srcprev->srcnext = node->srcnext;
454: } else {
455: node->source->mrtlink = node->srcnext;
456: if (!node->srcnext) {
457: /* Delete the srcentry if this was the last routing entry */
458: delete_srcentry(node->source);
459: }
460: }
461:
462: if (node->srcnext)
463: node->srcnext->srcprev = node->srcprev;
464:
465: FREE_MRTENTRY(node);
466: }
467:
468: free(grp);
469: }
470:
471:
472: void delete_mrtentry(mrtentry_t *mrt)
473: {
474: grpentry_t *grp;
475: mrtentry_t *mrt_wc;
476: mrtentry_t *mrt_rp;
477:
478: if (!mrt)
479: return;
480:
481: /* Delete the kernel cache first */
482: if (mrt->flags & MRTF_KERNEL_CACHE)
483: delete_mrtentry_all_kernel_cache(mrt);
484:
485: #ifdef RSRR
486: /* Tell the reservation daemon */
487: rsrr_cache_clean(mrt);
488: #endif /* RSRR */
489:
490: if (mrt->flags & MRTF_PMBR) {
491: /* (*,*,RP) mrtentry */
492: mrt->source->mrtlink = NULL;
493: } else if (mrt->flags & MRTF_SG) {
494: /* (S,G) mrtentry */
495:
496: /* Delete from the grpentry MRT chain */
497: if (mrt->grpprev) {
498: mrt->grpprev->grpnext = mrt->grpnext;
499: } else {
500: mrt->group->mrtlink = mrt->grpnext;
501: if (!mrt->grpnext) {
502: /* All (S,G) MRT entries are gone. Allow creating (*,G) MFC entries. */
503: mrt_rp = mrt->group->active_rp_grp->rp->rpentry->mrtlink;
504: mrt_wc = mrt->group->grp_route;
505: if (mrt_rp)
506: mrt_rp->flags &= ~MRTF_MFC_CLONE_SG;
507:
508: if (mrt_wc)
509: mrt_wc->flags &= ~MRTF_MFC_CLONE_SG;
510: else
511: /* Delete the group entry if it has no (*,G) routing entry */
512: delete_grpentry(mrt->group);
513: }
514: }
515:
516: if (mrt->grpnext)
517: mrt->grpnext->grpprev = mrt->grpprev;
518:
519: /* Delete from the srcentry MRT chain */
520: if (mrt->srcprev) {
521: mrt->srcprev->srcnext = mrt->srcnext;
522: } else {
523: mrt->source->mrtlink = mrt->srcnext;
524: if (!mrt->srcnext)
525: /* Delete the srcentry if this was the last routing entry */
526: delete_srcentry(mrt->source);
527: }
528:
529: if (mrt->srcnext)
530: mrt->srcnext->srcprev = mrt->srcprev;
531: } else {
532: /* This mrtentry should be (*,G) */
533: grp = mrt->group;
534: grp->grp_route = NULL;
535:
536: /* Delete the group entry if it has no (S,G) entries */
537: if (!grp->mrtlink)
538: delete_grpentry(grp);
539: }
540:
541: FREE_MRTENTRY(mrt);
542: }
543:
544:
545: static int search_srclist(uint32_t source, srcentry_t **found)
546: {
547: srcentry_t *prev, *node;
548: uint32_t source_h = ntohl(source);
549:
550: for (prev = srclist, node = prev->next; node; prev = node, node = node->next) {
551: /* The srclist is ordered with the smallest addresses first.
552: * The first entry is not used. */
553: if (ntohl(node->address) < source_h)
554: continue;
555:
556: if (node->address == source) {
557: *found = node;
558: return TRUE;
559: }
560: break;
561: }
562:
563: *found = prev; /* The insertion point is between s_prev and s */
564:
565: return FALSE;
566: }
567:
568:
569: static int search_grplist(uint32_t group, grpentry_t **found)
570: {
571: grpentry_t *prev, *node;
572: uint32_t group_h = ntohl(group);
573:
574: for (prev = grplist, node = prev->next; node; prev = node, node = node->next) {
575: /* The grplist is ordered with the smallest address first.
576: * The first entry is not used. */
577: if (ntohl(node->group) < group_h)
578: continue;
579:
580: if (node->group == group) {
581: *found = node;
582: return TRUE;
583: }
584: break;
585: }
586:
587: *found = prev; /* The insertion point is between prev and g */
588:
589: return FALSE;
590: }
591:
592:
593: static srcentry_t *create_srcentry(uint32_t source)
594: {
595: srcentry_t *node;
596: srcentry_t *prev;
597:
598: if (search_srclist(source, &prev) == TRUE)
599: return prev;
600:
601: node = calloc(1, sizeof(srcentry_t));
602: if (!node) {
603: logit(LOG_WARNING, 0, "Memory allocation error for srcentry %s",
604: inet_fmt(source, s1, sizeof(s1)));
605: return NULL;
606: }
607:
608: node->address = source;
609: /* Free the memory if there is error getting the iif and
610: * the next hop (upstream) router. */
611: if (set_incoming(node, PIM_IIF_SOURCE) == FALSE) {
612: free(node);
613: return NULL;
614: }
615:
616: RESET_TIMER(node->timer);
617: node->mrtlink = NULL;
618: node->cand_rp = NULL;
619: node->next = prev->next;
620: prev->next = node;
621: node->prev = prev;
622: if (node->next)
623: node->next->prev = node;
624:
625: IF_DEBUG(DEBUG_MFC) {
626: logit(LOG_DEBUG, 0, "create source entry, source %s",
627: inet_fmt(source, s1, sizeof(s1)));
628: }
629:
630: return node;
631: }
632:
633:
634: static grpentry_t *create_grpentry(uint32_t group)
635: {
636: grpentry_t *node;
637: grpentry_t *prev;
638:
639: /* If already exists, return it. Otheriwse search_grplist() returns the
640: * insertion point in prev. */
641: if (search_grplist(group, &prev) == TRUE)
642: return prev;
643:
644: node = calloc(1, sizeof(grpentry_t));
645: if (!node) {
646: logit(LOG_WARNING, 0, "Memory allocation error for grpentry %s",
647: inet_fmt(group, s1, sizeof(s1)));
648: return NULL;
649: }
650:
651: /*
652: * TODO: XXX: Note that this is NOT a (*,G) routing entry, but simply
653: * a group entry, probably used to search the routing table (to find
654: * (S,G) entries for example.)
655: * To become (*,G) routing entry, we must setup node->grp_route
656: */
657: node->group = group;
658: node->rpaddr = INADDR_ANY_N;
659: node->mrtlink = NULL;
660: node->active_rp_grp = NULL;
661: node->grp_route = NULL;
662: node->rpnext = NULL;
663: node->rpprev = NULL;
664:
665: /* Now it is safe to include the new group entry */
666: node->next = prev->next;
667: prev->next = node;
668: node->prev = prev;
669: if (node->next)
670: node->next->prev = node;
671:
672: IF_DEBUG(DEBUG_MFC) {
673: logit(LOG_DEBUG, 0, "create group entry, group %s", inet_fmt(group, s1, sizeof(s1)));
674: }
675:
676: return node;
677: }
678:
679:
680: /*
681: * Return TRUE if the entry is found and then *found is set to point to
682: * that entry. Otherwise return FALSE and *found points the previous
683: * entry, or NULL if first in the chain.
684: */
685: static int search_srcmrtlink(srcentry_t *src, uint32_t group, mrtentry_t **found)
686: {
687: mrtentry_t *node;
688: mrtentry_t *prev = NULL;
689: uint32_t group_h = ntohl(group);
690:
691: for (node = src->mrtlink; node; prev = node, node = node->srcnext) {
692: /* The entries are ordered with the smaller group address first.
693: * The addresses are in network order. */
694: if (ntohl(node->group->group) < group_h)
695: continue;
696:
697: if (node->group->group == group) {
698: *found = node;
699: return TRUE;
700: }
701:
702: break;
703: }
704:
705: *found = prev;
706:
707: return FALSE;
708: }
709:
710:
711: /*
712: * Return TRUE if the entry is found and then *found is set to point to
713: * that entry. Otherwise return FALSE and *found points the previous
714: * entry, or NULL if first in the chain.
715: */
716: static int search_grpmrtlink(grpentry_t *grp, uint32_t source, mrtentry_t **found)
717: {
718: mrtentry_t *node;
719: mrtentry_t *prev = NULL;
720: uint32_t source_h = ntohl(source);
721:
722: for (node = grp->mrtlink; node; prev = node, node = node->grpnext) {
723: /* The entries are ordered with the smaller source address first.
724: * The addresses are in network order. */
725: if (ntohl(node->source->address) < source_h)
726: continue;
727:
728: if (source == node->source->address) {
729: *found = node;
730: return TRUE;
731: }
732:
733: break;
734: }
735:
736: *found = prev;
737:
738: return FALSE;
739: }
740:
741:
742: static void insert_srcmrtlink(mrtentry_t *node, mrtentry_t *prev, srcentry_t *src)
743: {
744: if (!prev) {
745: /* Has to be insert as the head entry for this source */
746: node->srcnext = src->mrtlink;
747: node->srcprev = NULL;
748: src->mrtlink = node;
749: } else {
750: /* Insert right after the prev */
751: node->srcnext = prev->srcnext;
752: node->srcprev = prev;
753: prev->srcnext = node;
754: }
755:
756: if (node->srcnext)
757: node->srcnext->srcprev = node;
758: }
759:
760:
761: static void insert_grpmrtlink(mrtentry_t *node, mrtentry_t *prev, grpentry_t *grp)
762: {
763: if (!prev) {
764: /* Has to be insert as the head entry for this group */
765: node->grpnext = grp->mrtlink;
766: node->grpprev = NULL;
767: grp->mrtlink = node;
768: } else {
769: /* Insert right after the prev */
770: node->grpnext = prev->grpnext;
771: node->grpprev = prev;
772: prev->grpnext = node;
773: }
774:
775: if (node->grpnext)
776: node->grpnext->grpprev = node;
777: }
778:
779:
780: static mrtentry_t *alloc_mrtentry(srcentry_t *src, grpentry_t *grp)
781: {
782: mrtentry_t *mrt;
783: uint16_t i, *timer;
784: uint8_t vif_numbers;
785:
786: mrt = calloc(1, sizeof(mrtentry_t));
787: if (!mrt) {
788: logit(LOG_WARNING, 0, "alloc_mrtentry(): out of memory");
789: return NULL;
790: }
791:
792: /*
793: * grpnext, grpprev, srcnext, srcprev will be setup when we link the
794: * mrtentry to the source and group chains
795: */
796: mrt->source = src;
797: mrt->group = grp;
798: mrt->incoming = NO_VIF;
799: VIFM_CLRALL(mrt->joined_oifs);
800: VIFM_CLRALL(mrt->leaves);
801: VIFM_CLRALL(mrt->pruned_oifs);
802: VIFM_CLRALL(mrt->asserted_oifs);
803: VIFM_CLRALL(mrt->oifs);
804: mrt->upstream = NULL;
805: mrt->metric = 0;
806: mrt->preference = 0;
807: mrt->pmbr_addr = INADDR_ANY_N;
808: #ifdef RSRR
809: mrt->rsrr_cache = NULL;
810: #endif /* RSRR */
811:
812: /* XXX: TODO: if we are short in memory, we can reserve as few as possible
813: * space for vif timers (per group and/or routing entry), but then everytime
814: * when a new interfaces is configured, the router will be restarted and
815: * will delete the whole routing table. The "memory is cheap" solution is
816: * to reserve timer space for all potential vifs in advance and then no
817: * need to delete the routing table and disturb the forwarding.
818: */
819: #ifdef SAVE_MEMORY
820: mrt->vif_timers = (uint16_t *)calloc(1, sizeof(uint16_t) * numvifs);
821: mrt->vif_deletion_delay = (uint16_t *)calloc(1, sizeof(uint16_t) * numvifs);
822: vif_numbers = numvifs;
823: #else
824: mrt->vif_timers = (uint16_t *)calloc(1, sizeof(uint16_t) * total_interfaces);
825: mrt->vif_deletion_delay = (uint16_t *)calloc(1, sizeof(uint16_t) * total_interfaces);
826: vif_numbers = total_interfaces;
827: #endif /* SAVE_MEMORY */
828: if (!mrt->vif_timers || !mrt->vif_deletion_delay) {
829: logit(LOG_WARNING, 0, "alloc_mrtentry(): out of memory");
830: FREE_MRTENTRY(mrt);
831: return NULL;
832: }
833:
834: /* Reset the timers */
835: for (i = 0, timer = mrt->vif_timers; i < vif_numbers; i++, timer++)
836: RESET_TIMER(*timer);
837:
838: for (i = 0, timer = mrt->vif_deletion_delay; i < vif_numbers; i++, timer++)
839: RESET_TIMER(*timer);
840:
841: mrt->flags = MRTF_NEW;
842: RESET_TIMER(mrt->timer);
843: RESET_TIMER(mrt->jp_timer);
844: RESET_TIMER(mrt->rs_timer);
845: RESET_TIMER(mrt->assert_timer);
846: RESET_TIMER(mrt->assert_rate_timer);
847: mrt->kernel_cache = NULL;
848:
849: return mrt;
850: }
851:
852:
853: static mrtentry_t *create_mrtentry(srcentry_t *src, grpentry_t *grp, uint16_t flags)
854: {
855: mrtentry_t *node;
856: mrtentry_t *grp_insert, *src_insert; /* pointers to insert */
857: uint32_t source;
858: uint32_t group;
859:
860: if (flags & MRTF_SG) {
861: /* (S,G) entry */
862: source = src->address;
863: group = grp->group;
864:
865: if (search_grpmrtlink(grp, source, &grp_insert) == TRUE)
866: return grp_insert;
867:
868: if (search_srcmrtlink(src, group, &src_insert) == TRUE) {
869: /* Hmmm, search_grpmrtlink() didn't find the entry, but
870: * search_srcmrtlink() did find it! Shouldn't happen. Panic! */
871: logit(LOG_ERR, 0, "MRT inconsistency for src %s and grp %s\n",
872: inet_fmt(source, s1, sizeof(s1)), inet_fmt(group, s2, sizeof(s2)));
873:
874: /* not reached but to make lint happy */
875: return NULL;
876: }
877:
878: /* Create and insert in group mrtlink and source mrtlink chains. */
879: node = alloc_mrtentry(src, grp);
880: if (!node)
881: return NULL;
882:
883: /* node has to be insert right after grp_insert in the grp
884: * mrtlink chain and right after src_insert in the src mrtlink
885: * chain */
886: insert_grpmrtlink(node, grp_insert, grp);
887: insert_srcmrtlink(node, src_insert, src);
888: node->flags |= MRTF_SG;
889:
890: return node;
891: }
892:
893: if (flags & MRTF_WC) {
894: /* (*,G) entry */
895: if (grp->grp_route)
896: return grp->grp_route;
897:
898: node = alloc_mrtentry(src, grp);
899: if (!node)
900: return NULL;
901:
902: grp->grp_route = node;
903: node->flags |= (MRTF_WC | MRTF_RP);
904:
905: return node;
906: }
907:
908: if (flags & MRTF_PMBR) {
909: /* (*,*,RP) entry */
910: if (src->mrtlink)
911: return src->mrtlink;
912:
913: node = alloc_mrtentry(src, grp);
914: if (!node)
915: return NULL;
916:
917: src->mrtlink = node;
918: node->flags |= (MRTF_PMBR | MRTF_RP);
919:
920: return node;
921: }
922:
923: return NULL;
924: }
925:
926:
927: /*
928: * Delete all kernel cache for this mrtentry
929: */
930: void delete_mrtentry_all_kernel_cache(mrtentry_t *mrt)
931: {
932: kernel_cache_t *prev;
933: kernel_cache_t *node;
934:
935: if (!(mrt->flags & MRTF_KERNEL_CACHE))
936: return;
937:
938: /* Free all kernel_cache entries */
939: for (node = mrt->kernel_cache; node; ) {
940: prev = node;
941: node = node->next;
942:
943: logit(LOG_DEBUG, 0, "delete_mrtentry_all_kernel_cache: SG");
944: k_del_mfc(igmp_socket, prev->source, prev->group);
945: free(prev);
946: }
947: mrt->kernel_cache = NULL;
948:
949: /* turn off the cache flag(s) */
950: mrt->flags &= ~(MRTF_KERNEL_CACHE | MRTF_MFC_CLONE_SG);
951: }
952:
953:
954: void delete_single_kernel_cache(mrtentry_t *mrt, kernel_cache_t *node)
955: {
956: if (!mrt || !node)
957: return;
958:
959: if (!node->prev) {
960: mrt->kernel_cache = node->next;
961: if (!mrt->kernel_cache)
962: mrt->flags &= ~(MRTF_KERNEL_CACHE | MRTF_MFC_CLONE_SG);
963: } else {
964: node->prev->next = node->next;
965: }
966:
967: if (node->next)
968: node->next->prev = node->prev;
969:
970: IF_DEBUG(DEBUG_MFC) {
971: logit(LOG_DEBUG, 0, "Deleting MFC entry for source %s and group %s",
972: inet_fmt(node->source, s1, sizeof(s1)),
973: inet_fmt(node->group, s2, sizeof(s2)));
974: }
975:
976: logit(LOG_DEBUG, 0, "delete_single_kernel_cache: SG");
977: k_del_mfc(igmp_socket, node->source, node->group);
978: free(node);
979: }
980:
981:
982: void delete_single_kernel_cache_addr(mrtentry_t *mrt, uint32_t source, uint32_t group)
983: {
984: uint32_t source_h;
985: uint32_t group_h;
986: kernel_cache_t *node;
987:
988: if (!mrt)
989: return;
990:
991: source_h = ntohl(source);
992: group_h = ntohl(group);
993:
994: /* Find the exact (S,G) kernel_cache entry */
995: for (node = mrt->kernel_cache; node; node = node->next) {
996: if (ntohl(node->group) < group_h)
997: continue;
998: if (ntohl(node->group) > group_h)
999: return; /* Not found */
1000: if (ntohl(node->source) < source_h)
1001: continue;
1002: if (ntohl(node->source) > source_h)
1003: return; /* Not found */
1004:
1005: /* Found exact match */
1006: break;
1007: }
1008:
1009: if (!node)
1010: return;
1011:
1012: /* Found. Delete it */
1013: if (!node->prev) {
1014: mrt->kernel_cache = node->next;
1015: if (!mrt->kernel_cache)
1016: mrt->flags &= ~(MRTF_KERNEL_CACHE | MRTF_MFC_CLONE_SG);
1017: } else{
1018: node->prev->next = node->next;
1019: }
1020:
1021: if (node->next)
1022: node->next->prev = node->prev;
1023:
1024: IF_DEBUG(DEBUG_MFC) {
1025: logit(LOG_DEBUG, 0, "Deleting MFC entry for source %s and group %s",
1026: inet_fmt(node->source, s1, sizeof(s1)),
1027: inet_fmt(node->group, s2, sizeof(s2)));
1028: }
1029:
1030: logit(LOG_DEBUG, 0, "delete_single_kernel_cache_addr: SG");
1031: k_del_mfc(igmp_socket, node->source, node->group);
1032: free(node);
1033: }
1034:
1035:
1036: /*
1037: * Installs kernel cache for (source, group). Assumes mrt
1038: * is the correct entry.
1039: */
1040: void add_kernel_cache(mrtentry_t *mrt, uint32_t source, uint32_t group, uint16_t flags)
1041: {
1042: uint32_t source_h;
1043: uint32_t group_h;
1044: kernel_cache_t *next;
1045: kernel_cache_t *prev;
1046: kernel_cache_t *node;
1047:
1048: if (!mrt)
1049: return;
1050:
1051: move_kernel_cache(mrt, flags);
1052:
1053: if (mrt->flags & MRTF_SG) {
1054: /* (S,G) */
1055: if (mrt->flags & MRTF_KERNEL_CACHE)
1056: return;
1057:
1058: node = (kernel_cache_t *)calloc(1, sizeof(kernel_cache_t));
1059: node->next = NULL;
1060: node->prev = NULL;
1061: node->source = source;
1062: node->group = group;
1063: node->sg_count.pktcnt = 0;
1064: node->sg_count.bytecnt = 0;
1065: node->sg_count.wrong_if = 0;
1066: mrt->kernel_cache = node;
1067: mrt->flags |= MRTF_KERNEL_CACHE;
1068:
1069: return;
1070: }
1071:
1072: source_h = ntohl(source);
1073: group_h = ntohl(group);
1074: prev = NULL;
1075:
1076: for (next = mrt->kernel_cache; next; prev = next, next = next->next) {
1077: if (ntohl(next->group) < group_h)
1078: continue;
1079: if (ntohl(next->group) > group_h)
1080: break;
1081: if (ntohl(next->source) < source_h)
1082: continue;
1083: if (ntohl(next->source) > source_h)
1084: break;
1085:
1086: /* Found exact match. Nothing to change. */
1087: return;
1088: }
1089:
1090: /* The new entry must be placed between prev and
1091: * next */
1092: node = calloc(1, sizeof(kernel_cache_t));
1093: if (prev)
1094: prev->next = node;
1095: else
1096: mrt->kernel_cache = node;
1097:
1098: if (next)
1099: next->prev = node;
1100:
1101: node->prev = prev;
1102: node->next = next;
1103: node->source = source;
1104: node->group = group;
1105: node->sg_count.pktcnt = 0;
1106: node->sg_count.bytecnt = 0;
1107: node->sg_count.wrong_if = 0;
1108:
1109: mrt->flags |= MRTF_KERNEL_CACHE;
1110: }
1111:
1112: /*
1113: * Bring the kernel cache "UP": from the (*,*,RP) to (*,G) or (S,G)
1114: */
1115: static void move_kernel_cache(mrtentry_t *mrt, uint16_t flags)
1116: {
1117: kernel_cache_t *node;
1118: kernel_cache_t *insert_node;
1119: kernel_cache_t *first_node;
1120: kernel_cache_t *last_node;
1121: kernel_cache_t *prev_node;
1122: mrtentry_t *mrtentry_pmbr;
1123: mrtentry_t *mrtentry_rp;
1124: uint32_t group_h;
1125: uint32_t source_h;
1126: int found;
1127:
1128: if (!mrt)
1129: return;
1130:
1131: if (mrt->flags & MRTF_PMBR)
1132: return;
1133:
1134: if (mrt->flags & MRTF_WC) {
1135: /* Move the cache info from (*,*,RP) to (*,G) */
1136: group_h = ntohl(mrt->group->group);
1137: mrtentry_pmbr = mrt->group->active_rp_grp->rp->rpentry->mrtlink;
1138: if (!mrtentry_pmbr)
1139: return; /* Nothing to move */
1140:
1141: first_node = last_node = NULL;
1142: for (node = mrtentry_pmbr->kernel_cache; node; node = node->next) {
1143: /*
1144: * The order is: (1) smaller group;
1145: * (2) smaller source within group
1146: */
1147: if (ntohl(node->group) < group_h)
1148: continue;
1149:
1150: if (ntohl(node->group) != group_h)
1151: break;
1152:
1153: /* Select the kernel_cache entries to move */
1154: if (!first_node)
1155: first_node = last_node = node;
1156: else
1157: last_node = node;
1158: }
1159:
1160: if (first_node) {
1161: /* Fix the old chain */
1162: if (first_node->prev)
1163: first_node->prev->next = last_node->next;
1164: else
1165: mrtentry_pmbr->kernel_cache = last_node->next;
1166:
1167: if (last_node->next)
1168: last_node->next->prev = first_node->prev;
1169:
1170: if (!mrtentry_pmbr->kernel_cache)
1171: mrtentry_pmbr->flags &= ~(MRTF_KERNEL_CACHE | MRTF_MFC_CLONE_SG);
1172:
1173: /* Insert in the new place */
1174: prev_node = NULL;
1175: last_node->next = NULL;
1176: mrt->flags |= MRTF_KERNEL_CACHE;
1177:
1178: for (node = mrt->kernel_cache; node; ) {
1179: if (!first_node)
1180: break; /* All entries have been inserted */
1181:
1182: if (ntohl(node->source) > ntohl(first_node->source)) {
1183: /* Insert the entry before node */
1184: insert_node = first_node;
1185: first_node = first_node->next;
1186:
1187: if (node->prev)
1188: node->prev->next = insert_node;
1189: else
1190: mrt->kernel_cache = insert_node;
1191:
1192: insert_node->prev = node->prev;
1193: insert_node->next = node;
1194: node->prev = insert_node;
1195: }
1196: prev_node = node;
1197: node = node->next;
1198: }
1199:
1200: if (first_node) {
1201: /* Place all at the end after prev_node */
1202: if (prev_node)
1203: prev_node->next = first_node;
1204: else
1205: mrt->kernel_cache = first_node;
1206:
1207: first_node->prev = prev_node;
1208: }
1209: }
1210:
1211: return;
1212: }
1213:
1214: if (mrt->flags & MRTF_SG) {
1215: logit(LOG_DEBUG, 0, "move_kernel_cache: SG");
1216: /* (S,G) entry. Move the whole group cache from (*,*,RP) to (*,G) and
1217: * then get the necessary entry from (*,G).
1218: * TODO: Not optimized! The particular entry is moved first to (*,G),
1219: * then we have to search again (*,G) to find it and move to (S,G).
1220: */
1221: /* TODO: XXX: No need for this? Thinking.... */
1222: /* move_kernel_cache(mrt->group->grp_route, flags); */
1223: mrtentry_rp = mrt->group->grp_route;
1224: if (!mrtentry_rp) {
1225: mrtentry_rp = mrt->group->active_rp_grp->rp->rpentry->mrtlink;
1226: if (!mrtentry_rp)
1227: return;
1228: }
1229:
1230: if (mrtentry_rp->incoming != mrt->incoming) {
1231: /* XXX: the (*,*,RP) (or (*,G)) iif is different from the
1232: * (S,G) iif. No need to move the cache, because (S,G) don't
1233: * need it. After the first packet arrives on the shortest path,
1234: * the correct cache entry will be created.
1235: * If (flags & MFC_MOVE_FORCE) then we must move the cache.
1236: * This usually happens when switching to the shortest path.
1237: * The calling function will immediately call k_chg_mfc()
1238: * to modify the kernel cache.
1239: */
1240: if (!(flags & MFC_MOVE_FORCE))
1241: return;
1242: }
1243:
1244: /* Find the exact entry */
1245: source_h = ntohl(mrt->source->address);
1246: group_h = ntohl(mrt->group->group);
1247: found = FALSE;
1248: for (node = mrtentry_rp->kernel_cache; node; node = node->next) {
1249: if (ntohl(node->group) < group_h)
1250: continue;
1251:
1252: if (ntohl(node->group) > group_h)
1253: break;
1254:
1255: if (ntohl(node->source) < source_h)
1256: continue;
1257:
1258: if (ntohl(node->source) > source_h)
1259: break;
1260:
1261: /* We found it! */
1262: if (node->prev)
1263: node->prev->next = node->next;
1264: else
1265: mrtentry_rp->kernel_cache = node->next;
1266:
1267: if (node->next)
1268: node->next->prev = node->prev;
1269:
1270: found = TRUE;
1271:
1272: break;
1273: }
1274:
1275: if (found == TRUE) {
1276: if (!mrtentry_rp->kernel_cache)
1277: mrtentry_rp->flags &= ~(MRTF_KERNEL_CACHE | MRTF_MFC_CLONE_SG);
1278:
1279: if (mrt->kernel_cache)
1280: free(mrt->kernel_cache);
1281:
1282: mrt->flags |= MRTF_KERNEL_CACHE;
1283: mrt->kernel_cache = node;
1284:
1285: node->prev = NULL;
1286: node->next = NULL;
1287: }
1288: }
1289: }
1290:
1291: /**
1292: * Local Variables:
1293: * version-control: t
1294: * indent-tabs-mode: t
1295: * c-file-style: "ellemtel"
1296: * c-basic-offset: 4
1297: * End:
1298: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mrt.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pimd