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 "thread.h"
27: #include "memory.h"
28:
29: #include "pimd.h"
30: #include "pim_pim.h"
31: #include "pim_time.h"
32: #include "pim_iface.h"
33: #include "pim_sock.h"
34: #include "pim_str.h"
35: #include "pim_util.h"
36: #include "pim_tlv.h"
37: #include "pim_neighbor.h"
38: #include "pim_hello.h"
39: #include "pim_join.h"
40: #include "pim_assert.h"
41: #include "pim_msg.h"
42:
43: static int on_pim_hello_send(struct thread *t);
44: static int pim_hello_send(struct interface *ifp,
45: uint16_t holdtime);
46:
47: static void sock_close(struct interface *ifp)
48: {
49: struct pim_interface *pim_ifp = ifp->info;
50:
51: if (PIM_DEBUG_PIM_TRACE) {
52: if (pim_ifp->t_pim_sock_read) {
53: zlog_debug("Cancelling READ event for PIM socket fd=%d on interface %s",
54: pim_ifp->pim_sock_fd,
55: ifp->name);
56: }
57: }
58: THREAD_OFF(pim_ifp->t_pim_sock_read);
59:
60: if (PIM_DEBUG_PIM_TRACE) {
61: if (pim_ifp->t_pim_hello_timer) {
62: zlog_debug("Cancelling PIM hello timer for interface %s",
63: ifp->name);
64: }
65: }
66: THREAD_OFF(pim_ifp->t_pim_hello_timer);
67:
68: if (PIM_DEBUG_PIM_TRACE) {
69: zlog_debug("Deleting PIM socket fd=%d on interface %s",
70: pim_ifp->pim_sock_fd, ifp->name);
71: }
72:
73: if (close(pim_ifp->pim_sock_fd)) {
74: zlog_warn("Failure closing PIM socket fd=%d on interface %s: errno=%d: %s",
75: pim_ifp->pim_sock_fd, ifp->name,
76: errno, safe_strerror(errno));
77: }
78:
79: pim_ifp->pim_sock_fd = -1;
80: pim_ifp->pim_sock_creation = 0;
81:
82: zassert(pim_ifp->pim_sock_fd < 0);
83: zassert(!pim_ifp->t_pim_sock_read);
84: zassert(!pim_ifp->t_pim_hello_timer);
85: zassert(!pim_ifp->pim_sock_creation);
86: }
87:
88: void pim_sock_delete(struct interface *ifp, const char *delete_message)
89: {
90: zlog_info("PIM INTERFACE DOWN: on interface %s: %s",
91: ifp->name, delete_message);
92:
93: if (!ifp->info) {
94: zlog_err("%s: %s: but PIM not enabled on interface %s (!)",
95: __PRETTY_FUNCTION__, delete_message, ifp->name);
96: return;
97: }
98:
99: /*
100: RFC 4601: 4.3.1. Sending Hello Messages
101:
102: Before an interface goes down or changes primary IP address, a Hello
103: message with a zero HoldTime should be sent immediately (with the
104: old IP address if the IP address changed).
105: */
106: pim_hello_send(ifp, 0 /* zero-sec holdtime */);
107:
108: pim_neighbor_delete_all(ifp, delete_message);
109:
110: sock_close(ifp);
111: }
112:
113: int pim_pim_packet(struct interface *ifp, uint8_t *buf, size_t len)
114: {
115: struct ip *ip_hdr;
116: size_t ip_hlen; /* ip header length in bytes */
117: char src_str[100];
118: char dst_str[100];
119: uint8_t *pim_msg;
120: int pim_msg_len;
121: uint8_t pim_version;
122: uint8_t pim_type;
123: uint16_t pim_checksum; /* received checksum */
124: uint16_t checksum; /* computed checksum */
125: struct pim_neighbor *neigh;
126:
127: if (!ifp->info) {
128: zlog_warn("%s: PIM not enabled on interface %s",
129: __PRETTY_FUNCTION__, ifp->name);
130: return -1;
131: }
132:
133: if (len < sizeof(*ip_hdr)) {
134: zlog_warn("PIM packet size=%zu shorter than minimum=%zu",
135: len, sizeof(*ip_hdr));
136: return -1;
137: }
138:
139: ip_hdr = (struct ip *) buf;
140:
141: pim_inet4_dump("<src?>", ip_hdr->ip_src, src_str, sizeof(src_str));
142: pim_inet4_dump("<dst?>", ip_hdr->ip_dst, dst_str, sizeof(dst_str));
143:
144: ip_hlen = ip_hdr->ip_hl << 2; /* ip_hl gives length in 4-byte words */
145:
146: if (PIM_DEBUG_PIM_PACKETS) {
147: zlog_debug("Recv IP packet from %s to %s on %s: size=%zu ip_header_size=%zu ip_proto=%d",
148: src_str, dst_str, ifp->name, len, ip_hlen, ip_hdr->ip_p);
149: }
150:
151: if (ip_hdr->ip_p != PIM_IP_PROTO_PIM) {
152: zlog_warn("IP packet protocol=%d is not PIM=%d",
153: ip_hdr->ip_p, PIM_IP_PROTO_PIM);
154: return -1;
155: }
156:
157: if (ip_hlen < PIM_IP_HEADER_MIN_LEN) {
158: zlog_warn("IP packet header size=%zu shorter than minimum=%d",
159: ip_hlen, PIM_IP_HEADER_MIN_LEN);
160: return -1;
161: }
162: if (ip_hlen > PIM_IP_HEADER_MAX_LEN) {
163: zlog_warn("IP packet header size=%zu greater than maximum=%d",
164: ip_hlen, PIM_IP_HEADER_MAX_LEN);
165: return -1;
166: }
167:
168: pim_msg = buf + ip_hlen;
169: pim_msg_len = len - ip_hlen;
170:
171: if (PIM_DEBUG_PIM_PACKETDUMP_RECV) {
172: pim_pkt_dump(__PRETTY_FUNCTION__, pim_msg, pim_msg_len);
173: }
174:
175: if (pim_msg_len < PIM_PIM_MIN_LEN) {
176: zlog_warn("PIM message size=%d shorter than minimum=%d",
177: pim_msg_len, PIM_PIM_MIN_LEN);
178: return -1;
179: }
180:
181: pim_version = PIM_MSG_HDR_GET_VERSION(pim_msg);
182: pim_type = PIM_MSG_HDR_GET_TYPE(pim_msg);
183:
184: if (pim_version != PIM_PROTO_VERSION) {
185: zlog_warn("Ignoring PIM pkt from %s with unsupported version: %d",
186: ifp->name, pim_version);
187: return -1;
188: }
189:
190: /* save received checksum */
191: pim_checksum = PIM_MSG_HDR_GET_CHECKSUM(pim_msg);
192:
193: /* for computing checksum */
194: *(uint16_t *) PIM_MSG_HDR_OFFSET_CHECKSUM(pim_msg) = 0;
195:
196: checksum = in_cksum(pim_msg, pim_msg_len);
197: if (checksum != pim_checksum) {
198: zlog_warn("Ignoring PIM pkt from %s with invalid checksum: received=%x calculated=%x",
199: ifp->name, pim_checksum, checksum);
200: return -1;
201: }
202:
203: if (PIM_DEBUG_PIM_PACKETS) {
204: zlog_debug("Recv PIM packet from %s to %s on %s: ttl=%d pim_version=%d pim_type=%d pim_msg_size=%d checksum=%x",
205: src_str, dst_str, ifp->name, ip_hdr->ip_ttl,
206: pim_version, pim_type, pim_msg_len, checksum);
207: }
208:
209: if (pim_type == PIM_MSG_TYPE_REGISTER ||
210: pim_type == PIM_MSG_TYPE_REG_STOP ||
211: pim_type == PIM_MSG_TYPE_BOOTSTRAP ||
212: pim_type == PIM_MSG_TYPE_GRAFT ||
213: pim_type == PIM_MSG_TYPE_GRAFT_ACK ||
214: pim_type == PIM_MSG_TYPE_CANDIDATE)
215: {
216: if (PIM_DEBUG_PIM_PACKETS) {
217: zlog_debug("Recv PIM packet type %d which is not currently understood",
218: pim_type);
219: }
220: return -1;
221: }
222:
223: if (pim_type == PIM_MSG_TYPE_HELLO) {
224: int result = pim_hello_recv(ifp,
225: ip_hdr->ip_src,
226: pim_msg + PIM_MSG_HEADER_LEN,
227: pim_msg_len - PIM_MSG_HEADER_LEN);
228: return result;
229: }
230:
231: neigh = pim_neighbor_find(ifp, ip_hdr->ip_src);
232: if (!neigh) {
233: zlog_warn("%s %s: non-hello PIM message type=%d from non-neighbor %s on %s",
234: __FILE__, __PRETTY_FUNCTION__,
235: pim_type, src_str, ifp->name);
236: return -1;
237: }
238:
239: switch (pim_type) {
240: case PIM_MSG_TYPE_JOIN_PRUNE:
241: return pim_joinprune_recv(ifp, neigh,
242: ip_hdr->ip_src,
243: pim_msg + PIM_MSG_HEADER_LEN,
244: pim_msg_len - PIM_MSG_HEADER_LEN);
245: case PIM_MSG_TYPE_ASSERT:
246: return pim_assert_recv(ifp, neigh,
247: ip_hdr->ip_src,
248: pim_msg + PIM_MSG_HEADER_LEN,
249: pim_msg_len - PIM_MSG_HEADER_LEN);
250: default:
251: zlog_warn("%s %s: unsupported PIM message type=%d from %s on %s",
252: __FILE__, __PRETTY_FUNCTION__,
253: pim_type, src_str, ifp->name);
254: }
255:
256: return -1;
257: }
258:
259: static void pim_sock_read_on(struct interface *ifp);
260:
261: static int pim_sock_read(struct thread *t)
262: {
263: struct interface *ifp;
264: struct pim_interface *pim_ifp;
265: int fd;
266: struct sockaddr_in from;
267: struct sockaddr_in to;
268: socklen_t fromlen = sizeof(from);
269: socklen_t tolen = sizeof(to);
270: uint8_t buf[PIM_PIM_BUFSIZE_READ];
271: int len;
272: ifindex_t ifindex = -1;
273: int result = -1; /* defaults to bad */
274:
275: zassert(t);
276:
277: ifp = THREAD_ARG(t);
278: zassert(ifp);
279:
280: fd = THREAD_FD(t);
281:
282: pim_ifp = ifp->info;
283: zassert(pim_ifp);
284:
285: zassert(fd == pim_ifp->pim_sock_fd);
286:
287: len = pim_socket_recvfromto(fd, buf, sizeof(buf),
288: &from, &fromlen,
289: &to, &tolen,
290: &ifindex);
291: if (len < 0) {
292: zlog_warn("Failure receiving IP PIM packet on fd=%d: errno=%d: %s",
293: fd, errno, safe_strerror(errno));
294: goto done;
295: }
296:
297: if (PIM_DEBUG_PIM_PACKETS) {
298: char from_str[100];
299: char to_str[100];
300:
301: if (!inet_ntop(AF_INET, &from.sin_addr, from_str, sizeof(from_str)))
302: sprintf(from_str, "<from?>");
303: if (!inet_ntop(AF_INET, &to.sin_addr, to_str, sizeof(to_str)))
304: sprintf(to_str, "<to?>");
305:
306: zlog_debug("Recv IP PIM pkt size=%d from %s to %s on fd=%d on ifindex=%d (sock_ifindex=%d)",
307: len, from_str, to_str, fd, ifindex, ifp->ifindex);
308: }
309:
310: if (PIM_DEBUG_PIM_PACKETDUMP_RECV) {
311: pim_pkt_dump(__PRETTY_FUNCTION__, buf, len);
312: }
313:
314: #ifdef PIM_CHECK_RECV_IFINDEX_SANITY
315: /* ifindex sanity check */
316: if (ifindex != (int) ifp->ifindex) {
317: char from_str[100];
318: char to_str[100];
319: struct interface *recv_ifp;
320:
321: if (!inet_ntop(AF_INET, &from.sin_addr, from_str , sizeof(from_str)))
322: sprintf(from_str, "<from?>");
323: if (!inet_ntop(AF_INET, &to.sin_addr, to_str , sizeof(to_str)))
324: sprintf(to_str, "<to?>");
325:
326: recv_ifp = if_lookup_by_index(ifindex);
327: if (recv_ifp) {
328: zassert(ifindex == (int) recv_ifp->ifindex);
329: }
330:
331: #ifdef PIM_REPORT_RECV_IFINDEX_MISMATCH
332: zlog_warn("Interface mismatch: recv PIM pkt from %s to %s on fd=%d: recv_ifindex=%d (%s) sock_ifindex=%d (%s)",
333: from_str, to_str, fd,
334: ifindex, recv_ifp ? recv_ifp->name : "<if-notfound>",
335: ifp->ifindex, ifp->name);
336: #endif
337: goto done;
338: }
339: #endif
340:
341: int fail = pim_pim_packet(ifp, buf, len);
342: if (fail) {
343: zlog_warn("%s: pim_pim_packet() return=%d",
344: __PRETTY_FUNCTION__, fail);
345: goto done;
346: }
347:
348: result = 0; /* good */
349:
350: done:
351: pim_sock_read_on(ifp);
352:
353: if (result) {
354: ++pim_ifp->pim_ifstat_hello_recvfail;
355: }
356:
357: return result;
358: }
359:
360: static void pim_sock_read_on(struct interface *ifp)
361: {
362: struct pim_interface *pim_ifp;
363:
364: zassert(ifp);
365: zassert(ifp->info);
366:
367: pim_ifp = ifp->info;
368:
369: if (PIM_DEBUG_PIM_TRACE) {
370: zlog_debug("Scheduling READ event on PIM socket fd=%d",
371: pim_ifp->pim_sock_fd);
372: }
373: pim_ifp->t_pim_sock_read = 0;
374: zassert(!pim_ifp->t_pim_sock_read);
375: THREAD_READ_ON(master, pim_ifp->t_pim_sock_read, pim_sock_read, ifp,
376: pim_ifp->pim_sock_fd);
377: }
378:
379: static int pim_sock_open(struct in_addr ifaddr, ifindex_t ifindex)
380: {
381: int fd;
382:
383: fd = pim_socket_mcast(IPPROTO_PIM, ifaddr, 0 /* loop=false */);
384: if (fd < 0)
385: return -1;
386:
387: if (pim_socket_join(fd, qpim_all_pim_routers_addr, ifaddr, ifindex)) {
388: close(fd);
389: return -2;
390: }
391:
392: return fd;
393: }
394:
395: void pim_ifstat_reset(struct interface *ifp)
396: {
397: struct pim_interface *pim_ifp;
398:
399: zassert(ifp);
400:
401: pim_ifp = ifp->info;
402: if (!pim_ifp) {
403: return;
404: }
405:
406: pim_ifp->pim_ifstat_start = pim_time_monotonic_sec();
407: pim_ifp->pim_ifstat_hello_sent = 0;
408: pim_ifp->pim_ifstat_hello_sendfail = 0;
409: pim_ifp->pim_ifstat_hello_recv = 0;
410: pim_ifp->pim_ifstat_hello_recvfail = 0;
411: }
412:
413: void pim_sock_reset(struct interface *ifp)
414: {
415: struct pim_interface *pim_ifp;
416:
417: zassert(ifp);
418: zassert(ifp->info);
419:
420: pim_ifp = ifp->info;
421:
422: pim_ifp->primary_address = pim_find_primary_addr(ifp);
423:
424: pim_ifp->pim_sock_fd = -1;
425: pim_ifp->pim_sock_creation = 0;
426: pim_ifp->t_pim_sock_read = 0;
427:
428: pim_ifp->t_pim_hello_timer = 0;
429: pim_ifp->pim_hello_period = PIM_DEFAULT_HELLO_PERIOD;
430: pim_ifp->pim_default_holdtime = -1; /* unset: means 3.5 * pim_hello_period */
431: pim_ifp->pim_triggered_hello_delay = PIM_DEFAULT_TRIGGERED_HELLO_DELAY;
432: pim_ifp->pim_dr_priority = PIM_DEFAULT_DR_PRIORITY;
433: pim_ifp->pim_propagation_delay_msec = PIM_DEFAULT_PROPAGATION_DELAY_MSEC;
434: pim_ifp->pim_override_interval_msec = PIM_DEFAULT_OVERRIDE_INTERVAL_MSEC;
435: if (PIM_DEFAULT_CAN_DISABLE_JOIN_SUPPRESSION) {
436: PIM_IF_DO_PIM_CAN_DISABLE_JOIN_SUPRESSION(pim_ifp->options);
437: }
438: else {
439: PIM_IF_DONT_PIM_CAN_DISABLE_JOIN_SUPRESSION(pim_ifp->options);
440: }
441:
442: /* neighbors without lan_delay */
443: pim_ifp->pim_number_of_nonlandelay_neighbors = 0;
444: pim_ifp->pim_neighbors_highest_propagation_delay_msec = 0;
445: pim_ifp->pim_neighbors_highest_override_interval_msec = 0;
446:
447: /* DR Election */
448: pim_ifp->pim_dr_election_last = 0; /* timestamp */
449: pim_ifp->pim_dr_election_count = 0;
450: pim_ifp->pim_dr_election_changes = 0;
451: pim_ifp->pim_dr_num_nondrpri_neighbors = 0; /* neighbors without dr_pri */
452: pim_ifp->pim_dr_addr = pim_ifp->primary_address;
453:
454: pim_ifstat_reset(ifp);
455: }
456:
457: int pim_msg_send(int fd,
458: struct in_addr dst,
459: uint8_t *pim_msg,
460: int pim_msg_size,
461: const char *ifname)
462: {
463: ssize_t sent;
464: struct sockaddr_in to;
465: socklen_t tolen;
466:
467: if (PIM_DEBUG_PIM_PACKETS) {
468: char dst_str[100];
469: pim_inet4_dump("<dst?>", dst, dst_str, sizeof(dst_str));
470: zlog_debug("%s: to %s on %s: msg_size=%d checksum=%x",
471: __PRETTY_FUNCTION__,
472: dst_str, ifname, pim_msg_size,
473: *(uint16_t *) PIM_MSG_HDR_OFFSET_CHECKSUM(pim_msg));
474: }
475:
476: #if 0
477: memset(&to, 0, sizeof(to));
478: #endif
479: to.sin_family = AF_INET;
480: to.sin_addr = dst;
481: #if 0
482: to.sin_port = htons(0);
483: #endif
484: tolen = sizeof(to);
485:
486: if (PIM_DEBUG_PIM_PACKETDUMP_SEND) {
487: pim_pkt_dump(__PRETTY_FUNCTION__, pim_msg, pim_msg_size);
488: }
489:
490: sent = sendto(fd, pim_msg, pim_msg_size, MSG_DONTWAIT,
491: (struct sockaddr *)&to, tolen);
492: if (sent != (ssize_t) pim_msg_size) {
493: int e = errno;
494: char dst_str[100];
495: pim_inet4_dump("<dst?>", dst, dst_str, sizeof(dst_str));
496: if (sent < 0) {
497: zlog_warn("%s: sendto() failure to %s on %s: fd=%d msg_size=%d: errno=%d: %s",
498: __PRETTY_FUNCTION__,
499: dst_str, ifname, fd, pim_msg_size,
500: e, safe_strerror(e));
501: }
502: else {
503: zlog_warn("%s: sendto() partial to %s on %s: fd=%d msg_size=%d: sent=%zd",
504: __PRETTY_FUNCTION__,
505: dst_str, ifname, fd,
506: pim_msg_size, sent);
507: }
508: return -1;
509: }
510:
511: return 0;
512: }
513:
514: static int hello_send(struct interface *ifp,
515: uint16_t holdtime)
516: {
517: uint8_t pim_msg[PIM_PIM_BUFSIZE_WRITE];
518: struct pim_interface *pim_ifp;
519: int pim_tlv_size;
520: int pim_msg_size;
521:
522: pim_ifp = ifp->info;
523:
524: if (PIM_DEBUG_PIM_HELLO) {
525: char dst_str[100];
526: pim_inet4_dump("<dst?>", qpim_all_pim_routers_addr, dst_str, sizeof(dst_str));
527: zlog_debug("%s: to %s on %s: holdt=%u prop_d=%u overr_i=%u dis_join_supp=%d dr_prio=%u gen_id=%08x addrs=%d",
528: __PRETTY_FUNCTION__,
529: dst_str, ifp->name,
530: holdtime,
531: pim_ifp->pim_propagation_delay_msec, pim_ifp->pim_override_interval_msec,
532: PIM_IF_TEST_PIM_CAN_DISABLE_JOIN_SUPRESSION(pim_ifp->options),
533: pim_ifp->pim_dr_priority, pim_ifp->pim_generation_id,
534: listcount(ifp->connected));
535: }
536:
537: pim_tlv_size = pim_hello_build_tlv(ifp->name,
538: pim_msg + PIM_PIM_MIN_LEN,
539: sizeof(pim_msg) - PIM_PIM_MIN_LEN,
540: holdtime,
541: pim_ifp->pim_dr_priority,
542: pim_ifp->pim_generation_id,
543: pim_ifp->pim_propagation_delay_msec,
544: pim_ifp->pim_override_interval_msec,
545: PIM_IF_TEST_PIM_CAN_DISABLE_JOIN_SUPRESSION(pim_ifp->options),
546: ifp->connected);
547: if (pim_tlv_size < 0) {
548: return -1;
549: }
550:
551: pim_msg_size = pim_tlv_size + PIM_PIM_MIN_LEN;
552:
553: zassert(pim_msg_size >= PIM_PIM_MIN_LEN);
554: zassert(pim_msg_size <= PIM_PIM_BUFSIZE_WRITE);
555:
556: pim_msg_build_header(pim_msg, pim_msg_size,
557: PIM_MSG_TYPE_HELLO);
558:
559: if (pim_msg_send(pim_ifp->pim_sock_fd,
560: qpim_all_pim_routers_addr,
561: pim_msg,
562: pim_msg_size,
563: ifp->name)) {
564: if (PIM_DEBUG_PIM_HELLO) {
565: zlog_debug("%s: could not send PIM message on interface %s",
566: __PRETTY_FUNCTION__, ifp->name);
567: }
568: return -2;
569: }
570:
571: return 0;
572: }
573:
574: static int pim_hello_send(struct interface *ifp,
575: uint16_t holdtime)
576: {
577: struct pim_interface *pim_ifp;
578:
579: zassert(ifp);
580: pim_ifp = ifp->info;
581: zassert(pim_ifp);
582:
583: if (hello_send(ifp, holdtime)) {
584: ++pim_ifp->pim_ifstat_hello_sendfail;
585:
586: if (PIM_DEBUG_PIM_HELLO) {
587: zlog_warn("Could not send PIM hello on interface %s",
588: ifp->name);
589: }
590: return -1;
591: }
592:
593: ++pim_ifp->pim_ifstat_hello_sent;
594:
595: return 0;
596: }
597:
598: static void hello_resched(struct interface *ifp)
599: {
600: struct pim_interface *pim_ifp;
601:
602: zassert(ifp);
603: pim_ifp = ifp->info;
604: zassert(pim_ifp);
605:
606: if (PIM_DEBUG_PIM_HELLO) {
607: zlog_debug("Rescheduling %d sec hello on interface %s",
608: pim_ifp->pim_hello_period, ifp->name);
609: }
610: THREAD_OFF(pim_ifp->t_pim_hello_timer);
611: THREAD_TIMER_ON(master, pim_ifp->t_pim_hello_timer,
612: on_pim_hello_send,
613: ifp, pim_ifp->pim_hello_period);
614: }
615:
616: /*
617: Periodic hello timer
618: */
619: static int on_pim_hello_send(struct thread *t)
620: {
621: struct pim_interface *pim_ifp;
622: struct interface *ifp;
623:
624: zassert(t);
625: ifp = THREAD_ARG(t);
626: zassert(ifp);
627:
628: pim_ifp = ifp->info;
629:
630: /*
631: * Schedule next hello
632: */
633: pim_ifp->t_pim_hello_timer = 0;
634: hello_resched(ifp);
635:
636: /*
637: * Send hello
638: */
639: return pim_hello_send(ifp, PIM_IF_DEFAULT_HOLDTIME(pim_ifp));
640: }
641:
642: /*
643: RFC 4601: 4.3.1. Sending Hello Messages
644:
645: Thus, if a router needs to send a Join/Prune or Assert message on an
646: interface on which it has not yet sent a Hello message with the
647: currently configured IP address, then it MUST immediately send the
648: relevant Hello message without waiting for the Hello Timer to
649: expire, followed by the Join/Prune or Assert message.
650: */
651: void pim_hello_restart_now(struct interface *ifp)
652: {
653: struct pim_interface *pim_ifp;
654:
655: zassert(ifp);
656: pim_ifp = ifp->info;
657: zassert(pim_ifp);
658:
659: /*
660: * Reset next hello timer
661: */
662: hello_resched(ifp);
663:
664: /*
665: * Immediately send hello
666: */
667: pim_hello_send(ifp, PIM_IF_DEFAULT_HOLDTIME(pim_ifp));
668: }
669:
670: /*
671: RFC 4601: 4.3.1. Sending Hello Messages
672:
673: To allow new or rebooting routers to learn of PIM neighbors quickly,
674: when a Hello message is received from a new neighbor, or a Hello
675: message with a new GenID is received from an existing neighbor, a
676: new Hello message should be sent on this interface after a
677: randomized delay between 0 and Triggered_Hello_Delay.
678: */
679: void pim_hello_restart_triggered(struct interface *ifp)
680: {
681: struct pim_interface *pim_ifp;
682: int triggered_hello_delay_msec;
683: int random_msec;
684:
685: zassert(ifp);
686: pim_ifp = ifp->info;
687: zassert(pim_ifp);
688:
689: triggered_hello_delay_msec = 1000 * pim_ifp->pim_triggered_hello_delay;
690:
691: if (pim_ifp->t_pim_hello_timer) {
692: long remain_msec = pim_time_timer_remain_msec(pim_ifp->t_pim_hello_timer);
693: if (remain_msec <= triggered_hello_delay_msec) {
694: /* Rescheduling hello would increase the delay, then it's faster
695: to just wait for the scheduled periodic hello. */
696: return;
697: }
698:
699: THREAD_OFF(pim_ifp->t_pim_hello_timer);
700: pim_ifp->t_pim_hello_timer = 0;
701: }
702: zassert(!pim_ifp->t_pim_hello_timer);
703:
704: random_msec = random() % (triggered_hello_delay_msec + 1);
705:
706: if (PIM_DEBUG_PIM_HELLO) {
707: zlog_debug("Scheduling %d msec triggered hello on interface %s",
708: random_msec, ifp->name);
709: }
710:
711: THREAD_TIMER_MSEC_ON(master, pim_ifp->t_pim_hello_timer,
712: on_pim_hello_send,
713: ifp, random_msec);
714: }
715:
716: int pim_sock_add(struct interface *ifp)
717: {
718: struct pim_interface *pim_ifp;
719: struct in_addr ifaddr;
720: uint32_t old_genid;
721:
722: pim_ifp = ifp->info;
723: zassert(pim_ifp);
724:
725: if (pim_ifp->pim_sock_fd >= 0) {
726: zlog_warn("Can't recreate existing PIM socket fd=%d for interface %s",
727: pim_ifp->pim_sock_fd, ifp->name);
728: return -1;
729: }
730:
731: ifaddr = pim_ifp->primary_address;
732:
733: pim_ifp->pim_sock_fd = pim_sock_open(ifaddr, ifp->ifindex);
734: if (pim_ifp->pim_sock_fd < 0) {
735: zlog_warn("Could not open PIM socket on interface %s",
736: ifp->name);
737: return -2;
738: }
739:
740: pim_ifp->t_pim_sock_read = 0;
741: pim_ifp->pim_sock_creation = pim_time_monotonic_sec();
742:
743: /*
744: * Just ensure that the new generation id
745: * actually chooses something different.
746: * Actually ran across a case where this
747: * happened, pre-switch to random().
748: * While this is unlikely to happen now
749: * let's make sure it doesn't.
750: */
751: old_genid = pim_ifp->pim_generation_id;
752:
753: while (old_genid == pim_ifp->pim_generation_id)
754: pim_ifp->pim_generation_id = random();
755:
756: zlog_info("PIM INTERFACE UP: on interface %s ifindex=%d",
757: ifp->name, ifp->ifindex);
758:
759: /*
760: * Start receiving PIM messages
761: */
762: pim_sock_read_on(ifp);
763:
764: /*
765: * Start sending PIM hello's
766: */
767: pim_hello_restart_triggered(ifp);
768:
769: return 0;
770: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pim_pim.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