Annotation of embedaddon/pimd/pim.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.c,v 1.24 2002/09/26 00:59:30 pavlin Exp $
32: */
33:
34: #include "defs.h"
35:
36: #define SEND_DEBUG_NUMBER 50 /* For throttling log messages */
37:
38: /*
39: * Exported variables.
40: */
41: char *pim_recv_buf; /* input packet buffer */
42: char *pim_send_buf; /* output packet buffer */
43:
44: uint32_t allpimrouters_group; /* ALL_PIM_ROUTERS address in net order */
45: int pim_socket; /* socket for PIM control msgs */
46:
47: #ifdef RAW_OUTPUT_IS_RAW
48: extern int curttl;
49: #endif /* RAW_OUTPUT_IS_RAW */
50:
51: /*
52: * Local variables.
53: */
54: static uint16_t ip_id = 0;
55: //static u_int pim_send_cnt = 0;
56:
57:
58: /*
59: * Local function definitions.
60: */
61: static void pim_read (int f, fd_set *rfd);
62: static void accept_pim (ssize_t recvlen);
63: static int send_frame (char *buf, size_t len, size_t frag, size_t mtu, struct sockaddr *dst, size_t salen);
64:
65: /*
66: * Setup raw kernel socket for PIM protocol and send/receive buffers.
67: */
68: void init_pim(void)
69: {
70: struct ip *ip;
71:
72: /* Setup the PIM raw socket */
73: if ((pim_socket = socket(AF_INET, SOCK_RAW, IPPROTO_PIM)) < 0)
74: logit(LOG_ERR, errno, "Failed creating PIM socket");
75: k_hdr_include(pim_socket, TRUE); /* include IP header when sending */
76: k_set_sndbuf(pim_socket, SO_SEND_BUF_SIZE_MAX,
77: SO_SEND_BUF_SIZE_MIN); /* lots of output buffering */
78: k_set_rcvbuf(pim_socket, SO_RECV_BUF_SIZE_MAX,
79: SO_RECV_BUF_SIZE_MIN); /* lots of input buffering */
80: k_set_ttl(pim_socket, MINTTL); /* restrict multicasts to one hop */
81: k_set_loop(pim_socket, FALSE); /* disable multicast loopback */
82:
83: allpimrouters_group = htonl(INADDR_ALL_PIM_ROUTERS);
84:
85: pim_recv_buf = calloc(1, RECV_BUF_SIZE);
86: pim_send_buf = calloc(1, SEND_BUF_SIZE);
87: if (!pim_recv_buf || !pim_send_buf)
88: logit(LOG_ERR, 0, "Ran out of memory in init_pim()");
89:
90: /* One time setup in the buffers */
91: ip = (struct ip *)pim_send_buf;
92: memset(ip, 0, sizeof(*ip));
93: ip->ip_v = IPVERSION;
94: ip->ip_hl = (sizeof(struct ip) >> 2);
95: ip->ip_tos = 0; /* TODO: setup?? */
96: ip->ip_id = 0; /* Make sure to update ID field, maybe fragmenting below */
97: ip->ip_off = 0;
98: ip->ip_p = IPPROTO_PIM;
99: ip->ip_sum = 0; /* let kernel fill in */
100:
101: if (register_input_handler(pim_socket, pim_read) < 0)
102: logit(LOG_ERR, 0, "Failed registering pim_read() as an input handler");
103:
104: /* Initialize the building Join/Prune messages working area */
105: build_jp_message_pool = (build_jp_message_t *)NULL;
106: build_jp_message_pool_counter = 0;
107: }
108:
109:
110: /* Read a PIM message */
111: static void pim_read(int f __attribute__((unused)), fd_set *rfd __attribute__((unused)))
112: {
113: ssize_t len;
114: socklen_t dummy = 0;
115: sigset_t block, oblock;
116:
117: while ((len = recvfrom(pim_socket, pim_recv_buf, RECV_BUF_SIZE, 0, NULL, &dummy)) < 0) {
118: if (errno == EINTR)
119: continue; /* Received signal, retry syscall. */
120:
121: logit(LOG_ERR, errno, "Failed recvfrom() in pim_read()");
122: return;
123: }
124:
125: sigemptyset(&block);
126: sigaddset(&block, SIGALRM);
127: if (sigprocmask(SIG_BLOCK, &block, &oblock) < 0)
128: logit(LOG_ERR, errno, "sigprocmask");
129:
130: accept_pim(len);
131:
132: sigprocmask(SIG_SETMASK, &oblock, (sigset_t *)NULL);
133: }
134:
135: static void accept_pim(ssize_t recvlen)
136: {
137: uint32_t src, dst;
138: struct ip *ip;
139: pim_header_t *pim;
140: int iphdrlen, pimlen;
141: char source[20], dest[20];
142:
143: if (recvlen < (ssize_t)sizeof(struct ip)) {
144: logit(LOG_WARNING, 0, "Received PIM packet too short (%u bytes) for IP header", recvlen);
145: return;
146: }
147:
148: ip = (struct ip *)pim_recv_buf;
149: src = ip->ip_src.s_addr;
150: dst = ip->ip_dst.s_addr;
151: iphdrlen = ip->ip_hl << 2;
152:
153: pim = (pim_header_t *)(pim_recv_buf + iphdrlen);
154: pimlen = recvlen - iphdrlen;
155:
156: /* Sanity check packet length */
157: if (pimlen < (ssize_t)sizeof(*pim)) {
158: logit(LOG_WARNING, 0, "IP data field too short (%d bytes) for PIM header, from %s to %s",
159: pimlen, inet_fmt(src, source, sizeof(source)), inet_fmt(dst, dest, sizeof(dest)));
160: return;
161: }
162:
163: IF_DEBUG(DEBUG_PIM_DETAIL) {
164: IF_DEBUG(DEBUG_PIM) {
165: logit(LOG_DEBUG, 0, "RECV %5d bytes %s from %-15s to %s ", recvlen,
166: packet_kind(IPPROTO_PIM, pim->pim_type, 0),
167: inet_fmt(src, source, sizeof(source)), inet_fmt(dst, dest, sizeof(dest)));
168: }
169: }
170:
171: /* TODO: Check PIM version */
172: /* TODO: check the dest. is ALL_PIM_ROUTERS (if multicast address) */
173: /* TODO: Checksum verification is done in each of the processing functions.
174: * No need for checksum, if already done in the kernel?
175: */
176: switch (pim->pim_type) {
177: case PIM_HELLO:
178: receive_pim_hello(src, dst, (char *)(pim), pimlen);
179: break;
180:
181: case PIM_REGISTER:
182: receive_pim_register(src, dst, (char *)(pim), pimlen);
183: break;
184:
185: case PIM_REGISTER_STOP:
186: receive_pim_register_stop(src, dst, (char *)(pim), pimlen);
187: break;
188:
189: case PIM_JOIN_PRUNE:
190: receive_pim_join_prune(src, dst, (char *)(pim), pimlen);
191: break;
192:
193: case PIM_BOOTSTRAP:
194: receive_pim_bootstrap(src, dst, (char *)(pim), pimlen);
195: break;
196:
197: case PIM_ASSERT:
198: receive_pim_assert(src, dst, (char *)(pim), pimlen);
199: break;
200:
201: case PIM_GRAFT:
202: case PIM_GRAFT_ACK:
203: logit(LOG_INFO, 0, "ignore %s from %s to %s", packet_kind(IPPROTO_PIM, pim->pim_type, 0),
204: inet_fmt(src, source, sizeof(source)), inet_fmt(dst, dest, sizeof(dest)));
205: break;
206:
207: case PIM_CAND_RP_ADV:
208: receive_pim_cand_rp_adv(src, dst, (char *)(pim), pimlen);
209: break;
210:
211: default:
212: logit(LOG_INFO, 0, "ignore unknown PIM message code %u from %s to %s", pim->pim_type,
213: inet_fmt(src, source, sizeof(source)), inet_fmt(dst, dest, sizeof(dest)));
214: break;
215: }
216: }
217:
218:
219: /*
220: * Send a multicast PIM packet from src to dst, PIM message type = "type"
221: * and data length (after the PIM header) = "len"
222: */
223: void send_pim(char *buf, uint32_t src, uint32_t dst, int type, size_t len)
224: {
225: struct sockaddr_in sin;
226: struct ip *ip;
227: pim_header_t *pim;
228: int sendlen = sizeof(struct ip) + sizeof(pim_header_t) + len;
229: int setloop = 0;
230: char source[20], dest[20];
231:
232: /* Prepare the IP header */
233: ip = (struct ip *)buf;
234: ip->ip_id = htons(++ip_id);
235: ip->ip_off = 0;
236: ip->ip_src.s_addr = src;
237: ip->ip_dst.s_addr = dst;
238: ip->ip_ttl = MAXTTL; /* applies to unicast only */
239: #ifdef HAVE_IP_HDRINCL_BSD_ORDER
240: ip->ip_len = sendlen;
241: #else
242: ip->ip_len = htons(sendlen);
243: #endif
244:
245: /* Prepare the PIM packet */
246: pim = (pim_header_t *)(buf + sizeof(struct ip));
247: pim->pim_type = type;
248: pim->pim_vers = PIM_PROTOCOL_VERSION;
249: pim->pim_reserved = 0;
250: pim->pim_cksum = 0;
251:
252: /* TODO: XXX: if start using this code for PIM_REGISTERS, exclude the
253: * encapsulated packet from the checsum. */
254: pim->pim_cksum = inet_cksum((uint16_t *)pim, sizeof(pim_header_t) + len);
255:
256: if (IN_MULTICAST(ntohl(dst))) {
257: k_set_if(pim_socket, src);
258: if ((dst == allhosts_group) ||
259: (dst == allrouters_group) ||
260: (dst == allpimrouters_group) ||
261: (dst == allreports_group)) {
262: setloop = 1;
263: k_set_loop(pim_socket, TRUE);
264: }
265: #ifdef RAW_OUTPUT_IS_RAW
266: ip->ip_ttl = curttl;
267: } else {
268: ip->ip_ttl = MAXTTL;
269: #endif /* RAW_OUTPUT_IS_RAW */
270: }
271:
272: memset(&sin, 0, sizeof(sin));
273: sin.sin_family = AF_INET;
274: sin.sin_addr.s_addr = dst;
275: #ifdef HAVE_SA_LEN
276: sin.sin_len = sizeof(sin);
277: #endif
278:
279: while (sendto(pim_socket, buf, sendlen, 0, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
280: if (errno == EINTR)
281: continue; /* Received signal, retry syscall. */
282: if (errno == ENETDOWN || errno == ENODEV)
283: check_vif_state();
284: else if (errno == EPERM || errno == EHOSTUNREACH)
285: logit(LOG_WARNING, 0, "Not allowed to send PIM message from %s to %s, possibly firewall"
286: #ifdef __linux__
287: ", or SELinux policy violation,"
288: #endif
289: " related problem."
290: ,
291: inet_fmt(src, source, sizeof(source)), inet_fmt(dst, dest, sizeof(dest)));
292: else
293: logit(LOG_WARNING, errno, "sendto from %s to %s",
294: inet_fmt(src, source, sizeof(source)), inet_fmt(dst, dest, sizeof(dest)));
295: if (setloop)
296: k_set_loop(pim_socket, FALSE);
297: return;
298: }
299:
300: if (setloop)
301: k_set_loop(pim_socket, FALSE);
302:
303: IF_DEBUG(DEBUG_PIM_DETAIL) {
304: IF_DEBUG(DEBUG_PIM) {
305: logit(LOG_DEBUG, 0, "SENT %5d bytes %s from %-15s to %s",
306: sendlen, packet_kind(IPPROTO_PIM, type, 0),
307: src == INADDR_ANY_N ? "INADDR_ANY" :
308: inet_fmt(src, source, sizeof(source)), inet_fmt(dst, dest, sizeof(dest)));
309: }
310: }
311: }
312:
313:
314: /* TODO: This can be merged with the above procedure */
315: /*
316: * Send an unicast PIM packet from src to dst, PIM message type = "type"
317: * and data length (after the PIM common header) = "len"
318: */
319: void send_pim_unicast(char *buf, int mtu, uint32_t src, uint32_t dst, int type, size_t len)
320: {
321: struct sockaddr_in sin;
322: struct ip *ip;
323: pim_header_t *pim;
324: int result, sendlen = sizeof(struct ip) + sizeof(pim_header_t) + len;
325: char source[20], dest[20];
326:
327: /* Prepare the IP header */
328: ip = (struct ip *)buf;
329: ip->ip_id = htons(++ip_id);
330: ip->ip_src.s_addr = src;
331: ip->ip_dst.s_addr = dst;
332: ip->ip_ttl = MAXTTL; /* TODO: XXX: setup TTL from the inner mcast packet? */
333: #ifdef HAVE_IP_HDRINCL_BSD_ORDER
334: ip->ip_len = sendlen;
335: #else
336: ip->ip_len = htons(sendlen);
337: #endif
338:
339: /* Prepare the PIM packet */
340: pim = (pim_header_t *)(buf + sizeof(struct ip));
341: pim->pim_type = type;
342: pim->pim_vers = PIM_PROTOCOL_VERSION;
343: pim->pim_reserved = 0;
344: pim->pim_cksum = 0;
345:
346: /* XXX: The PIM_REGISTERs don't include the encapsulated
347: * inner packet in the checksum.
348: * Well, try to explain this to cisco...
349: * If your RP is cisco and if it shows many PIM_REGISTER checksum
350: * errors from this router, then #define BROKEN_CISCO_CHECKSUM here
351: * or in your Makefile.
352: * Note that such checksum is not in the spec, and such PIM_REGISTERS
353: * may be dropped by some implementations (pimd should be OK).
354: */
355: #ifdef BROKEN_CISCO_CHECKSUM
356: pim->pim_cksum = inet_cksum((uint16_t *)pim, sizeof(pim_header_t) + len);
357: #else
358: if (PIM_REGISTER == type) {
359: pim->pim_cksum = inet_cksum((uint16_t *)pim, sizeof(pim_header_t) + sizeof(pim_register_t));
360: } else {
361: pim->pim_cksum = inet_cksum((uint16_t *)pim, sizeof(pim_header_t) + len);
362: }
363: #endif /* BROKEN_CISCO_CHECKSUM */
364:
365: memset(&sin, 0, sizeof(sin));
366: sin.sin_family = AF_INET;
367: sin.sin_addr.s_addr = dst;
368: #ifdef HAVE_SA_LEN
369: sin.sin_len = sizeof(sin);
370: #endif
371:
372: IF_DEBUG(DEBUG_PIM_DETAIL) {
373: IF_DEBUG(DEBUG_PIM) {
374: logit(LOG_DEBUG, 0, "SEND %5d bytes %s from %-15s to %s ...",
375: sendlen, packet_kind(IPPROTO_PIM, type, 0),
376: inet_fmt(src, source, sizeof(source)), inet_fmt(dst, dest, sizeof(dest)));
377: }
378: }
379:
380: result = send_frame(buf, sendlen, 0, mtu, (struct sockaddr *)&sin, sizeof(sin));
381: if (result) {
382: logit(LOG_WARNING, errno, "sendto from %s to %s",
383: inet_fmt(ip->ip_src.s_addr, source, sizeof(source)),
384: inet_fmt(ip->ip_dst.s_addr, dest, sizeof(dest)));
385: return;
386: }
387:
388: IF_DEBUG(DEBUG_PIM_DETAIL) {
389: IF_DEBUG(DEBUG_PIM) {
390: #if 0 /* TODO: use pim_send_cnt? */
391: if (++pim_send_cnt > SEND_DEBUG_NUMBER) {
392: pim_send_cnt = 0;
393: logit(LOG_DEBUG, 0, "SENT %5d bytes %s from %-15s to %s",
394: sendlen, packet_kind(IPPROTO_PIM, type, 0),
395: inet_fmt(src, source, sizeof(source)), inet_fmt(dst, dest, sizeof(dest)));
396: }
397: #endif
398: logit(LOG_DEBUG, 0, "SENT %5d bytes %s from %-15s to %s",
399: sendlen, packet_kind(IPPROTO_PIM, type, 0),
400: inet_fmt(src, source, sizeof(source)), inet_fmt(dst, dest, sizeof(dest)));
401: }
402: }
403: }
404:
405:
406: #if 1
407: /*
408: * send unicast register frames
409: * Version: Michael Fine
410: * Staus: Works, albeit non-optimal
411: * Design: Only fragments if sendto() fails with EMSGSIZE
412: * It then tries to re-send by splitting the frame in two equal halves,
413: * calling send_frame() recursively until the frame has been sent.
414: */
415: static int send_frame(char *buf, size_t len, size_t frag, size_t mtu, struct sockaddr *dst, size_t salen)
416: {
417: struct ip *ip = (struct ip *)buf;
418: char source[20], dest[20];
419:
420: IF_DEBUG(DEBUG_PIM_REGISTER) {
421: logit(LOG_INFO, 0, "Sending unicast: len = %d, frag %zd, mtu %zd, to %s",
422: len, frag, mtu, inet_fmt(ip->ip_dst.s_addr, source, sizeof(source)));
423: dump_frame(NULL, buf, len);
424: }
425:
426: while (sendto(pim_socket, buf, len, 0, dst, salen) < 0) {
427: switch (errno) {
428: case EINTR:
429: continue; /* Received signal, retry syscall. */
430:
431: case ENETDOWN:
432: check_vif_state();
433: return -1;
434:
435: case EMSGSIZE:
436: {
437: /* split it in half and recursively send each half */
438: size_t hdrsize = sizeof(struct ip);
439: size_t newlen1 = ((len - hdrsize) / 2) & 0xFFF8; /* 8 byte boundary */
440: size_t sendlen = newlen1 + hdrsize;
441: size_t offset = ntohs(ip->ip_off);
442:
443: /* send first half */
444: ip->ip_len = htons(sendlen);
445: ip->ip_off = htons(offset | IP_MF);
446: if (send_frame(buf, sendlen, 1, newlen1, dst, salen) == 0) {
447: /* send second half */
448: struct ip *ip2 = (struct ip *)(buf + newlen1);
449: size_t newlen2 = len - sendlen;
450: sendlen = newlen2 + hdrsize;
451:
452: memcpy(ip2, ip, hdrsize);
453: ip2->ip_len = htons(sendlen);
454: ip2->ip_off = htons(offset + (newlen1 >> 3)); /* keep flgs */
455: return send_frame((char *)ip2, sendlen, 1, newlen2, dst, salen);
456: }
457:
458: return -1;
459: }
460:
461: default:
462: logit(LOG_WARNING, errno, "sendto from %s to %s",
463: inet_fmt(ip->ip_src.s_addr, source, sizeof(source)),
464: inet_fmt(ip->ip_dst.s_addr, dest, sizeof(dest)));
465: return -1;
466: }
467: }
468:
469: return 0;
470: }
471:
472: #else
473: /*
474: * send unicast register frames
475: * Version: Joachim Nilsson
476: * Staus: Does not work (yet!)
477: * Design: Fragment IP frames when the frame length exceeds the MTU
478: * reported from the interface. Optimizes for less fragments
479: * and fewer syscalls, should get better network utilization.
480: * Can be easily modified to use the PMTU instead.
481: *
482: * Feel free to debug this version and submit your patches -- it should work! --Joachim
483: */
484: static int send_frame(char *buf, size_t len, size_t frag, size_t mtu, struct sockaddr *dst, size_t salen)
485: {
486: struct ip *next, *ip = (struct ip *)buf;
487: size_t xferlen, offset;
488: char source[20], dest[20];
489:
490: if (!mtu)
491: mtu = IP_MSS;
492:
493: if (len > mtu)
494: xferlen = (mtu - sizeof(struct ip)) & 0xFFF8;
495: else
496: xferlen = len;
497:
498: offset = (ntohs(ip->ip_off) & IP_OFFMASK) + (frag >> 3);
499: ip->ip_off = offset;
500: len = len - xferlen;
501: if (len)
502: ip->ip_off |= IP_MF;
503: ip->ip_off = htons(ip->ip_off);
504: ip->ip_len = htons(xferlen);
505:
506: IF_DEBUG(DEBUG_PIM_REGISTER) {
507: logit(LOG_INFO, 0, "Sending %-4d bytes %sunicast (MTU %-4d, offset %zd) to %s",
508: xferlen, len ? "fragmented " : "", mtu, offset,
509: inet_fmt(ip->ip_dst.s_addr, source, sizeof(source)));
510: dump_frame(NULL, buf, xferlen);
511: }
512:
513: /* send first fragment */
514: while (sendto(pim_socket, ip, xferlen, 0, dst, salen) < 0) {
515: switch (errno) {
516: case EINTR:
517: continue; /* Received signal, retry syscall. */
518:
519: case ENETDOWN:
520: check_vif_state();
521: return -1;
522:
523: case EMSGSIZE:
524: if (mtu > IP_MSS)
525: return send_frame((char *)ip, xferlen, frag, IP_MSS, dst, salen);
526: /* fall through */
527:
528: default:
529: return -1;
530: }
531: }
532:
533: /* send reminder */
534: if (len) {
535: size_t hdrsz = sizeof(struct ip);
536:
537: /* Update data pointers */
538: next = (struct ip *)(buf + xferlen - hdrsz);
539: memcpy(next, ip, hdrsz);
540:
541: return send_frame((char *)next, len + hdrsz, xferlen, mtu, dst, salen);
542: }
543:
544: return 0;
545: }
546: #endif
547:
548: /**
549: * Local Variables:
550: * version-control: t
551: * indent-tabs-mode: t
552: * c-file-style: "ellemtel"
553: * c-basic-offset: 4
554: * End:
555: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to 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 / pimd