Annotation of embedaddon/pimd/igmp.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: igmp.c,v 1.18 2002/09/26 00:59:29 pavlin Exp $
32: */
33: /*
34: * Part of this program has been derived from mrouted.
35: * The mrouted program is covered by the license in the accompanying file
36: * named "LICENSE.mrouted".
37: *
38: * The mrouted program is COPYRIGHT 1989 by The Board of Trustees of
39: * Leland Stanford Junior University.
40: *
41: */
42:
43: #include "defs.h"
44:
45: /*
46: * Exported variables.
47: */
48: char *igmp_recv_buf; /* input packet buffer */
49: char *igmp_send_buf; /* output packet buffer */
50: int igmp_socket; /* socket for all network I/O */
51: uint32_t allhosts_group; /* allhosts addr in net order */
52: uint32_t allrouters_group; /* All-Routers addr in net order */
53: uint32_t allreports_group; /* All IGMP routers in net order */
54:
55: #ifdef RAW_OUTPUT_IS_RAW
56: extern int curttl;
57: #endif /* RAW_OUTPUT_IS_RAW */
58:
59: /*
60: * Local functions definitions.
61: */
62: static void igmp_read (int i, fd_set *rfd);
63: static void accept_igmp (ssize_t recvlen);
64:
65:
66: /*
67: * Open and initialize the igmp socket, and fill in the non-changing
68: * IP header fields in the output packet buffer.
69: */
70: void init_igmp(void)
71: {
72: struct ip *ip;
73: char *router_alert;
74:
75: igmp_recv_buf = calloc(1, RECV_BUF_SIZE);
76: igmp_send_buf = calloc(1, SEND_BUF_SIZE);
77: if (!igmp_recv_buf || !igmp_send_buf)
78: logit(LOG_ERR, 0, "Ran out of memory in init_igmp()");
79:
80: if ((igmp_socket = socket(AF_INET, SOCK_RAW, IPPROTO_IGMP)) < 0)
81: logit(LOG_ERR, errno, "Failed creating IGMP socket in init_igmp()");
82:
83: k_hdr_include(igmp_socket, TRUE); /* include IP header when sending */
84: k_set_sndbuf(igmp_socket, SO_SEND_BUF_SIZE_MAX,
85: SO_SEND_BUF_SIZE_MIN); /* lots of output buffering */
86: k_set_rcvbuf(igmp_socket, SO_RECV_BUF_SIZE_MAX,
87: SO_RECV_BUF_SIZE_MIN); /* lots of input buffering */
88: k_set_ttl(igmp_socket, MINTTL); /* restrict multicasts to one hop */
89: k_set_loop(igmp_socket, FALSE); /* disable multicast loopback */
90:
91: ip = (struct ip *)igmp_send_buf;
92: memset(ip, 0, IP_IGMP_HEADER_LEN);
93: ip->ip_v = IPVERSION;
94: ip->ip_hl = IP_IGMP_HEADER_LEN >> 2;
95: ip->ip_tos = 0xc0; /* Internet Control */
96: ip->ip_id = 0; /* let kernel fill in */
97: ip->ip_off = 0;
98: ip->ip_ttl = MAXTTL; /* applies to unicasts only */
99: ip->ip_p = IPPROTO_IGMP;
100: ip->ip_sum = 0; /* let kernel fill in */
101:
102: /* Enable RFC2113 IP Router Alert. Per spec this is required to
103: * force certain routers/switches to inspect this frame. */
104: router_alert = igmp_send_buf + sizeof(struct ip);
105: router_alert[0] = IPOPT_RA;
106: router_alert[1] = 4;
107: router_alert[2] = 0;
108: router_alert[3] = 0;
109:
110: /* Everywhere in the daemon we use network-byte-order */
111: allhosts_group = htonl(INADDR_ALLHOSTS_GROUP);
112: allrouters_group = htonl(INADDR_ALLRTRS_GROUP);
113: allreports_group = htonl(INADDR_ALLRPTS_GROUP);
114:
115: if (register_input_handler(igmp_socket, igmp_read) < 0)
116: logit(LOG_ERR, 0, "Failed registering igmp_read() as an input handler in init_igmp()");
117: }
118:
119:
120: /* Read an IGMP message */
121: static void igmp_read(int i __attribute__((unused)), fd_set *rfd __attribute__((unused)))
122: {
123: ssize_t len;
124: socklen_t dummy = 0;
125:
126: while ((len = recvfrom(igmp_socket, igmp_recv_buf, RECV_BUF_SIZE, 0, NULL, &dummy)) < 0) {
127: if (errno == EINTR)
128: continue; /* Received signal, retry syscall. */
129:
130: logit(LOG_ERR, errno, "Failed recvfrom() in igmp_read()");
131: return;
132: }
133:
134: accept_igmp(len);
135: }
136:
137: /*
138: * Process a newly received IGMP packet that is sitting in the input
139: * packet buffer.
140: */
141: static void accept_igmp(ssize_t recvlen)
142: {
143: int ipdatalen, iphdrlen, igmpdatalen;
144: uint32_t src, dst, group;
145: struct ip *ip;
146: struct igmp *igmp;
147: int igmp_version = 3;
148:
149: if (recvlen < (ssize_t)sizeof(struct ip)) {
150: logit(LOG_WARNING, 0, "Received IGMP packet too short (%u bytes) for IP header", recvlen);
151: return;
152: }
153:
154: ip = (struct ip *)igmp_recv_buf;
155: src = ip->ip_src.s_addr;
156: dst = ip->ip_dst.s_addr;
157:
158: /* packets sent up from kernel to daemon have ip->ip_p = 0 */
159: if (ip->ip_p == 0) {
160: #if 0 /* XXX */
161: if (src == 0 || dst == 0)
162: logit(LOG_WARNING, 0, "Kernel request not accurate, src %s dst %s",
163: inet_fmt(src, s1, sizeof(s1)), inet_fmt(dst, s2, sizeof(s2)));
164: else
165: #endif
166: process_kernel_call();
167: return;
168: }
169:
170: iphdrlen = ip->ip_hl << 2;
171: #if 0
172: #ifdef HAVE_IP_HDRINCL_BSD_ORDER
173: #ifdef __NetBSD__
174: ipdatalen = ip->ip_len; /* The NetBSD kernel subtracts hlen for us, unfortunately. */
175: #else
176: ipdatalen = ip->ip_len - iphdrlen;
177: #endif
178: #else
179: ipdatalen = ntohs(ip->ip_len) - iphdrlen;
180: #endif
181: #else /* !0 */
182: ipdatalen = recvlen - iphdrlen;
183: #endif /* O */
184:
185: if (iphdrlen + ipdatalen != recvlen) {
186: logit(LOG_WARNING, 0, "Received packet from %s shorter (%u bytes) than hdr+data length (%u+%u)",
187: inet_fmt(src, s1, sizeof(s1)), recvlen, iphdrlen, ipdatalen);
188: return;
189: }
190:
191: igmp = (struct igmp *)(igmp_recv_buf + iphdrlen);
192: group = igmp->igmp_group.s_addr;
193: igmpdatalen = ipdatalen - IGMP_MINLEN;
194:
195: if (igmpdatalen < 0) {
196: logit(LOG_WARNING, 0, "Received IP data field too short (%u bytes) for IGMP, from %s",
197: ipdatalen, inet_fmt(src, s1, sizeof(s1)));
198: return;
199: }
200:
201: IF_DEBUG(DEBUG_IGMP)
202: logit(LOG_DEBUG, 0, "Received %s from %s to %s",
203: packet_kind(IPPROTO_IGMP, igmp->igmp_type, igmp->igmp_code),
204: inet_fmt(src, s1, sizeof(s1)), inet_fmt(dst, s2, sizeof(s2)));
205:
206: switch (igmp->igmp_type) {
207: case IGMP_MEMBERSHIP_QUERY:
208: /* RFC 3376:7.1 */
209: if (ipdatalen == 8) {
210: if (igmp->igmp_code == 0)
211: igmp_version = 1;
212: else
213: igmp_version = 2;
214: } else if (ipdatalen >= 12) {
215: igmp_version = 3;
216: } else {
217: logit(LOG_DEBUG, 0, "Received invalid IGMP Membership query: Max Resp Code = %d, length = %d",
218: igmp->igmp_code, ipdatalen);
219: }
220: accept_membership_query(src, dst, group, igmp->igmp_code, igmp_version);
221: return;
222:
223: case IGMP_V1_MEMBERSHIP_REPORT:
224: case IGMP_V2_MEMBERSHIP_REPORT:
225: accept_group_report(src, dst, group, igmp->igmp_type);
226: return;
227:
228: case IGMP_V2_LEAVE_GROUP:
229: accept_leave_message(src, dst, group);
230: return;
231:
232: case IGMP_V3_MEMBERSHIP_REPORT:
233: if (igmpdatalen < IGMP_V3_GROUP_RECORD_MIN_SIZE) {
234: logit(LOG_DEBUG, 0, "Too short IGMP v3 Membership report: igmpdatalen(%d) < MIN(%d)", igmpdatalen, IGMP_V3_GROUP_RECORD_MIN_SIZE);
235: return;
236: }
237: accept_membership_report(src, dst, (struct igmpv3_report *)(igmp_recv_buf + iphdrlen), recvlen - iphdrlen);
238: return;
239:
240: case IGMP_DVMRP:
241: /* XXX: TODO: most of the stuff below is not implemented. We are still
242: * only PIM router.
243: */
244: group = ntohl(group);
245:
246: switch (igmp->igmp_code) {
247: case DVMRP_PROBE:
248: dvmrp_accept_probe(src, dst, (uint8_t *)(igmp+1), igmpdatalen, group);
249: return;
250:
251: case DVMRP_REPORT:
252: dvmrp_accept_report(src, dst, (uint8_t *)(igmp+1), igmpdatalen, group);
253: return;
254:
255: case DVMRP_ASK_NEIGHBORS:
256: accept_neighbor_request(src, dst);
257: return;
258:
259: case DVMRP_ASK_NEIGHBORS2:
260: accept_neighbor_request2(src, dst);
261: return;
262:
263: case DVMRP_NEIGHBORS:
264: dvmrp_accept_neighbors(src, dst, (uint8_t *)(igmp+1), igmpdatalen, group);
265: return;
266:
267: case DVMRP_NEIGHBORS2:
268: dvmrp_accept_neighbors2(src, dst, (uint8_t *)(igmp+1), igmpdatalen, group);
269: return;
270:
271: case DVMRP_PRUNE:
272: dvmrp_accept_prune(src, dst, (uint8_t *)(igmp+1), igmpdatalen);
273: return;
274:
275: case DVMRP_GRAFT:
276: dvmrp_accept_graft(src, dst, (uint8_t *)(igmp+1), igmpdatalen);
277: return;
278:
279: case DVMRP_GRAFT_ACK:
280: dvmrp_accept_g_ack(src, dst, (uint8_t *)(igmp+1), igmpdatalen);
281: return;
282:
283: case DVMRP_INFO_REQUEST:
284: dvmrp_accept_info_request(src, dst, (uint8_t *)(igmp+1), igmpdatalen);
285: return;
286:
287: case DVMRP_INFO_REPLY:
288: dvmrp_accept_info_reply(src, dst, (uint8_t *)(igmp+1), igmpdatalen);
289: return;
290:
291: default:
292: logit(LOG_INFO, 0, "Ignoring unknown DVMRP message code %u from %s to %s",
293: igmp->igmp_code, inet_fmt(src, s1, sizeof(s1)), inet_fmt(dst, s2, sizeof(s2)));
294: return;
295: }
296:
297: case IGMP_PIM:
298: return; /* TODO: this is PIM v1 message. Handle it?. */
299:
300: case IGMP_MTRACE_RESP:
301: return; /* TODO: implement it */
302:
303: case IGMP_MTRACE:
304: accept_mtrace(src, dst, group, (char *)(igmp+1), igmp->igmp_code, igmpdatalen);
305: return;
306:
307: default:
308: logit(LOG_INFO, 0, "Ignoring unknown IGMP message type %x from %s to %s",
309: igmp->igmp_type, inet_fmt(src, s1, sizeof(s1)), inet_fmt(dst, s2, sizeof(s2)));
310: return;
311: }
312: }
313:
314: static void send_ip_frame(uint32_t src, uint32_t dst, int type, int code, char *buf, size_t len)
315: {
316: int setloop = 0;
317: struct ip *ip;
318: struct sockaddr_in sin;
319: char source[20], dest[20];
320:
321: /* Prepare the IP header */
322: len += IP_IGMP_HEADER_LEN;
323: ip = (struct ip *)buf;
324: ip->ip_id = 0; /* let kernel fill in */
325: ip->ip_off = 0;
326: ip->ip_src.s_addr = src;
327: ip->ip_dst.s_addr = dst;
328: #ifdef HAVE_IP_HDRINCL_BSD_ORDER
329: ip->ip_len = len;
330: #else
331: ip->ip_len = htons(len);
332: #endif
333:
334: if (IN_MULTICAST(ntohl(dst))) {
335: k_set_if(igmp_socket, src);
336: if (type != IGMP_DVMRP || dst == allhosts_group) {
337: setloop = 1;
338: k_set_loop(igmp_socket, TRUE);
339: }
340: #ifdef RAW_OUTPUT_IS_RAW
341: ip->ip_ttl = curttl;
342: } else {
343: ip->ip_ttl = MAXTTL;
344: #endif
345: }
346:
347: memset(&sin, 0, sizeof(sin));
348: sin.sin_family = AF_INET;
349: sin.sin_addr.s_addr = dst;
350: #ifdef HAVE_SA_LEN
351: sin.sin_len = sizeof(sin);
352: #endif
353:
354: IF_DEBUG(DEBUG_IGMP)
355: logit(LOG_DEBUG, 0, "Send %s from %s to %s",
356: packet_kind(IPPROTO_IGMP, type, code),
357: src == INADDR_ANY_N ? "INADDR_ANY" :
358: inet_fmt(src, s1, sizeof(s1)), inet_fmt(dst, s2, sizeof(s2)));
359:
360: while (sendto(igmp_socket, buf, len, 0, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
361: if (errno == EINTR)
362: continue; /* Received signal, retry syscall. */
363: if (errno == ENETDOWN || errno == ENODEV)
364: check_vif_state();
365: else if (errno == EPERM || errno == EHOSTUNREACH)
366: logit(LOG_WARNING, 0, "Not allowed to send IGMP message from %s to %s, possibly firewall"
367: #ifdef __linux__
368: ", or SELinux policy violation,"
369: #endif
370: " related problem."
371: ,
372: inet_fmt(src, source, sizeof(source)), inet_fmt(dst, dest, sizeof(dest)));
373: else
374: logit(log_level(IPPROTO_IGMP, type, code), errno, "Sendto to %s on %s",
375: inet_fmt(dst, s1, sizeof(s1)), inet_fmt(src, s2, sizeof(s2)));
376:
377: if (setloop)
378: k_set_loop(igmp_socket, FALSE);
379:
380: return;
381: }
382:
383: if (setloop)
384: k_set_loop(igmp_socket, FALSE);
385:
386: IF_DEBUG(DEBUG_PKT | debug_kind(IPPROTO_IGMP, type, code)) {
387: logit(LOG_DEBUG, 0, "SENT %5d bytes %s from %-15s to %s", len,
388: packet_kind(IPPROTO_IGMP, type, code),
389: src == INADDR_ANY_N
390: ? "INADDR_ANY"
391: : inet_fmt(src, s1, sizeof(s1)),
392: inet_fmt(dst, s2, sizeof(s2)));
393: }
394: }
395:
396: /*
397: * RFC-3376 states that Max Resp Code (MRC) and Querier's Query Interval Code
398: * (QQIC) should be presented in floating point value if their value exceeds
399: * 128. The following formula is used by IGMPv3 clients to calculate the
400: * actual value of the floating point:
401: *
402: * 0 1 2 3 4 5 6 7
403: * +-+-+-+-+-+-+-+-+
404: * |1| exp | mant |
405: * +-+-+-+-+-+-+-+-+
406: *
407: * QQI / MRT = (mant | 0x10) << (exp + 3)
408: *
409: * This requires us to find the largest set (fls) bit in the 15-bit number
410: * and set the exponent based on its index in the bits 15-8. ie.
411: *
412: * exponent 0: igmp_fls(0000 0000 1000 0010)
413: * exponent 5: igmp_fls(0001 0000 0000 0000)
414: * exponent 7: igmp_fls(0111 0101 0000 0000)
415: *
416: * and set that as the exponent. The mantissa is set to the last 4 bits
417: * remaining after the (3 + exponent) shifts to the right.
418: *
419: * Note!
420: * The numbers 31744-32767 are the maximum we can present with floating
421: * point that has an exponent of 3 and a mantissa of 4. After this the
422: * implementation just wraps around back to zero.
423: */
424: static inline uint8_t igmp_floating_point(unsigned int mantissa)
425: {
426: unsigned int exponent;
427:
428: /* Wrap around numbers larger than 2^15, since those can not be
429: * presented with 7-bit floating point. */
430: mantissa &= 0x00007FFF;
431:
432: /* If top 8 bits are zero. */
433: if (!(mantissa & 0x00007F80))
434: return mantissa;
435:
436: /* Shift the mantissa and mark this code floating point. */
437: mantissa >>= 3;
438: /* At this point the actual exponent (bits 7-5) are still 0, but the
439: * exponent might be incremented below. */
440: exponent = 0x00000080;
441:
442: /* If bits 7-4 are not zero. */
443: if (mantissa & 0x00000F00) {
444: mantissa >>= 4;
445: /* The index of largest set bit is at least 4. */
446: exponent |= 0x00000040;
447: }
448:
449: /* If bits 7-6 OR bits 3-2 are not zero. */
450: if (mantissa & 0x000000C0) {
451: mantissa >>= 2;
452: /* The index of largest set bit is atleast 6 if we shifted the
453: * mantissa earlier or atleast 2 if we did not shift it. */
454: exponent |= 0x00000020;
455: }
456:
457: /* If bit 7 OR bit 3 OR bit 1 is not zero. */
458: if (mantissa & 0x00000020) {
459: mantissa >>= 1;
460: /* The index of largest set bit is atleast 7 if we shifted the
461: * mantissa two times earlier or atleast 3 if we shifted the
462: * mantissa last time or atleast 1 if we did not shift it. */
463: exponent |= 0x00000010;
464: }
465:
466: return exponent | (mantissa & 0x0000000F);
467: }
468:
469: void send_igmp(char *buf, uint32_t src, uint32_t dst, int type, int code, uint32_t group, int datalen)
470: {
471: size_t len = IGMP_MINLEN + datalen;
472: struct igmpv3_query *igmp;
473:
474: igmp = (struct igmpv3_query *)(buf + IP_IGMP_HEADER_LEN);
475: igmp->type = type;
476: if (datalen >= 4)
477: igmp->code = igmp_floating_point(code);
478: else
479: igmp->code = code;
480: igmp->group = group;
481: igmp->csum = 0;
482: igmp->csum = inet_cksum((uint16_t *)igmp, len);
483:
484: if (datalen >= 4) {
485: igmp->qrv = 2;
486: igmp->qqic = igmp_floating_point(igmp_query_interval);
487: }
488:
489: send_ip_frame(src, dst, type, code, buf, len);
490: }
491:
492: /**
493: * Local Variables:
494: * version-control: t
495: * indent-tabs-mode: t
496: * c-file-style: "ellemtel"
497: * c-basic-offset: 4
498: * End:
499: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to igmp.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