![[BACK]](/icons/back.gif){kind=icon}
Return to igmp.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / netinet|
Return to igmp.c CVS log | Up to [local] / sys / netinet |
1.1 nbrk 1: /* $OpenBSD: igmp.c,v 1.24 2007/07/20 19:00:35 claudio Exp $ */
2: /* $NetBSD: igmp.c,v 1.15 1996/02/13 23:41:25 christos Exp $ */
3:
4: /*
5: * Internet Group Management Protocol (IGMP) routines.
6: *
7: * Written by Steve Deering, Stanford, May 1988.
8: * Modified by Rosen Sharma, Stanford, Aug 1994.
9: * Modified by Bill Fenner, Xerox PARC, Feb 1995.
10: *
11: * MULTICAST Revision: 1.3
12: */
13:
14: #include <sys/param.h>
15: #include <sys/mbuf.h>
16: #include <sys/socket.h>
17: #include <sys/protosw.h>
18:
19: #include <net/if.h>
20: #include <net/route.h>
21:
22: #include <netinet/in.h>
23: #include <netinet/in_var.h>
24: #include <netinet/in_systm.h>
25: #include <netinet/ip.h>
26: #include <netinet/ip_var.h>
27: #include <netinet/igmp.h>
28: #include <netinet/igmp_var.h>
29: #include <dev/rndvar.h>
30:
31: #include <sys/stdarg.h>
32:
33: #define IP_MULTICASTOPTS 0
34:
35: int igmp_timers_are_running;
36: static struct router_info *rti_head;
37: struct igmpstat igmpstat;
38:
39: void igmp_sendpkt(struct in_multi *, int, in_addr_t);
40: int rti_fill(struct in_multi *);
41: struct router_info * rti_find(struct ifnet *);
42:
43: void
44: igmp_init()
45: {
46:
47: /*
48: * To avoid byte-swapping the same value over and over again.
49: */
50: igmp_timers_are_running = 0;
51: rti_head = 0;
52: }
53:
54: /* Return -1 for error. */
55: int
56: rti_fill(inm)
57: struct in_multi *inm;
58: {
59: struct router_info *rti;
60:
61: for (rti = rti_head; rti != 0; rti = rti->rti_next) {
62: if (rti->rti_ifp == inm->inm_ia->ia_ifp) {
63: inm->inm_rti = rti;
64: if (rti->rti_type == IGMP_v1_ROUTER)
65: return (IGMP_v1_HOST_MEMBERSHIP_REPORT);
66: else
67: return (IGMP_v2_HOST_MEMBERSHIP_REPORT);
68: }
69: }
70:
71: rti = (struct router_info *)malloc(sizeof(struct router_info),
72: M_MRTABLE, M_NOWAIT);
73: if (rti == NULL)
74: return (-1);
75: rti->rti_ifp = inm->inm_ia->ia_ifp;
76: rti->rti_type = IGMP_v2_ROUTER;
77: rti->rti_next = rti_head;
78: rti_head = rti;
79: inm->inm_rti = rti;
80: return (IGMP_v2_HOST_MEMBERSHIP_REPORT);
81: }
82:
83: struct router_info *
84: rti_find(ifp)
85: struct ifnet *ifp;
86: {
87: struct router_info *rti;
88:
89: for (rti = rti_head; rti != 0; rti = rti->rti_next) {
90: if (rti->rti_ifp == ifp)
91: return (rti);
92: }
93:
94: rti = (struct router_info *)malloc(sizeof(struct router_info),
95: M_MRTABLE, M_NOWAIT);
96: if (rti == NULL)
97: return (NULL);
98: rti->rti_ifp = ifp;
99: rti->rti_type = IGMP_v2_ROUTER;
100: rti->rti_next = rti_head;
101: rti_head = rti;
102: return (rti);
103: }
104:
105: void
106: rti_delete(ifp)
107: struct ifnet *ifp;
108: {
109: struct router_info *rti, **prti = &rti_head;
110:
111: for (rti = rti_head; rti != 0; rti = rti->rti_next) {
112: if (rti->rti_ifp == ifp) {
113: *prti = rti->rti_next;
114: free(rti, M_MRTABLE);
115: break;
116: }
117: prti = &rti->rti_next;
118: }
119: }
120:
121: void
122: igmp_input(struct mbuf *m, ...)
123: {
124: int iphlen;
125: struct ifnet *ifp = m->m_pkthdr.rcvif;
126: struct ip *ip = mtod(m, struct ip *);
127: struct igmp *igmp;
128: int igmplen;
129: int minlen;
130: struct in_multi *inm;
131: struct in_multistep step;
132: struct router_info *rti;
133: struct in_ifaddr *ia;
134: int timer;
135: va_list ap;
136:
137: va_start(ap, m);
138: iphlen = va_arg(ap, int);
139: va_end(ap);
140:
141: ++igmpstat.igps_rcv_total;
142:
143: igmplen = ntohs(ip->ip_len) - iphlen;
144:
145: /*
146: * Validate lengths
147: */
148: if (igmplen < IGMP_MINLEN) {
149: ++igmpstat.igps_rcv_tooshort;
150: m_freem(m);
151: return;
152: }
153: minlen = iphlen + IGMP_MINLEN;
154: if ((m->m_flags & M_EXT || m->m_len < minlen) &&
155: (m = m_pullup(m, minlen)) == NULL) {
156: ++igmpstat.igps_rcv_tooshort;
157: return;
158: }
159:
160: /*
161: * Validate checksum
162: */
163: m->m_data += iphlen;
164: m->m_len -= iphlen;
165: igmp = mtod(m, struct igmp *);
166: if (in_cksum(m, igmplen)) {
167: ++igmpstat.igps_rcv_badsum;
168: m_freem(m);
169: return;
170: }
171: m->m_data -= iphlen;
172: m->m_len += iphlen;
173: ip = mtod(m, struct ip *);
174:
175: switch (igmp->igmp_type) {
176:
177: case IGMP_HOST_MEMBERSHIP_QUERY:
178: ++igmpstat.igps_rcv_queries;
179:
180: if (ifp->if_flags & IFF_LOOPBACK)
181: break;
182:
183: if (igmp->igmp_code == 0) {
184: rti = rti_find(ifp);
185: if (rti == NULL) {
186: m_freem(m);
187: return;
188: }
189: rti->rti_type = IGMP_v1_ROUTER;
190: rti->rti_age = 0;
191:
192: if (ip->ip_dst.s_addr != INADDR_ALLHOSTS_GROUP) {
193: ++igmpstat.igps_rcv_badqueries;
194: m_freem(m);
195: return;
196: }
197:
198: /*
199: * Start the timers in all of our membership records
200: * for the interface on which the query arrived,
201: * except those that are already running and those
202: * that belong to a "local" group (224.0.0.X).
203: */
204: IN_FIRST_MULTI(step, inm);
205: while (inm != NULL) {
206: if (inm->inm_ia->ia_ifp == ifp &&
207: inm->inm_timer == 0 &&
208: !IN_LOCAL_GROUP(inm->inm_addr.s_addr)) {
209: inm->inm_state = IGMP_DELAYING_MEMBER;
210: inm->inm_timer = IGMP_RANDOM_DELAY(
211: IGMP_MAX_HOST_REPORT_DELAY * PR_FASTHZ);
212: igmp_timers_are_running = 1;
213: }
214: IN_NEXT_MULTI(step, inm);
215: }
216: } else {
217: if (!IN_MULTICAST(ip->ip_dst.s_addr)) {
218: ++igmpstat.igps_rcv_badqueries;
219: m_freem(m);
220: return;
221: }
222:
223: timer = igmp->igmp_code * PR_FASTHZ / IGMP_TIMER_SCALE;
224: if (timer == 0)
225: timer = 1;
226:
227: /*
228: * Start the timers in all of our membership records
229: * for the interface on which the query arrived,
230: * except those that are already running and those
231: * that belong to a "local" group (224.0.0.X). For
232: * timers already running, check if they need to be
233: * reset.
234: */
235: IN_FIRST_MULTI(step, inm);
236: while (inm != NULL) {
237: if (inm->inm_ia->ia_ifp == ifp &&
238: !IN_LOCAL_GROUP(inm->inm_addr.s_addr) &&
239: (ip->ip_dst.s_addr == INADDR_ALLHOSTS_GROUP ||
240: ip->ip_dst.s_addr == inm->inm_addr.s_addr)) {
241: switch (inm->inm_state) {
242: case IGMP_DELAYING_MEMBER:
243: if (inm->inm_timer <= timer)
244: break;
245: /* FALLTHROUGH */
246: case IGMP_IDLE_MEMBER:
247: case IGMP_LAZY_MEMBER:
248: case IGMP_AWAKENING_MEMBER:
249: inm->inm_state =
250: IGMP_DELAYING_MEMBER;
251: inm->inm_timer =
252: IGMP_RANDOM_DELAY(timer);
253: igmp_timers_are_running = 1;
254: break;
255: case IGMP_SLEEPING_MEMBER:
256: inm->inm_state =
257: IGMP_AWAKENING_MEMBER;
258: break;
259: }
260: }
261: IN_NEXT_MULTI(step, inm);
262: }
263: }
264:
265: break;
266:
267: case IGMP_v1_HOST_MEMBERSHIP_REPORT:
268: ++igmpstat.igps_rcv_reports;
269:
270: if (ifp->if_flags & IFF_LOOPBACK)
271: break;
272:
273: if (!IN_MULTICAST(igmp->igmp_group.s_addr) ||
274: igmp->igmp_group.s_addr != ip->ip_dst.s_addr) {
275: ++igmpstat.igps_rcv_badreports;
276: m_freem(m);
277: return;
278: }
279:
280: /*
281: * KLUDGE: if the IP source address of the report has an
282: * unspecified (i.e., zero) subnet number, as is allowed for
283: * a booting host, replace it with the correct subnet number
284: * so that a process-level multicast routing daemon can
285: * determine which subnet it arrived from. This is necessary
286: * to compensate for the lack of any way for a process to
287: * determine the arrival interface of an incoming packet.
288: */
289: if ((ip->ip_src.s_addr & IN_CLASSA_NET) == 0) {
290: IFP_TO_IA(ifp, ia);
291: if (ia)
292: ip->ip_src.s_addr = ia->ia_subnet;
293: }
294:
295: /*
296: * If we belong to the group being reported, stop
297: * our timer for that group.
298: */
299: IN_LOOKUP_MULTI(igmp->igmp_group, ifp, inm);
300: if (inm != NULL) {
301: inm->inm_timer = 0;
302: ++igmpstat.igps_rcv_ourreports;
303:
304: switch (inm->inm_state) {
305: case IGMP_IDLE_MEMBER:
306: case IGMP_LAZY_MEMBER:
307: case IGMP_AWAKENING_MEMBER:
308: case IGMP_SLEEPING_MEMBER:
309: inm->inm_state = IGMP_SLEEPING_MEMBER;
310: break;
311: case IGMP_DELAYING_MEMBER:
312: if (inm->inm_rti->rti_type == IGMP_v1_ROUTER)
313: inm->inm_state = IGMP_LAZY_MEMBER;
314: else
315: inm->inm_state = IGMP_SLEEPING_MEMBER;
316: break;
317: }
318: }
319:
320: break;
321:
322: case IGMP_v2_HOST_MEMBERSHIP_REPORT:
323: #ifdef MROUTING
324: /*
325: * Make sure we don't hear our own membership report. Fast
326: * leave requires knowing that we are the only member of a
327: * group.
328: */
329: IFP_TO_IA(ifp, ia);
330: if (ia && ip->ip_src.s_addr == ia->ia_addr.sin_addr.s_addr)
331: break;
332: #endif
333:
334: ++igmpstat.igps_rcv_reports;
335:
336: if (ifp->if_flags & IFF_LOOPBACK)
337: break;
338:
339: if (!IN_MULTICAST(igmp->igmp_group.s_addr) ||
340: igmp->igmp_group.s_addr != ip->ip_dst.s_addr) {
341: ++igmpstat.igps_rcv_badreports;
342: m_freem(m);
343: return;
344: }
345:
346: /*
347: * KLUDGE: if the IP source address of the report has an
348: * unspecified (i.e., zero) subnet number, as is allowed for
349: * a booting host, replace it with the correct subnet number
350: * so that a process-level multicast routing daemon can
351: * determine which subnet it arrived from. This is necessary
352: * to compensate for the lack of any way for a process to
353: * determine the arrival interface of an incoming packet.
354: */
355: if ((ip->ip_src.s_addr & IN_CLASSA_NET) == 0) {
356: #ifndef MROUTING
357: IFP_TO_IA(ifp, ia);
358: #endif
359: if (ia)
360: ip->ip_src.s_addr = ia->ia_subnet;
361: }
362:
363: /*
364: * If we belong to the group being reported, stop
365: * our timer for that group.
366: */
367: IN_LOOKUP_MULTI(igmp->igmp_group, ifp, inm);
368: if (inm != NULL) {
369: inm->inm_timer = 0;
370: ++igmpstat.igps_rcv_ourreports;
371:
372: switch (inm->inm_state) {
373: case IGMP_DELAYING_MEMBER:
374: case IGMP_IDLE_MEMBER:
375: case IGMP_AWAKENING_MEMBER:
376: inm->inm_state = IGMP_LAZY_MEMBER;
377: break;
378: case IGMP_LAZY_MEMBER:
379: case IGMP_SLEEPING_MEMBER:
380: break;
381: }
382: }
383:
384: break;
385:
386: }
387:
388: /*
389: * Pass all valid IGMP packets up to any process(es) listening
390: * on a raw IGMP socket.
391: */
392: rip_input(m);
393: }
394:
395: void
396: igmp_joingroup(inm)
397: struct in_multi *inm;
398: {
399: int i, s = splsoftnet();
400:
401: inm->inm_state = IGMP_IDLE_MEMBER;
402:
403: if (!IN_LOCAL_GROUP(inm->inm_addr.s_addr) &&
404: (inm->inm_ia->ia_ifp->if_flags & IFF_LOOPBACK) == 0) {
405: if ((i = rti_fill(inm)) == -1) {
406: splx(s);
407: return;
408: }
409: igmp_sendpkt(inm, i, 0);
410: inm->inm_state = IGMP_DELAYING_MEMBER;
411: inm->inm_timer = IGMP_RANDOM_DELAY(
412: IGMP_MAX_HOST_REPORT_DELAY * PR_FASTHZ);
413: igmp_timers_are_running = 1;
414: } else
415: inm->inm_timer = 0;
416: splx(s);
417: }
418:
419: void
420: igmp_leavegroup(inm)
421: struct in_multi *inm;
422: {
423:
424: switch (inm->inm_state) {
425: case IGMP_DELAYING_MEMBER:
426: case IGMP_IDLE_MEMBER:
427: if (!IN_LOCAL_GROUP(inm->inm_addr.s_addr) &&
428: (inm->inm_ia->ia_ifp->if_flags & IFF_LOOPBACK) == 0)
429: if (inm->inm_rti->rti_type != IGMP_v1_ROUTER)
430: igmp_sendpkt(inm, IGMP_HOST_LEAVE_MESSAGE,
431: INADDR_ALLROUTERS_GROUP);
432: break;
433: case IGMP_LAZY_MEMBER:
434: case IGMP_AWAKENING_MEMBER:
435: case IGMP_SLEEPING_MEMBER:
436: break;
437: }
438: }
439:
440: void
441: igmp_fasttimo()
442: {
443: struct in_multi *inm;
444: struct in_multistep step;
445: int s;
446:
447: /*
448: * Quick check to see if any work needs to be done, in order
449: * to minimize the overhead of fasttimo processing.
450: */
451: if (!igmp_timers_are_running)
452: return;
453:
454: s = splsoftnet();
455: igmp_timers_are_running = 0;
456: IN_FIRST_MULTI(step, inm);
457: while (inm != NULL) {
458: if (inm->inm_timer == 0) {
459: /* do nothing */
460: } else if (--inm->inm_timer == 0) {
461: if (inm->inm_state == IGMP_DELAYING_MEMBER) {
462: if (inm->inm_rti->rti_type == IGMP_v1_ROUTER)
463: igmp_sendpkt(inm,
464: IGMP_v1_HOST_MEMBERSHIP_REPORT, 0);
465: else
466: igmp_sendpkt(inm,
467: IGMP_v2_HOST_MEMBERSHIP_REPORT, 0);
468: inm->inm_state = IGMP_IDLE_MEMBER;
469: }
470: } else {
471: igmp_timers_are_running = 1;
472: }
473: IN_NEXT_MULTI(step, inm);
474: }
475: splx(s);
476: }
477:
478: void
479: igmp_slowtimo()
480: {
481: struct router_info *rti;
482: int s;
483:
484: s = splsoftnet();
485: for (rti = rti_head; rti != 0; rti = rti->rti_next) {
486: if (rti->rti_type == IGMP_v1_ROUTER &&
487: ++rti->rti_age >= IGMP_AGE_THRESHOLD) {
488: rti->rti_type = IGMP_v2_ROUTER;
489: }
490: }
491: splx(s);
492: }
493:
494: void
495: igmp_sendpkt(inm, type, addr)
496: struct in_multi *inm;
497: int type;
498: in_addr_t addr;
499: {
500: struct mbuf *m;
501: struct igmp *igmp;
502: struct ip *ip;
503: struct ip_moptions imo;
504: #ifdef MROUTING
505: extern struct socket *ip_mrouter;
506: #endif /* MROUTING */
507:
508: MGETHDR(m, M_DONTWAIT, MT_HEADER);
509: if (m == NULL)
510: return;
511: /*
512: * Assume max_linkhdr + sizeof(struct ip) + IGMP_MINLEN
513: * is smaller than mbuf size returned by MGETHDR.
514: */
515: m->m_data += max_linkhdr;
516: m->m_len = sizeof(struct ip) + IGMP_MINLEN;
517: m->m_pkthdr.len = sizeof(struct ip) + IGMP_MINLEN;
518:
519: ip = mtod(m, struct ip *);
520: ip->ip_tos = 0;
521: ip->ip_len = htons(sizeof(struct ip) + IGMP_MINLEN);
522: ip->ip_off = 0;
523: ip->ip_p = IPPROTO_IGMP;
524: ip->ip_src.s_addr = INADDR_ANY;
525: if (addr) {
526: ip->ip_dst.s_addr = addr;
527: } else {
528: ip->ip_dst = inm->inm_addr;
529: }
530:
531: m->m_data += sizeof(struct ip);
532: m->m_len -= sizeof(struct ip);
533: igmp = mtod(m, struct igmp *);
534: igmp->igmp_type = type;
535: igmp->igmp_code = 0;
536: igmp->igmp_group = inm->inm_addr;
537: igmp->igmp_cksum = 0;
538: igmp->igmp_cksum = in_cksum(m, IGMP_MINLEN);
539: m->m_data -= sizeof(struct ip);
540: m->m_len += sizeof(struct ip);
541:
542: imo.imo_multicast_ifp = inm->inm_ia->ia_ifp;
543: imo.imo_multicast_ttl = 1;
544: #ifdef RSVP_ISI
545: imo.imo_multicast_vif = -1;
546: #endif
547: /*
548: * Request loopback of the report if we are acting as a multicast
549: * router, so that the process-level routing daemon can hear it.
550: */
551: #ifdef MROUTING
552: imo.imo_multicast_loop = (ip_mrouter != NULL);
553: #else
554: imo.imo_multicast_loop = 0;
555: #endif /* MROUTING */
556:
557: ip_output(m, (struct mbuf *)0, (struct route *)0, IP_MULTICASTOPTS,
558: &imo, (void *)NULL);
559:
560: ++igmpstat.igps_snd_reports;
561: }