Annotation of embedaddon/pimd/pim_proto.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: pim_proto.c,v 1.47 2003/05/28 22:57:16 pavlin Exp $
32: */
33:
34: #include <arpa/inet.h>
35: #include "defs.h"
36:
37: typedef struct {
38: uint16_t holdtime;
39: uint32_t dr_prio;
40: int8_t dr_prio_present;
41: uint32_t genid;
42: } pim_hello_opts_t;
43:
44: /*
45: * Local functions definitions.
46: */
47: static int restart_dr_election (struct uvif *v);
48: static int parse_pim_hello (char *msg, size_t len, uint32_t src, pim_hello_opts_t *opts);
49: static void cache_nbr_settings (pim_nbr_entry_t *nbr, pim_hello_opts_t *opts);
50: static int send_pim_register_stop (uint32_t reg_src, uint32_t reg_dst, uint32_t inner_grp, uint32_t inner_source);
51: static build_jp_message_t *get_jp_working_buff (void);
52: static void return_jp_working_buff (pim_nbr_entry_t *pim_nbr);
53: static void pack_jp_message (pim_nbr_entry_t *pim_nbr);
54: static void send_jp_message (pim_nbr_entry_t *pim_nbr);
55: static int compare_metrics (uint32_t local_preference,
56: uint32_t local_metric,
57: uint32_t local_address,
58: uint32_t remote_preference,
59: uint32_t remote_metric,
60: uint32_t remote_address);
61:
62: build_jp_message_t *build_jp_message_pool;
63: int build_jp_message_pool_counter;
64:
65: /************************************************************************
66: * PIM_HELLO
67: ************************************************************************/
68: int receive_pim_hello(uint32_t src, uint32_t dst __attribute__((unused)), char *msg, size_t len)
69: {
70: vifi_t vifi;
71: struct uvif *v;
72: size_t bsr_length;
73: pim_nbr_entry_t *nbr, *prev_nbr, *new_nbr;
74: pim_hello_opts_t opts;
75: srcentry_t *srcentry;
76: mrtentry_t *mrtentry;
77:
78: if (inet_cksum((uint16_t *)msg, len))
79: return FALSE;
80:
81: vifi = find_vif_direct(src);
82: if (vifi == NO_VIF) {
83: /* Either a local vif or somehow received PIM_HELLO from
84: * non-directly connected router. Ignore it. */
85: if (local_address(src) == NO_VIF)
86: logit(LOG_DEBUG, 0, "Ignoring PIM_HELLO from non-neighbor router %s",
87: inet_fmt(src, s1, sizeof(s1)));
88:
89: return FALSE;
90: }
91:
92: v = &uvifs[vifi];
93: if (v->uv_flags & (VIFF_DOWN | VIFF_DISABLED | VIFF_REGISTER))
94: return FALSE; /* Shoudn't come on this interface */
95:
96: /* Get the Holdtime (in seconds) and any DR priority from the message. Return if error. */
97: if (parse_pim_hello(msg, len, src, &opts) == FALSE)
98: return FALSE;
99:
100: IF_DEBUG(DEBUG_PIM_HELLO | DEBUG_PIM_TIMER)
101: logit(LOG_DEBUG, 0, "PIM HELLO holdtime from %s is %u",
102: inet_fmt(src, s1, sizeof(s1)), opts.holdtime);
103:
104: IF_DEBUG(DEBUG_PIM_HELLO | DEBUG_PIM_TIMER)
105: logit(LOG_DEBUG, 0, "PIM DR PRIORITY from %s is %u",
106: inet_fmt(src, s1, sizeof(s1)), opts.dr_prio);
107:
108: IF_DEBUG(DEBUG_PIM_HELLO | DEBUG_PIM_TIMER)
109: logit(LOG_DEBUG, 0, "PIM GenID from %s is %u",
110: inet_fmt(src, s1, sizeof(s1)), opts.genid);
111:
112: for (prev_nbr = NULL, nbr = v->uv_pim_neighbors; nbr; prev_nbr = nbr, nbr = nbr->next) {
113: /* The PIM neighbors are sorted in decreasing order of the
114: * network addresses (note that to be able to compare them
115: * correctly we must translate the addresses in host order.
116: */
117: if (ntohl(src) < ntohl(nbr->address))
118: continue;
119:
120: if (src == nbr->address) {
121: /* We already have an entry for this host */
122: if (0 == opts.holdtime) {
123: /* Looks like we have a nice neighbor who is going down
124: * and wants to inform us by sending "holdtime=0". Thanks
125: * buddy and see you again!
126: */
127: logit(LOG_INFO, 0, "PIM HELLO received: neighbor %s going down",
128: inet_fmt(src, s1, sizeof(s1)));
129: delete_pim_nbr(nbr);
130:
131: return TRUE;
132: }
133:
134: /* https://tools.ietf.org/html/draft-ietf-pim-hello-genid-01 */
135: if (nbr->genid != opts.genid) {
136: /* Known neighbor rebooted, update info and resend RP-Set */
137: cache_nbr_settings(nbr, &opts);
138: goto rebooted;
139: }
140:
141: if (nbr->dr_prio != opts.dr_prio) {
142: /* New DR priority for neighbor, restart DR election */
143: cache_nbr_settings(nbr, &opts);
144: goto election;
145: }
146:
147: cache_nbr_settings(nbr, &opts);
148: return TRUE;
149: }
150:
151: /* No entry for this neighbor. Exit loop to create an entry for it. */
152: break;
153: }
154:
155: /*
156: * This is a new neighbor. Create a new entry for it.
157: * It must be added right after `prev_nbr`
158: */
159: IF_DEBUG(DEBUG_PIM_HELLO | DEBUG_PIM_TIMER)
160: logit(LOG_INFO, 0, "Received PIM HELLO from new neighbor %s", inet_fmt(src, s1, sizeof(s1)));
161:
162: new_nbr = calloc(1, sizeof(pim_nbr_entry_t));
163: if (!new_nbr)
164: logit(LOG_ERR, 0, "Ran out of memory in receive_pim_hello()");
165:
166: new_nbr->address = src;
167: new_nbr->vifi = vifi;
168: new_nbr->build_jp_message = NULL;
169: new_nbr->next = nbr;
170: new_nbr->prev = prev_nbr;
171:
172: /* Add PIM Hello options */
173: cache_nbr_settings(new_nbr, &opts);
174:
175: /* Add to linked list of neighbors */
176: if (prev_nbr)
177: prev_nbr->next = new_nbr;
178: else
179: v->uv_pim_neighbors = new_nbr;
180:
181: if (new_nbr->next)
182: new_nbr->next->prev = new_nbr;
183:
184: v->uv_flags &= ~VIFF_NONBRS;
185: v->uv_flags |= VIFF_PIM_NBR;
186:
187: /* Since a new neighbour has come up, let it know your existence */
188: /* XXX: TODO: not in the spec,
189: * but probably should send the message after a short random period?
190: */
191: send_pim_hello(v, pim_timer_hello_holdtime);
192:
193: rebooted:
194: if (v->uv_flags & VIFF_DR) {
195: /*
196: * If I am the current DR on that interface, so
197: * send an RP-Set message to the new neighbor.
198: */
199: if ((bsr_length = create_pim_bootstrap_message(pim_send_buf)))
200: send_pim_unicast(pim_send_buf, v->uv_mtu, v->uv_lcl_addr, src, PIM_BOOTSTRAP, bsr_length);
201: }
202:
203: election:
204: if (restart_dr_election(v)) {
205: /* I was the DR, but not anymore. Remove all register_vif from
206: * oif list for all directly connected sources (for vifi). */
207:
208: /* TODO: XXX: first entry is not used! */
209: for (srcentry = srclist->next; srcentry; srcentry = srcentry->next) {
210: /* If not directly connected source for vifi */
211: if ((srcentry->incoming != vifi) || srcentry->upstream)
212: continue;
213:
214: for (mrtentry = srcentry->mrtlink; mrtentry; mrtentry = mrtentry->srcnext) {
215:
216: if (!(mrtentry->flags & MRTF_SG))
217: continue; /* This is not (S,G) entry */
218:
219: /* Remove the register oif */
220: VIFM_CLR(reg_vif_num, mrtentry->joined_oifs);
221: change_interfaces(mrtentry,
222: mrtentry->incoming,
223: mrtentry->joined_oifs,
224: mrtentry->pruned_oifs,
225: mrtentry->leaves,
226: mrtentry->asserted_oifs, 0);
227: }
228: }
229: }
230:
231: /*
232: * TODO: XXX: does a new neighbor change any routing entries info?
233: * Need to trigger joins?
234: */
235:
236: IF_DEBUG(DEBUG_PIM_HELLO)
237: dump_vifs(stderr); /* Show we got a new neighbor */
238:
239: return TRUE;
240: }
241:
242:
243: void delete_pim_nbr(pim_nbr_entry_t *nbr_delete)
244: {
245: srcentry_t *src;
246: srcentry_t *src_next;
247: mrtentry_t *mrt;
248: mrtentry_t *mrt_srcs;
249: grpentry_t *grp;
250: cand_rp_t *cand_rp;
251: rp_grp_entry_t *rp_grp;
252: rpentry_t *rp;
253: struct uvif *v;
254:
255: IF_DEBUG(DEBUG_PIM_HELLO | DEBUG_PIM_TIMER)
256: logit(LOG_INFO, 0, "Deleting PIM neighbor %s", inet_fmt(nbr_delete->address, s1, sizeof(s1)));
257:
258: v = &uvifs[nbr_delete->vifi];
259:
260: /* Delete the entry from the pim_nbrs chain */
261: if (nbr_delete->prev)
262: nbr_delete->prev->next = nbr_delete->next;
263: else
264: v->uv_pim_neighbors = nbr_delete->next;
265:
266: if (nbr_delete->next)
267: nbr_delete->next->prev = nbr_delete->prev;
268:
269: return_jp_working_buff(nbr_delete);
270:
271: /* That neighbor could've been the DR */
272: restart_dr_election(v);
273:
274: /* Update the source entries */
275: for (src = srclist; src; src = src_next) {
276: src_next = src->next;
277:
278: if (src->upstream != nbr_delete)
279: continue;
280:
281: /* Reset the next hop (PIM) router */
282: if (set_incoming(src, PIM_IIF_SOURCE) == FALSE) {
283: /* Coudn't reset it. Sorry, the hext hop router toward that
284: * source is probably not a PIM router, or cannot find route
285: * at all, hence I cannot handle this source and have to
286: * delete it.
287: */
288: logit(LOG_WARNING, 0, "Delete source entry for source %s", inet_fmt(src->address, s1, sizeof(s1)));
289: delete_srcentry(src);
290: } else if (src->upstream) {
291: /* Ignore the local or directly connected sources */
292: /* Browse all MRT entries for this source and reset the
293: * upstream router. Note that the upstream router is not always
294: * toward the source: it could be toward the RP for example.
295: */
296: for (mrt = src->mrtlink; mrt; mrt = mrt->srcnext) {
297: if (!(mrt->flags & MRTF_RP)) {
298: mrt->upstream = src->upstream;
299: mrt->metric = src->metric;
300: mrt->preference = src->preference;
301: change_interfaces(mrt, src->incoming,
302: mrt->joined_oifs,
303: mrt->pruned_oifs,
304: mrt->leaves,
305: mrt->asserted_oifs, 0);
306: }
307: }
308: }
309: }
310:
311: /* Update the RP entries */
312: for (cand_rp = cand_rp_list; cand_rp; cand_rp = cand_rp->next) {
313: if (cand_rp->rpentry->upstream != nbr_delete)
314: continue;
315:
316: rp = cand_rp->rpentry;
317:
318: /* Reset the RP entry iif
319: * TODO: check if error setting the iif! */
320: if (local_address(rp->address) == NO_VIF) {
321: set_incoming(rp, PIM_IIF_RP);
322: } else {
323: rp->incoming = reg_vif_num;
324: rp->upstream = NULL;
325: }
326:
327: mrt = rp->mrtlink;
328: if (mrt) {
329: mrt->upstream = rp->upstream;
330: mrt->metric = rp->metric;
331: mrt->preference = rp->preference;
332: change_interfaces(mrt,
333: rp->incoming,
334: mrt->joined_oifs,
335: mrt->pruned_oifs,
336: mrt->leaves,
337: mrt->asserted_oifs, 0);
338: }
339:
340: /* Update the group entries for this RP */
341: for (rp_grp = cand_rp->rp_grp_next; rp_grp; rp_grp = rp_grp->rp_grp_next) {
342: for (grp = rp_grp->grplink; grp; grp = grp->rpnext) {
343:
344: mrt = grp->grp_route;
345: if (mrt) {
346: mrt->upstream = rp->upstream;
347: mrt->metric = rp->metric;
348: mrt->preference = rp->preference;
349: change_interfaces(mrt,
350: rp->incoming,
351: mrt->joined_oifs,
352: mrt->pruned_oifs,
353: mrt->leaves,
354: mrt->asserted_oifs, 0);
355: }
356:
357: /* Update only the (S,G)RPbit entries for this group */
358: for (mrt_srcs = grp->mrtlink; mrt_srcs; mrt_srcs = mrt_srcs->grpnext) {
359: if (mrt_srcs->flags & MRTF_RP) {
360: mrt_srcs->upstream = rp->upstream;
361: mrt_srcs->metric = rp->metric;
362: mrt_srcs->preference = rp->preference;
363: change_interfaces(mrt_srcs,
364: rp->incoming,
365: mrt_srcs->joined_oifs,
366: mrt_srcs->pruned_oifs,
367: mrt_srcs->leaves,
368: mrt_srcs->asserted_oifs, 0);
369: }
370: }
371: }
372: }
373: }
374:
375: /* Fix GitHub issue #22: Crash in (S,G) state when neighbor is lost */
376: for (cand_rp = cand_rp_list; cand_rp; cand_rp = cand_rp->next) {
377: for (rp_grp = cand_rp->rp_grp_next; rp_grp; rp_grp = rp_grp->rp_grp_next) {
378: for (grp = rp_grp->grplink; grp; grp = grp->next) {
379: mrt = grp->grp_route;
380: if (mrt && mrt->upstream) {
381: if (mrt->upstream == nbr_delete)
382: mrt->upstream = NULL;
383: }
384: }
385: }
386: }
387:
388: free(nbr_delete);
389: }
390:
391: /*
392: * If all PIM routers on a network segment support DR-Priority we use
393: * that to elect the DR, and use the highest IP address as the tie
394: * breaker. If any routers does *not* support DR-Priority all routers
395: * must use the IP address to elect the DR, this for backwards compat.
396: *
397: * Returns TRUE if we lost the DR role, elected another router.
398: */
399: static int restart_dr_election(struct uvif *v)
400: {
401: int was_dr = 0, use_dr_prio = 1;
402: uint32_t best_dr_prio = 0;
403: pim_nbr_entry_t *nbr;
404:
405: if (v->uv_flags & VIFF_DR)
406: was_dr = 1;
407:
408: if (!v->uv_pim_neighbors) {
409: /* This was our last neighbor, now we're it. */
410: IF_DEBUG(DEBUG_PIM_HELLO | DEBUG_PIM_TIMER)
411: logit(LOG_DEBUG, 0, "All neighbor PIM routers on %s lost, we are the DR now.",
412: inet_fmt(v->uv_lcl_addr, s1, sizeof(s1)));
413:
414: v->uv_flags &= ~VIFF_PIM_NBR;
415: v->uv_flags |= (VIFF_NONBRS | VIFF_DR);
416:
417: return FALSE;
418: }
419:
420: /* Check if all routers on segment advertise DR Priority option
421: * in their PIM Hello messages. Figure out highest prio. */
422: for (nbr = v->uv_pim_neighbors; nbr; nbr = nbr->next) {
423: if (!nbr->dr_prio_present) {
424: use_dr_prio = 0;
425: break;
426: }
427:
428: if (nbr->dr_prio > best_dr_prio)
429: best_dr_prio = nbr->dr_prio;
430: }
431:
432: /*
433: * RFC4601 sec. 4.3.2
434: */
435: if (use_dr_prio) {
436: IF_DEBUG(DEBUG_PIM_HELLO | DEBUG_PIM_TIMER)
437: logit(LOG_DEBUG, 0, "All routers in %s segment support DR Priority based DR election.",
438: inet_fmt(v->uv_lcl_addr, s1, sizeof(s1)));
439:
440: if (best_dr_prio < v->uv_dr_prio) {
441: v->uv_flags |= VIFF_DR;
442: return FALSE;
443: }
444:
445: if (best_dr_prio == v->uv_dr_prio)
446: goto tiebreak;
447: } else {
448: tiebreak:
449: IF_DEBUG(DEBUG_PIM_HELLO | DEBUG_PIM_TIMER)
450: logit(LOG_DEBUG, 0, "Using fallback DR election on %s.",
451: inet_fmt(v->uv_lcl_addr, s1, sizeof(s1)));
452:
453: if (ntohl(v->uv_lcl_addr) > ntohl(v->uv_pim_neighbors->address)) {
454: /* The first address is the new potential remote
455: * DR address, but the local address is the winner. */
456: v->uv_flags |= VIFF_DR;
457: return FALSE;
458: }
459: }
460:
461: if (was_dr) {
462: IF_DEBUG(DEBUG_PIM_HELLO | DEBUG_PIM_TIMER)
463: logit(LOG_INFO, 0, "We lost DR role on %s in election.",
464: inet_fmt(v->uv_lcl_addr, s1, sizeof(s1)));
465:
466: v->uv_flags &= ~VIFF_DR;
467: return TRUE; /* Lost election, clean up. */
468: }
469:
470: return FALSE;
471: }
472:
473: static int validate_pim_opt(uint32_t src, char *str, uint16_t len, uint16_t opt_len)
474: {
475: if (len != opt_len) {
476: IF_DEBUG(DEBUG_PIM_HELLO | DEBUG_PIM_TIMER)
477: logit(LOG_DEBUG, 0, "PIM HELLO %s from %s: invalid OptionLength = %u",
478: str, inet_fmt(src, s1, sizeof(s1)), opt_len);
479:
480: return FALSE;
481: }
482:
483: return TRUE;
484: }
485:
486: static int parse_pim_hello(char *msg, size_t len, uint32_t src, pim_hello_opts_t *opts)
487: {
488: int result = FALSE;
489: size_t rec_len;
490: uint8_t *data;
491: uint16_t opt_type;
492: uint16_t opt_len;
493:
494: /* Assume no opts. */
495: memset(opts, 0, sizeof(*opts));
496:
497: /* Body of PIM message */
498: msg += sizeof(pim_header_t);
499:
500: /* Ignore any data if shorter than (pim_hello header) */
501: for (len -= sizeof(pim_header_t); len >= sizeof(pim_hello_t); len -= rec_len) {
502: data = (uint8_t *)msg;
503: GET_HOSTSHORT(opt_type, data);
504: GET_HOSTSHORT(opt_len, data);
505:
506: switch (opt_type) {
507: case PIM_HELLO_HOLDTIME:
508: result = validate_pim_opt(src, "Holdtime", PIM_HELLO_HOLDTIME_LEN, opt_len);
509: if (TRUE == result)
510: GET_HOSTSHORT(opts->holdtime, data);
511: break;
512:
513: case PIM_HELLO_DR_PRIO:
514: result = validate_pim_opt(src, "DR Priority", PIM_HELLO_DR_PRIO_LEN, opt_len);
515: if (TRUE == result) {
516: opts->dr_prio_present = 1;
517: GET_HOSTLONG(opts->dr_prio, data);
518: }
519: break;
520:
521: case PIM_HELLO_GENID:
522: result = validate_pim_opt(src, "GenID", PIM_HELLO_GENID_LEN, opt_len);
523: if (TRUE == result)
524: GET_HOSTLONG(opts->genid, data);
525: break;
526:
527: default:
528: break; /* Ignore any unknown options */
529: }
530:
531: /* Move to the next option */
532: rec_len = (sizeof(pim_hello_t) + opt_len);
533: if (len < rec_len || result == FALSE)
534: return FALSE;
535:
536: msg += rec_len;
537: }
538:
539: return result;
540: }
541:
542: static void cache_nbr_settings(pim_nbr_entry_t *nbr, pim_hello_opts_t *opts)
543: {
544: SET_TIMER(nbr->timer, opts->holdtime);
545: nbr->genid = opts->genid;
546: nbr->dr_prio = opts->dr_prio;
547: nbr->dr_prio_present = opts->dr_prio_present;
548: }
549:
550: int send_pim_hello(struct uvif *v, uint16_t holdtime)
551: {
552: char *buf;
553: uint8_t *data;
554: size_t len;
555:
556: buf = pim_send_buf + sizeof(struct ip) + sizeof(pim_header_t);
557: data = (uint8_t *)buf;
558: PUT_HOSTSHORT(PIM_HELLO_HOLDTIME, data);
559: PUT_HOSTSHORT(PIM_HELLO_HOLDTIME_LEN, data);
560: PUT_HOSTSHORT(holdtime, data);
561:
562: PUT_HOSTSHORT(PIM_HELLO_DR_PRIO, data);
563: PUT_HOSTSHORT(PIM_HELLO_DR_PRIO_LEN, data);
564: PUT_HOSTLONG(v->uv_dr_prio, data);
565:
566: #ifdef ENABLE_PIM_HELLO_GENID
567: PUT_HOSTSHORT(PIM_HELLO_GENID, data);
568: PUT_HOSTSHORT(PIM_HELLO_GENID_LEN, data);
569: PUT_HOSTLONG(v->uv_genid, data);
570: #endif
571:
572: len = data - (uint8_t *)buf;
573: send_pim(pim_send_buf, v->uv_lcl_addr, allpimrouters_group, PIM_HELLO, len);
574: SET_TIMER(v->uv_hello_timer, pim_timer_hello_interval);
575:
576: return TRUE;
577: }
578:
579:
580: /************************************************************************
581: * PIM_REGISTER
582: ************************************************************************/
583: /* TODO: XXX: IF THE BORDER BIT IS SET, THEN
584: * FORWARD THE WHOLE PACKET FROM USER SPACE
585: * AND AT THE SAME TIME IGNORE ANY CACHE_MISS
586: * SIGNALS FROM THE KERNEL.
587: */
588: int receive_pim_register(uint32_t reg_src, uint32_t reg_dst, char *msg, size_t len)
589: {
590: uint32_t inner_src, inner_grp;
591: pim_register_t *reg;
592: struct ip *ip;
593: uint32_t is_border, is_null;
594: mrtentry_t *mrtentry;
595: mrtentry_t *mrtentry2;
596: vifbitmap_t oifs;
597:
598: /*
599: * If instance specific multicast routing table is in use, check
600: * that we are the target of the register packet. Otherwise we
601: * might end up responding to register packet belonging to another
602: * pimd instance. If we are not an RP candidate, we shouldn't have
603: * pimreg interface and shouldn't receive register packets, but we'll
604: * check the cand_rp flag anyway, just to be on the safe side.
605: */
606: if (mrt_table_id != 0) {
607: if (!cand_rp_flag || my_cand_rp_address != reg_dst) {
608: IF_DEBUG(DEBUG_PIM_REGISTER)
609: logit(LOG_DEBUG, 0, "PIM register: packet from %s to %s is not destined for us",
610: inet_fmt(reg_src, s1, sizeof(s1)), inet_fmt(reg_dst, s2, sizeof(s2)));
611:
612: return FALSE;
613: }
614: }
615:
616: IF_DEBUG(DEBUG_PIM_REGISTER)
617: logit(LOG_INFO, 0, "Received PIM register: len = %d from %s",
618: len, inet_fmt(reg_src, s1, sizeof(s1)));
619:
620: /*
621: * Message length validation.
622: * This is suppose to be done in the kernel, but some older kernel
623: * versions do not pefrorm the check for the NULL register messages.
624: */
625: if (len < sizeof(pim_header_t) + sizeof(pim_register_t) + sizeof(struct ip)) {
626: IF_DEBUG(DEBUG_PIM_REGISTER)
627: logit(LOG_INFO, 0, "PIM register: short packet (len = %d) from %s",
628: len, inet_fmt(reg_src, s1, sizeof(s1)));
629:
630: return FALSE;
631: }
632:
633: /*
634: * XXX: For PIM_REGISTER the checksum does not include
635: * the inner IP packet. However, some older routers might
636: * create the checksum over the whole packet. Hence,
637: * verify the checksum over the first 8 bytes, and if fails,
638: * then over the whole Register
639: */
640: if ((inet_cksum((uint16_t *)msg, sizeof(pim_header_t) + sizeof(pim_register_t)))
641: && (inet_cksum((uint16_t *)msg, len))) {
642: IF_DEBUG(DEBUG_PIM_REGISTER)
643: logit(LOG_DEBUG, 0, "PIM REGISTER from DR %s: invalid PIM header checksum",
644: inet_fmt(reg_src, s1, sizeof(s1)));
645:
646: return FALSE;
647: }
648:
649: /* Lookup register message flags */
650: reg = (pim_register_t *)(msg + sizeof(pim_header_t));
651: is_border = ntohl(reg->reg_flags) & PIM_REGISTER_BORDER_BIT;
652: is_null = ntohl(reg->reg_flags) & PIM_REGISTER_NULL_REGISTER_BIT;
653:
654: /* initialize the pointer to the encapsulated packet */
655: ip = (struct ip *)(msg + sizeof(pim_header_t) + sizeof(pim_register_t));
656:
657: /* check the IP version (especially for the NULL register...see above) */
658: if (ip->ip_v != IPVERSION && (! is_null)) {
659: IF_DEBUG(DEBUG_PIM_REGISTER)
660: logit(LOG_INFO, 0, "PIM register: incorrect IP version (%d) of the inner packet from %s",
661: ip->ip_v, inet_fmt(reg_src, s1, sizeof(s1)));
662:
663: return FALSE;
664: }
665:
666: /* We are keeping all addresses in network order, so no need for ntohl()*/
667: inner_src = ip->ip_src.s_addr;
668: inner_grp = ip->ip_dst.s_addr;
669:
670: /*
671: * inner_src and inner_grp must be valid IP unicast and multicast address
672: * respectively. XXX: not in the spec.
673: * PIM-SSM support: inner_grp must not be in PIM-SSM range
674: */
675: if ((!inet_valid_host(inner_src)) || (!IN_MULTICAST(ntohl(inner_grp))) || IN_PIM_SSM_RANGE(inner_grp)) {
676: if (!inet_valid_host(inner_src)) {
677: logit(LOG_WARNING, 0, "Inner source address of register message by %s is invalid: %s",
678: inet_fmt(reg_src, s1, sizeof(s1)), inet_fmt(inner_src, s2, sizeof(s2)));
679: }
680: if (!IN_MULTICAST(ntohl(inner_grp))) {
681: logit(LOG_WARNING, 0, "Inner group address of register message by %s is invalid: %s",
682: inet_fmt(reg_src, s1, sizeof(s1)), inet_fmt(inner_grp, s2, sizeof(s2)));
683: }
684: send_pim_register_stop(reg_dst, reg_src, inner_grp, inner_src);
685:
686: return FALSE;
687: }
688:
689: mrtentry = find_route(inner_src, inner_grp, MRTF_SG | MRTF_WC | MRTF_PMBR, DONT_CREATE);
690: if (!mrtentry) {
691: /* No routing entry. Send REGISTER_STOP and return. */
692: IF_DEBUG(DEBUG_PIM_REGISTER)
693: logit(LOG_DEBUG, 0, "No routing entry for source %s and/or group %s" ,
694: inet_fmt(inner_src, s1, sizeof(s1)), inet_fmt(inner_grp, s2, sizeof(s2)));
695:
696: /* TODO: XXX: shouldn't it be inner_src=INADDR_ANY? Not in the spec. */
697: send_pim_register_stop(reg_dst, reg_src, inner_grp, inner_src);
698:
699: return TRUE;
700: }
701:
702: /* Check if I am the RP for that group */
703: if ((local_address(reg_dst) == NO_VIF) || !check_mrtentry_rp(mrtentry, reg_dst)) {
704: IF_DEBUG(DEBUG_PIM_REGISTER)
705: logit(LOG_DEBUG, 0, "Not RP in address %s", inet_fmt(reg_dst, s1, sizeof(s1)));
706:
707: send_pim_register_stop(reg_dst, reg_src, inner_grp, inner_src);
708:
709: return TRUE;
710: }
711:
712: /* I am the RP */
713:
714: if (mrtentry->flags & MRTF_SG) {
715: /* (S,G) found */
716: /* TODO: check the timer again */
717: SET_TIMER(mrtentry->timer, PIM_DATA_TIMEOUT); /* restart timer */
718: if (!(mrtentry->flags & MRTF_SPT)) { /* The SPT bit is not set */
719: if (!is_null) {
720: calc_oifs(mrtentry, &oifs);
721: if (VIFM_ISEMPTY(oifs) && (mrtentry->incoming == reg_vif_num)) {
722: IF_DEBUG(DEBUG_PIM_REGISTER)
723: logit(LOG_DEBUG, 0, "No output intefaces found for group %s source %s",
724: inet_fmt(inner_grp, s1, sizeof(s1)), inet_fmt(inner_src, s2, sizeof(s2)));
725:
726: send_pim_register_stop(reg_dst, reg_src, inner_grp, inner_src);
727:
728: return TRUE;
729: }
730:
731: /*
732: * TODO: XXX: BUG!!!
733: * The data will be forwarded by the kernel MFC!!!
734: * Need to set a special flag for this routing entry so after
735: * a cache miss occur, the multicast packet will be forwarded
736: * from user space and won't install entry in the kernel MFC.
737: * The problem is that the kernel MFC doesn't know the
738: * PMBR address and simply sets the multicast forwarding
739: * cache to accept/forward all data coming from the
740: * register_vif.
741: */
742: if (is_border) {
743: if (mrtentry->pmbr_addr != reg_src) {
744: IF_DEBUG(DEBUG_PIM_REGISTER)
745: logit(LOG_DEBUG, 0, "pmbr_addr (%s) != reg_src (%s)",
746: inet_fmt(mrtentry->pmbr_addr, s1, sizeof(s1)), inet_fmt(reg_src, s2, sizeof(s2)));
747:
748: send_pim_register_stop(reg_dst, reg_src, inner_grp, inner_src);
749:
750: return TRUE;
751: }
752: }
753:
754: return TRUE;
755: }
756:
757: /* TODO: XXX: if NULL_REGISTER and has (S,G) with SPT=0, then..?*/
758: return TRUE;
759: }
760: else {
761: /* The SPT bit is set */
762: IF_DEBUG(DEBUG_PIM_REGISTER)
763: logit(LOG_DEBUG, 0, "SPT bit is set for group %s source %s",
764: inet_fmt(inner_grp, s1, sizeof(s1)), inet_fmt(inner_src, s2, sizeof(s2)));
765:
766: send_pim_register_stop(reg_dst, reg_src, inner_grp, inner_src);
767:
768: return TRUE;
769: }
770: }
771: if (mrtentry->flags & (MRTF_WC | MRTF_PMBR)) {
772: if (is_border) {
773: /* Create (S,G) state. The oifs will be the copied from the
774: * existing (*,G) or (*,*,RP) entry. */
775: mrtentry2 = find_route(inner_src, inner_grp, MRTF_SG, CREATE);
776: if (mrtentry2) {
777: mrtentry2->pmbr_addr = reg_src;
778: /* Clear the SPT flag */
779: mrtentry2->flags &= ~(MRTF_SPT | MRTF_NEW);
780: SET_TIMER(mrtentry2->timer, PIM_DATA_TIMEOUT);
781: /* TODO: explicitly call the Join/Prune send function? */
782: FIRE_TIMER(mrtentry2->jp_timer); /* Send the Join immediately */
783: /* TODO: explicitly call this function?
784: send_pim_join_prune(mrtentry2->upstream->vifi,
785: mrtentry2->upstream,
786: PIM_JOIN_PRUNE_HOLDTIME);
787: */
788: }
789: }
790: }
791:
792: if (mrtentry->flags & MRTF_WC) {
793:
794: /* First PIM Register for this routing entry, log it */
795: logit(LOG_INFO, 0, "Received PIM REGISTER: src %s, group %s",
796: inet_fmt(reg_src, s1, sizeof(s1)), inet_fmt(inner_grp, s2, sizeof(s2)));
797:
798: /* (*,G) entry */
799: calc_oifs(mrtentry, &oifs);
800: if (VIFM_ISEMPTY(oifs)) {
801: IF_DEBUG(DEBUG_PIM_REGISTER)
802: logit(LOG_DEBUG, 0, "No output intefaces found for group %s source %s (*,G)",
803: inet_fmt(inner_grp, s1, sizeof(s1)), inet_fmt(inner_src, s2, sizeof(s2)));
804:
805: send_pim_register_stop(reg_dst, reg_src, inner_grp, INADDR_ANY_N);
806:
807: return FALSE;
808: } else { /* XXX: TODO: check with the spec again */
809: if (!is_null) {
810: uint32_t mfc_source = inner_src;
811:
812: /* Install cache entry in the kernel */
813: /* TODO: XXX: probably redundant here, because the
814: * decapsulated mcast packet in the kernel will
815: * result in CACHE_MISS
816: */
817: #ifdef KERNEL_MFC_WC_G
818: if (!(mrtentry->flags & MRTF_MFC_CLONE_SG))
819: mfc_source = INADDR_ANY_N;
820: #endif /* KERNEL_MFC_WC_G */
821: add_kernel_cache(mrtentry, mfc_source, inner_grp, 0);
822: k_chg_mfc(igmp_socket, mfc_source, inner_grp,
823: mrtentry->incoming, mrtentry->oifs,
824: mrtentry->group->rpaddr);
825:
826: return TRUE;
827: }
828: }
829:
830: return TRUE;
831: }
832:
833: if (mrtentry->flags & MRTF_PMBR) {
834: /* (*,*,RP) entry */
835: if (!is_null) {
836: uint32_t mfc_source = inner_src;
837:
838: /* XXX: have to create either (S,G) or (*,G).
839: * The choice below is (*,G)
840: */
841: mrtentry2 = find_route(INADDR_ANY_N, inner_grp, MRTF_WC, CREATE);
842: if (!mrtentry2)
843: return FALSE;
844:
845: if (mrtentry2->flags & MRTF_NEW) {
846: /* TODO: something else? Have the feeling sth is missing */
847: mrtentry2->flags &= ~MRTF_NEW;
848: /* TODO: XXX: copy the timer from the (*,*,RP) entry? */
849: COPY_TIMER(mrtentry->timer, mrtentry2->timer);
850: }
851:
852: /* Install cache entry in the kernel */
853: #ifdef KERNEL_MFC_WC_G
854: if (!(mrtentry->flags & MRTF_MFC_CLONE_SG))
855: mfc_source = INADDR_ANY_N;
856: #endif /* KERNEL_MFC_WC_G */
857: add_kernel_cache(mrtentry, mfc_source, inner_grp, 0);
858: k_chg_mfc(igmp_socket, mfc_source, inner_grp,
859: mrtentry->incoming, mrtentry->oifs,
860: mrtentry2->group->rpaddr);
861:
862: return TRUE;
863: }
864: }
865:
866: /* Shoudn't happen: invalid routing entry? */
867: /* XXX: TODO: shoudn't be inner_src=INADDR_ANY? Not in the spec. */
868: IF_DEBUG(DEBUG_PIM_REGISTER)
869: logit(LOG_DEBUG, 0, "Shoudn't happen: invalid routing entry? (%s, %s, %s, %s)",
870: inet_fmt(reg_dst, s1, sizeof(s1)), inet_fmt(reg_src, s2, sizeof(s2)),
871: inet_fmt(inner_grp, s3, sizeof(s3)), inet_fmt(inner_src, s4, sizeof(s4)));
872:
873: send_pim_register_stop(reg_dst, reg_src, inner_grp, inner_src);
874:
875: return TRUE;
876: }
877:
878:
879: int send_pim_register(char *packet)
880: {
881: struct ip *ip;
882: uint32_t source, group;
883: vifi_t vifi;
884: rpentry_t *rpentry;
885: mrtentry_t *mrtentry;
886: mrtentry_t *mrtentry2;
887: uint32_t reg_src, reg_dst;
888: int reg_mtu, pktlen = 0;
889: char *buf;
890:
891: ip = (struct ip *)packet;
892: source = ip->ip_src.s_addr;
893: group = ip->ip_dst.s_addr;
894:
895: if (IN_PIM_SSM_RANGE(group))
896: return FALSE; /* Group is in PIM-SSM range, don't send register. */
897:
898: if ((vifi = find_vif_direct_local(source)) == NO_VIF)
899: return FALSE;
900:
901: if (!(uvifs[vifi].uv_flags & VIFF_DR))
902: return FALSE; /* I am not the DR for that subnet */
903:
904: rpentry = rp_match(group);
905: if (!rpentry)
906: return FALSE; /* No RP for this group */
907:
908: if (local_address(rpentry->address) != NO_VIF) {
909: /* TODO: XXX: not sure it is working! */
910: return FALSE; /* I am the RP for this group */
911: }
912:
913: mrtentry = find_route(source, group, MRTF_SG, CREATE);
914: if (!mrtentry)
915: return FALSE; /* Cannot create (S,G) state */
916:
917: if (mrtentry->flags & MRTF_NEW) {
918: /* A new entry, log it */
919: reg_src = uvifs[vifi].uv_lcl_addr;
920: reg_dst = mrtentry->group->rpaddr;
921:
922: logit(LOG_INFO, 0, "Send PIM REGISTER: src %s dst %s, group %s",
923: inet_fmt(reg_src, s1, sizeof(s1)), inet_fmt(reg_dst, s2, sizeof(s2)),
924: inet_fmt(group, s3, sizeof(s3)));
925:
926: mrtentry->flags &= ~MRTF_NEW;
927: RESET_TIMER(mrtentry->rs_timer); /* Reset the Register-Suppression timer */
928: mrtentry2 = mrtentry->group->grp_route;
929: if (!mrtentry2)
930: mrtentry2 = mrtentry->group->active_rp_grp->rp->rpentry->mrtlink;
931: if (mrtentry2) {
932: FIRE_TIMER(mrtentry2->jp_timer); /* Timeout the Join/Prune timer */
933: /* TODO: explicitly call this function?
934: send_pim_join_prune(mrtentry2->upstream->vifi,
935: mrtentry2->upstream,
936: PIM_JOIN_PRUNE_HOLDTIME);
937: */
938: }
939: }
940: /* Restart the (S,G) Entry-timer */
941: SET_TIMER(mrtentry->timer, PIM_DATA_TIMEOUT);
942:
943: IF_TIMER_NOT_SET(mrtentry->rs_timer) {
944: /* The Register-Suppression Timer is not running.
945: * Encapsulate the data and send to the RP.
946: */
947: buf = pim_send_buf + sizeof(struct ip) + sizeof(pim_header_t);
948: memset(buf, 0, sizeof(pim_register_t)); /* No flags set */
949: buf += sizeof(pim_register_t);
950:
951: /* Copy the data packet at the back of the register packet */
952: pktlen = ntohs(ip->ip_len);
953: memcpy(buf, ip, pktlen);
954:
955: pktlen += sizeof(pim_register_t); /* 'sizeof(struct ip) + sizeof(pim_header_t)' added by send_pim() */
956: reg_mtu = uvifs[vifi].uv_mtu; /* XXX: Use PMTU to RP instead! */
957: reg_src = uvifs[vifi].uv_lcl_addr;
958: reg_dst = mrtentry->group->rpaddr;
959:
960: send_pim_unicast(pim_send_buf, reg_mtu, reg_src, reg_dst, PIM_REGISTER, pktlen);
961:
962: return TRUE;
963: }
964:
965: return TRUE;
966: }
967:
968:
969: int send_pim_null_register(mrtentry_t *mrtentry)
970: {
971: struct ip *ip;
972: pim_register_t *pim_register;
973: int reg_mtu, pktlen;
974: vifi_t vifi;
975: uint32_t reg_src, reg_dst;
976:
977: /* No directly connected source; no local address */
978: if ((vifi = find_vif_direct_local(mrtentry->source->address))== NO_VIF)
979: return FALSE;
980:
981: pim_register = (pim_register_t *)(pim_send_buf + sizeof(struct ip) +
982: sizeof(pim_header_t));
983: memset(pim_register, 0, sizeof(pim_register_t));
984: pim_register->reg_flags = htonl(pim_register->reg_flags
985: | PIM_REGISTER_NULL_REGISTER_BIT);
986:
987: ip = (struct ip *)(pim_register + 1);
988: /* set src/dst in dummy hdr */
989: ip->ip_v = IPVERSION;
990: ip->ip_hl = (sizeof(struct ip) >> 2);
991: ip->ip_tos = 0;
992: ip->ip_id = 0;
993: ip->ip_off = 0;
994: ip->ip_p = IPPROTO_UDP; /* XXX: bogus */
995: ip->ip_len = htons(sizeof(struct ip));
996: ip->ip_ttl = MINTTL; /* TODO: XXX: check whether need to setup the ttl */
997: ip->ip_src.s_addr = mrtentry->source->address;
998: ip->ip_dst.s_addr = mrtentry->group->group;
999: ip->ip_sum = 0;
1000: ip->ip_sum = inet_cksum((uint16_t *)ip, sizeof(struct ip));
1001:
1002: /* include the dummy ip header */
1003: pktlen = sizeof(pim_register_t) + sizeof(struct ip);
1004:
1005: reg_mtu = uvifs[vifi].uv_mtu;
1006: reg_dst = mrtentry->group->rpaddr;
1007: reg_src = uvifs[vifi].uv_lcl_addr;
1008:
1009: send_pim_unicast(pim_send_buf, reg_mtu, reg_src, reg_dst, PIM_REGISTER, pktlen);
1010:
1011: return TRUE;
1012: }
1013:
1014:
1015: /************************************************************************
1016: * PIM_REGISTER_STOP
1017: ************************************************************************/
1018: int receive_pim_register_stop(uint32_t reg_src, uint32_t reg_dst, char *msg, size_t len)
1019: {
1020: pim_encod_grp_addr_t egaddr;
1021: pim_encod_uni_addr_t eusaddr;
1022: uint8_t *data;
1023: mrtentry_t *mrtentry;
1024: vifbitmap_t pruned_oifs;
1025:
1026: /* Checksum */
1027: if (inet_cksum((uint16_t *)msg, len))
1028: return FALSE;
1029:
1030: data = (uint8_t *)(msg + sizeof(pim_header_t));
1031: GET_EGADDR(&egaddr, data);
1032: GET_EUADDR(&eusaddr, data);
1033:
1034: logit(LOG_INFO, 0, "Received PIM_REGISTER_STOP from RP %s to %s for src = %s and group = %s",
1035: inet_fmt(reg_src, s1, sizeof(s1)), inet_fmt(reg_dst, s2, sizeof(s2)),
1036: inet_fmt(eusaddr.unicast_addr, s3, sizeof(s3)),
1037: inet_fmt(egaddr.mcast_addr, s4, sizeof(s4)));
1038:
1039: /* TODO: apply the group mask and do register_stop for all grp addresses */
1040: /* TODO: check for SourceAddress == 0 */
1041: mrtentry = find_route(eusaddr.unicast_addr, egaddr.mcast_addr, MRTF_SG, DONT_CREATE);
1042: if (!mrtentry)
1043: return FALSE;
1044:
1045: /* XXX: not in the spec: check if the PIM_REGISTER_STOP originator is
1046: * really the RP
1047: */
1048: if (check_mrtentry_rp(mrtentry, reg_src) == FALSE)
1049: return FALSE;
1050:
1051: /* restart the Register-Suppression timer */
1052: SET_TIMER(mrtentry->rs_timer, (0.5 * PIM_REGISTER_SUPPRESSION_TIMEOUT)
1053: + (RANDOM() % (PIM_REGISTER_SUPPRESSION_TIMEOUT + 1)));
1054: /* Prune the register_vif from the outgoing list */
1055: VIFM_COPY(mrtentry->pruned_oifs, pruned_oifs);
1056: VIFM_SET(reg_vif_num, pruned_oifs);
1057: change_interfaces(mrtentry, mrtentry->incoming,
1058: mrtentry->joined_oifs, pruned_oifs,
1059: mrtentry->leaves,
1060: mrtentry->asserted_oifs, 0);
1061:
1062: return TRUE;
1063: }
1064:
1065:
1066: /* TODO: optional rate limiting is not implemented yet */
1067: /* Unicasts a REGISTER_STOP message to the DR */
1068: static int
1069: send_pim_register_stop(uint32_t reg_src, uint32_t reg_dst, uint32_t inner_grp, uint32_t inner_src)
1070: {
1071: char *buf;
1072: uint8_t *data;
1073:
1074: if (IN_PIM_SSM_RANGE(inner_grp))
1075: return TRUE;
1076:
1077: logit(LOG_INFO, 0, "Send PIM REGISTER STOP from %s to router %s for src = %s and group = %s",
1078: inet_fmt(reg_src, s1, sizeof(s1)), inet_fmt(reg_dst, s2, sizeof(s2)),
1079: inet_fmt(inner_src, s3, sizeof(s3)), inet_fmt(inner_grp, s4, sizeof(s4)));
1080:
1081: buf = pim_send_buf + sizeof(struct ip) + sizeof(pim_header_t);
1082: data = (uint8_t *)buf;
1083: PUT_EGADDR(inner_grp, SINGLE_GRP_MSKLEN, 0, data);
1084: PUT_EUADDR(inner_src, data);
1085: send_pim_unicast(pim_send_buf, 0, reg_src, reg_dst, PIM_REGISTER_STOP, data - (uint8_t *)buf);
1086:
1087: return TRUE;
1088: }
1089:
1090:
1091: /************************************************************************
1092: * PIM_JOIN_PRUNE
1093: ************************************************************************/
1094: int join_or_prune(mrtentry_t *mrtentry, pim_nbr_entry_t *upstream_router)
1095: {
1096: vifbitmap_t entry_oifs;
1097: mrtentry_t *mrtentry_grp;
1098:
1099: if (!mrtentry || !upstream_router)
1100: return PIM_ACTION_NOTHING;
1101:
1102: calc_oifs(mrtentry, &entry_oifs);
1103: if (mrtentry->flags & (MRTF_PMBR | MRTF_WC)) {
1104: if (IN_PIM_SSM_RANGE(mrtentry->group->group)) {
1105: logit(LOG_DEBUG, 0, "No action for SSM (PMBR|WC)");
1106: return PIM_ACTION_NOTHING;
1107: }
1108: /* (*,*,RP) or (*,G) entry */
1109: /* The (*,*,RP) or (*,G) J/P messages are sent only toward the RP */
1110: if (upstream_router != mrtentry->upstream)
1111: return PIM_ACTION_NOTHING;
1112:
1113: /* TODO: XXX: Can we have (*,*,RP) prune? */
1114: if (VIFM_ISEMPTY(entry_oifs)) {
1115: /* NULL oifs */
1116:
1117: if (!(uvifs[mrtentry->incoming].uv_flags & VIFF_DR))
1118: /* I am not the DR for that subnet. */
1119: return PIM_ACTION_PRUNE;
1120:
1121: if (VIFM_ISSET(mrtentry->incoming, mrtentry->leaves))
1122: /* I am the DR and have local leaves */
1123: return PIM_ACTION_JOIN;
1124:
1125: /* Probably the last local member hast timeout */
1126: return PIM_ACTION_PRUNE;
1127: }
1128:
1129: return PIM_ACTION_JOIN;
1130: }
1131:
1132: if (mrtentry->flags & MRTF_SG) {
1133: /* (S,G) entry */
1134: /* TODO: check again */
1135: if (mrtentry->upstream == upstream_router) {
1136: if (!(mrtentry->flags & MRTF_RP)) {
1137: /* Upstream router toward S */
1138: if (VIFM_ISEMPTY(entry_oifs)) {
1139: if (mrtentry->group->active_rp_grp &&
1140: mrtentry->group->rpaddr == my_cand_rp_address) {
1141: /* (S,G) at the RP. Don't send Join/Prune
1142: * (see the end of Section 3.3.2)
1143: */
1144: return PIM_ACTION_NOTHING;
1145: }
1146:
1147: return PIM_ACTION_PRUNE;
1148: }
1149: else {
1150: return PIM_ACTION_JOIN;
1151: }
1152: }
1153: else {
1154: if (IN_PIM_SSM_RANGE(mrtentry->group->group)) {
1155: logit(LOG_DEBUG, 0, "No action for SSM (RP)");
1156: return PIM_ACTION_NOTHING;
1157: }
1158: /* Upstream router toward RP */
1159: if (VIFM_ISEMPTY(entry_oifs))
1160: return PIM_ACTION_PRUNE;
1161: }
1162: }
1163:
1164: /* Looks like the case when the upstream router toward S is
1165: * different from the upstream router toward RP
1166: */
1167: if (!mrtentry->group->active_rp_grp)
1168: return PIM_ACTION_NOTHING;
1169:
1170: mrtentry_grp = mrtentry->group->grp_route;
1171: if (!mrtentry_grp) {
1172: mrtentry_grp = mrtentry->group->active_rp_grp->rp->rpentry->mrtlink;
1173: if (!mrtentry_grp)
1174: return PIM_ACTION_NOTHING;
1175: }
1176:
1177: if (mrtentry_grp->upstream != upstream_router)
1178: return PIM_ACTION_NOTHING; /* XXX: shoudn't happen */
1179:
1180: if (!(mrtentry->flags & MRTF_RP) && (mrtentry->flags & MRTF_SPT))
1181: return PIM_ACTION_PRUNE;
1182: }
1183:
1184: return PIM_ACTION_NOTHING;
1185: }
1186:
1187: /*
1188: * Log PIM Join/Prune message. Send log event for every join and prune separately.
1189: * Format of the Join/Prune message starting from dataptr is following:
1190: ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1191: | Multicast Group Address 1 (Encoded-Group format) |
1192: +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1193: | Number of Joined Sources | Number of Pruned Sources |
1194: +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1195: | Joined Source Address 1 (Encoded-Source format) |
1196: +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1197: | . |
1198: | . |
1199: +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1200: | Joined Source Address n (Encoded-Source format) |
1201: +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1202: | Pruned Source Address 1 (Encoded-Source format) |
1203: +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1204: | . |
1205: | . |
1206: +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1207: | Pruned Source Address n (Encoded-Source format) |
1208: +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1209: | Multicast Group Address m (Encoded-Group format) |
1210: +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1211: | Number of Joined Sources | Number of Pruned Sources |
1212: +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1213: | Joined Source Address 1 (Encoded-Source format) |
1214: +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1215: | . |
1216: | . |
1217: +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1218: | Joined Source Address n (Encoded-Source format) |
1219: +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1220: | Pruned Source Address 1 (Encoded-Source format) |
1221: +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1222: | . |
1223: | . |
1224: +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1225: | Pruned Source Address n (Encoded-Source format) |
1226: +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1227: */
1228: void log_pim_join_prune(uint32_t src, uint8_t *data_ptr, int num_groups, char* ifname)
1229: {
1230: pim_encod_grp_addr_t encod_group;
1231: pim_encod_src_addr_t encod_src;
1232: uint32_t group, source;
1233: uint16_t num_j_srcs;
1234: uint16_t num_p_srcs;
1235:
1236: /* Message validity check is done by caller */
1237: while (num_groups--) {
1238:
1239: GET_EGADDR(&encod_group, data_ptr);
1240: GET_HOSTSHORT(num_j_srcs, data_ptr);
1241: GET_HOSTSHORT(num_p_srcs, data_ptr);
1242: group = encod_group.mcast_addr;
1243:
1244: while(num_j_srcs--) {
1245: GET_ESADDR(&encod_src, data_ptr);
1246: source = encod_src.src_addr;
1247: logit(LOG_INFO, 0, "Received PIM JOIN from %s to group %s for multicast source %s on %s",
1248: inet_fmt(src, s1, sizeof(s1)), inet_fmt(group, s2, sizeof(s2)), inet_fmt(source, s3, sizeof(s3)), ifname);
1249: }
1250:
1251: while (num_p_srcs--) {
1252: GET_ESADDR(&encod_src, data_ptr);
1253: source = encod_src.src_addr;
1254: logit(LOG_INFO, 0, "Received PIM PRUNE from %s to group %s for multicast source %s on %s",
1255: inet_fmt(src, s1, sizeof(s1)), inet_fmt(group, s2, sizeof(s2)), inet_fmt(source, s3, sizeof(s3)), ifname);
1256: }
1257: }
1258: }
1259:
1260: /* TODO: when parsing, check if we go beyond message size */
1261: /* TODO: too long, simplify it! */
1262: #define PIM_JOIN_PRUNE_MINLEN (4 + PIM_ENCODE_UNI_ADDR_LEN + 4)
1263: int receive_pim_join_prune(uint32_t src, uint32_t dst __attribute__((unused)), char *msg, size_t len)
1264: {
1265: vifi_t vifi;
1266: struct uvif *v;
1267: pim_encod_uni_addr_t eutaddr;
1268: pim_encod_grp_addr_t egaddr;
1269: pim_encod_src_addr_t esaddr;
1270: uint8_t *data;
1271: uint8_t *data_start;
1272: uint8_t *data_group_end;
1273: uint8_t num_groups;
1274: uint8_t num_groups_tmp;
1275: int star_star_rp_found;
1276: uint16_t holdtime;
1277: uint16_t num_j_srcs;
1278: uint16_t num_j_srcs_tmp;
1279: uint16_t num_p_srcs;
1280: uint32_t source;
1281: uint32_t group;
1282: uint32_t s_mask;
1283: uint32_t g_mask;
1284: uint8_t s_flags;
1285: uint8_t reserved __attribute__((unused));
1286: rpentry_t *rpentry;
1287: mrtentry_t *mrt;
1288: mrtentry_t *mrt_srcs;
1289: mrtentry_t *mrt_rp;
1290: grpentry_t *grp;
1291: uint16_t jp_value;
1292: pim_nbr_entry_t *upstream_router;
1293: int my_action;
1294: int ignore_group;
1295: rp_grp_entry_t *rp_grp;
1296: uint8_t *data_group_j_start;
1297: uint8_t *data_group_p_start;
1298:
1299: if ((vifi = find_vif_direct(src)) == NO_VIF) {
1300: /* Either a local vif or somehow received PIM_JOIN_PRUNE from
1301: * non-directly connected router. Ignore it.
1302: */
1303: if (local_address(src) == NO_VIF) {
1304: logit(LOG_DEBUG, 0, "Ignoring PIM_JOIN_PRUNE from non-neighbor router %s",
1305: inet_fmt(src, s1, sizeof(s1)));
1306: }
1307:
1308: return FALSE;
1309: }
1310:
1311: /* Checksum */
1312: if (inet_cksum((uint16_t *)msg, len))
1313: return FALSE;
1314:
1315: v = &uvifs[vifi];
1316: if (uvifs[vifi].uv_flags & (VIFF_DOWN | VIFF_DISABLED | VIFF_NONBRS | VIFF_REGISTER))
1317: return FALSE; /* Shoudn't come on this interface */
1318:
1319: /* sanity check for the minimum length */
1320: if (len < PIM_JOIN_PRUNE_MINLEN) {
1321: logit(LOG_NOTICE, 0, "%s(): Too short Join/Prune message (%u bytes) from %s on %s",
1322: __func__, len, inet_fmt(src, s1, sizeof(s1)), v->uv_name);
1323:
1324: return FALSE;
1325: }
1326:
1327: len -= PIM_JOIN_PRUNE_MINLEN;
1328: data = (uint8_t *)(msg + sizeof(pim_header_t));
1329:
1330: /* Get the target address */
1331: GET_EUADDR(&eutaddr, data);
1332: GET_BYTE(reserved, data);
1333: GET_BYTE(num_groups, data);
1334: GET_HOSTSHORT(holdtime, data);
1335:
1336: if (num_groups == 0) {
1337: /* No indication for groups in the message */
1338: logit(LOG_NOTICE, 0, "%s(): No groups in Join/Prune message from %s on %s!",
1339: __func__, inet_fmt(src, s1, sizeof(s1)), v->uv_name);
1340: return FALSE;
1341: }
1342:
1343: logit(LOG_INFO, 0, "Received PIM JOIN/PRUNE from %s on %s",
1344: inet_fmt(src, s1, sizeof(s1)), v->uv_name);
1345:
1346: /* Sanity check for the message length through all the groups */
1347: num_groups_tmp = num_groups;
1348: data_start = data;
1349: while (num_groups_tmp--) {
1350: size_t srclen;
1351:
1352: /* group addr + #join + #src */
1353: if (len < PIM_ENCODE_GRP_ADDR_LEN + sizeof(uint32_t)) {
1354: logit(LOG_NOTICE, 0, "%s(): Join/Prune message from %s on %s is"
1355: " too short to contain enough data",
1356: __func__, inet_fmt(src, s1, sizeof(s1)), v->uv_name);
1357: return FALSE;
1358: }
1359:
1360: len -= (PIM_ENCODE_GRP_ADDR_LEN + sizeof(uint32_t));
1361: data += PIM_ENCODE_GRP_ADDR_LEN;
1362:
1363: /* joined source addresses and pruned source addresses */
1364: GET_HOSTSHORT(num_j_srcs, data);
1365: GET_HOSTSHORT(num_p_srcs, data);
1366: srclen = (num_j_srcs + num_p_srcs) * PIM_ENCODE_SRC_ADDR_LEN;
1367: if (len < srclen) {
1368: logit(LOG_NOTICE, 0, "%s(): Join/Prune message from %s on %s is"
1369: " too short to contain enough data", __func__,
1370: inet_fmt(src, s1, sizeof(s1)), v->uv_name);
1371: return FALSE;
1372: }
1373: len -= srclen;
1374: data += srclen;
1375: }
1376: data = data_start;
1377: num_groups_tmp = num_groups;
1378:
1379: /* Sanity check is done. Log the message */
1380: log_pim_join_prune(src, data, num_groups, v->uv_name);
1381:
1382: if (eutaddr.unicast_addr != v->uv_lcl_addr) {
1383: /* if I am not the target of the join message */
1384: /* Join/Prune suppression code. This either modifies the J/P timers
1385: * or triggers an overriding Join.
1386: */
1387: /* Note that if we have (S,G) prune and (*,G) Join, we must send
1388: * them in the same message. We don't bother to modify both timers
1389: * here. The Join/Prune sending function will take care of that.
1390: */
1391: upstream_router = find_pim_nbr(eutaddr.unicast_addr);
1392: if (!upstream_router)
1393: return FALSE; /* I have no such neighbor */
1394:
1395: while (num_groups--) {
1396: GET_EGADDR(&egaddr, data);
1397: GET_HOSTSHORT(num_j_srcs, data);
1398: GET_HOSTSHORT(num_p_srcs, data);
1399: MASKLEN_TO_MASK(egaddr.masklen, g_mask);
1400: group = egaddr.mcast_addr;
1401: if (!IN_MULTICAST(ntohl(group))) {
1402: data += (num_j_srcs + num_p_srcs) * sizeof(pim_encod_src_addr_t);
1403: continue; /* Ignore this group and jump to the next */
1404: }
1405:
1406: if ((ntohl(group) == CLASSD_PREFIX) && (egaddr.masklen == STAR_STAR_RP_MSKLEN)) {
1407: /* (*,*,RP) Join suppression */
1408:
1409: while (num_j_srcs--) {
1410: GET_ESADDR(&esaddr, data);
1411: source = esaddr.src_addr;
1412: if (!inet_valid_host(source))
1413: continue;
1414:
1415: s_flags = esaddr.flags;
1416: MASKLEN_TO_MASK(esaddr.masklen, s_mask);
1417: if ((s_flags & USADDR_RP_BIT) && (s_flags & USADDR_WC_BIT)) {
1418: /* This is the RP address. */
1419: rpentry = rp_find(source);
1420: if (!rpentry)
1421: continue; /* Don't have such RP. Ignore */
1422:
1423: mrt_rp = rpentry->mrtlink;
1424: my_action = join_or_prune(mrt_rp, upstream_router);
1425: if (my_action != PIM_ACTION_JOIN)
1426: continue;
1427:
1428: /* Check the holdtime */
1429: /* TODO: XXX: TIMER implem. dependency! */
1430: if (mrt_rp->jp_timer > holdtime)
1431: continue;
1432:
1433: if ((mrt_rp->jp_timer == holdtime) && (ntohl(src) > ntohl(v->uv_lcl_addr)))
1434: continue;
1435:
1436: /* Set the Join/Prune suppression timer for this
1437: * routing entry by increasing the current
1438: * Join/Prune timer.
1439: */
1440: jp_value = PIM_JOIN_PRUNE_PERIOD + 0.5 * (RANDOM() % PIM_JOIN_PRUNE_PERIOD);
1441: /* TODO: XXX: TIMER implem. dependency! */
1442: if (mrt_rp->jp_timer < jp_value)
1443: SET_TIMER(mrt_rp->jp_timer, jp_value);
1444: }
1445: } /* num_j_srcs */
1446:
1447: while (num_p_srcs--) {
1448: /* TODO: XXX: Can we have (*,*,RP) prune message?
1449: * Not in the spec, but anyway, the code below
1450: * can handle them: either suppress
1451: * the local (*,*,RP) prunes or override the prunes by
1452: * sending (*,*,RP) and/or (*,G) and/or (S,G) Join.
1453: */
1454: GET_ESADDR(&esaddr, data);
1455: source = esaddr.src_addr;
1456: if (!inet_valid_host(source))
1457: continue;
1458:
1459: s_flags = esaddr.flags;
1460: MASKLEN_TO_MASK(esaddr.masklen, s_mask);
1461: if ((s_flags & USADDR_RP_BIT) && (s_flags & USADDR_WC_BIT)) {
1462: /* This is the RP address. */
1463: rpentry = rp_find(source);
1464: if (!rpentry)
1465: continue; /* Don't have such RP. Ignore */
1466:
1467: mrt_rp = rpentry->mrtlink;
1468: my_action = join_or_prune(mrt_rp, upstream_router);
1469: if (my_action == PIM_ACTION_PRUNE) {
1470: /* TODO: XXX: TIMER implem. dependency! */
1471: if ((mrt_rp->jp_timer < holdtime)
1472: || ((mrt_rp->jp_timer == holdtime) &&
1473: (ntohl(src) > ntohl(v->uv_lcl_addr)))) {
1474: /* Suppress the Prune */
1475: jp_value = PIM_JOIN_PRUNE_PERIOD + 0.5 * (RANDOM() % PIM_JOIN_PRUNE_PERIOD);
1476: if (mrt_rp->jp_timer < jp_value)
1477: SET_TIMER(mrt_rp->jp_timer, jp_value);
1478: }
1479: } else if (my_action == PIM_ACTION_JOIN) {
1480: /* Override the Prune by scheduling a Join */
1481: jp_value = (RANDOM() % (int)(10 * PIM_RANDOM_DELAY_JOIN_TIMEOUT)) / 10;
1482: /* TODO: XXX: TIMER implem. dependency! */
1483: if (mrt_rp->jp_timer > jp_value)
1484: SET_TIMER(mrt_rp->jp_timer, jp_value);
1485: }
1486:
1487: /* Check all (*,G) and (S,G) matching to this RP.
1488: * If my_action == JOIN, then send a Join and override
1489: * the (*,*,RP) Prune.
1490: */
1491: for (grp = rpentry->cand_rp->rp_grp_next->grplink; grp; grp = grp->rpnext) {
1492: my_action = join_or_prune(grp->grp_route, upstream_router);
1493: if (my_action == PIM_ACTION_JOIN) {
1494: jp_value = (RANDOM() % (int)(10 * PIM_RANDOM_DELAY_JOIN_TIMEOUT)) / 10;
1495: /* TODO: XXX: TIMER implem. dependency! */
1496: if (grp->grp_route->jp_timer > jp_value)
1497: SET_TIMER(grp->grp_route->jp_timer, jp_value);
1498: }
1499: for (mrt_srcs = grp->mrtlink; mrt_srcs; mrt_srcs = mrt_srcs->grpnext) {
1500: my_action = join_or_prune(mrt_srcs, upstream_router);
1501: if (my_action == PIM_ACTION_JOIN) {
1502: jp_value = (RANDOM() % (int)(10 * PIM_RANDOM_DELAY_JOIN_TIMEOUT)) / 10;
1503: /* TODO: XXX: TIMER implem. dependency! */
1504: if (mrt_srcs->jp_timer > jp_value)
1505: SET_TIMER(mrt_srcs->jp_timer, jp_value);
1506: }
1507: } /* For all (S,G) */
1508: } /* For all (*,G) */
1509: }
1510: } /* num_p_srcs */
1511: continue; /* This was (*,*,RP) suppression */
1512: }
1513:
1514: /* (*,G) or (S,G) suppression */
1515: /* TODO: XXX: currently, accumulated groups
1516: * (i.e. group_masklen < egaddress_lengt) are not
1517: * implemented. Just need to create a loop and apply the
1518: * procedure below for all groups matching the prefix.
1519: */
1520: while (num_j_srcs--) {
1521: GET_ESADDR(&esaddr, data);
1522: source = esaddr.src_addr;
1523: if (!inet_valid_host(source))
1524: continue;
1525:
1526: s_flags = esaddr.flags;
1527: MASKLEN_TO_MASK(esaddr.masklen, s_mask);
1528:
1529: if ((s_flags & USADDR_RP_BIT) && (s_flags & USADDR_WC_BIT)) {
1530: /* (*,G) JOIN_REQUEST (toward the RP) */
1531: mrt = find_route(INADDR_ANY_N, group, MRTF_WC, DONT_CREATE);
1532: if (!mrt)
1533: continue;
1534:
1535: my_action = join_or_prune(mrt, upstream_router);
1536: if (my_action != PIM_ACTION_JOIN)
1537: continue;
1538:
1539: /* (*,G) Join suppresion */
1540: if (source != mrt->group->active_rp_grp->rp->rpentry->address)
1541: continue; /* The RP address doesn't match. Ignore. */
1542:
1543: /* Check the holdtime */
1544: /* TODO: XXX: TIMER implem. dependency! */
1545: if (mrt->jp_timer > holdtime)
1546: continue;
1547:
1548: if ((mrt->jp_timer == holdtime) && (ntohl(src) > ntohl(v->uv_lcl_addr)))
1549: continue;
1550:
1551: jp_value = PIM_JOIN_PRUNE_PERIOD + 0.5 * (RANDOM() % PIM_JOIN_PRUNE_PERIOD);
1552: if (mrt->jp_timer < jp_value)
1553: SET_TIMER(mrt->jp_timer, jp_value);
1554: continue;
1555: } /* End of (*,G) Join suppression */
1556:
1557: /* (S,G) Join suppresion */
1558: mrt = find_route(source, group, MRTF_SG, DONT_CREATE);
1559: if (!mrt)
1560: continue;
1561:
1562: my_action = join_or_prune(mrt, upstream_router);
1563: if (my_action != PIM_ACTION_JOIN)
1564: continue;
1565:
1566: /* Check the holdtime */
1567: /* TODO: XXX: TIMER implem. dependency! */
1568: if (mrt->jp_timer > holdtime)
1569: continue;
1570:
1571: if ((mrt->jp_timer == holdtime) && (ntohl(src) > ntohl(v->uv_lcl_addr)))
1572: continue;
1573:
1574: jp_value = PIM_JOIN_PRUNE_PERIOD + 0.5 * (RANDOM() % PIM_JOIN_PRUNE_PERIOD);
1575: if (mrt->jp_timer < jp_value)
1576: SET_TIMER(mrt->jp_timer, jp_value);
1577: continue;
1578: }
1579:
1580: /* Prunes suppression */
1581: while (num_p_srcs--) {
1582: GET_ESADDR(&esaddr, data);
1583: source = esaddr.src_addr;
1584: if (!inet_valid_host(source))
1585: continue;
1586:
1587: s_flags = esaddr.flags;
1588: MASKLEN_TO_MASK(esaddr.masklen, s_mask);
1589: if ((s_flags & USADDR_RP_BIT) && (s_flags & USADDR_WC_BIT)) {
1590: /* (*,G) prune suppression */
1591: rpentry = rp_match(group);
1592: if (!rpentry || (rpentry->address != source))
1593: continue; /* No such RP or it is different. Ignore */
1594:
1595: mrt = find_route(INADDR_ANY_N, group, MRTF_WC, DONT_CREATE);
1596: if (!mrt)
1597: continue;
1598:
1599: my_action = join_or_prune(mrt, upstream_router);
1600: if (my_action == PIM_ACTION_PRUNE) {
1601: /* TODO: XXX: TIMER implem. dependency! */
1602: if ((mrt->jp_timer < holdtime)
1603: || ((mrt->jp_timer == holdtime)
1604: && (ntohl(src) > ntohl(v->uv_lcl_addr)))) {
1605: /* Suppress the Prune */
1606: jp_value = PIM_JOIN_PRUNE_PERIOD + 0.5 * (RANDOM() % PIM_JOIN_PRUNE_PERIOD);
1607: if (mrt->jp_timer < jp_value)
1608: SET_TIMER(mrt->jp_timer, jp_value);
1609: }
1610: }
1611: else if (my_action == PIM_ACTION_JOIN) {
1612: /* Override the Prune by scheduling a Join */
1613: jp_value = (RANDOM() % (int)(10 * PIM_RANDOM_DELAY_JOIN_TIMEOUT)) / 10;
1614: /* TODO: XXX: TIMER implem. dependency! */
1615: if (mrt->jp_timer > jp_value)
1616: SET_TIMER(mrt->jp_timer, jp_value);
1617: }
1618:
1619: /* Check all (S,G) entries for this group.
1620: * If my_action == JOIN, then send the Join and override
1621: * the (*,G) Prune.
1622: */
1623: for (mrt_srcs = mrt->group->mrtlink; mrt_srcs; mrt_srcs = mrt_srcs->grpnext) {
1624: my_action = join_or_prune(mrt_srcs, upstream_router);
1625: if (my_action == PIM_ACTION_JOIN) {
1626: jp_value = (RANDOM() % (int)(10 * PIM_RANDOM_DELAY_JOIN_TIMEOUT)) / 10;
1627: /* TODO: XXX: TIMER implem. dependency! */
1628: if (mrt->jp_timer > jp_value)
1629: SET_TIMER(mrt->jp_timer, jp_value);
1630: }
1631: } /* For all (S,G) */
1632: continue; /* End of (*,G) prune suppression */
1633: }
1634:
1635: /* (S,G) prune suppression */
1636: mrt = find_route(source, group, MRTF_SG, DONT_CREATE);
1637: if (!mrt)
1638: continue;
1639:
1640: my_action = join_or_prune(mrt, upstream_router);
1641: if (my_action == PIM_ACTION_PRUNE) {
1642: /* Suppress the (S,G) Prune */
1643: /* TODO: XXX: TIMER implem. dependency! */
1644: if ((mrt->jp_timer < holdtime)
1645: || ((mrt->jp_timer == holdtime)
1646: && (ntohl(src) > ntohl(v->uv_lcl_addr)))) {
1647: jp_value = PIM_JOIN_PRUNE_PERIOD + 0.5 * (RANDOM() % PIM_JOIN_PRUNE_PERIOD);
1648: if (mrt->jp_timer < jp_value)
1649: SET_TIMER(mrt->jp_timer, jp_value);
1650: }
1651: }
1652: else if (my_action == PIM_ACTION_JOIN) {
1653: /* Override the Prune by scheduling a Join */
1654: jp_value = (RANDOM() % (int)(10 * PIM_RANDOM_DELAY_JOIN_TIMEOUT)) / 10;
1655: /* TODO: XXX: TIMER implem. dependency! */
1656: if (mrt->jp_timer > jp_value)
1657: SET_TIMER(mrt->jp_timer, jp_value);
1658: }
1659: } /* while (num_p_srcs--) */
1660: } /* while (num_groups--) */
1661: return TRUE;
1662: } /* End of Join/Prune suppression code */
1663:
1664: /* I am the target of this join, so process the message */
1665:
1666: /* The spec says that if there is (*,G) Join, it has priority over
1667: * old existing ~(S,G) prunes in the routing table.
1668: * However, if the (*,G) Join and the ~(S,G) prune are in
1669: * the same message, ~(S,G) has the priority. The spec doesn't say it,
1670: * but I think the same is true for (*,*,RP) and ~(S,G) prunes.
1671: *
1672: * The code below do:
1673: * (1) Check the whole message for (*,*,RP) Joins.
1674: * (1.1) If found, clean all pruned_oifs for all (*,G) and all (S,G)
1675: * for each RP in the list, but do not update the kernel cache.
1676: * Then go back to the beginning of the message and start
1677: * processing for each group:
1678: * (2) Check for Prunes. If no prunes, process the Joins.
1679: * (3) If there are Prunes:
1680: * (3.1) Scan the Join part for existing (*,G) Join.
1681: * (3.1.1) If there is (*,G) Join, clear join interface from
1682: * the pruned_oifs for all (S,G), but DO NOT flush the
1683: * change to the kernel (by using change_interfaces()
1684: * for example)
1685: * (3.2) After the pruned_oifs are eventually cleared in (3.1.1),
1686: * process the Prune part of the message normally
1687: * (setting the prune_oifs and flashing the changes to the (kernel).
1688: * (3.3) After the Prune part is processed, process the Join part
1689: * normally (by applying any changes to the kernel)
1690: * (4) If there were (*,*,RP) Join/Prune, process them.
1691: *
1692: * If the Join/Prune list is too long, it may result in long processing
1693: * overhead. The idea above is not to place any wrong info in the
1694: * kernel, because it may result in short-time existing traffic
1695: * forwarding on wrong interface.
1696: * Hopefully, in the future will find a better way to implement it.
1697: */
1698: num_groups_tmp = num_groups;
1699: data_start = data;
1700: star_star_rp_found = FALSE; /* Indicating whether we have (*,*,RP) join */
1701: while (num_groups_tmp--) {
1702: /* Search for (*,*,RP) Join */
1703: GET_EGADDR(&egaddr, data);
1704: GET_HOSTSHORT(num_j_srcs, data);
1705: GET_HOSTSHORT(num_p_srcs, data);
1706: group = egaddr.mcast_addr;
1707: if ((ntohl(group) != CLASSD_PREFIX) || (egaddr.masklen != STAR_STAR_RP_MSKLEN)) {
1708: /* This is not (*,*,RP). Jump to the next group. */
1709: data += (num_j_srcs + num_p_srcs) * sizeof(pim_encod_src_addr_t);
1710: continue;
1711: }
1712:
1713: /* (*,*,RP) found. For each RP and each (*,G) and each (S,G) clear
1714: * the pruned oif, but do not update the kernel.
1715: */
1716: star_star_rp_found = TRUE;
1717: while (num_j_srcs--) {
1718: GET_ESADDR(&esaddr, data);
1719: rpentry = rp_find(esaddr.src_addr);
1720: if (!rpentry)
1721: continue;
1722:
1723: for (rp_grp = rpentry->cand_rp->rp_grp_next; rp_grp; rp_grp = rp_grp->rp_grp_next) {
1724: for (grp = rp_grp->grplink; grp; grp = grp->rpnext) {
1725: if (grp->grp_route)
1726: VIFM_CLR(vifi, grp->grp_route->pruned_oifs);
1727: for (mrt = grp->mrtlink; mrt; mrt = mrt->grpnext)
1728: VIFM_CLR(vifi, mrt->pruned_oifs);
1729: }
1730: }
1731: }
1732: data += (num_p_srcs) * sizeof(pim_encod_src_addr_t);
1733: }
1734:
1735: /*
1736: * Start processing the groups. If this is (*,*,RP), skip it, but process
1737: * it at the end.
1738: */
1739: data = data_start;
1740: num_groups_tmp = num_groups;
1741: while (num_groups_tmp--) {
1742: GET_EGADDR(&egaddr, data);
1743: GET_HOSTSHORT(num_j_srcs, data);
1744: GET_HOSTSHORT(num_p_srcs, data);
1745: group = egaddr.mcast_addr;
1746: if (!IN_MULTICAST(ntohl(group))) {
1747: data += (num_j_srcs + num_p_srcs) * sizeof(pim_encod_src_addr_t);
1748: continue; /* Ignore this group and jump to the next one */
1749: }
1750:
1751: if ((ntohl(group) == CLASSD_PREFIX)
1752: && (egaddr.masklen == STAR_STAR_RP_MSKLEN)) {
1753: /* This is (*,*,RP). Jump to the next group. */
1754: data += (num_j_srcs + num_p_srcs) * sizeof(pim_encod_src_addr_t);
1755: continue;
1756: }
1757:
1758: rpentry = rp_match(group);
1759: if (!rpentry) {
1760: data += (num_j_srcs + num_p_srcs) * sizeof(pim_encod_src_addr_t);
1761: continue;
1762: }
1763:
1764: data_group_j_start = data;
1765: data_group_p_start = data + num_j_srcs * sizeof(pim_encod_src_addr_t);
1766: data_group_end = data + (num_j_srcs + num_p_srcs) * sizeof(pim_encod_src_addr_t);
1767:
1768: /* Scan the Join part for (*,G) Join and then clear the
1769: * particular interface from pruned_oifs for all (S,G).
1770: * If the RP address in the Join message is different from
1771: * the local match, ignore the whole group.
1772: */
1773: num_j_srcs_tmp = num_j_srcs;
1774: ignore_group = FALSE;
1775: while (num_j_srcs_tmp--) {
1776: GET_ESADDR(&esaddr, data);
1777: if ((esaddr.flags & USADDR_RP_BIT) && (esaddr.flags & USADDR_WC_BIT)) {
1778: /* This is the RP address, i.e. (*,G) Join.
1779: * Check if the RP-mapping is consistent and if "yes",
1780: * then Reset the pruned_oifs for all (S,G) entries.
1781: */
1782: if (rpentry->address != esaddr.src_addr) {
1783: ignore_group = TRUE;
1784: break;
1785: }
1786:
1787: mrt = find_route(INADDR_ANY_N, group, MRTF_WC, DONT_CREATE);
1788: if (mrt) {
1789: for (mrt_srcs = mrt->group->mrtlink;
1790: mrt_srcs;
1791: mrt_srcs = mrt_srcs->grpnext)
1792: VIFM_CLR(vifi, mrt_srcs->pruned_oifs);
1793: }
1794: break;
1795: }
1796: }
1797:
1798: if (ignore_group == TRUE) {
1799: data += (num_j_srcs_tmp + num_p_srcs) * sizeof(pim_encod_src_addr_t);
1800: continue;
1801: }
1802:
1803: data = data_group_p_start;
1804: /* Process the Prune part first */
1805: while (num_p_srcs--) {
1806: GET_ESADDR(&esaddr, data);
1807: source = esaddr.src_addr;
1808: if (!inet_valid_host(source))
1809: continue;
1810:
1811: s_flags = esaddr.flags;
1812: if (!(s_flags & (USADDR_WC_BIT | USADDR_RP_BIT))) {
1813: /* (S,G) prune sent toward S */
1814: mrt = find_route(source, group, MRTF_SG, DONT_CREATE);
1815: if (!mrt)
1816: continue; /* I don't have (S,G) to prune. Ignore. */
1817:
1818: /* If the link is point-to-point, timeout the oif
1819: * immediately, otherwise decrease the timer to allow
1820: * other downstream routers to override the prune.
1821: */
1822: /* TODO: XXX: increase the entry timer? */
1823: if (v->uv_flags & VIFF_POINT_TO_POINT) {
1824: FIRE_TIMER(mrt->vif_timers[vifi]);
1825: } else {
1826: /* TODO: XXX: TIMER implem. dependency! */
1827: if (mrt->vif_timers[vifi] > mrt->vif_deletion_delay[vifi])
1828: SET_TIMER(mrt->vif_timers[vifi],
1829: mrt->vif_deletion_delay[vifi]);
1830: }
1831: IF_TIMER_NOT_SET(mrt->vif_timers[vifi]) {
1832: VIFM_CLR(vifi, mrt->joined_oifs);
1833: VIFM_SET(vifi, mrt->pruned_oifs);
1834: change_interfaces(mrt,
1835: mrt->incoming,
1836: mrt->joined_oifs,
1837: mrt->pruned_oifs,
1838: mrt->leaves,
1839: mrt->asserted_oifs, 0);
1840: }
1841: continue;
1842: }
1843:
1844: if ((s_flags & USADDR_RP_BIT) && (!(s_flags & USADDR_WC_BIT))) {
1845: /* ~(S,G)RPbit prune sent toward the RP */
1846: mrt = find_route(source, group, MRTF_SG, DONT_CREATE);
1847: if (mrt) {
1848: SET_TIMER(mrt->timer, holdtime);
1849: if (v->uv_flags & VIFF_POINT_TO_POINT) {
1850: FIRE_TIMER(mrt->vif_timers[vifi]);
1851: } else {
1852: /* TODO: XXX: TIMER implem. dependency! */
1853: if (mrt->vif_timers[vifi] > mrt->vif_deletion_delay[vifi])
1854: SET_TIMER(mrt->vif_timers[vifi],
1855: mrt->vif_deletion_delay[vifi]);
1856: }
1857: IF_TIMER_NOT_SET(mrt->vif_timers[vifi]) {
1858: VIFM_CLR(vifi, mrt->joined_oifs);
1859: VIFM_SET(vifi, mrt->pruned_oifs);
1860: change_interfaces(mrt,
1861: mrt->incoming,
1862: mrt->joined_oifs,
1863: mrt->pruned_oifs,
1864: mrt->leaves,
1865: mrt->asserted_oifs, 0);
1866: }
1867: continue;
1868: }
1869:
1870: /* There is no (S,G) entry. Check for (*,G) or (*,*,RP) */
1871: mrt = find_route(INADDR_ANY_N, group, MRTF_WC | MRTF_PMBR, DONT_CREATE);
1872: if (mrt) {
1873: mrt = find_route(source, group, MRTF_SG | MRTF_RP, CREATE);
1874: if (!mrt)
1875: continue;
1876:
1877: mrt->flags &= ~MRTF_NEW;
1878: RESET_TIMER(mrt->vif_timers[vifi]);
1879: /* TODO: XXX: The spec doens't say what value to use for
1880: * the entry time. Use the J/P holdtime.
1881: */
1882: SET_TIMER(mrt->timer, holdtime);
1883: /* TODO: XXX: The spec says to delete the oif. However,
1884: * its timer only should be lowered, so the prune can be
1885: * overwritten on multiaccess LAN. Spec BUG.
1886: */
1887: VIFM_CLR(vifi, mrt->joined_oifs);
1888: VIFM_SET(vifi, mrt->pruned_oifs);
1889: change_interfaces(mrt,
1890: mrt->incoming,
1891: mrt->joined_oifs,
1892: mrt->pruned_oifs,
1893: mrt->leaves,
1894: mrt->asserted_oifs, 0);
1895: }
1896: continue;
1897: }
1898:
1899: if ((s_flags & USADDR_RP_BIT) && (s_flags & USADDR_WC_BIT)) {
1900: /* (*,G) Prune */
1901: mrt = find_route(INADDR_ANY_N, group, MRTF_WC | MRTF_PMBR, DONT_CREATE);
1902: if (mrt) {
1903: if (mrt->flags & MRTF_WC) {
1904: /* TODO: XXX: Should check the whole Prune list in
1905: * advance for (*,G) prune and if the RP address
1906: * does not match the local RP-map, then ignore the
1907: * whole group, not only this particular (*,G) prune.
1908: */
1909: if (mrt->group->active_rp_grp->rp->rpentry->address != source)
1910: continue; /* The RP address doesn't match. */
1911:
1912: if (v->uv_flags & VIFF_POINT_TO_POINT) {
1913: FIRE_TIMER(mrt->vif_timers[vifi]);
1914: } else {
1915: /* TODO: XXX: TIMER implem. dependency! */
1916: if (mrt->vif_timers[vifi] > mrt->vif_deletion_delay[vifi])
1917: SET_TIMER(mrt->vif_timers[vifi],
1918: mrt->vif_deletion_delay[vifi]);
1919: }
1920: IF_TIMER_NOT_SET(mrt->vif_timers[vifi]) {
1921: VIFM_CLR(vifi, mrt->joined_oifs);
1922: VIFM_SET(vifi, mrt->pruned_oifs);
1923: change_interfaces(mrt,
1924: mrt->incoming,
1925: mrt->joined_oifs,
1926: mrt->pruned_oifs,
1927: mrt->leaves,
1928: mrt->asserted_oifs, 0);
1929: }
1930: continue;
1931: }
1932:
1933: /* No (*,G) entry, but found (*,*,RP). Create (*,G) */
1934: if (mrt->source->address != source)
1935: continue; /* The RP address doesn't match. */
1936:
1937: mrt = find_route(INADDR_ANY_N, group, MRTF_WC, CREATE);
1938: if (!mrt)
1939: continue;
1940:
1941: mrt->flags &= ~MRTF_NEW;
1942: RESET_TIMER(mrt->vif_timers[vifi]);
1943: /* TODO: XXX: should only lower the oif timer, so it can
1944: * be overwritten on multiaccess LAN. Spec bug.
1945: */
1946: VIFM_CLR(vifi, mrt->joined_oifs);
1947: VIFM_SET(vifi, mrt->pruned_oifs);
1948: change_interfaces(mrt,
1949: mrt->incoming,
1950: mrt->joined_oifs,
1951: mrt->pruned_oifs,
1952: mrt->leaves,
1953: mrt->asserted_oifs, 0);
1954: } /* (*,G) or (*,*,RP) found */
1955: } /* (*,G) prune */
1956: } /* while (num_p_srcs--) */
1957: /* End of (S,G) and (*,G) Prune handling */
1958:
1959: /* Jump back to the Join part and process it */
1960: data = data_group_j_start;
1961: while (num_j_srcs--) {
1962: GET_ESADDR(&esaddr, data);
1963: source = esaddr.src_addr;
1964: if (!inet_valid_host(source))
1965: continue;
1966:
1967: s_flags = esaddr.flags;
1968: MASKLEN_TO_MASK(esaddr.masklen, s_mask);
1969: if ((s_flags & USADDR_WC_BIT) && (s_flags & USADDR_RP_BIT)) {
1970: /* (*,G) Join toward RP */
1971: /* It has been checked already that this RP address is
1972: * the same as the local RP-maping.
1973: */
1974: mrt = find_route(INADDR_ANY_N, group, MRTF_WC, CREATE);
1975: if (!mrt)
1976: continue;
1977:
1978: VIFM_SET(vifi, mrt->joined_oifs);
1979: VIFM_CLR(vifi, mrt->pruned_oifs);
1980: VIFM_CLR(vifi, mrt->asserted_oifs);
1981: /* TODO: XXX: TIMER implem. dependency! */
1982: if (mrt->vif_timers[vifi] < holdtime) {
1983: SET_TIMER(mrt->vif_timers[vifi], holdtime);
1984: mrt->vif_deletion_delay[vifi] = holdtime/3;
1985: }
1986: if (mrt->timer < holdtime)
1987: SET_TIMER(mrt->timer, holdtime);
1988: mrt->flags &= ~MRTF_NEW;
1989: change_interfaces(mrt,
1990: mrt->incoming,
1991: mrt->joined_oifs,
1992: mrt->pruned_oifs,
1993: mrt->leaves,
1994: mrt->asserted_oifs, 0);
1995: /* Need to update the (S,G) entries, because of the previous
1996: * cleaning of the pruned_oifs. The reason is that if the
1997: * oifs for (*,G) weren't changed, the (S,G) entries won't
1998: * be updated by change_interfaces()
1999: */
2000: for (mrt_srcs = mrt->group->mrtlink; mrt_srcs; mrt_srcs = mrt_srcs->grpnext)
2001: change_interfaces(mrt_srcs,
2002: mrt_srcs->incoming,
2003: mrt_srcs->joined_oifs,
2004: mrt_srcs->pruned_oifs,
2005: mrt_srcs->leaves,
2006: mrt_srcs->asserted_oifs, 0);
2007: continue;
2008: }
2009:
2010: if (!(s_flags & (USADDR_WC_BIT | USADDR_RP_BIT))) {
2011: /* (S,G) Join toward S */
2012: if (vifi == get_iif(source))
2013: continue; /* Ignore this (S,G) Join */
2014:
2015: mrt = find_route(source, group, MRTF_SG, CREATE);
2016: if (!mrt)
2017: continue;
2018:
2019: VIFM_SET(vifi, mrt->joined_oifs);
2020: VIFM_CLR(vifi, mrt->pruned_oifs);
2021: VIFM_CLR(vifi, mrt->asserted_oifs);
2022: /* TODO: XXX: TIMER implem. dependency! */
2023: if (mrt->vif_timers[vifi] < holdtime) {
2024: SET_TIMER(mrt->vif_timers[vifi], holdtime);
2025: mrt->vif_deletion_delay[vifi] = holdtime/3;
2026: }
2027: if (mrt->timer < holdtime)
2028: SET_TIMER(mrt->timer, holdtime);
2029: /* TODO: if this is a new entry, send immediately the
2030: * Join message toward S. The Join/Prune timer for new
2031: * entries is 0, but it does not means the message will
2032: * be sent immediately.
2033: */
2034: mrt->flags &= ~MRTF_NEW;
2035: /* Note that we must create (S,G) without the RPbit set.
2036: * If we already had such entry, change_interfaces() will
2037: * reset the RPbit propertly.
2038: */
2039: change_interfaces(mrt,
2040: mrt->source->incoming,
2041: mrt->joined_oifs,
2042: mrt->pruned_oifs,
2043: mrt->leaves,
2044: mrt->asserted_oifs, 0);
2045: continue;
2046: }
2047: } /* while (num_j_srcs--) */
2048: data = data_group_end;
2049: } /* for all groups */
2050:
2051: /* Now process the (*,*,RP) Join/Prune */
2052: if (star_star_rp_found != TRUE)
2053: return TRUE;
2054:
2055: data = data_start;
2056: while (num_groups--) {
2057: /* The conservative approach is to scan again the whole message,
2058: * just in case if we have more than one (*,*,RP) requests.
2059: */
2060: GET_EGADDR(&egaddr, data);
2061: GET_HOSTSHORT(num_j_srcs, data);
2062: GET_HOSTSHORT(num_p_srcs, data);
2063: group = egaddr.mcast_addr;
2064: if ((ntohl(group) != CLASSD_PREFIX)
2065: || (egaddr.masklen != STAR_STAR_RP_MSKLEN)) {
2066: /* This is not (*,*,RP). Jump to the next group. */
2067: data +=
2068: (num_j_srcs + num_p_srcs) * sizeof(pim_encod_src_addr_t);
2069: continue;
2070: }
2071: /* (*,*,RP) found */
2072: while (num_j_srcs--) {
2073: /* TODO: XXX: check that the iif is different from the Join oifs */
2074: GET_ESADDR(&esaddr, data);
2075: source = esaddr.src_addr;
2076: if (!inet_valid_host(source))
2077: continue;
2078:
2079: s_flags = esaddr.flags;
2080: MASKLEN_TO_MASK(esaddr.masklen, s_mask);
2081: mrt = find_route(source, INADDR_ANY_N, MRTF_PMBR, CREATE);
2082: if (!mrt)
2083: continue;
2084:
2085: VIFM_SET(vifi, mrt->joined_oifs);
2086: VIFM_CLR(vifi, mrt->pruned_oifs);
2087: VIFM_CLR(vifi, mrt->asserted_oifs);
2088: /* TODO: XXX: TIMER implem. dependency! */
2089: if (mrt->vif_timers[vifi] < holdtime) {
2090: SET_TIMER(mrt->vif_timers[vifi], holdtime);
2091: mrt->vif_deletion_delay[vifi] = holdtime/3;
2092: }
2093: if (mrt->timer < holdtime)
2094: SET_TIMER(mrt->timer, holdtime);
2095: mrt->flags &= ~MRTF_NEW;
2096: change_interfaces(mrt,
2097: mrt->incoming,
2098: mrt->joined_oifs,
2099: mrt->pruned_oifs,
2100: mrt->leaves,
2101: mrt->asserted_oifs, 0);
2102:
2103: /* Need to update the (S,G) and (*,G) entries, because of
2104: * the previous cleaning of the pruned_oifs. The reason is
2105: * that if the oifs for (*,*,RP) weren't changed, the
2106: * (*,G) and (S,G) entries won't be updated by change_interfaces()
2107: */
2108: for (rp_grp = mrt->source->cand_rp->rp_grp_next; rp_grp; rp_grp = rp_grp->rp_grp_next) {
2109: for (grp = rp_grp->grplink; grp; grp = grp->rpnext) {
2110: /* Update the (*,G) entry */
2111: if (grp->grp_route) {
2112: change_interfaces(grp->grp_route,
2113: grp->grp_route->incoming,
2114: grp->grp_route->joined_oifs,
2115: grp->grp_route->pruned_oifs,
2116: grp->grp_route->leaves,
2117: grp->grp_route->asserted_oifs, 0);
2118: }
2119: /* Update the (S,G) entries */
2120: for (mrt_srcs = grp->mrtlink; mrt_srcs; mrt_srcs = mrt_srcs->grpnext)
2121: change_interfaces(mrt_srcs,
2122: mrt_srcs->incoming,
2123: mrt_srcs->joined_oifs,
2124: mrt_srcs->pruned_oifs,
2125: mrt_srcs->leaves,
2126: mrt_srcs->asserted_oifs, 0);
2127: }
2128: }
2129: continue;
2130: }
2131:
2132: while (num_p_srcs--) {
2133: /* TODO: XXX: can we have (*,*,RP) Prune? */
2134: GET_ESADDR(&esaddr, data);
2135: source = esaddr.src_addr;
2136: if (!inet_valid_host(source))
2137: continue;
2138:
2139: s_flags = esaddr.flags;
2140: MASKLEN_TO_MASK(esaddr.masklen, s_mask);
2141: mrt = find_route(source, INADDR_ANY_N, MRTF_PMBR, DONT_CREATE);
2142: if (!mrt)
2143: continue;
2144:
2145: /* If the link is point-to-point, timeout the oif
2146: * immediately, otherwise decrease the timer to allow
2147: * other downstream routers to override the prune.
2148: */
2149: /* TODO: XXX: increase the entry timer? */
2150: if (v->uv_flags & VIFF_POINT_TO_POINT) {
2151: FIRE_TIMER(mrt->vif_timers[vifi]);
2152: } else {
2153: /* TODO: XXX: TIMER implem. dependency! */
2154: if (mrt->vif_timers[vifi] > mrt->vif_deletion_delay[vifi])
2155: SET_TIMER(mrt->vif_timers[vifi],
2156: mrt->vif_deletion_delay[vifi]);
2157: }
2158: IF_TIMER_NOT_SET(mrt->vif_timers[vifi]) {
2159: VIFM_CLR(vifi, mrt->joined_oifs);
2160: VIFM_SET(vifi, mrt->pruned_oifs);
2161: VIFM_SET(vifi, mrt->asserted_oifs);
2162: change_interfaces(mrt,
2163: mrt->incoming,
2164: mrt->joined_oifs,
2165: mrt->pruned_oifs,
2166: mrt->leaves,
2167: mrt->asserted_oifs, 0);
2168: }
2169:
2170: }
2171: } /* For all groups processing (*,*,R) */
2172:
2173: return TRUE;
2174: }
2175:
2176:
2177: /*
2178: * TODO: NOT USED, probably buggy, but may need it in the future.
2179: */
2180: /*
2181: * TODO: create two functions: periodic which timeout the timers
2182: * and non-periodic which only check but don't timeout the timers.
2183: */
2184: /*
2185: * Create and send Join/Prune messages per interface.
2186: * Only the entries which have the Join/Prune timer expired are included.
2187: * In the special case when we have ~(S,G)RPbit Prune entry, we must
2188: * include any (*,G) or (*,*,RP)
2189: * Currently the whole table is scanned. In the future will have all
2190: * routing entries linked in a chain with the corresponding upstream
2191: * pim_nbr_entry.
2192: *
2193: * If pim_nbr is not NULL, then send to only this particular PIM neighbor,
2194: */
2195: int send_periodic_pim_join_prune(vifi_t vifi, pim_nbr_entry_t *pim_nbr, uint16_t holdtime)
2196: {
2197: grpentry_t *grp;
2198: mrtentry_t *mrt;
2199: rpentry_t *rp;
2200: uint32_t addr;
2201: struct uvif *v;
2202: pim_nbr_entry_t *nbr;
2203: cand_rp_t *cand_rp;
2204:
2205: /* Walk through all routing entries. The iif must match to include the
2206: * entry. Check first the (*,G) entry and then all associated (S,G).
2207: * At the end of the message will add any (*,*,RP) entries.
2208: * TODO: check other PIM-SM implementations and decide the more
2209: * appropriate place to put the (*,*,RP) entries: in the beginning of the
2210: * message or at the end.
2211: */
2212:
2213: v = &uvifs[vifi];
2214:
2215: /* Check the (*,G) and (S,G) entries */
2216: for (grp = grplist; grp; grp = grp->next) {
2217: mrt = grp->grp_route;
2218: /* TODO: XXX: TIMER implem. dependency! */
2219: if (mrt && (mrt->incoming == vifi) && (mrt->jp_timer <= TIMER_INTERVAL)) {
2220:
2221: /* If join/prune to a particular neighbor only was specified */
2222: if (pim_nbr && mrt->upstream != pim_nbr)
2223: continue;
2224:
2225: /* Don't send (*,G) or (S,G,rpt) Join/Prune */
2226: /* TODO: this handles (S,G,rpt) Join/Prune? */
2227: if (!(mrt->flags & MRTF_SG) && IN_PIM_SSM_RANGE(grp->group)) {
2228: logit(LOG_DEBUG, 0, "Skip j/p for SSM (!SG)");
2229: continue;
2230: }
2231:
2232: /* TODO: XXX: The J/P suppression timer is not in the spec! */
2233: if (!VIFM_ISEMPTY(mrt->joined_oifs) || (v->uv_flags & VIFF_DR)) {
2234: add_jp_entry(mrt->upstream, holdtime,
2235: grp->group,
2236: SINGLE_GRP_MSKLEN,
2237: grp->rpaddr,
2238: SINGLE_SRC_MSKLEN, 0, PIM_ACTION_JOIN);
2239: }
2240: /* TODO: XXX: TIMER implem. dependency! */
2241: if (VIFM_ISEMPTY(mrt->joined_oifs)
2242: && (!(v->uv_flags & VIFF_DR))
2243: && (mrt->jp_timer <= TIMER_INTERVAL)) {
2244: add_jp_entry(mrt->upstream, holdtime,
2245: grp->group, SINGLE_GRP_MSKLEN,
2246: grp->rpaddr,
2247: SINGLE_SRC_MSKLEN, 0, PIM_ACTION_PRUNE);
2248: }
2249: }
2250:
2251: /* Check the (S,G) entries */
2252: for (mrt = grp->mrtlink; mrt; mrt = mrt->grpnext) {
2253: /* If join/prune to a particular neighbor only was specified */
2254: if (pim_nbr && mrt->upstream != pim_nbr)
2255: continue;
2256:
2257: if (mrt->flags & MRTF_RP) {
2258: /* RPbit set */
2259: addr = mrt->source->address;
2260: if (VIFM_ISEMPTY(mrt->joined_oifs) || find_vif_direct_local(addr) != NO_VIF) {
2261: /* TODO: XXX: TIMER implem. dependency! */
2262: if (grp->grp_route &&
2263: grp->grp_route->incoming == vifi &&
2264: grp->grp_route->jp_timer <= TIMER_INTERVAL)
2265: /* S is directly connected. Send toward RP */
2266: add_jp_entry(grp->grp_route->upstream,
2267: holdtime,
2268: grp->group, SINGLE_GRP_MSKLEN,
2269: addr, SINGLE_SRC_MSKLEN,
2270: MRTF_RP, PIM_ACTION_PRUNE);
2271: }
2272: }
2273: else {
2274: /* RPbit cleared */
2275: if (VIFM_ISEMPTY(mrt->joined_oifs)) {
2276: /* TODO: XXX: TIMER implem. dependency! */
2277: if (mrt->incoming == vifi && mrt->jp_timer <= TIMER_INTERVAL)
2278: add_jp_entry(mrt->upstream, holdtime,
2279: grp->group, SINGLE_GRP_MSKLEN,
2280: mrt->source->address,
2281: SINGLE_SRC_MSKLEN, 0, PIM_ACTION_PRUNE);
2282: } else {
2283: logit(LOG_DEBUG, 0 , "Joined not empty, group %s",
2284: inet_ntoa(*(struct in_addr *)&grp->group));
2285: /* TODO: XXX: TIMER implem. dependency! */
2286: if (mrt->incoming == vifi && mrt->jp_timer <= TIMER_INTERVAL)
2287: add_jp_entry(mrt->upstream, holdtime,
2288: grp->group, SINGLE_GRP_MSKLEN,
2289: mrt->source->address,
2290: SINGLE_SRC_MSKLEN, 0, PIM_ACTION_JOIN);
2291: }
2292: /* TODO: XXX: TIMER implem. dependency! */
2293: if ((mrt->flags & MRTF_SPT) &&
2294: grp->grp_route &&
2295: mrt->incoming != grp->grp_route->incoming &&
2296: grp->grp_route->incoming == vifi &&
2297: grp->grp_route->jp_timer <= TIMER_INTERVAL)
2298: add_jp_entry(grp->grp_route->upstream, holdtime,
2299: grp->group, SINGLE_GRP_MSKLEN,
2300: mrt->source->address,
2301: SINGLE_SRC_MSKLEN, MRTF_RP,
2302: PIM_ACTION_PRUNE);
2303: }
2304: }
2305: }
2306:
2307: /* Check the (*,*,RP) entries */
2308: for (cand_rp = cand_rp_list; cand_rp; cand_rp = cand_rp->next) {
2309: rp = cand_rp->rpentry;
2310:
2311: /* If join/prune to a particular neighbor only was specified */
2312: if (pim_nbr && rp->upstream != pim_nbr)
2313: continue;
2314:
2315: /* TODO: XXX: TIMER implem. dependency! */
2316: if (rp->mrtlink &&
2317: rp->incoming == vifi &&
2318: rp->mrtlink->jp_timer <= TIMER_INTERVAL) {
2319: add_jp_entry(rp->upstream, holdtime, htonl(CLASSD_PREFIX), STAR_STAR_RP_MSKLEN,
2320: rp->address, SINGLE_SRC_MSKLEN, MRTF_RP | MRTF_WC, PIM_ACTION_JOIN);
2321: }
2322: }
2323:
2324: /* Send all pending Join/Prune messages */
2325: for (nbr = v->uv_pim_neighbors; nbr; nbr = nbr->next) {
2326: /* If join/prune to a particular neighbor only was specified */
2327: if (pim_nbr && (nbr != pim_nbr))
2328: continue;
2329:
2330: pack_and_send_jp_message(nbr);
2331: }
2332:
2333: return TRUE;
2334: }
2335:
2336:
2337: int add_jp_entry(pim_nbr_entry_t *pim_nbr, uint16_t holdtime, uint32_t group,
2338: uint8_t grp_msklen, uint32_t source, uint8_t src_msklen,
2339: uint16_t addr_flags, uint8_t join_prune)
2340: {
2341: build_jp_message_t *bjpm;
2342: uint8_t *data;
2343: uint8_t flags = 0;
2344: int rp_flag;
2345:
2346: bjpm = pim_nbr->build_jp_message;
2347: if (bjpm) {
2348: if ((bjpm->jp_message_size + bjpm->join_list_size +
2349: bjpm->prune_list_size + bjpm->rp_list_join_size +
2350: bjpm->rp_list_prune_size >= MAX_JP_MESSAGE_SIZE)
2351: || (bjpm->join_list_size >= MAX_JOIN_LIST_SIZE)
2352: || (bjpm->prune_list_size >= MAX_PRUNE_LIST_SIZE)
2353: || (bjpm->rp_list_join_size >= MAX_JOIN_LIST_SIZE)
2354: || (bjpm->rp_list_prune_size >= MAX_PRUNE_LIST_SIZE)) {
2355: /* TODO: XXX: BUG: If the list is getting too large, must
2356: * be careful with the fragmentation.
2357: */
2358: pack_and_send_jp_message(pim_nbr);
2359: bjpm = pim_nbr->build_jp_message; /* The buffer will be freed */
2360: }
2361: }
2362:
2363: if (bjpm) {
2364: if ((bjpm->curr_group != group)
2365: || (bjpm->curr_group_msklen != grp_msklen)
2366: || (bjpm->holdtime != holdtime)) {
2367: pack_jp_message(pim_nbr);
2368: }
2369: }
2370:
2371: if (!bjpm) {
2372: bjpm = get_jp_working_buff();
2373: if (!bjpm) {
2374: logit(LOG_ERR, 0, "Failed allocating working buffer in add_jp_entry()");
2375: exit (-1);
2376: }
2377:
2378: pim_nbr->build_jp_message = bjpm;
2379: data = bjpm->jp_message;
2380: PUT_EUADDR(pim_nbr->address, data);
2381: PUT_BYTE(0, data); /* Reserved */
2382: bjpm->num_groups_ptr = data++; /* The pointer for numgroups */
2383: *(bjpm->num_groups_ptr) = 0; /* Zero groups */
2384: PUT_HOSTSHORT(holdtime, data);
2385: bjpm->holdtime = holdtime;
2386: bjpm->jp_message_size = data - bjpm->jp_message;
2387: }
2388:
2389: /* TODO: move somewhere else, only when it is a new group */
2390: bjpm->curr_group = group;
2391: bjpm->curr_group_msklen = grp_msklen;
2392:
2393: if (group == htonl(CLASSD_PREFIX) && grp_msklen == STAR_STAR_RP_MSKLEN)
2394: rp_flag = TRUE;
2395: else
2396: rp_flag = FALSE;
2397:
2398: switch (join_prune) {
2399: case PIM_ACTION_JOIN:
2400: if (rp_flag == TRUE)
2401: data = bjpm->rp_list_join + bjpm->rp_list_join_size;
2402: else
2403: data = bjpm->join_list + bjpm->join_list_size;
2404: break;
2405:
2406: case PIM_ACTION_PRUNE:
2407: if (rp_flag == TRUE)
2408: data = bjpm->rp_list_prune + bjpm->rp_list_prune_size;
2409: else
2410: data = bjpm->prune_list + bjpm->prune_list_size;
2411: break;
2412:
2413: default:
2414: return FALSE;
2415: }
2416:
2417: flags |= USADDR_S_BIT; /* Mandatory for PIMv2 */
2418: if (addr_flags & MRTF_RP)
2419: flags |= USADDR_RP_BIT;
2420: if (addr_flags & MRTF_WC)
2421: flags |= USADDR_WC_BIT;
2422: PUT_ESADDR(source, src_msklen, flags, data);
2423:
2424: switch (join_prune) {
2425: case PIM_ACTION_JOIN:
2426: if (rp_flag == TRUE) {
2427: bjpm->rp_list_join_size = data - bjpm->rp_list_join;
2428: bjpm->rp_list_join_number++;
2429: } else {
2430: bjpm->join_list_size = data - bjpm->join_list;
2431: bjpm->join_addr_number++;
2432: }
2433: break;
2434:
2435: case PIM_ACTION_PRUNE:
2436: if (rp_flag == TRUE) {
2437: bjpm->rp_list_prune_size = data - bjpm->rp_list_prune;
2438: bjpm->rp_list_prune_number++;
2439: } else {
2440: bjpm->prune_list_size = data - bjpm->prune_list;
2441: bjpm->prune_addr_number++;
2442: }
2443: break;
2444:
2445: default:
2446: return FALSE;
2447: }
2448:
2449: return TRUE;
2450: }
2451:
2452:
2453: /* TODO: check again the size of the buffers */
2454: static build_jp_message_t *get_jp_working_buff(void)
2455: {
2456: build_jp_message_t *bjpm;
2457:
2458: if (build_jp_message_pool_counter == 0) {
2459: bjpm = calloc(1, sizeof(build_jp_message_t));
2460: if (!bjpm)
2461: return NULL;
2462:
2463: bjpm->next = NULL;
2464: bjpm->jp_message = calloc(1, MAX_JP_MESSAGE_SIZE +
2465: sizeof(pim_jp_encod_grp_t) +
2466: 2 * sizeof(pim_encod_src_addr_t));
2467: if (!bjpm->jp_message) {
2468: free(bjpm);
2469: return NULL;
2470: }
2471:
2472: bjpm->jp_message_size = 0;
2473: bjpm->join_list_size = 0;
2474: bjpm->join_addr_number = 0;
2475: bjpm->join_list = calloc(1, MAX_JOIN_LIST_SIZE + sizeof(pim_encod_src_addr_t));
2476: if (!bjpm->join_list) {
2477: free(bjpm->jp_message);
2478: free(bjpm);
2479: return NULL;
2480: }
2481: bjpm->prune_list_size = 0;
2482: bjpm->prune_addr_number = 0;
2483: bjpm->prune_list = calloc(1, MAX_PRUNE_LIST_SIZE + sizeof(pim_encod_src_addr_t));
2484: if (!bjpm->prune_list) {
2485: free(bjpm->join_list);
2486: free(bjpm->jp_message);
2487: free(bjpm);
2488: return NULL;
2489: }
2490: bjpm->rp_list_join_size = 0;
2491: bjpm->rp_list_join_number = 0;
2492: bjpm->rp_list_join = calloc(1, MAX_JOIN_LIST_SIZE + sizeof(pim_encod_src_addr_t));
2493: if (!bjpm->rp_list_join) {
2494: free(bjpm->prune_list);
2495: free(bjpm->join_list);
2496: free(bjpm->jp_message);
2497: free(bjpm);
2498: return NULL;
2499: }
2500: bjpm->rp_list_prune_size = 0;
2501: bjpm->rp_list_prune_number = 0;
2502: bjpm->rp_list_prune = calloc(1, MAX_PRUNE_LIST_SIZE + sizeof(pim_encod_src_addr_t));
2503: if (!bjpm->rp_list_prune) {
2504: free(bjpm->rp_list_join);
2505: free(bjpm->prune_list);
2506: free(bjpm->join_list);
2507: free(bjpm->jp_message);
2508: free(bjpm);
2509: return NULL;
2510: }
2511: bjpm->curr_group = INADDR_ANY_N;
2512: bjpm->curr_group_msklen = 0;
2513: bjpm->holdtime = 0;
2514:
2515: return bjpm;
2516: }
2517:
2518: bjpm = build_jp_message_pool;
2519: build_jp_message_pool = build_jp_message_pool->next;
2520: build_jp_message_pool_counter--;
2521: bjpm->jp_message_size = 0;
2522: bjpm->join_list_size = 0;
2523: bjpm->join_addr_number = 0;
2524: bjpm->prune_list_size = 0;
2525: bjpm->prune_addr_number = 0;
2526: bjpm->curr_group = INADDR_ANY_N;
2527: bjpm->curr_group_msklen = 0;
2528:
2529: return bjpm;
2530: }
2531:
2532:
2533: static void return_jp_working_buff(pim_nbr_entry_t *pim_nbr)
2534: {
2535: build_jp_message_t *bjpm = pim_nbr->build_jp_message;
2536:
2537: if (!bjpm)
2538: return;
2539:
2540: /* Don't waste memory by keeping too many free buffers */
2541: /* TODO: check/modify the definitions for POOL_NUMBER and size */
2542: if (build_jp_message_pool_counter >= MAX_JP_MESSAGE_POOL_NUMBER) {
2543: free(bjpm->jp_message);
2544: free(bjpm->join_list);
2545: free(bjpm->prune_list);
2546: free(bjpm->rp_list_join);
2547: free(bjpm->rp_list_prune);
2548: free(bjpm);
2549: } else {
2550: bjpm->next = build_jp_message_pool;
2551: build_jp_message_pool = bjpm;
2552: build_jp_message_pool_counter++;
2553: }
2554:
2555: pim_nbr->build_jp_message = NULL;
2556: }
2557:
2558:
2559: /* TODO: XXX: Currently, the (*,*,RP) stuff goes at the end of the
2560: * Join/Prune message. However, this particular implementation of PIM
2561: * processes the Join/Prune messages faster if (*,*,RP) is at the beginning.
2562: * Modify some of the functions below such that the
2563: * outgoing messages place (*,*,RP) at the beginning, not at the end.
2564: */
2565: static void pack_jp_message(pim_nbr_entry_t *pim_nbr)
2566: {
2567: build_jp_message_t *bjpm;
2568: uint8_t *data;
2569:
2570: bjpm = pim_nbr->build_jp_message;
2571: if (!bjpm || (bjpm->curr_group == INADDR_ANY_N))
2572: return;
2573:
2574: data = bjpm->jp_message + bjpm->jp_message_size;
2575: PUT_EGADDR(bjpm->curr_group, bjpm->curr_group_msklen, 0, data);
2576: PUT_HOSTSHORT(bjpm->join_addr_number, data);
2577: PUT_HOSTSHORT(bjpm->prune_addr_number, data);
2578: memcpy(data, bjpm->join_list, bjpm->join_list_size);
2579: data += bjpm->join_list_size;
2580: memcpy(data, bjpm->prune_list, bjpm->prune_list_size);
2581: data += bjpm->prune_list_size;
2582: bjpm->jp_message_size = (data - bjpm->jp_message);
2583: bjpm->curr_group = INADDR_ANY_N;
2584: bjpm->curr_group_msklen = 0;
2585: bjpm->join_list_size = 0;
2586: bjpm->join_addr_number = 0;
2587: bjpm->prune_list_size = 0;
2588: bjpm->prune_addr_number = 0;
2589: (*bjpm->num_groups_ptr)++;
2590:
2591: if (*bjpm->num_groups_ptr == ((uint8_t)~0 - 1)) {
2592: if (bjpm->rp_list_join_number + bjpm->rp_list_prune_number) {
2593: /* Add the (*,*,RP) at the end */
2594: data = bjpm->jp_message + bjpm->jp_message_size;
2595: PUT_EGADDR(htonl(CLASSD_PREFIX), STAR_STAR_RP_MSKLEN, 0, data);
2596: PUT_HOSTSHORT(bjpm->rp_list_join_number, data);
2597: PUT_HOSTSHORT(bjpm->rp_list_prune_number, data);
2598: memcpy(data, bjpm->rp_list_join, bjpm->rp_list_join_size);
2599: data += bjpm->rp_list_join_size;
2600: memcpy(data, bjpm->rp_list_prune, bjpm->rp_list_prune_size);
2601: data += bjpm->rp_list_prune_size;
2602: bjpm->jp_message_size = (data - bjpm->jp_message);
2603: bjpm->rp_list_join_size = 0;
2604: bjpm->rp_list_join_number = 0;
2605: bjpm->rp_list_prune_size = 0;
2606: bjpm->rp_list_prune_number = 0;
2607: (*bjpm->num_groups_ptr)++;
2608: }
2609: send_jp_message(pim_nbr);
2610: }
2611: }
2612:
2613:
2614: void pack_and_send_jp_message(pim_nbr_entry_t *pim_nbr)
2615: {
2616: uint8_t *data;
2617: build_jp_message_t *bjpm;
2618:
2619: if (!pim_nbr || !pim_nbr->build_jp_message)
2620: return;
2621:
2622: pack_jp_message(pim_nbr);
2623:
2624: bjpm = pim_nbr->build_jp_message;
2625: if (bjpm->rp_list_join_number + bjpm->rp_list_prune_number) {
2626: /* Add the (*,*,RP) at the end */
2627: data = bjpm->jp_message + bjpm->jp_message_size;
2628: PUT_EGADDR(htonl(CLASSD_PREFIX), STAR_STAR_RP_MSKLEN, 0, data);
2629: PUT_HOSTSHORT(bjpm->rp_list_join_number, data);
2630: PUT_HOSTSHORT(bjpm->rp_list_prune_number, data);
2631: memcpy(data, bjpm->rp_list_join, bjpm->rp_list_join_size);
2632: data += bjpm->rp_list_join_size;
2633: memcpy(data, bjpm->rp_list_prune, bjpm->rp_list_prune_size);
2634: data += bjpm->rp_list_prune_size;
2635: bjpm->jp_message_size = (data - bjpm->jp_message);
2636: bjpm->rp_list_join_size = 0;
2637: bjpm->rp_list_join_number = 0;
2638: bjpm->rp_list_prune_size = 0;
2639: bjpm->rp_list_prune_number = 0;
2640: (*bjpm->num_groups_ptr)++;
2641: }
2642: send_jp_message(pim_nbr);
2643: }
2644:
2645:
2646: static void send_jp_message(pim_nbr_entry_t *pim_nbr)
2647: {
2648: size_t len;
2649: vifi_t vifi;
2650:
2651: len = pim_nbr->build_jp_message->jp_message_size;
2652: vifi = pim_nbr->vifi;
2653: memcpy(pim_send_buf + sizeof(struct ip) + sizeof(pim_header_t),
2654: pim_nbr->build_jp_message->jp_message, len);
2655: logit(LOG_INFO, 0, "Send PIM JOIN/PRUNE from %s on %s",
2656: inet_fmt(uvifs[vifi].uv_lcl_addr, s1, sizeof(s1)), uvifs[vifi].uv_name);
2657: send_pim(pim_send_buf, uvifs[vifi].uv_lcl_addr, allpimrouters_group,
2658: PIM_JOIN_PRUNE, len);
2659: return_jp_working_buff(pim_nbr);
2660: }
2661:
2662:
2663: /************************************************************************
2664: * PIM_ASSERT
2665: ************************************************************************/
2666: int receive_pim_assert(uint32_t src, uint32_t dst __attribute__((unused)), char *msg, size_t len)
2667: {
2668: vifi_t vifi;
2669: pim_encod_uni_addr_t eusaddr;
2670: pim_encod_grp_addr_t egaddr;
2671: uint32_t source, group;
2672: mrtentry_t *mrt, *mrt2;
2673: uint8_t *data;
2674: struct uvif *v;
2675: uint32_t assert_preference;
2676: uint32_t assert_metric;
2677: uint32_t assert_rptbit;
2678: uint32_t local_metric;
2679: uint32_t local_preference;
2680: uint8_t local_rptbit;
2681: uint8_t local_wins;
2682: pim_nbr_entry_t *original_upstream_router;
2683:
2684: vifi = find_vif_direct(src);
2685: if (vifi == NO_VIF) {
2686: /* Either a local vif or somehow received PIM_ASSERT from
2687: * non-directly connected router. Ignore it.
2688: */
2689: if (local_address(src) == NO_VIF)
2690: logit(LOG_DEBUG, 0, "Ignoring PIM_ASSERT from non-neighbor router %s",
2691: inet_fmt(src, s1, sizeof(s1)));
2692:
2693: return FALSE;
2694: }
2695:
2696: /* Checksum */
2697: if (inet_cksum((uint16_t *)msg, len))
2698: return FALSE;
2699:
2700: v = &uvifs[vifi];
2701: if (uvifs[vifi].uv_flags & (VIFF_DOWN | VIFF_DISABLED | VIFF_NONBRS | VIFF_REGISTER))
2702: return FALSE; /* Shoudn't come on this interface */
2703:
2704: data = (uint8_t *)(msg + sizeof(pim_header_t));
2705:
2706: /* Get the group and source addresses */
2707: GET_EGADDR(&egaddr, data);
2708: GET_EUADDR(&eusaddr, data);
2709:
2710: /* Get the metric related info */
2711: GET_HOSTLONG(assert_preference, data);
2712: GET_HOSTLONG(assert_metric, data);
2713: assert_rptbit = assert_preference & PIM_ASSERT_RPT_BIT;
2714:
2715: source = eusaddr.unicast_addr;
2716: group = egaddr.mcast_addr;
2717:
2718: logit(LOG_INFO, 0, "Received PIM ASSERT from %s for group %s and source %s",
2719: inet_fmt(src, s1, sizeof(s1)), inet_fmt(group, s2, sizeof(s2)),
2720: inet_fmt(source, s3, sizeof(s3)));
2721:
2722: /* Find the longest "active" entry, i.e. the one with a kernel mirror */
2723: if (assert_rptbit) {
2724: mrt = find_route(INADDR_ANY_N, group, MRTF_WC | MRTF_PMBR, DONT_CREATE);
2725: if (mrt && !(mrt->flags & MRTF_KERNEL_CACHE)) {
2726: if (mrt->flags & MRTF_WC)
2727: mrt = mrt->group->active_rp_grp->rp->rpentry->mrtlink;
2728: }
2729: } else {
2730: mrt = find_route(source, group, MRTF_SG | MRTF_WC | MRTF_PMBR, DONT_CREATE);
2731: if (mrt && !(mrt->flags & MRTF_KERNEL_CACHE)) {
2732: if (mrt->flags & MRTF_SG) {
2733: mrt2 = mrt->group->grp_route;
2734: if (mrt2 && (mrt2->flags & MRTF_KERNEL_CACHE))
2735: mrt = mrt2;
2736: else
2737: mrt = mrt->group->active_rp_grp->rp->rpentry->mrtlink;
2738: } else {
2739: if (mrt->flags & MRTF_WC)
2740: mrt = mrt->group->active_rp_grp->rp->rpentry->mrtlink;
2741: }
2742: }
2743: }
2744:
2745: if (!mrt || !(mrt->flags & MRTF_KERNEL_CACHE)) {
2746: /* No routing entry or not "active" entry. Ignore the assert */
2747: return FALSE;
2748: }
2749:
2750: /* Prepare the local preference and metric */
2751: if ((mrt->flags & MRTF_PMBR)
2752: || ((mrt->flags & MRTF_SG)
2753: && !(mrt->flags & MRTF_RP))) {
2754: /* Either (S,G) (toward S) or (*,*,RP). */
2755: /* TODO: XXX: get the info from mrt, or source or from kernel ? */
2756: /*
2757: local_metric = mrt->source->metric;
2758: local_preference = mrt->source->preference;
2759: */
2760: local_metric = mrt->metric;
2761: local_preference = mrt->preference;
2762: } else {
2763: /* Should be (*,G) or (S,G)RPbit entry.
2764: * Get what we need from the RP info.
2765: */
2766: /* TODO: get the info from mrt, RP-entry or kernel? */
2767: /*
2768: local_metric =
2769: mrt->group->active_rp_grp->rp->rpentry->metric;
2770: local_preference =
2771: mrt->group->active_rp_grp->rp->rpentry->preference;
2772: */
2773: local_metric = mrt->metric;
2774: local_preference = mrt->preference;
2775: }
2776:
2777: local_rptbit = (mrt->flags & MRTF_RP);
2778: if (local_rptbit) {
2779: /* Make the RPT bit the most significant one */
2780: local_preference |= PIM_ASSERT_RPT_BIT;
2781: }
2782:
2783: if (VIFM_ISSET(vifi, mrt->oifs)) {
2784: /* The ASSERT has arrived on oif */
2785:
2786: /* TODO: XXX: here the processing order is different from the spec.
2787: * The spec requires first eventually to create a routing entry
2788: * (see 3.5.2.1(1) and then compare the metrics. Here we compare
2789: * first the metrics with the existing longest match entry and
2790: * if we lose then create a new entry and compare again. This saves
2791: * us the unnecessary creating of a routing entry if we anyway are
2792: * going to lose: for example the local (*,*,RP) vs the remote
2793: * (*,*,RP) or (*,G)
2794: */
2795:
2796: local_wins = compare_metrics(local_preference, local_metric,
2797: v->uv_lcl_addr, assert_preference,
2798: assert_metric, src);
2799:
2800: if (local_wins == TRUE) {
2801: /* TODO: verify the parameters */
2802: send_pim_assert(source, group, vifi, mrt);
2803: return TRUE;
2804: }
2805:
2806: /* Create a "better" routing entry and try again */
2807: if (assert_rptbit && (mrt->flags & MRTF_PMBR)) {
2808: /* The matching entry was (*,*,RP). Create (*,G) */
2809: mrt2 = find_route(INADDR_ANY_N, group, MRTF_WC, CREATE);
2810: } else if (!assert_rptbit && (mrt->flags & (MRTF_WC | MRTF_PMBR))) {
2811: /* create (S,G) */
2812: mrt2 = find_route(source, group, MRTF_SG, CREATE);
2813: } else {
2814: /* We have no chance to win. Give up and prune the oif */
2815: mrt2 = NULL;
2816: }
2817:
2818: if (mrt2 && (mrt2->flags & MRTF_NEW)) {
2819: mrt2->flags &= ~MRTF_NEW;
2820: /* TODO: XXX: The spec doesn't say what entry timer value
2821: * to use when the routing entry is created because of asserts.
2822: */
2823: SET_TIMER(mrt2->timer, PIM_DATA_TIMEOUT);
2824: if (mrt2->flags & MRTF_RP) {
2825: /* Either (*,G) or (S,G)RPbit entry.
2826: * Get what we need from the RP info.
2827: */
2828: /* TODO: where to get the metric+preference from? */
2829: /*
2830: local_metric =
2831: mrt->group->active_rp_grp->rp->rpentry->metric;
2832: local_preference =
2833: mrt->group->active_rp_grp->rp->rpentry->preference;
2834: */
2835: local_metric = mrt->metric;
2836: local_preference = mrt->preference;
2837: local_preference |= PIM_ASSERT_RPT_BIT;
2838: } else {
2839: /* (S,G) toward the source */
2840: /* TODO: where to get the metric from ? */
2841: /*
2842: local_metric = mrt->source->metric;
2843: local_preference = mrt->source->preference;
2844: */
2845: local_metric = mrt->metric;
2846: local_preference = mrt->preference;
2847: }
2848:
2849: local_wins = compare_metrics(local_preference, local_metric,
2850: v->uv_lcl_addr, assert_preference,
2851: assert_metric, src);
2852: if (local_wins == TRUE) {
2853: /* TODO: verify the parameters */
2854: send_pim_assert(source, group, vifi, mrt);
2855: return TRUE;
2856: }
2857: /* We lost, but have created the entry which has to be pruned */
2858: mrt = mrt2;
2859: }
2860:
2861: /* Have to remove that outgoing vifi from mrt */
2862: VIFM_SET(vifi, mrt->asserted_oifs);
2863: mrt->flags |= MRTF_ASSERTED;
2864: if (mrt->assert_timer < PIM_ASSERT_TIMEOUT)
2865: SET_TIMER(mrt->assert_timer, PIM_ASSERT_TIMEOUT);
2866:
2867: /* TODO: XXX: check that the timer of all affected routing entries
2868: * has been restarted.
2869: */
2870: change_interfaces(mrt,
2871: mrt->incoming,
2872: mrt->joined_oifs,
2873: mrt->pruned_oifs,
2874: mrt->leaves,
2875: mrt->asserted_oifs, 0);
2876:
2877: return FALSE; /* Doesn't matter the return value */
2878: } /* End of assert received on oif */
2879:
2880:
2881: if (mrt->incoming == vifi) {
2882: /* Assert received on iif */
2883: if (assert_rptbit) {
2884: if (!(mrt->flags & MRTF_RP))
2885: return TRUE; /* The locally used upstream router will
2886: * win the assert, so don't change it.
2887: */
2888: }
2889:
2890: /* Ignore assert message if we do not have an upstream router */
2891: if (mrt->upstream == NULL)
2892: return FALSE;
2893:
2894: /* TODO: where to get the local metric and preference from?
2895: * system call or mrt is fine?
2896: */
2897: local_metric = mrt->metric;
2898: local_preference = mrt->preference;
2899: if (mrt->flags & MRTF_RP)
2900: local_preference |= PIM_ASSERT_RPT_BIT;
2901:
2902: local_wins = compare_metrics(local_preference, local_metric,
2903: mrt->upstream->address,
2904: assert_preference, assert_metric, src);
2905:
2906: if (local_wins == TRUE)
2907: return TRUE; /* return whatever */
2908:
2909: /* The upstream must be changed to the winner */
2910: mrt->preference = assert_preference;
2911: mrt->metric = assert_metric;
2912: mrt->upstream = find_pim_nbr(src);
2913:
2914: /* Check if the upstream router is different from the original one */
2915: if (mrt->flags & MRTF_PMBR) {
2916: original_upstream_router = mrt->source->upstream;
2917: } else {
2918: if (mrt->flags & MRTF_RP)
2919: original_upstream_router = mrt->group->active_rp_grp->rp->rpentry->upstream;
2920: else
2921: original_upstream_router = mrt->source->upstream;
2922: }
2923:
2924: if (mrt->upstream != original_upstream_router) {
2925: mrt->flags |= MRTF_ASSERTED;
2926: SET_TIMER(mrt->assert_timer, PIM_ASSERT_TIMEOUT);
2927: } else {
2928: mrt->flags &= ~MRTF_ASSERTED;
2929: }
2930: }
2931:
2932: return TRUE;
2933: }
2934:
2935:
2936: int send_pim_assert(uint32_t source, uint32_t group, vifi_t vifi, mrtentry_t *mrt)
2937: {
2938: uint8_t *data;
2939: uint8_t *data_start;
2940: uint32_t local_preference;
2941: uint32_t local_metric;
2942: srcentry_t *srcentry __attribute__((unused));
2943:
2944: /* Don't send assert if the outgoing interface a tunnel or register vif */
2945: /* TODO: XXX: in the code above asserts are accepted over VIFF_TUNNEL.
2946: * Check if anything can go wrong if asserts are accepted and/or
2947: * sent over VIFF_TUNNEL.
2948: */
2949: if (uvifs[vifi].uv_flags & (VIFF_REGISTER | VIFF_TUNNEL))
2950: return FALSE;
2951:
2952: data = (uint8_t *)(pim_send_buf + sizeof(struct ip) + sizeof(pim_header_t));
2953: data_start = data;
2954: PUT_EGADDR(group, SINGLE_GRP_MSKLEN, 0, data);
2955: PUT_EUADDR(source, data);
2956:
2957: /* TODO: XXX: where to get the metric from: srcentry or mrt
2958: * or from the kernel?
2959: */
2960: if (mrt->flags & MRTF_PMBR) {
2961: /* (*,*,RP) */
2962: srcentry = mrt->source;
2963: /* TODO:
2964: set_incoming(srcentry, PIM_IIF_RP);
2965: */
2966: } else if (mrt->flags & MRTF_RP) {
2967: /* (*,G) or (S,G)RPbit (iif toward RP) */
2968: srcentry = mrt->group->active_rp_grp->rp->rpentry;
2969: /* TODO:
2970: set_incoming(srcentry, PIM_IIF_RP);
2971: */
2972: } else {
2973: /* (S,G) toward S */
2974: srcentry = mrt->source;
2975: /* TODO:
2976: set_incoming(srcentry, PIM_IIF_SOURCE);
2977: */
2978: }
2979:
2980: /* TODO: check again!
2981: local_metric = srcentry->metric;
2982: local_preference = srcentry->preference;
2983: */
2984: local_metric = mrt->metric;
2985: local_preference = mrt->preference;
2986:
2987: if (mrt->flags & MRTF_RP)
2988: local_preference |= PIM_ASSERT_RPT_BIT;
2989: PUT_HOSTLONG(local_preference, data);
2990: PUT_HOSTLONG(local_metric, data);
2991:
2992: logit(LOG_INFO, 0, "Send PIM ASSERT from %s for group %s and source %s",
2993: inet_fmt(uvifs[vifi].uv_lcl_addr, s1, sizeof(s1)),
2994: inet_fmt(group, s2, sizeof(s2)),
2995: inet_fmt(source, s3, sizeof(s3)));
2996:
2997: send_pim(pim_send_buf, uvifs[vifi].uv_lcl_addr, allpimrouters_group,
2998: PIM_ASSERT, data - data_start);
2999:
3000: return TRUE;
3001: }
3002:
3003:
3004: /* Return TRUE if the local win, otherwise FALSE */
3005: static int compare_metrics(uint32_t local_preference, uint32_t local_metric, uint32_t local_address,
3006: uint32_t remote_preference, uint32_t remote_metric, uint32_t remote_address)
3007: {
3008: /* Now lets see who has a smaller gun (aka "asserts war") */
3009: /* FYI, the smaller gun...err metric wins, but if the same
3010: * caliber, then the bigger network address wins. The order of
3011: * threatment is: preference, metric, address.
3012: */
3013: /* The RPT bits are already included as the most significant bits
3014: * of the preferences.
3015: */
3016: if (remote_preference > local_preference)
3017: return TRUE;
3018:
3019: if (remote_preference < local_preference)
3020: return FALSE;
3021:
3022: if (remote_metric > local_metric)
3023: return TRUE;
3024:
3025: if (remote_metric < local_metric)
3026: return FALSE;
3027:
3028: if (ntohl(local_address) > ntohl(remote_address))
3029: return TRUE;
3030:
3031: return FALSE;
3032: }
3033:
3034:
3035: /************************************************************************
3036: * PIM_BOOTSTRAP
3037: ************************************************************************/
3038: #define PIM_BOOTSTRAP_MINLEN (PIM_MINLEN + PIM_ENCODE_UNI_ADDR_LEN)
3039: int receive_pim_bootstrap(uint32_t src, uint32_t dst, char *msg, size_t len)
3040: {
3041: uint8_t *data;
3042: uint8_t *max_data;
3043: uint16_t new_bsr_fragment_tag;
3044: uint8_t new_bsr_hash_masklen;
3045: uint8_t new_bsr_priority;
3046: pim_encod_uni_addr_t new_bsr_uni_addr;
3047: uint32_t new_bsr_address;
3048: struct rpfctl rpfc;
3049: pim_nbr_entry_t *n, *rpf_neighbor __attribute__((unused));
3050: uint32_t neighbor_addr;
3051: vifi_t vifi, incoming = NO_VIF;
3052: int min_datalen;
3053: pim_encod_grp_addr_t curr_group_addr;
3054: pim_encod_uni_addr_t curr_rp_addr;
3055: uint8_t curr_rp_count;
3056: uint8_t curr_frag_rp_count;
3057: uint16_t reserved_short __attribute__((unused));
3058: uint16_t curr_rp_holdtime;
3059: uint8_t curr_rp_priority;
3060: uint8_t reserved_byte __attribute__((unused));
3061: uint32_t curr_group_mask;
3062: uint32_t prefix_h;
3063: grp_mask_t *grp_mask;
3064: grp_mask_t *grp_mask_next;
3065: rp_grp_entry_t *grp_rp;
3066: rp_grp_entry_t *grp_rp_next;
3067:
3068: /* Checksum */
3069: if (inet_cksum((uint16_t *)msg, len))
3070: return FALSE;
3071:
3072: if (find_vif_direct(src) == NO_VIF) {
3073: /* Either a local vif or somehow received PIM_BOOTSTRAP from
3074: * non-directly connected router. Ignore it.
3075: */
3076: if (local_address(src) == NO_VIF)
3077: logit(LOG_DEBUG, 0, "Ignoring PIM_BOOTSTRAP from non-neighbor router %s",
3078: inet_fmt(src, s1, sizeof(s1)));
3079:
3080: return FALSE;
3081: }
3082:
3083: /* sanity check for the minimum length */
3084: if (len < PIM_BOOTSTRAP_MINLEN) {
3085: logit(LOG_NOTICE, 0, "receive_pim_bootstrap: Bootstrap message size(%u) is too short from %s",
3086: len, inet_fmt(src, s1, sizeof(s1)));
3087:
3088: return FALSE;
3089: }
3090:
3091: data = (uint8_t *)(msg + sizeof(pim_header_t));
3092:
3093: /* Parse the PIM_BOOTSTRAP message */
3094: GET_HOSTSHORT(new_bsr_fragment_tag, data);
3095: GET_BYTE(new_bsr_hash_masklen, data);
3096: GET_BYTE(new_bsr_priority, data);
3097: GET_EUADDR(&new_bsr_uni_addr, data);
3098: new_bsr_address = new_bsr_uni_addr.unicast_addr;
3099:
3100: if (local_address(new_bsr_address) != NO_VIF)
3101: return FALSE; /* The new BSR is one of my local addresses */
3102:
3103: /*
3104: * Compare the current BSR priority with the priority of the BSR
3105: * included in the message.
3106: */
3107: /* TODO: if I am just starting and will become the BSR,
3108: * I should accept the message coming from the current BSR and get the
3109: * current Cand-RP-Set.
3110: */
3111: if ((curr_bsr_priority > new_bsr_priority) ||
3112: ((curr_bsr_priority == new_bsr_priority)
3113: && (ntohl(curr_bsr_address) > ntohl(new_bsr_address)))) {
3114: /* The message's BSR is less preferred than the current BSR */
3115: return FALSE; /* Ignore the received BSR message */
3116: }
3117:
3118: logit(LOG_INFO, 0, "Received PIM Bootstrap candidate %s, priority %d",
3119: inet_fmt(new_bsr_address, s1, sizeof(s1)), new_bsr_priority);
3120:
3121: /* Check the iif, if this was PIM-ROUTERS multicast */
3122: if (dst == allpimrouters_group) {
3123: k_req_incoming(new_bsr_address, &rpfc);
3124: if (rpfc.iif == NO_VIF || rpfc.rpfneighbor.s_addr == INADDR_ANY_N) {
3125: /* coudn't find a route to the BSR */
3126: return FALSE;
3127: }
3128:
3129: neighbor_addr = rpfc.rpfneighbor.s_addr;
3130: incoming = rpfc.iif;
3131: if (uvifs[incoming].uv_flags & (VIFF_DISABLED | VIFF_DOWN | VIFF_REGISTER))
3132: return FALSE; /* Shoudn't arrive on that interface */
3133:
3134: /* Find the upstream router */
3135: for (n = uvifs[incoming].uv_pim_neighbors; n; n = n->next) {
3136: if (ntohl(neighbor_addr) < ntohl(n->address))
3137: continue;
3138:
3139: if (neighbor_addr == n->address) {
3140: rpf_neighbor = n;
3141: break;
3142: }
3143:
3144: return FALSE; /* No neighbor toward BSR found */
3145: }
3146:
3147: if (!n || n->address != src)
3148: return FALSE; /* Sender of this message is not the RPF neighbor */
3149:
3150: } else {
3151: if (local_address(dst) == NO_VIF) {
3152: /* TODO: XXX: this situation should be handled earlier:
3153: * The destination is neither ALL_PIM_ROUTERS neither me
3154: */
3155: return FALSE;
3156: }
3157:
3158: /* Probably unicasted from the current DR */
3159: if (cand_rp_list) {
3160: /* Hmmm, I do have a Cand-RP-list, but some neighbor has a
3161: * different opinion and is unicasting it to me. Ignore this guy.
3162: */
3163: return FALSE;
3164: }
3165:
3166: for (vifi = 0; vifi < numvifs; vifi++) {
3167: if (uvifs[vifi].uv_flags & (VIFF_DISABLED | VIFF_DOWN | VIFF_REGISTER))
3168: continue;
3169:
3170: if (uvifs[vifi].uv_lcl_addr == dst) {
3171: incoming = vifi;
3172: break;
3173: }
3174: }
3175:
3176: if (incoming == NO_VIF) {
3177: /* Cannot find the receiving iif toward that DR */
3178: IF_DEBUG(DEBUG_RPF | DEBUG_PIM_BOOTSTRAP)
3179: logit(LOG_DEBUG, 0, "Unicast boostrap message from %s to ignored: cannot find iif",
3180: inet_fmt(src, s1, sizeof(s1)), inet_fmt(dst, s2, sizeof(s2)));
3181:
3182: return FALSE;
3183: }
3184: /* TODO: check the sender is directly connected and I am really the DR */
3185: }
3186:
3187: if (cand_rp_flag == TRUE) {
3188: /* If change in the BSR address, schedule immediate Cand-RP-Adv */
3189: /* TODO: use some random delay? */
3190: if (new_bsr_address != curr_bsr_address)
3191: SET_TIMER(pim_cand_rp_adv_timer, 0);
3192: }
3193:
3194: /* Forward the BSR Message first and then update the RP-set list */
3195: /* TODO: if the message was unicasted to me, resend? */
3196: for (vifi = 0; vifi < numvifs; vifi++) {
3197: if (vifi == incoming)
3198: continue;
3199:
3200: if (uvifs[vifi].uv_flags & (VIFF_DISABLED | VIFF_DOWN | VIFF_REGISTER | VIFF_NONBRS))
3201: continue;
3202:
3203: memcpy(pim_send_buf + sizeof(struct ip), msg, len);
3204: send_pim(pim_send_buf, uvifs[vifi].uv_lcl_addr, allpimrouters_group,
3205: PIM_BOOTSTRAP, len - sizeof(pim_header_t));
3206: }
3207:
3208: max_data = (uint8_t *)msg + len;
3209: /* TODO: XXX: this 22 is HARDCODING!!! Do a bunch of definitions
3210: * and make it stylish!
3211: */
3212: min_datalen = 22;
3213:
3214: if (new_bsr_fragment_tag != curr_bsr_fragment_tag || new_bsr_address != curr_bsr_address) {
3215: /* Throw away the old segment */
3216: delete_rp_list(&segmented_cand_rp_list, &segmented_grp_mask_list);
3217: }
3218:
3219: curr_bsr_address = new_bsr_address;
3220: curr_bsr_priority = new_bsr_priority;
3221: curr_bsr_fragment_tag = new_bsr_fragment_tag;
3222: MASKLEN_TO_MASK(new_bsr_hash_masklen, curr_bsr_hash_mask);
3223: SET_TIMER(pim_bootstrap_timer, PIM_BOOTSTRAP_TIMEOUT);
3224:
3225: while (data + min_datalen <= max_data) {
3226: GET_EGADDR(&curr_group_addr, data);
3227: GET_BYTE(curr_rp_count, data);
3228: GET_BYTE(curr_frag_rp_count, data);
3229: GET_HOSTSHORT(reserved_short, data);
3230: MASKLEN_TO_MASK(curr_group_addr.masklen, curr_group_mask);
3231: if (curr_rp_count == 0) {
3232: delete_grp_mask(&cand_rp_list, &grp_mask_list,
3233: curr_group_addr.mcast_addr, curr_group_mask);
3234: continue;
3235: }
3236:
3237: if (curr_rp_count == curr_frag_rp_count) {
3238: /* Add all RPs */
3239: while (curr_frag_rp_count--) {
3240: GET_EUADDR(&curr_rp_addr, data);
3241: GET_HOSTSHORT(curr_rp_holdtime, data);
3242: GET_BYTE(curr_rp_priority, data);
3243: GET_BYTE(reserved_byte, data);
3244: MASKLEN_TO_MASK(curr_group_addr.masklen, curr_group_mask);
3245: add_rp_grp_entry(&cand_rp_list, &grp_mask_list,
3246: curr_rp_addr.unicast_addr, curr_rp_priority,
3247: curr_rp_holdtime, curr_group_addr.mcast_addr,
3248: curr_group_mask,
3249: curr_bsr_hash_mask,
3250: curr_bsr_fragment_tag);
3251: }
3252: continue;
3253: }
3254:
3255: /*
3256: * This is a partial list of the RPs for this group prefix.
3257: * Save until all segments arrive.
3258: */
3259: prefix_h = ntohl(curr_group_addr.mcast_addr & curr_group_mask);
3260: for (grp_mask = segmented_grp_mask_list; grp_mask; grp_mask = grp_mask->next) {
3261: if (ntohl(grp_mask->group_addr & grp_mask->group_mask) > prefix_h)
3262: continue;
3263:
3264: break;
3265: }
3266:
3267: if (grp_mask
3268: && (grp_mask->group_addr == curr_group_addr.mcast_addr)
3269: && (grp_mask->group_mask == curr_group_mask)
3270: && (grp_mask->group_rp_number + curr_frag_rp_count == curr_rp_count)) {
3271: /* All missing PRs have arrived. Add all RP entries */
3272: while (curr_frag_rp_count--) {
3273: GET_EUADDR(&curr_rp_addr, data);
3274: GET_HOSTSHORT(curr_rp_holdtime, data);
3275: GET_BYTE(curr_rp_priority, data);
3276: GET_BYTE(reserved_byte, data);
3277: MASKLEN_TO_MASK(curr_group_addr.masklen, curr_group_mask);
3278: add_rp_grp_entry(&cand_rp_list,
3279: &grp_mask_list,
3280: curr_rp_addr.unicast_addr,
3281: curr_rp_priority,
3282: curr_rp_holdtime,
3283: curr_group_addr.mcast_addr,
3284: curr_group_mask,
3285: curr_bsr_hash_mask,
3286: curr_bsr_fragment_tag);
3287: }
3288:
3289: /* Add the rest from the previously saved segments */
3290: for (grp_rp = grp_mask->grp_rp_next; grp_rp; grp_rp = grp_rp->grp_rp_next) {
3291: add_rp_grp_entry(&cand_rp_list,
3292: &grp_mask_list,
3293: grp_rp->rp->rpentry->address,
3294: grp_rp->priority,
3295: grp_rp->holdtime,
3296: curr_group_addr.mcast_addr,
3297: curr_group_mask,
3298: curr_bsr_hash_mask,
3299: curr_bsr_fragment_tag);
3300: }
3301: delete_grp_mask(&segmented_cand_rp_list,
3302: &segmented_grp_mask_list,
3303: curr_group_addr.mcast_addr,
3304: curr_group_mask);
3305: } else {
3306: /* Add the partially received RP-list to the group of pending RPs*/
3307: while (curr_frag_rp_count--) {
3308: GET_EUADDR(&curr_rp_addr, data);
3309: GET_HOSTSHORT(curr_rp_holdtime, data);
3310: GET_BYTE(curr_rp_priority, data);
3311: GET_BYTE(reserved_byte, data);
3312: MASKLEN_TO_MASK(curr_group_addr.masklen, curr_group_mask);
3313: add_rp_grp_entry(&segmented_cand_rp_list,
3314: &segmented_grp_mask_list,
3315: curr_rp_addr.unicast_addr,
3316: curr_rp_priority,
3317: curr_rp_holdtime,
3318: curr_group_addr.mcast_addr,
3319: curr_group_mask,
3320: curr_bsr_hash_mask,
3321: curr_bsr_fragment_tag);
3322: }
3323: }
3324: }
3325:
3326: /* Garbage collection. Check all group prefixes and if the
3327: * fragment_tag for a group-prefix is the same as curr_bsr_fragment_tag,
3328: * then remove all RPs for this group-prefix which have different
3329: * fragment tag.
3330: */
3331: for (grp_mask = grp_mask_list; grp_mask; grp_mask = grp_mask_next) {
3332: grp_mask_next = grp_mask->next;
3333:
3334: if (grp_mask->fragment_tag == curr_bsr_fragment_tag) {
3335: for (grp_rp = grp_mask->grp_rp_next; grp_rp; grp_rp = grp_rp_next) {
3336: grp_rp_next = grp_rp->grp_rp_next;
3337:
3338: if (grp_rp->fragment_tag != curr_bsr_fragment_tag)
3339: delete_rp_grp_entry(&cand_rp_list, &grp_mask_list, grp_rp);
3340: }
3341: }
3342: }
3343:
3344: /* Cleanup also the list used by incompleted segments */
3345: for (grp_mask = segmented_grp_mask_list; grp_mask; grp_mask = grp_mask_next) {
3346: grp_mask_next = grp_mask->next;
3347:
3348: if (grp_mask->fragment_tag == curr_bsr_fragment_tag) {
3349: for (grp_rp = grp_mask->grp_rp_next; grp_rp; grp_rp = grp_rp_next) {
3350: grp_rp_next = grp_rp->grp_rp_next;
3351:
3352: if (grp_rp->fragment_tag != curr_bsr_fragment_tag)
3353: delete_rp_grp_entry(&segmented_cand_rp_list, &segmented_grp_mask_list, grp_rp);
3354: }
3355: }
3356: }
3357:
3358: return TRUE;
3359: }
3360:
3361:
3362: void send_pim_bootstrap(void)
3363: {
3364: size_t len;
3365: vifi_t vifi;
3366:
3367: if ((len = create_pim_bootstrap_message(pim_send_buf))) {
3368: for (vifi = 0; vifi < numvifs; vifi++) {
3369: if (uvifs[vifi].uv_flags & (VIFF_DISABLED | VIFF_DOWN | VIFF_REGISTER))
3370: continue;
3371:
3372: send_pim(pim_send_buf, uvifs[vifi].uv_lcl_addr,
3373: allpimrouters_group, PIM_BOOTSTRAP, len);
3374: }
3375: }
3376: }
3377:
3378:
3379: /************************************************************************
3380: * PIM_CAND_RP_ADV
3381: ************************************************************************/
3382: /*
3383: * If I am the Bootstrap router, process the advertisement, otherwise
3384: * ignore it.
3385: */
3386: #define PIM_CAND_RP_ADV_MINLEN (PIM_MINLEN + PIM_ENCODE_UNI_ADDR_LEN)
3387: int receive_pim_cand_rp_adv(uint32_t src, uint32_t dst __attribute__((unused)), char *msg, size_t len)
3388: {
3389: uint8_t prefix_cnt;
3390: uint8_t priority;
3391: uint16_t holdtime;
3392: pim_encod_uni_addr_t euaddr;
3393: pim_encod_grp_addr_t egaddr;
3394: uint8_t *data_ptr;
3395: uint32_t grp_mask;
3396:
3397: /* Checksum */
3398: if (inet_cksum((uint16_t *)msg, len))
3399: return FALSE;
3400:
3401: /* if I am not the bootstrap RP, then do not accept the message */
3402: if (cand_bsr_flag == FALSE || curr_bsr_address != my_bsr_address)
3403: return FALSE;
3404:
3405: /* sanity check for the minimum length */
3406: if (len < PIM_CAND_RP_ADV_MINLEN) {
3407: logit(LOG_NOTICE, 0, "%s(): cand_RP message size(%u) is too short from %s",
3408: __func__, len, inet_fmt(src, s1, sizeof(s1)));
3409:
3410: return FALSE;
3411: }
3412:
3413: data_ptr = (uint8_t *)(msg + sizeof(pim_header_t));
3414: /* Parse the CAND_RP_ADV message */
3415: /* TODO: XXX: check len whether it is at least the minimum */
3416: GET_BYTE(prefix_cnt, data_ptr);
3417: GET_BYTE(priority, data_ptr);
3418: GET_HOSTSHORT(holdtime, data_ptr);
3419: GET_EUADDR(&euaddr, data_ptr);
3420: if (prefix_cnt == 0) {
3421: /* The default 224.0.0.0 and masklen of 4 */
3422: MASKLEN_TO_MASK(ALL_MCAST_GROUPS_LEN, grp_mask);
3423: add_rp_grp_entry(&cand_rp_list, &grp_mask_list,
3424: euaddr.unicast_addr, priority, holdtime,
3425: htonl(ALL_MCAST_GROUPS_ADDR), grp_mask,
3426: my_bsr_hash_mask,
3427: curr_bsr_fragment_tag);
3428:
3429: return TRUE;
3430: }
3431:
3432: while (prefix_cnt--) {
3433: GET_EGADDR(&egaddr, data_ptr);
3434: MASKLEN_TO_MASK(egaddr.masklen, grp_mask);
3435: /* Do not advertise internal virtual RP for SSM groups */
3436: if (!IN_PIM_SSM_RANGE(egaddr.mcast_addr)) {
3437: add_rp_grp_entry(&cand_rp_list, &grp_mask_list,
3438: euaddr.unicast_addr, priority, holdtime,
3439: egaddr.mcast_addr, grp_mask,
3440: my_bsr_hash_mask,
3441: curr_bsr_fragment_tag);
3442: }
3443: /* TODO: Check for len */
3444: }
3445:
3446: return TRUE;
3447: }
3448:
3449:
3450: int send_pim_cand_rp_adv(void)
3451: {
3452: uint8_t prefix_cnt;
3453: uint32_t mask;
3454: pim_encod_grp_addr_t addr;
3455: uint8_t *data;
3456:
3457: if (!inet_valid_host(curr_bsr_address))
3458: return FALSE; /* No BSR yet */
3459:
3460: if (curr_bsr_address == my_bsr_address) {
3461: /* I am the BSR and have to include my own group-prefix stuff */
3462: prefix_cnt = *cand_rp_adv_message.prefix_cnt_ptr;
3463: if (prefix_cnt == 0) {
3464: /* The default 224.0.0.0 and masklen of 4 */
3465: MASKLEN_TO_MASK(ALL_MCAST_GROUPS_LEN, mask);
3466: add_rp_grp_entry(&cand_rp_list, &grp_mask_list,
3467: my_cand_rp_address, my_cand_rp_priority,
3468: my_cand_rp_holdtime,
3469: htonl(ALL_MCAST_GROUPS_ADDR), mask,
3470: my_bsr_hash_mask,
3471: curr_bsr_fragment_tag);
3472: return TRUE;
3473: }
3474:
3475: /* TODO: hardcoding!! */
3476: data = cand_rp_adv_message.buffer + (4 + 6);
3477: while (prefix_cnt--) {
3478: GET_EGADDR(&addr, data);
3479: MASKLEN_TO_MASK(addr.masklen, mask);
3480: add_rp_grp_entry(&cand_rp_list,
3481: &grp_mask_list,
3482: my_cand_rp_address, my_cand_rp_priority,
3483: my_cand_rp_holdtime,
3484: addr.mcast_addr, mask,
3485: my_bsr_hash_mask,
3486: curr_bsr_fragment_tag);
3487: /* TODO: Check for len */
3488: }
3489:
3490: return TRUE;
3491: }
3492:
3493: data = (uint8_t *)(pim_send_buf + sizeof(struct ip) + sizeof(pim_header_t));
3494: memcpy(data, cand_rp_adv_message.buffer, cand_rp_adv_message.message_size);
3495: send_pim_unicast(pim_send_buf, 0, my_cand_rp_address, curr_bsr_address,
3496: PIM_CAND_RP_ADV, cand_rp_adv_message.message_size);
3497:
3498: return TRUE;
3499: }
3500:
3501: /**
3502: * Local Variables:
3503: * version-control: t
3504: * indent-tabs-mode: t
3505: * c-file-style: "ellemtel"
3506: * c-basic-offset: 4
3507: * End:
3508: */
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 / pimd