1: /*
2: PIM for Quagga
3: Copyright (C) 2008 Everton da Silva Marques
4:
5: This program is free software; you can redistribute it and/or modify
6: it under the terms of the GNU General Public License as published by
7: the Free Software Foundation; either version 2 of the License, or
8: (at your option) any later version.
9:
10: This program is distributed in the hope that it will be useful, but
11: WITHOUT ANY WARRANTY; without even the implied warranty of
12: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13: General Public License for more details.
14:
15: You should have received a copy of the GNU General Public License
16: along with this program; see the file COPYING; if not, write to the
17: Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
18: MA 02110-1301 USA
19:
20: $QuaggaId: $Format:%an, %ai, %h$ $
21: */
22:
23: #include <zebra.h>
24:
25: #include "log.h"
26: #include "prefix.h"
27:
28: #include "pimd.h"
29: #include "pim_int.h"
30: #include "pim_tlv.h"
31: #include "pim_str.h"
32: #include "pim_msg.h"
33:
34: uint8_t *pim_tlv_append_uint16(uint8_t *buf,
35: const uint8_t *buf_pastend,
36: uint16_t option_type,
37: uint16_t option_value)
38: {
39: uint16_t option_len = 2;
40:
41: if ((buf + PIM_TLV_OPTION_SIZE(option_len)) > buf_pastend)
42: return NULL;
43:
44: *(uint16_t *) buf = htons(option_type);
45: buf += 2;
46: *(uint16_t *) buf = htons(option_len);
47: buf += 2;
48: *(uint16_t *) buf = htons(option_value);
49: buf += option_len;
50:
51: return buf;
52: }
53:
54: uint8_t *pim_tlv_append_2uint16(uint8_t *buf,
55: const uint8_t *buf_pastend,
56: uint16_t option_type,
57: uint16_t option_value1,
58: uint16_t option_value2)
59: {
60: uint16_t option_len = 4;
61:
62: if ((buf + PIM_TLV_OPTION_SIZE(option_len)) > buf_pastend)
63: return NULL;
64:
65: *(uint16_t *) buf = htons(option_type);
66: buf += 2;
67: *(uint16_t *) buf = htons(option_len);
68: buf += 2;
69: *(uint16_t *) buf = htons(option_value1);
70: buf += 2;
71: *(uint16_t *) buf = htons(option_value2);
72: buf += 2;
73:
74: return buf;
75: }
76:
77: uint8_t *pim_tlv_append_uint32(uint8_t *buf,
78: const uint8_t *buf_pastend,
79: uint16_t option_type,
80: uint32_t option_value)
81: {
82: uint16_t option_len = 4;
83:
84: if ((buf + PIM_TLV_OPTION_SIZE(option_len)) > buf_pastend)
85: return NULL;
86:
87: *(uint16_t *) buf = htons(option_type);
88: buf += 2;
89: *(uint16_t *) buf = htons(option_len);
90: buf += 2;
91: pim_write_uint32(buf, option_value);
92: buf += option_len;
93:
94: return buf;
95: }
96:
97: #define ucast_ipv4_encoding_len (2 + sizeof(struct in_addr))
98:
99: uint8_t *pim_tlv_append_addrlist_ucast(uint8_t *buf,
100: const uint8_t *buf_pastend,
101: struct list *ifconnected)
102: {
103: struct listnode *node;
104: uint16_t option_len = 0;
105:
106: uint8_t *curr;
107:
108: node = listhead(ifconnected);
109:
110: /* Empty address list ? */
111: if (!node) {
112: return buf;
113: }
114:
115: /* Skip first address (primary) */
116: node = listnextnode(node);
117:
118: /* Scan secondary address list */
119: curr = buf + 4; /* skip T and L */
120: for (; node; node = listnextnode(node)) {
121: struct connected *ifc = listgetdata(node);
122: struct prefix *p = ifc->address;
123:
124: if (p->family != AF_INET)
125: continue;
126:
127: if ((curr + ucast_ipv4_encoding_len) > buf_pastend)
128: return 0;
129:
130: /* Write encoded unicast IPv4 address */
131: *(uint8_t *) curr = PIM_MSG_ADDRESS_FAMILY_IPV4; /* notice: AF_INET != PIM_MSG_ADDRESS_FAMILY_IPV4 */
132: ++curr;
133: *(uint8_t *) curr = 0; /* ucast IPv4 native encoding type (RFC 4601: 4.9.1) */
134: ++curr;
135: memcpy(curr, &p->u.prefix4, sizeof(struct in_addr));
136: curr += sizeof(struct in_addr);
137:
138: option_len += ucast_ipv4_encoding_len;
139: }
140:
141: if (PIM_DEBUG_PIM_TRACE) {
142: zlog_debug("%s: number of encoded secondary unicast IPv4 addresses: %zu",
143: __PRETTY_FUNCTION__,
144: option_len / ucast_ipv4_encoding_len);
145: }
146:
147: if (option_len < 1) {
148: /* Empty secondary unicast IPv4 address list */
149: return buf;
150: }
151:
152: /*
153: * Write T and L
154: */
155: *(uint16_t *) buf = htons(PIM_MSG_OPTION_TYPE_ADDRESS_LIST);
156: *(uint16_t *) (buf + 2) = htons(option_len);
157:
158: return curr;
159: }
160:
161: static int check_tlv_length(const char *label, const char *tlv_name,
162: const char *ifname, struct in_addr src_addr,
163: int correct_len, int option_len)
164: {
165: if (option_len != correct_len) {
166: char src_str[100];
167: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
168: zlog_warn("%s: PIM hello %s TLV with incorrect value size=%d correct=%d from %s on interface %s",
169: label, tlv_name,
170: option_len, correct_len,
171: src_str, ifname);
172: return -1;
173: }
174:
175: return 0;
176: }
177:
178: static void check_tlv_redefinition_uint16(const char *label, const char *tlv_name,
179: const char *ifname, struct in_addr src_addr,
180: pim_hello_options options,
181: pim_hello_options opt_mask,
182: uint16_t new, uint16_t old)
183: {
184: if (PIM_OPTION_IS_SET(options, opt_mask)) {
185: char src_str[100];
186: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
187: zlog_warn("%s: PIM hello TLV redefined %s=%u old=%u from %s on interface %s",
188: label, tlv_name,
189: new, old,
190: src_str, ifname);
191: }
192: }
193:
194: static void check_tlv_redefinition_uint32(const char *label, const char *tlv_name,
195: const char *ifname, struct in_addr src_addr,
196: pim_hello_options options,
197: pim_hello_options opt_mask,
198: uint32_t new, uint32_t old)
199: {
200: if (PIM_OPTION_IS_SET(options, opt_mask)) {
201: char src_str[100];
202: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
203: zlog_warn("%s: PIM hello TLV redefined %s=%u old=%u from %s on interface %s",
204: label, tlv_name,
205: new, old,
206: src_str, ifname);
207: }
208: }
209:
210: static void check_tlv_redefinition_uint32_hex(const char *label, const char *tlv_name,
211: const char *ifname, struct in_addr src_addr,
212: pim_hello_options options,
213: pim_hello_options opt_mask,
214: uint32_t new, uint32_t old)
215: {
216: if (PIM_OPTION_IS_SET(options, opt_mask)) {
217: char src_str[100];
218: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
219: zlog_warn("%s: PIM hello TLV redefined %s=%08x old=%08x from %s on interface %s",
220: label, tlv_name,
221: new, old,
222: src_str, ifname);
223: }
224: }
225:
226: int pim_tlv_parse_holdtime(const char *ifname, struct in_addr src_addr,
227: pim_hello_options *hello_options,
228: uint16_t *hello_option_holdtime,
229: uint16_t option_len,
230: const uint8_t *tlv_curr)
231: {
232: const char *label = "holdtime";
233:
234: if (check_tlv_length(__PRETTY_FUNCTION__, label,
235: ifname, src_addr,
236: sizeof(uint16_t), option_len)) {
237: return -1;
238: }
239:
240: check_tlv_redefinition_uint16(__PRETTY_FUNCTION__, label,
241: ifname, src_addr,
242: *hello_options, PIM_OPTION_MASK_HOLDTIME,
243: PIM_TLV_GET_HOLDTIME(tlv_curr),
244: *hello_option_holdtime);
245:
246: PIM_OPTION_SET(*hello_options, PIM_OPTION_MASK_HOLDTIME);
247:
248: *hello_option_holdtime = PIM_TLV_GET_HOLDTIME(tlv_curr);
249:
250: return 0;
251: }
252:
253: int pim_tlv_parse_lan_prune_delay(const char *ifname, struct in_addr src_addr,
254: pim_hello_options *hello_options,
255: uint16_t *hello_option_propagation_delay,
256: uint16_t *hello_option_override_interval,
257: uint16_t option_len,
258: const uint8_t *tlv_curr)
259: {
260: if (check_tlv_length(__PRETTY_FUNCTION__, "lan_prune_delay",
261: ifname, src_addr,
262: sizeof(uint32_t), option_len)) {
263: return -1;
264: }
265:
266: check_tlv_redefinition_uint16(__PRETTY_FUNCTION__, "propagation_delay",
267: ifname, src_addr,
268: *hello_options, PIM_OPTION_MASK_LAN_PRUNE_DELAY,
269: PIM_TLV_GET_PROPAGATION_DELAY(tlv_curr),
270: *hello_option_propagation_delay);
271:
272: PIM_OPTION_SET(*hello_options, PIM_OPTION_MASK_LAN_PRUNE_DELAY);
273:
274: *hello_option_propagation_delay = PIM_TLV_GET_PROPAGATION_DELAY(tlv_curr);
275: if (PIM_TLV_GET_CAN_DISABLE_JOIN_SUPPRESSION(tlv_curr)) {
276: PIM_OPTION_SET(*hello_options, PIM_OPTION_MASK_CAN_DISABLE_JOIN_SUPPRESSION);
277: }
278: else {
279: PIM_OPTION_UNSET(*hello_options, PIM_OPTION_MASK_CAN_DISABLE_JOIN_SUPPRESSION);
280: }
281: ++tlv_curr;
282: ++tlv_curr;
283: *hello_option_override_interval = PIM_TLV_GET_OVERRIDE_INTERVAL(tlv_curr);
284:
285: return 0;
286: }
287:
288: int pim_tlv_parse_dr_priority(const char *ifname, struct in_addr src_addr,
289: pim_hello_options *hello_options,
290: uint32_t *hello_option_dr_priority,
291: uint16_t option_len,
292: const uint8_t *tlv_curr)
293: {
294: const char *label = "dr_priority";
295:
296: if (check_tlv_length(__PRETTY_FUNCTION__, label,
297: ifname, src_addr,
298: sizeof(uint32_t), option_len)) {
299: return -1;
300: }
301:
302: check_tlv_redefinition_uint32(__PRETTY_FUNCTION__, label,
303: ifname, src_addr,
304: *hello_options, PIM_OPTION_MASK_DR_PRIORITY,
305: PIM_TLV_GET_DR_PRIORITY(tlv_curr),
306: *hello_option_dr_priority);
307:
308: PIM_OPTION_SET(*hello_options, PIM_OPTION_MASK_DR_PRIORITY);
309:
310: *hello_option_dr_priority = PIM_TLV_GET_DR_PRIORITY(tlv_curr);
311:
312: return 0;
313: }
314:
315: int pim_tlv_parse_generation_id(const char *ifname, struct in_addr src_addr,
316: pim_hello_options *hello_options,
317: uint32_t *hello_option_generation_id,
318: uint16_t option_len,
319: const uint8_t *tlv_curr)
320: {
321: const char *label = "generation_id";
322:
323: if (check_tlv_length(__PRETTY_FUNCTION__, label,
324: ifname, src_addr,
325: sizeof(uint32_t), option_len)) {
326: return -1;
327: }
328:
329: check_tlv_redefinition_uint32_hex(__PRETTY_FUNCTION__, label,
330: ifname, src_addr,
331: *hello_options, PIM_OPTION_MASK_GENERATION_ID,
332: PIM_TLV_GET_GENERATION_ID(tlv_curr),
333: *hello_option_generation_id);
334:
335: PIM_OPTION_SET(*hello_options, PIM_OPTION_MASK_GENERATION_ID);
336:
337: *hello_option_generation_id = PIM_TLV_GET_GENERATION_ID(tlv_curr);
338:
339: return 0;
340: }
341:
342: int pim_parse_addr_ucast(const char *ifname, struct in_addr src_addr,
343: struct prefix *p,
344: const uint8_t *buf,
345: int buf_size)
346: {
347: const int ucast_encoding_min_len = 3; /* 1 family + 1 type + 1 addr */
348: const uint8_t *addr;
349: const uint8_t *pastend;
350: int family;
351: int type;
352:
353: if (buf_size < ucast_encoding_min_len) {
354: char src_str[100];
355: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
356: zlog_warn("%s: unicast address encoding overflow: left=%d needed=%d from %s on %s",
357: __PRETTY_FUNCTION__,
358: buf_size, ucast_encoding_min_len,
359: src_str, ifname);
360: return -1;
361: }
362:
363: addr = buf;
364: pastend = buf + buf_size;
365:
366: family = *addr++;
367: type = *addr++;
368:
369: switch (family) {
370: case PIM_MSG_ADDRESS_FAMILY_IPV4:
371: if (type) {
372: char src_str[100];
373: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
374: zlog_warn("%s: unknown unicast address encoding type=%d from %s on %s",
375: __PRETTY_FUNCTION__,
376: type, src_str, ifname);
377: return -2;
378: }
379:
380: if ((addr + sizeof(struct in_addr)) > pastend) {
381: char src_str[100];
382: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
383: zlog_warn("%s: IPv4 unicast address overflow: left=%zd needed=%zu from %s on %s",
384: __PRETTY_FUNCTION__,
385: pastend - addr, sizeof(struct in_addr),
386: src_str, ifname);
387: return -3;
388: }
389:
390: p->family = AF_INET; /* notice: AF_INET != PIM_MSG_ADDRESS_FAMILY_IPV4 */
391: memcpy(&p->u.prefix4, addr, sizeof(struct in_addr));
392:
393: addr += sizeof(struct in_addr);
394:
395: break;
396: default:
397: {
398: char src_str[100];
399: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
400: zlog_warn("%s: unknown unicast address encoding family=%d from %s on %s",
401: __PRETTY_FUNCTION__,
402: family, src_str, ifname);
403: return -4;
404: }
405: }
406:
407: return addr - buf;
408: }
409:
410: int pim_parse_addr_group(const char *ifname, struct in_addr src_addr,
411: struct prefix *p,
412: const uint8_t *buf,
413: int buf_size)
414: {
415: const int grp_encoding_min_len = 4; /* 1 family + 1 type + 1 reserved + 1 addr */
416: const uint8_t *addr;
417: const uint8_t *pastend;
418: int family;
419: int type;
420: int mask_len;
421:
422: if (buf_size < grp_encoding_min_len) {
423: char src_str[100];
424: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
425: zlog_warn("%s: group address encoding overflow: left=%d needed=%d from %s on %s",
426: __PRETTY_FUNCTION__,
427: buf_size, grp_encoding_min_len,
428: src_str, ifname);
429: return -1;
430: }
431:
432: addr = buf;
433: pastend = buf + buf_size;
434:
435: family = *addr++;
436: type = *addr++;
437: //++addr;
438: ++addr; /* skip b_reserved_z fields */
439: mask_len = *addr++;
440:
441: switch (family) {
442: case PIM_MSG_ADDRESS_FAMILY_IPV4:
443: if (type) {
444: char src_str[100];
445: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
446: zlog_warn("%s: unknown group address encoding type=%d from %s on %s",
447: __PRETTY_FUNCTION__,
448: type, src_str, ifname);
449: return -2;
450: }
451:
452: if ((addr + sizeof(struct in_addr)) > pastend) {
453: char src_str[100];
454: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
455: zlog_warn("%s: IPv4 group address overflow: left=%zd needed=%zu from %s on %s",
456: __PRETTY_FUNCTION__,
457: pastend - addr, sizeof(struct in_addr),
458: src_str, ifname);
459: return -3;
460: }
461:
462: p->family = AF_INET; /* notice: AF_INET != PIM_MSG_ADDRESS_FAMILY_IPV4 */
463: memcpy(&p->u.prefix4, addr, sizeof(struct in_addr));
464: p->prefixlen = mask_len;
465:
466: addr += sizeof(struct in_addr);
467:
468: break;
469: default:
470: {
471: char src_str[100];
472: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
473: zlog_warn("%s: unknown group address encoding family=%d from %s on %s",
474: __PRETTY_FUNCTION__,
475: family, src_str, ifname);
476: return -4;
477: }
478: }
479:
480: return addr - buf;
481: }
482:
483: int pim_parse_addr_source(const char *ifname,
484: struct in_addr src_addr,
485: struct prefix *p,
486: uint8_t *flags,
487: const uint8_t *buf,
488: int buf_size)
489: {
490: const int src_encoding_min_len = 4; /* 1 family + 1 type + 1 reserved + 1 addr */
491: const uint8_t *addr;
492: const uint8_t *pastend;
493: int family;
494: int type;
495: int mask_len;
496:
497: if (buf_size < src_encoding_min_len) {
498: char src_str[100];
499: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
500: zlog_warn("%s: source address encoding overflow: left=%d needed=%d from %s on %s",
501: __PRETTY_FUNCTION__,
502: buf_size, src_encoding_min_len,
503: src_str, ifname);
504: return -1;
505: }
506:
507: addr = buf;
508: pastend = buf + buf_size;
509:
510: family = *addr++;
511: type = *addr++;
512: *flags = *addr++;
513: mask_len = *addr++;
514:
515: switch (family) {
516: case PIM_MSG_ADDRESS_FAMILY_IPV4:
517: if (type) {
518: char src_str[100];
519: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
520: zlog_warn("%s: unknown source address encoding type=%d from %s on %s: %02x%02x%02x%02x%02x%02x%02x%02x",
521: __PRETTY_FUNCTION__,
522: type, src_str, ifname,
523: buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]);
524: return -2;
525: }
526:
527: if ((addr + sizeof(struct in_addr)) > pastend) {
528: char src_str[100];
529: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
530: zlog_warn("%s: IPv4 source address overflow: left=%zd needed=%zu from %s on %s",
531: __PRETTY_FUNCTION__,
532: pastend - addr, sizeof(struct in_addr),
533: src_str, ifname);
534: return -3;
535: }
536:
537: p->family = AF_INET; /* notice: AF_INET != PIM_MSG_ADDRESS_FAMILY_IPV4 */
538: memcpy(&p->u.prefix4, addr, sizeof(struct in_addr));
539: p->prefixlen = mask_len;
540:
541: /*
542: RFC 4601: 4.9.1 Encoded Source and Group Address Formats
543:
544: Encoded-Source Address
545:
546: The mask length MUST be equal to the mask length in bits for
547: the given Address Family and Encoding Type (32 for IPv4 native
548: and 128 for IPv6 native). A router SHOULD ignore any messages
549: received with any other mask length.
550: */
551: if (p->prefixlen != 32) {
552: char src_str[100];
553: pim_inet4_dump("<src?>", p->u.prefix4, src_str, sizeof(src_str));
554: zlog_warn("%s: IPv4 bad source address mask: %s/%d",
555: __PRETTY_FUNCTION__, src_str, p->prefixlen);
556: return -4;
557: }
558:
559: addr += sizeof(struct in_addr);
560:
561: break;
562: default:
563: {
564: char src_str[100];
565: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
566: zlog_warn("%s: unknown source address encoding family=%d from %s on %s: %02x%02x%02x%02x%02x%02x%02x%02x",
567: __PRETTY_FUNCTION__,
568: family, src_str, ifname,
569: buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]);
570: return -5;
571: }
572: }
573:
574: return addr - buf;
575: }
576:
577: #define FREE_ADDR_LIST(hello_option_addr_list) \
578: { \
579: if (hello_option_addr_list) { \
580: list_delete(hello_option_addr_list); \
581: hello_option_addr_list = 0; \
582: } \
583: }
584:
585: int pim_tlv_parse_addr_list(const char *ifname, struct in_addr src_addr,
586: pim_hello_options *hello_options,
587: struct list **hello_option_addr_list,
588: uint16_t option_len,
589: const uint8_t *tlv_curr)
590: {
591: const uint8_t *addr;
592: const uint8_t *pastend;
593:
594: zassert(hello_option_addr_list);
595:
596: /*
597: Scan addr list
598: */
599: addr = tlv_curr;
600: pastend = tlv_curr + option_len;
601: while (addr < pastend) {
602: struct prefix tmp;
603: int addr_offset;
604:
605: /*
606: Parse ucast addr
607: */
608: addr_offset = pim_parse_addr_ucast(ifname, src_addr, &tmp,
609: addr, pastend - addr);
610: if (addr_offset < 1) {
611: char src_str[100];
612: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
613: zlog_warn("%s: pim_parse_addr_ucast() failure: from %s on %s",
614: __PRETTY_FUNCTION__,
615: src_str, ifname);
616: FREE_ADDR_LIST(*hello_option_addr_list);
617: return -1;
618: }
619: addr += addr_offset;
620:
621: /*
622: Debug
623: */
624: if (PIM_DEBUG_PIM_TRACE) {
625: switch (tmp.family) {
626: case AF_INET:
627: {
628: char addr_str[100];
629: char src_str[100];
630: pim_inet4_dump("<addr?>", tmp.u.prefix4, addr_str, sizeof(addr_str));
631: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
632: zlog_debug("%s: PIM hello TLV option: list_old_size=%d IPv4 address %s from %s on %s",
633: __PRETTY_FUNCTION__,
634: *hello_option_addr_list ?
635: ((int) listcount(*hello_option_addr_list)) : -1,
636: addr_str, src_str, ifname);
637: }
638: break;
639: default:
640: {
641: char src_str[100];
642: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
643: zlog_debug("%s: PIM hello TLV option: list_old_size=%d UNKNOWN address family from %s on %s",
644: __PRETTY_FUNCTION__,
645: *hello_option_addr_list ?
646: ((int) listcount(*hello_option_addr_list)) : -1,
647: src_str, ifname);
648: }
649: }
650: }
651:
652: /*
653: Exclude neighbor's primary address if incorrectly included in
654: the secondary address list
655: */
656: if (tmp.family == AF_INET) {
657: if (tmp.u.prefix4.s_addr == src_addr.s_addr) {
658: char src_str[100];
659: pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
660: zlog_warn("%s: ignoring primary address in secondary list from %s on %s",
661: __PRETTY_FUNCTION__,
662: src_str, ifname);
663: continue;
664: }
665: }
666:
667: /*
668: Allocate list if needed
669: */
670: if (!*hello_option_addr_list) {
671: *hello_option_addr_list = list_new();
672: if (!*hello_option_addr_list) {
673: zlog_err("%s %s: failure: hello_option_addr_list=list_new()",
674: __FILE__, __PRETTY_FUNCTION__);
675: return -2;
676: }
677: (*hello_option_addr_list)->del = (void (*)(void *)) prefix_free;
678: }
679:
680: /*
681: Attach addr to list
682: */
683: {
684: struct prefix *p;
685: p = prefix_new();
686: if (!p) {
687: zlog_err("%s %s: failure: prefix_new()",
688: __FILE__, __PRETTY_FUNCTION__);
689: FREE_ADDR_LIST(*hello_option_addr_list);
690: return -3;
691: }
692: p->family = tmp.family;
693: p->u.prefix4 = tmp.u.prefix4;
694: listnode_add(*hello_option_addr_list, p);
695: }
696:
697: } /* while (addr < pastend) */
698:
699: /*
700: Mark hello option
701: */
702: PIM_OPTION_SET(*hello_options, PIM_OPTION_MASK_ADDRESS_LIST);
703:
704: return 0;
705: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pim_tlv.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / pimd