Annotation of embedaddon/pimdd/pim_proto.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Copyright (c) 1998 by the University of Oregon.
3: * All rights reserved.
4: *
5: * Permission to use, copy, modify, and distribute this software and
6: * its documentation in source and binary forms for lawful
7: * purposes and without fee is hereby granted, provided
8: * that the above copyright notice appear in all copies and that both
9: * the copyright notice and this permission notice appear in supporting
10: * documentation, and that any documentation, advertising materials,
11: * and other materials related to such distribution and use acknowledge
12: * that the software was developed by the University of Oregon.
13: * The name of the University of Oregon may not be used to endorse or
14: * promote products derived from this software without specific prior
15: * written permission.
16: *
17: * THE UNIVERSITY OF OREGON DOES NOT MAKE ANY REPRESENTATIONS
18: * ABOUT THE SUITABILITY OF THIS SOFTWARE FOR ANY PURPOSE. THIS SOFTWARE IS
19: * PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
20: * INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
21: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, TITLE, AND
22: * NON-INFRINGEMENT.
23: *
24: * IN NO EVENT SHALL UO, OR ANY OTHER CONTRIBUTOR BE LIABLE FOR ANY
25: * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES, WHETHER IN CONTRACT,
26: * TORT, OR OTHER FORM OF ACTION, ARISING OUT OF OR IN CONNECTION WITH,
27: * THE USE OR PERFORMANCE OF THIS SOFTWARE.
28: *
29: * Other copyrights might apply to parts of this software and are so
30: * noted when applicable.
31: */
32: /*
33: * Questions concerning this software should be directed to
34: * Kurt Windisch (kurtw@antc.uoregon.edu)
35: *
36: * $Id: pim_proto.c,v 1.37 1998/12/22 21:50:18 kurtw Exp $
37: */
38: /*
39: * Part of this program has been derived from PIM sparse-mode pimd.
40: * The pimd program is covered by the license in the accompanying file
41: * named "LICENSE.pimd".
42: *
43: * The pimd program is COPYRIGHT 1998 by University of Southern California.
44: *
45: * Part of this program has been derived from mrouted.
46: * The mrouted program is covered by the license in the accompanying file
47: * named "LICENSE.mrouted".
48: *
49: * The mrouted program is COPYRIGHT 1989 by The Board of Trustees of
50: * Leland Stanford Junior University.
51: *
52: */
53:
54: #include "defs.h"
55:
56: /*
57: * Local functions definitions.
58: */
59: static int parse_pim_hello __P((char *pktPtr,
60: int datalen,
61: u_int32 src,
62: u_int16 *holdtime));
63: static int compare_metrics __P((u_int32 local_preference,
64: u_int32 local_metric,
65: u_int32 local_address,
66: u_int32 remote_preference,
67: u_int32 remote_metric,
68: u_int32 remote_address));
69:
70: vifbitmap_t nbr_vifs; /* Vifs that have one or more neighbors attached */
71:
72: /************************************************************************
73: * PIM_HELLO
74: ************************************************************************/
75: int
76: receive_pim_hello(src, dst, pim_message, datalen)
77: u_int32 src, dst;
78: register char *pim_message;
79: int datalen;
80: {
81: vifi_t vifi;
82: struct uvif *v;
83: register pim_nbr_entry_t *nbr, *prev_nbr, *new_nbr;
84: u_int16 holdtime;
85: u_int8 *data_ptr;
86: int state_change;
87: srcentry_t *srcentry_ptr;
88: srcentry_t *srcentry_ptr_next;
89: mrtentry_t *mrtentry_ptr;
90:
91: /* Checksum */
92: if (inet_cksum((u_int16 *)pim_message, datalen))
93: return(FALSE);
94:
95: if ((vifi = find_vif_direct(src)) == NO_VIF) {
96: /* Either a local vif or somehow received PIM_HELLO from
97: * non-directly connected router. Ignore it.
98: */
99: if (local_address(src) == NO_VIF)
100: log(LOG_INFO, 0, "Ignoring PIM_HELLO from non-neighbor router %s",
101: inet_fmt(src, s1));
102: return(FALSE);
103: }
104:
105: v = &uvifs[vifi];
106: if (v->uv_flags & (VIFF_DOWN | VIFF_DISABLED))
107: return(FALSE); /* Shoudn't come on this interface */
108: data_ptr = (u_int8 *)(pim_message + sizeof(pim_header_t));
109:
110: /* Get the Holdtime (in seconds) from the message. Return if error. */
111: if (parse_pim_hello(pim_message, datalen, src, &holdtime) == FALSE)
112: return(FALSE);
113: IF_DEBUG(DEBUG_PIM_HELLO | DEBUG_PIM_TIMER)
114: log(LOG_DEBUG, 0, "PIM HELLO holdtime from %s is %u",
115: inet_fmt(src, s1), holdtime);
116:
117: for (prev_nbr = (pim_nbr_entry_t *)NULL, nbr = v->uv_pim_neighbors;
118: nbr != (pim_nbr_entry_t *)NULL;
119: prev_nbr = nbr, nbr = nbr->next) {
120: /* The PIM neighbors are sorted in decreasing order of the
121: * network addresses (note that to be able to compare them
122: * correctly we must translate the addresses in host order.
123: */
124: if (ntohl(src) < ntohl(nbr->address))
125: continue;
126: if (src == nbr->address) {
127: /* We already have an entry for this host */
128: if (0 == holdtime) {
129: /* Looks like we have a nice neighbor who is going down
130: * and wants to inform us by sending "holdtime=0". Thanks
131: * buddy and see you again!
132: */
133: log(LOG_INFO, 0, "PIM HELLO received: neighbor %s going down",
134: inet_fmt(src, s1));
135: delete_pim_nbr(nbr);
136: return(TRUE);
137: }
138: SET_TIMER(nbr->timer, holdtime);
139: return(TRUE);
140: }
141: else
142: /*
143: * No entry for this neighbor. Exit the loop and create an
144: * entry for it.
145: */
146: break;
147: }
148:
149: /*
150: * This is a new neighbor. Create a new entry for it.
151: * It must be added right after `prev_nbr`
152: */
153: new_nbr = (pim_nbr_entry_t *)malloc(sizeof(pim_nbr_entry_t));
154: new_nbr->address = src;
155: new_nbr->vifi = vifi;
156: SET_TIMER(new_nbr->timer, holdtime);
157: new_nbr->next = nbr;
158: new_nbr->prev = prev_nbr;
159:
160: if (prev_nbr != (pim_nbr_entry_t *)NULL)
161: prev_nbr->next = new_nbr;
162: else
163: v->uv_pim_neighbors = new_nbr;
164: if (new_nbr->next != (pim_nbr_entry_t *)NULL)
165: new_nbr->next->prev = new_nbr;
166:
167: v->uv_flags &= ~VIFF_NONBRS;
168: v->uv_flags |= VIFF_PIM_NBR;
169: VIFM_SET(vifi, nbr_vifs);
170:
171: /* Elect a new DR */
172: if (ntohl(v->uv_lcl_addr) <
173: ntohl(v->uv_pim_neighbors->address)) {
174: /* The first address is the new potential remote
175: * DR address and it wins (is >) over the local address.
176: */
177: v->uv_flags &= ~VIFF_DR;
178: v->uv_flags &= ~VIFF_QUERIER;
179: }
180:
181: /* Since a new neighbour has come up, let it know your existence */
182: /* XXX: TODO: not in the spec,
183: * but probably should send the message after a short random period?
184: */
185: send_pim_hello(v, PIM_TIMER_HELLO_HOLDTIME);
186:
187: /* Update the source entries */
188: for (srcentry_ptr = srclist; srcentry_ptr != (srcentry_t *)NULL;
189: srcentry_ptr = srcentry_ptr_next) {
190: srcentry_ptr_next = srcentry_ptr->next;
191:
192: if (srcentry_ptr->incoming == vifi)
193: continue;
194:
195: for (mrtentry_ptr = srcentry_ptr->mrtlink;
196: mrtentry_ptr != (mrtentry_t *)NULL;
197: mrtentry_ptr = mrtentry_ptr->srcnext) {
198:
199: if(!(VIFM_ISSET(vifi, mrtentry_ptr->oifs))) {
200: state_change =
201: change_interfaces(mrtentry_ptr, srcentry_ptr->incoming,
202: mrtentry_ptr->pruned_oifs,
203: mrtentry_ptr->leaves);
204: if(state_change == 1)
205: trigger_join_alert(mrtentry_ptr);
206: }
207: }
208: }
209:
210: IF_DEBUG(DEBUG_PIM_HELLO)
211: dump_vifs(stderr); /* Show we got a new neighbor */
212: return(TRUE);
213: }
214:
215:
216: void
217: delete_pim_nbr(nbr_delete)
218: pim_nbr_entry_t *nbr_delete;
219: {
220: srcentry_t *srcentry_ptr;
221: srcentry_t *srcentry_ptr_next;
222: mrtentry_t *mrtentry_ptr;
223: struct uvif *v;
224: int state_change;
225:
226: v = &uvifs[nbr_delete->vifi];
227:
228: /* Delete the entry from the pim_nbrs chain */
229: if (nbr_delete->prev != (pim_nbr_entry_t *)NULL)
230: nbr_delete->prev->next = nbr_delete->next;
231: else
232: v->uv_pim_neighbors = nbr_delete->next;
233: if (nbr_delete->next != (pim_nbr_entry_t *)NULL)
234: nbr_delete->next->prev = nbr_delete->prev;
235:
236: if (v->uv_pim_neighbors == (pim_nbr_entry_t *)NULL) {
237: /* This was our last neighbor. */
238: v->uv_flags &= ~VIFF_PIM_NBR;
239: v->uv_flags |= (VIFF_NONBRS | VIFF_DR | VIFF_QUERIER);
240: VIFM_CLR(nbr_delete->vifi, nbr_vifs);
241: }
242: else {
243: if (ntohl(v->uv_lcl_addr) >
244: ntohl(v->uv_pim_neighbors->address)) {
245: /* The first address is the new potential remote
246: * DR address, but the local address is the winner.
247: */
248: v->uv_flags |= VIFF_DR;
249: v->uv_flags |= VIFF_QUERIER;
250: }
251: }
252:
253: /* Update the source entries:
254: * If the deleted nbr was my upstream, then reset incoming and
255: * update all (S,G) entries for sources reachable through it.
256: * If the deleted nbr was the last on a non-iif vif, then recalcuate
257: * outgoing interfaces.
258: */
259: for (srcentry_ptr = srclist; srcentry_ptr != (srcentry_t *)NULL;
260: srcentry_ptr = srcentry_ptr_next) {
261: srcentry_ptr_next = srcentry_ptr->next;
262:
263: /* The only time we don't need to scan all mrtentries is when the nbr
264: * was on the iif, but not the upstream nbr!
265: */
266: if (nbr_delete->vifi == srcentry_ptr->incoming &&
267: srcentry_ptr->upstream != nbr_delete)
268: continue;
269:
270: /* Reset the next hop (PIM) router */
271: if(srcentry_ptr->upstream == nbr_delete)
272: if (set_incoming(srcentry_ptr, PIM_IIF_SOURCE) == FALSE) {
273: /* Coudn't reset it. Sorry, the hext hop router toward that
274: * source is probably not a PIM router, or cannot find route
275: * at all, hence I cannot handle this source and have to
276: * delete it.
277: */
278: delete_srcentry(srcentry_ptr);
279: free((char *)nbr_delete);
280: return;
281: }
282:
283: for (mrtentry_ptr = srcentry_ptr->mrtlink;
284: mrtentry_ptr != (mrtentry_t *)NULL;
285: mrtentry_ptr = mrtentry_ptr->srcnext) {
286: mrtentry_ptr->incoming = srcentry_ptr->incoming;
287: mrtentry_ptr->upstream = srcentry_ptr->upstream;
288: mrtentry_ptr->metric = srcentry_ptr->metric;
289: mrtentry_ptr->preference = srcentry_ptr->preference;
290: state_change =
291: change_interfaces(mrtentry_ptr, srcentry_ptr->incoming,
292: mrtentry_ptr->pruned_oifs,
293: mrtentry_ptr->leaves);
294: if(state_change == -1) {
295: trigger_prune_alert(mrtentry_ptr);
296: } else if(state_change == 1) {
297: trigger_join_alert(mrtentry_ptr);
298: }
299: }
300: }
301:
302: free((char *)nbr_delete);
303: }
304:
305:
306: /* TODO: simplify it! */
307: static int
308: parse_pim_hello(pim_message, datalen, src, holdtime)
309: char *pim_message;
310: int datalen;
311: u_int32 src;
312: u_int16 *holdtime;
313: {
314: u_int8 *pim_hello_message;
315: u_int8 *data_ptr;
316: u_int16 option_type;
317: u_int16 option_length;
318: int holdtime_received_ok = FALSE;
319: int option_total_length;
320:
321: pim_hello_message = (u_int8 *)(pim_message + sizeof(pim_header_t));
322: datalen -= sizeof(pim_header_t);
323: for ( ; datalen >= sizeof(pim_hello_t); ) {
324: /* Ignore any data if shorter than (pim_hello header) */
325: data_ptr = pim_hello_message;
326: GET_HOSTSHORT(option_type, data_ptr);
327: GET_HOSTSHORT(option_length, data_ptr);
328: switch (option_type) {
329: case PIM_MESSAGE_HELLO_HOLDTIME:
330: if (PIM_MESSAGE_HELLO_HOLDTIME_LENGTH != option_length) {
331: IF_DEBUG(DEBUG_PIM_HELLO)
332: log(LOG_DEBUG, 0,
333: "PIM HELLO Holdtime from %s: invalid OptionLength = %u",
334: inet_fmt(src, s1), option_length);
335: return (FALSE);
336: }
337: GET_HOSTSHORT(*holdtime, data_ptr);
338: holdtime_received_ok = TRUE;
339: break;
340: default:
341: /* Ignore any unknown options */
342: break;
343: }
344:
345: /* Move to the next option */
346: /* XXX: TODO: If we are padding to the end of the 32 bit boundary,
347: * use the first method to move to the next option, otherwise
348: * simply (sizeof(pim_hello_t) + option_length).
349: */
350: #ifdef BOUNDARY_32_BIT
351: option_total_length = (sizeof(pim_hello_t) + (option_length & ~0x3) +
352: ((option_length & 0x3) ? 4 : 0));
353: #else
354: option_total_length = (sizeof(pim_hello_t) + option_length);
355: #endif /* BOUNDARY_32_BIT */
356: datalen -= option_total_length;
357: pim_hello_message += option_total_length;
358: }
359: return (holdtime_received_ok);
360: }
361:
362:
363: int
364: send_pim_hello(v, holdtime)
365: struct uvif *v;
366: u_int16 holdtime;
367: {
368: char *buf;
369: u_int8 *data_ptr;
370:
371: int datalen;
372:
373: buf = pim_send_buf + sizeof(struct ip) + sizeof(pim_header_t);
374: data_ptr = (u_int8 *)buf;
375: PUT_HOSTSHORT(PIM_MESSAGE_HELLO_HOLDTIME, data_ptr);
376: PUT_HOSTSHORT(PIM_MESSAGE_HELLO_HOLDTIME_LENGTH, data_ptr);
377: PUT_HOSTSHORT(holdtime, data_ptr);
378:
379: datalen = data_ptr - (u_int8 *)buf;
380:
381: send_pim(pim_send_buf, v->uv_lcl_addr, allpimrouters_group, PIM_HELLO,
382: datalen);
383: SET_TIMER(v->uv_pim_hello_timer, PIM_TIMER_HELLO_PERIOD);
384: return(TRUE);
385: }
386:
387:
388: /************************************************************************
389: * PIM_JOIN_PRUNE
390: ************************************************************************/
391:
392: typedef struct {
393: u_int32 source;
394: u_int32 group;
395: u_int32 target;
396: } join_delay_cbk_t;
397:
398: typedef struct {
399: vifi_t vifi;
400: u_int32 source;
401: u_int32 group;
402: u_int16 holdtime;
403: } prune_delay_cbk_t;
404:
405: static void
406: delayed_join_job(arg)
407: void *arg;
408: {
409: mrtentry_t *mrtentry_ptr;
410:
411: join_delay_cbk_t *cbk = (join_delay_cbk_t *)arg;
412:
413: mrtentry_ptr = find_route(cbk->source, cbk->group, MRTF_SG, DONT_CREATE);
414: if(mrtentry_ptr == (mrtentry_t *)NULL)
415: return;
416:
417: if(mrtentry_ptr->join_delay_timerid)
418: timer_clearTimer(mrtentry_ptr->join_delay_timerid);
419:
420: if(mrtentry_ptr->upstream)
421: send_pim_jp(mrtentry_ptr, PIM_ACTION_JOIN, mrtentry_ptr->incoming,
422: mrtentry_ptr->upstream->address, 0);
423:
424: free(cbk);
425: }
426:
427: static void
428: schedule_delayed_join(mrtentry_ptr, target)
429: mrtentry_t *mrtentry_ptr;
430: u_int32 target;
431: {
432: u_long random_delay;
433: join_delay_cbk_t *cbk;
434:
435: /* Delete existing timer */
436: if(mrtentry_ptr->join_delay_timerid)
437: timer_clearTimer(mrtentry_ptr->join_delay_timerid);
438:
439: #ifdef SYSV
440: random_delay = lrand48() % (long)PIM_RANDOM_DELAY_JOIN_TIMEOUT;
441: #else
442: random_delay = random() % (long)PIM_RANDOM_DELAY_JOIN_TIMEOUT;
443: #endif
444:
445: IF_DEBUG(DEBUG_PIM_JOIN_PRUNE)
446: log(LOG_DEBUG, 0, "Scheduling join for src %s, grp %s, delay %d",
447: inet_fmt(mrtentry_ptr->source->address, s1),
448: inet_fmt(mrtentry_ptr->group->group, s2),
449: random_delay);
450:
451: if(random_delay == 0 && mrtentry_ptr->upstream) {
452: send_pim_jp(mrtentry_ptr, PIM_ACTION_JOIN, mrtentry_ptr->incoming,
453: mrtentry_ptr->upstream->address, 0);
454: return;
455: }
456:
457: cbk = (join_delay_cbk_t *)malloc(sizeof(join_delay_cbk_t));
458: cbk->source = mrtentry_ptr->source->address;
459: cbk->group = mrtentry_ptr->group->group;
460: cbk->target = target;
461:
462: mrtentry_ptr->join_delay_timerid =
463: timer_setTimer(random_delay, delayed_join_job, cbk);
464: }
465:
466:
467: static void
468: delayed_prune_job(arg)
469: void *arg;
470: {
471: mrtentry_t *mrtentry_ptr;
472: vifbitmap_t new_pruned_oifs;
473: int state_change;
474:
475: prune_delay_cbk_t *cbk = (prune_delay_cbk_t *)arg;
476:
477: mrtentry_ptr = find_route(cbk->source, cbk->group, MRTF_SG, DONT_CREATE);
478: if(mrtentry_ptr == (mrtentry_t *)NULL)
479: return;
480:
481: if(mrtentry_ptr->prune_delay_timerids[cbk->vifi])
482: timer_clearTimer(mrtentry_ptr->prune_delay_timerids[cbk->vifi]);
483:
484: if(VIFM_ISSET(cbk->vifi, mrtentry_ptr->oifs)) {
485: IF_DEBUG(DEBUG_PIM_JOIN_PRUNE)
486: log(LOG_DEBUG, 0, "Deleting pruned vif %d for src %s, grp %s",
487: cbk->vifi,
488: inet_fmt(cbk->source, s1),
489: inet_fmt(cbk->group, s2));
490:
491: VIFM_COPY(mrtentry_ptr->pruned_oifs, new_pruned_oifs);
492: VIFM_SET(cbk->vifi, new_pruned_oifs);
493: SET_TIMER(mrtentry_ptr->prune_timers[cbk->vifi], cbk->holdtime);
494:
495: state_change =
496: change_interfaces(mrtentry_ptr,
497: mrtentry_ptr->incoming,
498: new_pruned_oifs,
499: mrtentry_ptr->leaves);
500:
501: /* Handle transition to negative cache */
502: if(state_change == -1)
503: trigger_prune_alert(mrtentry_ptr);
504: }
505:
506: free(cbk);
507: }
508:
509: static void
510: schedule_delayed_prune(mrtentry_ptr, vifi, holdtime)
511: mrtentry_t *mrtentry_ptr;
512: vifi_t vifi;
513: u_int16 holdtime;
514: {
515: prune_delay_cbk_t *cbk;
516:
517: /* Delete existing timer */
518: if(mrtentry_ptr->prune_delay_timerids[vifi])
519: timer_clearTimer(mrtentry_ptr->prune_delay_timerids[vifi]);
520:
521: cbk = (prune_delay_cbk_t *)malloc(sizeof(prune_delay_cbk_t));
522: cbk->vifi = vifi;
523: cbk->source = mrtentry_ptr->source->address;
524: cbk->group = mrtentry_ptr->group->group;
525: cbk->holdtime = holdtime;
526:
527: mrtentry_ptr->prune_delay_timerids[vifi] =
528: timer_setTimer((u_int16)PIM_RANDOM_DELAY_JOIN_TIMEOUT+1,
529: delayed_prune_job, cbk);
530: }
531:
532:
533: /* TODO: when parsing, check if we go beyong message size */
534: int
535: receive_pim_join_prune(src, dst, pim_message, datalen)
536: u_int32 src, dst;
537: char *pim_message;
538: register int datalen;
539: {
540: vifi_t vifi;
541: struct uvif *v;
542: pim_encod_uni_addr_t uni_target_addr;
543: pim_encod_grp_addr_t encod_group;
544: pim_encod_src_addr_t encod_src;
545: u_int8 *data_ptr;
546: u_int8 num_groups;
547: u_int16 holdtime;
548: u_int16 num_j_srcs;
549: u_int16 num_p_srcs;
550: u_int32 source;
551: u_int32 group;
552: u_int32 s_mask;
553: u_int32 g_mask;
554: u_int8 s_flags;
555: u_int8 reserved;
556: mrtentry_t *mrtentry_ptr;
557: pim_nbr_entry_t *upstream_router;
558: vifbitmap_t new_pruned_oifs;
559: int state_change;
560:
561: if ((vifi = find_vif_direct(src)) == NO_VIF) {
562: /* Either a local vif or somehow received PIM_JOIN_PRUNE from
563: * non-directly connected router. Ignore it.
564: */
565: if (local_address(src) == NO_VIF)
566: log(LOG_INFO, 0,
567: "Ignoring PIM_JOIN_PRUNE from non-neighbor router %s",
568: inet_fmt(src, s1));
569: return(FALSE);
570: }
571:
572: /* Checksum */
573: if (inet_cksum((u_int16 *)pim_message, datalen))
574: return(FALSE);
575:
576: v = &uvifs[vifi];
577: if (uvifs[vifi].uv_flags & (VIFF_DOWN | VIFF_DISABLED | VIFF_NONBRS))
578: return(FALSE); /* Shoudn't come on this interface */
579: data_ptr = (u_int8 *)(pim_message + sizeof(pim_header_t));
580:
581: /* Get the target address */
582: GET_EUADDR(&uni_target_addr, data_ptr);
583: GET_BYTE(reserved, data_ptr);
584: GET_BYTE(num_groups, data_ptr);
585: if (num_groups == 0)
586: return (FALSE); /* No indication for groups in the message */
587: GET_HOSTSHORT(holdtime, data_ptr);
588:
589: IF_DEBUG(DEBUG_PIM_JOIN_PRUNE)
590: log(LOG_DEBUG, 0,
591: "PIM Join/Prune received from %s : target %s, holdtime %d",
592: inet_fmt(src, s1), inet_fmt(uni_target_addr.unicast_addr, s2),
593: holdtime);
594:
595: if ((uni_target_addr.unicast_addr != v->uv_lcl_addr) &&
596: (uni_target_addr.unicast_addr != INADDR_ANY_N)) {
597: /* if I am not the target of the join or prune message */
598: /* Join Suppression: when receiving a join not addressed to me,
599: * if I am delaying a join for this (S,G) then cancel the delayed
600: * join.
601: * Prune Soliticiting Joins: when receiving a prune not addressed to
602: * me on a LAN, schedule delayed join if I have downstream receivers.
603: */
604:
605: upstream_router = find_pim_nbr(uni_target_addr.unicast_addr);
606: if (upstream_router == (pim_nbr_entry_t *)NULL)
607: return (FALSE); /* I have no such neighbor */
608: while (num_groups--) {
609: GET_EGADDR(&encod_group, data_ptr);
610: GET_HOSTSHORT(num_j_srcs, data_ptr);
611: GET_HOSTSHORT(num_p_srcs, data_ptr);
612: MASKLEN_TO_MASK(encod_group.masklen, g_mask);
613: group = encod_group.mcast_addr;
614: if (!IN_MULTICAST(ntohl(group))) {
615: data_ptr +=
616: (num_j_srcs + num_p_srcs) * sizeof(pim_encod_src_addr_t);
617: continue; /* Ignore this group and jump to the next */
618: }
619:
620: while (num_j_srcs--) {
621: GET_ESADDR(&encod_src, data_ptr);
622: source = encod_src.src_addr;
623: if (!inet_valid_host(source))
624: continue;
625: s_flags = encod_src.flags;
626: MASKLEN_TO_MASK(encod_src.masklen, s_mask);
627:
628: /* (S,G) Join suppresion */
629: mrtentry_ptr = find_route(source, group, MRTF_SG,
630: DONT_CREATE);
631: if(mrtentry_ptr == (mrtentry_t *)NULL)
632: continue;
633:
634: IF_DEBUG(DEBUG_PIM_JOIN_PRUNE)
635: log(LOG_DEBUG, 0,
636: "\tJOIN src %s, group %s - canceling delayed join",
637: inet_fmt(source, s1), inet_fmt(group, s2));
638:
639: /* Cancel the delayed join */
640: if(mrtentry_ptr->join_delay_timerid) {
641: timer_clearTimer(mrtentry_ptr->join_delay_timerid);
642: mrtentry_ptr->join_delay_timerid = 0;
643: }
644: }
645:
646: while (num_p_srcs--) {
647: GET_ESADDR(&encod_src, data_ptr);
648: source = encod_src.src_addr;
649: if (!inet_valid_host(source))
650: continue;
651: s_flags = encod_src.flags;
652:
653: /* if P2P link (not addressed to me) ignore
654: */
655: if(uvifs[vifi].uv_flags & VIFF_POINT_TO_POINT)
656: continue;
657:
658: /* if non-null oiflist then schedule delayed join
659: */
660: mrtentry_ptr = find_route(source, group, MRTF_SG,
661: DONT_CREATE);
662: if(mrtentry_ptr == (mrtentry_t *)NULL)
663: continue;
664:
665:
666: if(!(VIFM_ISEMPTY(mrtentry_ptr->oifs))) {
667: IF_DEBUG(DEBUG_PIM_JOIN_PRUNE)
668: log(LOG_DEBUG, 0,
669: "\tPRUNE src %s, group %s - scheduling delayed join",
670: inet_fmt(source, s1), inet_fmt(group, s2));
671:
672: schedule_delayed_join(mrtentry_ptr, uni_target_addr);
673: }
674: }
675:
676: } /* while groups */
677:
678: return(TRUE);
679: } /* if not unicast target */
680:
681: /* I am the target of this join/prune:
682: * For joins, cancel delayed prunes that I have scheduled.
683: * For prunes, echo the prune and schedule delayed prunes on LAN or
684: * prune immediately on point-to-point links.
685: */
686: else {
687: while (num_groups--) {
688: GET_EGADDR(&encod_group, data_ptr);
689: GET_HOSTSHORT(num_j_srcs, data_ptr);
690: GET_HOSTSHORT(num_p_srcs, data_ptr);
691: MASKLEN_TO_MASK(encod_group.masklen, g_mask);
692: group = encod_group.mcast_addr;
693: if (!IN_MULTICAST(ntohl(group))) {
694: data_ptr +=
695: (num_j_srcs + num_p_srcs) * sizeof(pim_encod_src_addr_t);
696: continue; /* Ignore this group and jump to the next */
697: }
698:
699: while (num_j_srcs--) {
700: GET_ESADDR(&encod_src, data_ptr);
701: source = encod_src.src_addr;
702: if (!inet_valid_host(source))
703: continue;
704: s_flags = encod_src.flags;
705: MASKLEN_TO_MASK(encod_src.masklen, s_mask);
706:
707: mrtentry_ptr = find_route(source, group, MRTF_SG,
708: DONT_CREATE);
709: if(mrtentry_ptr == (mrtentry_t *)NULL)
710: continue;
711:
712: IF_DEBUG(DEBUG_PIM_JOIN_PRUNE)
713: log(LOG_DEBUG, 0,
714: "\tJOIN src %s, group %s - canceling delayed prune",
715: inet_fmt(source, s1), inet_fmt(group, s2));
716:
717: /* Cancel the delayed prune */
718: if(mrtentry_ptr->prune_delay_timerids[vifi]) {
719: timer_clearTimer(mrtentry_ptr->prune_delay_timerids[vifi]);
720: mrtentry_ptr->prune_delay_timerids[vifi] = 0;
721: }
722: }
723:
724: while (num_p_srcs--) {
725: GET_ESADDR(&encod_src, data_ptr);
726: source = encod_src.src_addr;
727: if (!inet_valid_host(source))
728: continue;
729: s_flags = encod_src.flags;
730:
731:
732: mrtentry_ptr = find_route(source, group, MRTF_SG,
733: DONT_CREATE);
734: if(mrtentry_ptr == (mrtentry_t *)NULL)
735: continue;
736:
737: /* if P2P link (addressed to me) prune immediately
738: */
739: if(uvifs[vifi].uv_flags & VIFF_POINT_TO_POINT) {
740: if(VIFM_ISSET(vifi, mrtentry_ptr->pruned_oifs)) {
741:
742: IF_DEBUG(DEBUG_PIM_JOIN_PRUNE)
743: log(LOG_DEBUG, 0,
744: "\tPRUNE(P2P) src %s, group %s - pruning vif",
745: inet_fmt(source, s1), inet_fmt(group, s2));
746:
747: IF_DEBUG(DEBUG_MRT)
748: log(LOG_DEBUG, 0, "Deleting pruned vif %d for src %s, grp %s",
749: vifi,
750: inet_fmt(source, s1), inet_fmt(group, s2));
751:
752: VIFM_COPY(mrtentry_ptr->pruned_oifs, new_pruned_oifs);
753: VIFM_SET(vifi, new_pruned_oifs);
754: SET_TIMER(mrtentry_ptr->prune_timers[vifi], holdtime);
755:
756: state_change =
757: change_interfaces(mrtentry_ptr,
758: mrtentry_ptr->incoming,
759: new_pruned_oifs,
760: mrtentry_ptr->leaves);
761:
762: /* Handle transition to negative cache */
763: if(state_change == -1)
764: trigger_prune_alert(mrtentry_ptr);
765: } /* if is pruned */
766: } /* if p2p */
767:
768: /* if LAN link, echo the prune and schedule delayed
769: * oif deletion
770: */
771: else {
772: IF_DEBUG(DEBUG_PIM_JOIN_PRUNE)
773: log(LOG_DEBUG, 0,
774: "\tPRUNE(LAN) src %s, group %s - scheduling delayed prune",
775: inet_fmt(source, s1), inet_fmt(group, s2));
776:
777: send_pim_jp(mrtentry_ptr, PIM_ACTION_PRUNE, vifi,
778: uni_target_addr.unicast_addr, holdtime);
779: schedule_delayed_prune(mrtentry_ptr, vifi, holdtime);
780: }
781: }
782: } /* while groups */
783: } /* else I am unicast target */
784:
785: return(TRUE);
786: }
787:
788:
789: int
790: send_pim_jp(mrtentry_ptr, action, vifi, target_addr, holdtime)
791: mrtentry_t *mrtentry_ptr;
792: int action; /* PIM_ACTION_JOIN or PIM_ACTION_PRUNE */
793: vifi_t vifi; /* vif to send join/prune on */
794: u_int32 target_addr; /* encoded unicast target neighbor */
795: u_int16 holdtime; /* holdtime */
796: {
797: u_int8 *data_ptr, *data_start_ptr;
798:
799: data_ptr = (u_int8 *)(pim_send_buf + sizeof(struct ip)
800: + sizeof(pim_header_t));
801: data_start_ptr = data_ptr;
802:
803: if(mrtentry_ptr->upstream == (pim_nbr_entry_t *)NULL) {
804: /* No upstream neighbor - don't send */
805: return(FALSE);
806: }
807:
808: IF_DEBUG(DEBUG_PIM_JOIN_PRUNE)
809: log(LOG_DEBUG, 0,
810: "Sending %s: vif %s, src %s, group %s, target %s, holdtime %d",
811: action==PIM_ACTION_JOIN ? "JOIN" : "PRUNE",
812: inet_fmt(uvifs[vifi].uv_lcl_addr, s1),
813: inet_fmt(mrtentry_ptr->source->address, s2),
814: inet_fmt(mrtentry_ptr->group->group, s3),
815: inet_fmt(target_addr, s4), holdtime);
816:
817: PUT_EUADDR(target_addr, data_ptr); /* encoded unicast target addr */
818: PUT_BYTE(0, data_ptr); /* Reserved */
819: *data_ptr++ = (u_int8)1; /* number of groups */
820: PUT_HOSTSHORT(holdtime, data_ptr); /* holdtime */
821:
822: /* data_ptr points at the first, and only encoded mcast group */
823: PUT_EGADDR(mrtentry_ptr->group->group, SINGLE_GRP_MSKLEN, 0, data_ptr);
824:
825: /* set the number of join and prune sources */
826: if(action == PIM_ACTION_JOIN) {
827: PUT_HOSTSHORT(1, data_ptr);
828: PUT_HOSTSHORT(0, data_ptr);
829: } else if(action == PIM_ACTION_PRUNE) {
830: PUT_HOSTSHORT(0, data_ptr);
831: PUT_HOSTSHORT(1, data_ptr);
832: }
833:
834: PUT_ESADDR(mrtentry_ptr->source->address, SINGLE_SRC_MSKLEN,
835: 0, data_ptr);
836:
837: /* Cancel active graft */
838: delete_pim_graft_entry(mrtentry_ptr);
839:
840: send_pim(pim_send_buf, uvifs[vifi].uv_lcl_addr, allpimrouters_group,
841: PIM_JOIN_PRUNE, data_ptr - data_start_ptr);
842:
843: return(TRUE);
844: }
845:
846:
847: /************************************************************************
848: * PIM_ASSERT
849: ************************************************************************/
850:
851: /* Notes on assert prefs/metrics
852: * - For downstream routers, compare pref/metric previously received from
853: * winner against those in message.
854: * ==> store assert winner's pref/metric in mrtentry
855: * - For upstream router compare my actualy pref/metric for the source
856: * against those received in message.
857: * ==> store my actual pref/metric in srcentry
858: */
859:
860: int
861: receive_pim_assert(src, dst, pim_message, datalen)
862: u_int32 src, dst;
863: register char *pim_message;
864: int datalen;
865: {
866: vifi_t vifi;
867: pim_encod_uni_addr_t eusaddr;
868: pim_encod_grp_addr_t egaddr;
869: u_int32 source, group;
870: mrtentry_t *mrtentry_ptr;
871: u_int8 *data_ptr;
872: struct uvif *v;
873: u_int32 assert_preference;
874: u_int32 assert_metric;
875: u_int32 local_metric;
876: u_int32 local_preference;
877: u_int8 local_wins;
878: vifbitmap_t new_pruned_oifs;
879: int state_change;
880:
881: if ((vifi = find_vif_direct(src)) == NO_VIF) {
882: /* Either a local vif or somehow received PIM_ASSERT from
883: * non-directly connected router. Ignore it.
884: */
885: if (local_address(src) == NO_VIF)
886: log(LOG_INFO, 0,
887: "Ignoring PIM_ASSERT from non-neighbor router %s",
888: inet_fmt(src, s1));
889: return(FALSE);
890: }
891:
892: /* Checksum */
893: if (inet_cksum((u_int16 *)pim_message, datalen))
894: return(FALSE);
895:
896: v = &uvifs[vifi];
897: if (uvifs[vifi].uv_flags & (VIFF_DOWN | VIFF_DISABLED | VIFF_NONBRS))
898: return(FALSE); /* Shoudn't come on this interface */
899: data_ptr = (u_int8 *)(pim_message + sizeof(pim_header_t));
900:
901: /* Get the group and source addresses */
902: GET_EGADDR(&egaddr, data_ptr);
903: GET_EUADDR(&eusaddr, data_ptr);
904:
905: /* Get the metric related info */
906: GET_HOSTLONG(assert_preference, data_ptr);
907: GET_HOSTLONG(assert_metric, data_ptr);
908:
909: source = eusaddr.unicast_addr;
910: group = egaddr.mcast_addr;
911:
912: IF_DEBUG(DEBUG_PIM_ASSERT)
913: log(LOG_DEBUG, 0,
914: "PIM Assert received from : src %s, grp %s, pref %d, metric %d",
915: inet_fmt(src, s1), inet_fmt(source, s2), inet_fmt(group, s3),
916: assert_preference, assert_metric);
917:
918: mrtentry_ptr = find_route(source, group, MRTF_SG, CREATE);
919: if(mrtentry_ptr->flags & MRTF_NEW) {
920: /* For some reason, it's possible for asserts to be processed
921: * before the data alerts a cache miss. Therefore, when an
922: * assert is received, create (S,G) state and continue, since
923: * we know by the assert that there are upstream forwarders.
924: */
925: IF_DEBUG(DEBUG_PIM_ASSERT)
926: log(LOG_DEBUG, 0, "\tNo MRT entry - creating...");
927:
928: mrtentry_ptr->flags &= ~MRTF_NEW;
929:
930: /* Set oifs */
931: set_leaves(mrtentry_ptr);
932: calc_oifs(mrtentry_ptr, &(mrtentry_ptr->oifs));
933:
934: /* Add it to the kernel */
935: k_chg_mfc(igmp_socket, source, group, mrtentry_ptr->incoming,
936: mrtentry_ptr->oifs);
937:
938: #ifdef RSRR
939: rsrr_cache_send(mrtentry_ptr, RSRR_NOTIFICATION_OK);
940: #endif /* RSRR */
941:
942: /* No need to call change_interfaces, but check for NULL oiflist */
943: if(VIFM_ISEMPTY(mrtentry_ptr->oifs))
944: trigger_prune_alert(mrtentry_ptr);
945: }
946:
947: /* If arrived on iif, I'm downstream of the asserted LAN.
948: * If arrived on oif, I'm upstream of the asserted LAN.
949: */
950: if (vifi == mrtentry_ptr->incoming) {
951: /* assert arrived on iif ==> I'm a downstream router */
952:
953: /* Determine local (really that of upstream nbr!) pref/metric */
954: local_metric = mrtentry_ptr->metric;
955: local_preference = mrtentry_ptr->preference;
956:
957: if(mrtentry_ptr->upstream &&
958: mrtentry_ptr->upstream->address == src &&
959: assert_preference == local_preference &&
960: assert_metric == local_metric)
961:
962: /* if assert from previous winner w/ same pref/metric,
963: * then assert sender wins again */
964: local_wins = FALSE;
965:
966: else
967: /* assert from someone else or something changed */
968: local_wins = compare_metrics(local_preference, local_metric,
969: mrtentry_ptr->upstream->address,
970: assert_preference, assert_metric,
971: src);
972:
973: /* This is between the assert sender and previous winner or rpf
974: * (who is the "local" in this case).
975: */
976: if(local_wins == TRUE) {
977: /* the assert-sender loses, so discard the assert */
978: IF_DEBUG(DEBUG_PIM_ASSERT)
979: log(LOG_DEBUG, 0,
980: "\tAssert sender %s loses", inet_fmt(src, s1));
981: return(TRUE);
982: }
983:
984: /* The assert sender wins: upstream must be changed to the winner */
985: IF_DEBUG(DEBUG_PIM_ASSERT)
986: log(LOG_DEBUG, 0,
987: "\tAssert sender %s wins", inet_fmt(src, s1));
988: if(mrtentry_ptr->upstream->address != src) {
989: IF_DEBUG(DEBUG_PIM_ASSERT)
990: log(LOG_DEBUG, 0,
991: "\tChanging upstream nbr to %s", inet_fmt(src, s1));
992: mrtentry_ptr->preference = assert_preference;
993: mrtentry_ptr->metric = assert_metric;
994: mrtentry_ptr->upstream = find_pim_nbr(src);
995: }
996: SET_TIMER(mrtentry_ptr->assert_timer, PIM_ASSERT_TIMEOUT);
997: mrtentry_ptr->flags |= MRTF_ASSERTED;
998:
999: /* Send a join for the S,G if oiflist is non-empty */
1000: if(!(VIFM_ISEMPTY(mrtentry_ptr->oifs)))
1001: send_pim_jp(mrtentry_ptr, PIM_ACTION_JOIN, mrtentry_ptr->incoming,
1002: src, 0);
1003:
1004: } /* if assert on iif */
1005:
1006: /* If the assert arrived on an oif: */
1007: else {
1008: if(!(VIFM_ISSET(vifi, mrtentry_ptr->oifs)))
1009: return(FALSE);
1010: /* assert arrived on oif ==> I'm a upstream router */
1011:
1012: /* Determine local pref/metric */
1013: local_metric = mrtentry_ptr->source->metric;
1014: local_preference = mrtentry_ptr->source->preference;
1015:
1016: local_wins = compare_metrics(local_preference, local_metric,
1017: v->uv_lcl_addr,
1018: assert_preference, assert_metric, src);
1019:
1020: if(local_wins == FALSE) {
1021:
1022: /* Assert sender wins - prune the interface */
1023:
1024: IF_DEBUG(DEBUG_PIM_ASSERT)
1025: log(LOG_DEBUG, 0,
1026: "\tAssert sender %s wins - pruning...", inet_fmt(src, s1));
1027:
1028: VIFM_COPY(mrtentry_ptr->pruned_oifs, new_pruned_oifs);
1029: VIFM_SET(vifi, new_pruned_oifs);
1030: SET_TIMER(mrtentry_ptr->prune_timers[vifi],
1031: PIM_JOIN_PRUNE_HOLDTIME);
1032:
1033: state_change =
1034: change_interfaces(mrtentry_ptr,
1035: mrtentry_ptr->incoming,
1036: new_pruned_oifs,
1037: mrtentry_ptr->leaves);
1038:
1039: /* Handle transition to negative cache */
1040: if(state_change == -1)
1041: trigger_prune_alert(mrtentry_ptr);
1042:
1043: } /* assert sender wins */
1044:
1045: else {
1046:
1047: /* Local wins (assert sender loses):
1048: * send assert and schedule prune
1049: */
1050:
1051: IF_DEBUG(DEBUG_PIM_ASSERT)
1052: log(LOG_DEBUG, 0,
1053: "\tAssert sender %s loses - sending assert and scheuling prune",
1054: inet_fmt(src, s1));
1055:
1056: if(!(VIFM_ISSET(vifi, mrtentry_ptr->leaves))) {
1057: /* No directly connected receivers - delay prune */
1058: send_pim_jp(mrtentry_ptr, PIM_ACTION_PRUNE, vifi,
1059: v->uv_lcl_addr, PIM_JOIN_PRUNE_HOLDTIME);
1060: schedule_delayed_prune(mrtentry_ptr, vifi,
1061: PIM_JOIN_PRUNE_HOLDTIME);
1062: }
1063: send_pim_assert(source, group, vifi,
1064: mrtentry_ptr->source->preference,
1065: mrtentry_ptr->source->metric);
1066: }
1067:
1068: } /* if assert on oif */
1069:
1070: return(TRUE);
1071: }
1072:
1073:
1074: int
1075: send_pim_assert(source, group, vifi, local_preference, local_metric)
1076: u_int32 source;
1077: u_int32 group;
1078: vifi_t vifi;
1079: u_int32 local_preference;
1080: u_int32 local_metric;
1081: {
1082: u_int8 *data_ptr;
1083: u_int8 *data_start_ptr;
1084:
1085: data_ptr = (u_int8 *)(pim_send_buf + sizeof(struct ip)
1086: + sizeof(pim_header_t));
1087: data_start_ptr = data_ptr;
1088: PUT_EGADDR(group, SINGLE_GRP_MSKLEN, 0, data_ptr);
1089: PUT_EUADDR(source, data_ptr);
1090:
1091: PUT_HOSTLONG(local_preference, data_ptr);
1092: PUT_HOSTLONG(local_metric, data_ptr);
1093: send_pim(pim_send_buf, uvifs[vifi].uv_lcl_addr, allpimrouters_group,
1094: PIM_ASSERT, data_ptr - data_start_ptr);
1095:
1096: return(TRUE);
1097: }
1098:
1099:
1100: /* Return TRUE if the local win, otherwise FALSE */
1101: static int
1102: compare_metrics(local_preference, local_metric, local_address,
1103: remote_preference, remote_metric, remote_address)
1104: u_int32 local_preference;
1105: u_int32 local_metric;
1106: u_int32 local_address;
1107: u_int32 remote_preference;
1108: u_int32 remote_metric;
1109: u_int32 remote_address;
1110: {
1111: /* Now lets see who has a smaller gun (aka "asserts war") */
1112: /* FYI, the smaller gun...err metric wins, but if the same
1113: * caliber, then the bigger network address wins. The order of
1114: * treatment is: preference, metric, address.
1115: */
1116: /* The RPT bits are already included as the most significant bits
1117: * of the preferences.
1118: */
1119: if (remote_preference > local_preference)
1120: return TRUE;
1121: if (remote_preference < local_preference)
1122: return FALSE;
1123: if (remote_metric > local_metric)
1124: return TRUE;
1125: if (remote_metric < local_metric)
1126: return FALSE;
1127: if (ntohl(local_address) > ntohl(remote_address))
1128: return TRUE;
1129: return FALSE;
1130: }
1131:
1132:
1133:
1134:
1135: /************************************************************************
1136: * PIM_GRAFT
1137: ************************************************************************/
1138:
1139:
1140: u_long graft_retrans_timer; /* Graft retransmission timer */
1141: pim_graft_entry_t *graft_list; /* Active grafting entries */
1142:
1143:
1144: void
1145: delete_pim_graft_entry(mrtentry_ptr)
1146: mrtentry_t *mrtentry_ptr;
1147: {
1148: pim_graft_entry_t *graft_entry;
1149:
1150: if(mrtentry_ptr->graft == (pim_graft_entry_t *)NULL)
1151: return;
1152: graft_entry = mrtentry_ptr->graft;
1153:
1154: if(graft_entry->prev)
1155: graft_entry->prev->next = graft_entry->next;
1156: else
1157: graft_list = graft_entry->next;
1158: if(graft_entry->next)
1159: graft_entry->next->prev = graft_entry->prev;
1160: mrtentry_ptr->graft = (pim_graft_entry_t *)NULL;
1161: free(graft_entry);
1162:
1163: /* Stop the timer if there are no more entries */
1164: if(!graft_list) {
1165: timer_clearTimer(graft_retrans_timer);
1166: RESET_TIMER(graft_retrans_timer);
1167: }
1168: }
1169:
1170:
1171: int retransmit_pim_graft(mrtentry_ptr)
1172: mrtentry_t *mrtentry_ptr;
1173: {
1174: u_int8 *data_ptr, *data_start_ptr;
1175:
1176: data_ptr = (u_int8 *)(pim_send_buf + sizeof(struct ip)
1177: + sizeof(pim_header_t));
1178: data_start_ptr = data_ptr;
1179:
1180: if(mrtentry_ptr->upstream == (pim_nbr_entry_t *)NULL) {
1181: /* No upstream neighbor - don't send */
1182: return(FALSE);
1183: }
1184:
1185: IF_DEBUG(DEBUG_PIM_GRAFT)
1186: log(LOG_DEBUG, 0,
1187: "Sending GRAFT: vif %s, src %s, grp %s, dst %s",
1188: inet_fmt(uvifs[mrtentry_ptr->incoming].uv_lcl_addr, s1),
1189: inet_fmt(mrtentry_ptr->source->address, s2),
1190: inet_fmt(mrtentry_ptr->group->group, s3),
1191: inet_fmt(mrtentry_ptr->upstream->address, s4));
1192:
1193:
1194: PUT_EUADDR(mrtentry_ptr->upstream->address, data_ptr); /* unicast target */
1195: PUT_BYTE(0, data_ptr); /* Reserved */
1196: *data_ptr++ = (u_int8)1; /* number of groups */
1197: PUT_HOSTSHORT(0, data_ptr); /* no holdtime */
1198:
1199: /* data_ptr points at the first, and only encoded mcast group */
1200: PUT_EGADDR(mrtentry_ptr->group->group, SINGLE_GRP_MSKLEN, 0, data_ptr);
1201:
1202: /* set the number of join(graft) and prune sources */
1203: PUT_HOSTSHORT(1, data_ptr);
1204: PUT_HOSTSHORT(0, data_ptr);
1205:
1206: PUT_ESADDR(mrtentry_ptr->source->address, SINGLE_SRC_MSKLEN,
1207: 0, data_ptr);
1208:
1209: send_pim(pim_send_buf, uvifs[mrtentry_ptr->incoming].uv_lcl_addr,
1210: mrtentry_ptr->upstream->address,
1211: PIM_GRAFT, data_ptr - data_start_ptr);
1212:
1213: return(TRUE);
1214: }
1215:
1216:
1217: static void
1218: retransmit_all_pim_grafts(arg)
1219: void *arg; /* UNUSED */
1220: {
1221: pim_graft_entry_t *graft_ptr;
1222:
1223: IF_DEBUG(DEBUG_PIM_GRAFT)
1224: log(LOG_DEBUG, 0, "Retransmitting all pending PIM-Grafts");
1225:
1226:
1227: for(graft_ptr = graft_list;
1228: graft_ptr != NULL;
1229: graft_ptr = graft_ptr->next) {
1230:
1231: IF_DEBUG(DEBUG_PIM_GRAFT)
1232: log(LOG_DEBUG, 0, "\tGRAFT src %s, grp %s",
1233: inet_fmt(graft_ptr->mrtlink->source->address, s1),
1234: inet_fmt(graft_ptr->mrtlink->group->group, s2));
1235:
1236: retransmit_pim_graft(graft_ptr->mrtlink);
1237: }
1238:
1239: if(graft_list)
1240: timer_setTimer(PIM_GRAFT_RETRANS_PERIOD, retransmit_all_pim_grafts,
1241: (void *)NULL);
1242: }
1243:
1244:
1245: int
1246: receive_pim_graft(src, dst, pim_message, datalen, pimtype)
1247: u_int32 src, dst;
1248: register char *pim_message;
1249: int datalen;
1250: int pimtype;
1251: {
1252: vifi_t vifi;
1253: struct uvif *v;
1254: pim_encod_uni_addr_t uni_target_addr;
1255: pim_encod_grp_addr_t encod_group;
1256: pim_encod_src_addr_t encod_src;
1257: u_int8 *data_ptr;
1258: u_int8 num_groups;
1259: u_int16 holdtime;
1260: u_int16 num_j_srcs;
1261: u_int16 num_p_srcs;
1262: u_int32 source;
1263: u_int32 group;
1264: u_int32 s_mask;
1265: u_int32 g_mask;
1266: u_int8 s_flags;
1267: u_int8 reserved;
1268: mrtentry_t *mrtentry_ptr;
1269: int state_change;
1270:
1271: if ((vifi = find_vif_direct(src)) == NO_VIF) {
1272: /* Either a local vif or somehow received PIM_GRAFT from
1273: * non-directly connected router. Ignore it.
1274: */
1275: if (local_address(src) == NO_VIF)
1276: log(LOG_INFO, 0,
1277: "Ignoring PIM_GRAFT from non-neighbor router %s",
1278: inet_fmt(src, s1));
1279: return(FALSE);
1280: }
1281:
1282: /* Checksum */
1283: if (inet_cksum((u_int16 *)pim_message, datalen))
1284: return(FALSE);
1285:
1286: v = &uvifs[vifi];
1287: if (uvifs[vifi].uv_flags & (VIFF_DOWN | VIFF_DISABLED | VIFF_NONBRS))
1288: return(FALSE); /* Shoudn't come on this interface */
1289: data_ptr = (u_int8 *)(pim_message + sizeof(pim_header_t));
1290:
1291: /* Get the target address */
1292: GET_EUADDR(&uni_target_addr, data_ptr);
1293: GET_BYTE(reserved, data_ptr);
1294: GET_BYTE(num_groups, data_ptr);
1295: if (num_groups == 0)
1296: return (FALSE); /* No indication for groups in the message */
1297: GET_HOSTSHORT(holdtime, data_ptr);
1298:
1299: IF_DEBUG(DEBUG_PIM_GRAFT)
1300: log(LOG_DEBUG, 0,
1301: "PIM %s received from %s on vif %s",
1302: pimtype == PIM_GRAFT ? "GRAFT" : "GRAFT-ACK",
1303: inet_fmt(src, s1), inet_fmt(uvifs[vifi].uv_lcl_addr, s2));
1304:
1305: while (num_groups--) {
1306: GET_EGADDR(&encod_group, data_ptr);
1307: GET_HOSTSHORT(num_j_srcs, data_ptr);
1308: GET_HOSTSHORT(num_p_srcs, data_ptr);
1309: MASKLEN_TO_MASK(encod_group.masklen, g_mask);
1310: group = encod_group.mcast_addr;
1311: if (!IN_MULTICAST(ntohl(group))) {
1312: data_ptr +=
1313: (num_j_srcs + num_p_srcs) * sizeof(pim_encod_src_addr_t);
1314: continue; /* Ignore this group and jump to the next */
1315: }
1316:
1317: while (num_j_srcs--) {
1318: GET_ESADDR(&encod_src, data_ptr);
1319: source = encod_src.src_addr;
1320: if (!inet_valid_host(source))
1321: continue;
1322: s_flags = encod_src.flags;
1323: MASKLEN_TO_MASK(encod_src.masklen, s_mask);
1324:
1325: mrtentry_ptr = find_route(source, group, MRTF_SG,
1326: DONT_CREATE);
1327: if(mrtentry_ptr == (mrtentry_t *)NULL)
1328: continue;
1329:
1330: if(pimtype == PIM_GRAFT) {
1331: /* Graft */
1332: IF_DEBUG(DEBUG_PIM_GRAFT)
1333: log(LOG_DEBUG, 0,
1334: "\tGRAFT src %s, group %s - forward data on vif %d",
1335: inet_fmt(source, s1), inet_fmt(group, s2), vifi);
1336:
1337: /* Cancel any delayed prune */
1338: if(mrtentry_ptr->prune_delay_timerids[vifi]) {
1339: timer_clearTimer(mrtentry_ptr->prune_delay_timerids[vifi]);
1340: mrtentry_ptr->prune_delay_timerids[vifi] = 0;
1341: }
1342:
1343: /* Add to oiflist (unprune) */
1344: if (VIFM_ISSET(vifi, mrtentry_ptr->pruned_oifs)) {
1345: VIFM_CLR(vifi, mrtentry_ptr->pruned_oifs);
1346: SET_TIMER(mrtentry_ptr->prune_timers[vifi], 0);
1347: state_change =
1348: change_interfaces(mrtentry_ptr,
1349: mrtentry_ptr->incoming,
1350: mrtentry_ptr->pruned_oifs,
1351: mrtentry_ptr->leaves);
1352: if(state_change == 1)
1353: trigger_join_alert(mrtentry_ptr);
1354: }
1355: } /* Graft */
1356: else {
1357: /* Graft-Ack */
1358: if(mrtentry_ptr->graft)
1359: delete_pim_graft_entry(mrtentry_ptr);
1360: }
1361: }
1362: /* Ignore anything in the prune portion of the message! */
1363: }
1364:
1365: /* Respond to graft with a graft-ack */
1366: if(pimtype == PIM_GRAFT) {
1367: IF_DEBUG(DEBUG_PIM_GRAFT)
1368: log(LOG_DEBUG, 0, "Sending GRAFT-ACK: vif %s, dst %s",
1369: inet_fmt(uvifs[vifi].uv_lcl_addr, s1), inet_fmt(src, s2));
1370: bcopy(pim_message, pim_send_buf + sizeof(struct ip), datalen);
1371: send_pim(pim_send_buf, uvifs[vifi].uv_lcl_addr,
1372: src, PIM_GRAFT_ACK, datalen - sizeof(pim_header_t));
1373: }
1374:
1375: return(TRUE);
1376: }
1377:
1378: int
1379: send_pim_graft(mrtentry_ptr)
1380: mrtentry_t *mrtentry_ptr;
1381: {
1382: pim_graft_entry_t *new_graft;
1383: int was_sent = 0;
1384:
1385: if(mrtentry_ptr->graft != (pim_graft_entry_t *)NULL)
1386: /* Already sending grafts */
1387: return(FALSE);
1388:
1389: /* Send the first graft */
1390: was_sent = retransmit_pim_graft(mrtentry_ptr);
1391: if(!was_sent)
1392: return(FALSE);
1393:
1394: /* Set up retransmission */
1395: new_graft = (pim_graft_entry_t *)malloc(sizeof(pim_graft_entry_t));
1396: if (new_graft == (pim_graft_entry_t *)NULL) {
1397: log(LOG_WARNING, 0,
1398: "Memory allocation error for graft entry src %s, grp %s",
1399: inet_fmt(mrtentry_ptr->source->address, s1),
1400: inet_fmt(mrtentry_ptr->group->group, s2));
1401: return(FALSE);
1402: }
1403: new_graft->next = graft_list;
1404: new_graft->prev = (pim_graft_entry_t *)NULL;
1405: new_graft->mrtlink = mrtentry_ptr;
1406: if(graft_list == (pim_graft_entry_t *)NULL)
1407: graft_list = new_graft;
1408: mrtentry_ptr->graft = new_graft;
1409:
1410: /* Set up timer if not running */
1411: if(!graft_retrans_timer)
1412: SET_TIMER(graft_retrans_timer,
1413: timer_setTimer(PIM_GRAFT_RETRANS_PERIOD,
1414: retransmit_all_pim_grafts,
1415: (void *)NULL));
1416:
1417: return(TRUE);
1418: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pim_proto.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pimdd