![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to igmp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / netinet|
Return to igmp.c CVS log | Up to [Apple XNU] / XNU / bsd / netinet |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Copyright (c) 1988 Stephen Deering.
24: * Copyright (c) 1992, 1993
25: * The Regents of the University of California. All rights reserved.
26: *
27: * This code is derived from software contributed to Berkeley by
28: * Stephen Deering of Stanford University.
29: *
30: * Redistribution and use in source and binary forms, with or without
31: * modification, are permitted provided that the following conditions
32: * are met:
33: * 1. Redistributions of source code must retain the above copyright
34: * notice, this list of conditions and the following disclaimer.
35: * 2. Redistributions in binary form must reproduce the above copyright
36: * notice, this list of conditions and the following disclaimer in the
37: * documentation and/or other materials provided with the distribution.
38: * 3. All advertising materials mentioning features or use of this software
39: * must display the following acknowledgement:
40: * This product includes software developed by the University of
41: * California, Berkeley and its contributors.
42: * 4. Neither the name of the University nor the names of its contributors
43: * may be used to endorse or promote products derived from this software
44: * without specific prior written permission.
45: *
46: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
47: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
48: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
49: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
50: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
51: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
52: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
53: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
54: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
55: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56: * SUCH DAMAGE.
57: *
58: * @(#)igmp.c 8.1 (Berkeley) 7/19/93
59: */
60:
61: /*
62: * Internet Group Management Protocol (IGMP) routines.
63: *
64: * Written by Steve Deering, Stanford, May 1988.
65: * Modified by Rosen Sharma, Stanford, Aug 1994.
66: * Modified by Bill Fenner, Xerox PARC, Feb 1995.
67: * Modified to fully comply to IGMPv2 by Bill Fenner, Oct 1995.
68: *
69: * MULTICAST Revision: 3.5.1.4
70: */
71:
72: #include <sys/param.h>
73: #include <sys/systm.h>
74: #include <sys/malloc.h>
75: #include <sys/mbuf.h>
76: #include <sys/socket.h>
77: #include <sys/protosw.h>
78: #include <sys/kernel.h>
79: #include <sys/sysctl.h>
80:
81: #include <net/if.h>
82: #include <net/route.h>
83:
84: #include <netinet/in.h>
85: #include <netinet/in_var.h>
86: #include <netinet/in_systm.h>
87: #include <netinet/ip.h>
88: #include <netinet/ip_var.h>
89: #include <netinet/igmp.h>
90: #include <netinet/igmp_var.h>
91:
92: static MALLOC_DEFINE(M_IGMP, "igmp", "igmp state");
93:
94: static struct router_info *
95: find_rti __P((struct ifnet *ifp));
96:
97: static struct igmpstat igmpstat;
98:
99: SYSCTL_STRUCT(_net_inet_igmp, IGMPCTL_STATS, stats, CTLFLAG_RD,
100: &igmpstat, igmpstat, "");
101:
102: static int igmp_timers_are_running;
103: static u_long igmp_all_hosts_group;
104: static u_long igmp_all_rtrs_group;
105: static struct mbuf *router_alert;
106: static struct router_info *Head;
107:
108: static void igmp_sendpkt __P((struct in_multi *, int, unsigned long));
109:
110: void
111: igmp_init()
112: {
113: struct ipoption *ra;
114:
115: /*
116: * To avoid byte-swapping the same value over and over again.
117: */
118: igmp_all_hosts_group = htonl(INADDR_ALLHOSTS_GROUP);
119: igmp_all_rtrs_group = htonl(INADDR_ALLRTRS_GROUP);
120:
121: igmp_timers_are_running = 0;
122:
123: /*
124: * Construct a Router Alert option to use in outgoing packets
125: */
126: MGET(router_alert, M_DONTWAIT, MT_DATA);
127: ra = mtod(router_alert, struct ipoption *);
128: ra->ipopt_dst.s_addr = 0;
129: ra->ipopt_list[0] = IPOPT_RA; /* Router Alert Option */
130: ra->ipopt_list[1] = 0x04; /* 4 bytes long */
131: ra->ipopt_list[2] = 0x00;
132: ra->ipopt_list[3] = 0x00;
133: router_alert->m_len = sizeof(ra->ipopt_dst) + ra->ipopt_list[1];
134:
135: Head = (struct router_info *) 0;
136: }
137:
138: static struct router_info *
139: find_rti(ifp)
140: struct ifnet *ifp;
141: {
142: register struct router_info *rti = Head;
143:
144: #if IGMP_DEBUG
145: printf("[igmp.c, _find_rti] --> entering \n");
146: #endif
147: while (rti) {
148: if (rti->rti_ifp == ifp) {
149: #if IGMP_DEBUG
150: printf("[igmp.c, _find_rti] --> found old entry \n");
151: #endif
152: return rti;
153: }
154: rti = rti->rti_next;
155: }
156:
157: #if ISFB31
158: MALLOC(rti, struct router_info *, sizeof *rti, M_IGMP, M_NOWAIT);
159: #else
160: MALLOC(rti, struct router_info *, sizeof *rti, M_TEMP, M_NOWAIT);
161: #endif
162: rti->rti_ifp = ifp;
163: rti->rti_type = IGMP_V2_ROUTER;
164: rti->rti_time = 0;
165: rti->rti_next = Head;
166: Head = rti;
167: #if IGMP_DEBUG
168: printf("[igmp.c, _find_rti] --> created an entry \n");
169: #endif
170: return rti;
171: }
172:
173: void
174: igmp_input(m, iphlen)
175: register struct mbuf *m;
176: register int iphlen;
177: {
178: register struct igmp *igmp;
179: register struct ip *ip;
180: register int igmplen;
181: register struct ifnet *ifp = m->m_pkthdr.rcvif;
182: register int minlen;
183: register struct in_multi *inm;
184: register struct in_ifaddr *ia;
185: struct in_multistep step;
186: struct router_info *rti;
187:
188: int timer; /** timer value in the igmp query header **/
189:
190: ++igmpstat.igps_rcv_total;
191:
192: ip = mtod(m, struct ip *);
193: igmplen = ip->ip_len;
194:
195: /*
196: * Validate lengths
197: */
198: if (igmplen < IGMP_MINLEN) {
199: ++igmpstat.igps_rcv_tooshort;
200: m_freem(m);
201: return;
202: }
203: minlen = iphlen + IGMP_MINLEN;
204: if ((m->m_flags & M_EXT || m->m_len < minlen) &&
205: (m = m_pullup(m, minlen)) == 0) {
206: ++igmpstat.igps_rcv_tooshort;
207: return;
208: }
209:
210: /*
211: * Validate checksum
212: */
213: m->m_data += iphlen;
214: m->m_len -= iphlen;
215: igmp = mtod(m, struct igmp *);
216: if (in_cksum(m, igmplen)) {
217: ++igmpstat.igps_rcv_badsum;
218: m_freem(m);
219: return;
220: }
221: m->m_data -= iphlen;
222: m->m_len += iphlen;
223:
224: ip = mtod(m, struct ip *);
225: timer = igmp->igmp_code * PR_FASTHZ / IGMP_TIMER_SCALE;
226: if (timer == 0)
227: timer = 1;
228: rti = find_rti(ifp);
229:
230: /*
231: * In the IGMPv2 specification, there are 3 states and a flag.
232: *
233: * In Non-Member state, we simply don't have a membership record.
234: * In Delaying Member state, our timer is running (inm->inm_timer)
235: * In Idle Member state, our timer is not running (inm->inm_timer==0)
236: *
237: * The flag is inm->inm_state, it is set to IGMP_OTHERMEMBER if
238: * we have heard a report from another member, or IGMP_IREPORTEDLAST
239: * if I sent the last report.
240: */
241: switch (igmp->igmp_type) {
242:
243: case IGMP_MEMBERSHIP_QUERY:
244: ++igmpstat.igps_rcv_queries;
245:
246: if (ifp->if_flags & IFF_LOOPBACK)
247: break;
248:
249: if (igmp->igmp_code == 0) {
250: /*
251: * Old router. Remember that the querier on this
252: * interface is old, and set the timer to the
253: * value in RFC 1112.
254: */
255:
256: rti->rti_type = IGMP_V1_ROUTER;
257: rti->rti_time = 0;
258:
259: timer = IGMP_MAX_HOST_REPORT_DELAY * PR_FASTHZ;
260:
261: if (ip->ip_dst.s_addr != igmp_all_hosts_group ||
262: igmp->igmp_group.s_addr != 0) {
263: ++igmpstat.igps_rcv_badqueries;
264: m_freem(m);
265: return;
266: }
267: } else {
268: /*
269: * New router. Simply do the new validity check.
270: */
271:
272: if (igmp->igmp_group.s_addr != 0 &&
273: !IN_MULTICAST(ntohl(igmp->igmp_group.s_addr))) {
274: ++igmpstat.igps_rcv_badqueries;
275: m_freem(m);
276: return;
277: }
278: }
279:
280: /*
281: * - Start the timers in all of our membership records
282: * that the query applies to for the interface on
283: * which the query arrived excl. those that belong
284: * to the "all-hosts" group (224.0.0.1).
285: * - Restart any timer that is already running but has
286: * a value longer than the requested timeout.
287: * - Use the value specified in the query message as
288: * the maximum timeout.
289: */
290: IN_FIRST_MULTI(step, inm);
291: while (inm != NULL) {
292: if (inm->inm_ifp == ifp &&
293: inm->inm_addr.s_addr != igmp_all_hosts_group &&
294: (igmp->igmp_group.s_addr == 0 ||
295: igmp->igmp_group.s_addr == inm->inm_addr.s_addr)) {
296: if (inm->inm_timer == 0 ||
297: inm->inm_timer > timer) {
298: inm->inm_timer =
299: IGMP_RANDOM_DELAY(timer);
300: igmp_timers_are_running = 1;
301: }
302: }
303: IN_NEXT_MULTI(step, inm);
304: }
305:
306: break;
307:
308: case IGMP_V1_MEMBERSHIP_REPORT:
309: case IGMP_V2_MEMBERSHIP_REPORT:
310: /*
311: * For fast leave to work, we have to know that we are the
312: * last person to send a report for this group. Reports
313: * can potentially get looped back if we are a multicast
314: * router, so discard reports sourced by me.
315: */
316: IFP_TO_IA(ifp, ia);
317: if (ia && ip->ip_src.s_addr == IA_SIN(ia)->sin_addr.s_addr)
318: break;
319:
320: ++igmpstat.igps_rcv_reports;
321:
322: if (ifp->if_flags & IFF_LOOPBACK)
323: break;
324:
325: if (!IN_MULTICAST(ntohl(igmp->igmp_group.s_addr))) {
326: ++igmpstat.igps_rcv_badreports;
327: m_freem(m);
328: return;
329: }
330:
331: /*
332: * KLUDGE: if the IP source address of the report has an
333: * unspecified (i.e., zero) subnet number, as is allowed for
334: * a booting host, replace it with the correct subnet number
335: * so that a process-level multicast routing demon can
336: * determine which subnet it arrived from. This is necessary
337: * to compensate for the lack of any way for a process to
338: * determine the arrival interface of an incoming packet.
339: */
340: if ((ntohl(ip->ip_src.s_addr) & IN_CLASSA_NET) == 0)
341: if (ia) ip->ip_src.s_addr = htonl(ia->ia_subnet);
342:
343: /*
344: * If we belong to the group being reported, stop
345: * our timer for that group.
346: */
347: IN_LOOKUP_MULTI(igmp->igmp_group, ifp, inm);
348:
349: if (inm != NULL) {
350: inm->inm_timer = 0;
351: ++igmpstat.igps_rcv_ourreports;
352:
353: inm->inm_state = IGMP_OTHERMEMBER;
354: }
355:
356: break;
357: }
358:
359: /*
360: * Pass all valid IGMP packets up to any process(es) listening
361: * on a raw IGMP socket.
362: */
363: rip_input(m, iphlen);
364: }
365:
366: void
367: igmp_joingroup(inm)
368: struct in_multi *inm;
369: {
370: int s = splnet();
371:
372: if (inm->inm_addr.s_addr == igmp_all_hosts_group
373: || inm->inm_ifp->if_flags & IFF_LOOPBACK) {
374: inm->inm_timer = 0;
375: inm->inm_state = IGMP_OTHERMEMBER;
376: } else {
377: inm->inm_rti = find_rti(inm->inm_ifp);
378: igmp_sendpkt(inm, inm->inm_rti->rti_type, 0);
379: inm->inm_timer = IGMP_RANDOM_DELAY(
380: IGMP_MAX_HOST_REPORT_DELAY*PR_FASTHZ);
381: inm->inm_state = IGMP_IREPORTEDLAST;
382: igmp_timers_are_running = 1;
383: }
384: splx(s);
385: }
386:
387: void
388: igmp_leavegroup(inm)
389: struct in_multi *inm;
390: {
391: if (inm->inm_state == IGMP_IREPORTEDLAST &&
392: inm->inm_addr.s_addr != igmp_all_hosts_group &&
393: !(inm->inm_ifp->if_flags & IFF_LOOPBACK) &&
394: inm->inm_rti->rti_type != IGMP_V1_ROUTER)
395: igmp_sendpkt(inm, IGMP_V2_LEAVE_GROUP, igmp_all_rtrs_group);
396: }
397:
398: void
399: igmp_fasttimo()
400: {
401: register struct in_multi *inm;
402: struct in_multistep step;
403: int s;
404:
405: /*
406: * Quick check to see if any work needs to be done, in order
407: * to minimize the overhead of fasttimo processing.
408: */
409:
410: if (!igmp_timers_are_running)
411: return;
412:
413: s = splnet();
414: igmp_timers_are_running = 0;
415: IN_FIRST_MULTI(step, inm);
416: while (inm != NULL) {
417: if (inm->inm_timer == 0) {
418: /* do nothing */
419: } else if (--inm->inm_timer == 0) {
420: igmp_sendpkt(inm, inm->inm_rti->rti_type, 0);
421: inm->inm_state = IGMP_IREPORTEDLAST;
422: } else {
423: igmp_timers_are_running = 1;
424: }
425: IN_NEXT_MULTI(step, inm);
426: }
427: splx(s);
428: }
429:
430: void
431: igmp_slowtimo()
432: {
433: int s = splnet();
434: register struct router_info *rti = Head;
435:
436: #if IGMP_DEBUG
437: printf("[igmp.c,_slowtimo] -- > entering \n");
438: #endif
439: while (rti) {
440: if (rti->rti_type == IGMP_V1_ROUTER) {
441: rti->rti_time++;
442: if (rti->rti_time >= IGMP_AGE_THRESHOLD) {
443: rti->rti_type = IGMP_V2_ROUTER;
444: }
445: }
446: rti = rti->rti_next;
447: }
448: #if IGMP_DEBUG
449: printf("[igmp.c,_slowtimo] -- > exiting \n");
450: #endif
451: splx(s);
452: }
453:
454: static struct route igmprt;
455:
456: static void
457: igmp_sendpkt(inm, type, addr)
458: struct in_multi *inm;
459: int type;
460: unsigned long addr;
461: {
462: struct mbuf *m;
463: struct igmp *igmp;
464: struct ip *ip;
465: struct ip_moptions imo;
466:
467: MGETHDR(m, M_DONTWAIT, MT_HEADER);
468: if (m == NULL)
469: return;
470:
471: m->m_pkthdr.rcvif = loif;
472: m->m_pkthdr.len = sizeof(struct ip) + IGMP_MINLEN;
473: MH_ALIGN(m, IGMP_MINLEN + sizeof(struct ip));
474: m->m_data += sizeof(struct ip);
475: m->m_len = IGMP_MINLEN;
476: igmp = mtod(m, struct igmp *);
477: igmp->igmp_type = type;
478: igmp->igmp_code = 0;
479: igmp->igmp_group = inm->inm_addr;
480: igmp->igmp_cksum = 0;
481: igmp->igmp_cksum = in_cksum(m, IGMP_MINLEN);
482:
483: m->m_data -= sizeof(struct ip);
484: m->m_len += sizeof(struct ip);
485: ip = mtod(m, struct ip *);
486: ip->ip_tos = 0;
487: ip->ip_len = sizeof(struct ip) + IGMP_MINLEN;
488: ip->ip_off = 0;
489: ip->ip_p = IPPROTO_IGMP;
490: ip->ip_src.s_addr = INADDR_ANY;
491: ip->ip_dst.s_addr = addr ? addr : igmp->igmp_group.s_addr;
492:
493: imo.imo_multicast_ifp = inm->inm_ifp;
494: imo.imo_multicast_ttl = 1;
495: imo.imo_multicast_vif = -1;
496: /*
497: * Request loopback of the report if we are acting as a multicast
498: * router, so that the process-level routing demon can hear it.
499: */
500: imo.imo_multicast_loop = (ip_mrouter != NULL);
501:
502: /*
503: * XXX
504: * Do we have to worry about reentrancy here? Don't think so.
505: */
506: ip_output(m, router_alert, &igmprt, 0, &imo);
507:
508: ++igmpstat.igps_snd_reports;
509: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.