![[BACK]](/icons/back.gif){kind=icon}
Return to ip6_mroute.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / netinet6|
Return to ip6_mroute.c CVS log | Up to [local] / sys / netinet6 |
1.1 nbrk 1: /* $NetBSD: ip6_mroute.c,v 1.59 2003/12/10 09:28:38 itojun Exp $ */
2: /* $KAME: ip6_mroute.c,v 1.45 2001/03/25 08:38:51 itojun Exp $ */
3:
4: /*
5: * Copyright (C) 1998 WIDE Project.
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. Neither the name of the project nor the names of its contributors
17: * may be used to endorse or promote products derived from this software
18: * without specific prior written permission.
19: *
20: * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23: * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30: * SUCH DAMAGE.
31: */
32:
33: /* BSDI ip_mroute.c,v 2.10 1996/11/14 00:29:52 jch Exp */
34:
35: /*
36: * Copyright (c) 1989 Stephen Deering
37: * Copyright (c) 1992, 1993
38: * The Regents of the University of California. All rights reserved.
39: *
40: * This code is derived from software contributed to Berkeley by
41: * Stephen Deering of Stanford University.
42: *
43: * Redistribution and use in source and binary forms, with or without
44: * modification, are permitted provided that the following conditions
45: * are met:
46: * 1. Redistributions of source code must retain the above copyright
47: * notice, this list of conditions and the following disclaimer.
48: * 2. Redistributions in binary form must reproduce the above copyright
49: * notice, this list of conditions and the following disclaimer in the
50: * documentation and/or other materials provided with the distribution.
51: * 3. Neither the name of the University nor the names of its contributors
52: * may be used to endorse or promote products derived from this software
53: * without specific prior written permission.
54: *
55: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
56: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
57: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
58: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
59: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
60: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
61: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
62: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
63: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
64: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
65: * SUCH DAMAGE.
66: *
67: * @(#)ip_mroute.c 8.2 (Berkeley) 11/15/93
68: */
69:
70: /*
71: * IP multicast forwarding procedures
72: *
73: * Written by David Waitzman, BBN Labs, August 1988.
74: * Modified by Steve Deering, Stanford, February 1989.
75: * Modified by Mark J. Steiglitz, Stanford, May, 1991
76: * Modified by Van Jacobson, LBL, January 1993
77: * Modified by Ajit Thyagarajan, PARC, August 1993
78: * Modified by Bill Fenner, PARC, April 1994
79: *
80: * MROUTING Revision: 3.5.1.2 + PIM-SMv2 (pimd) Support
81: */
82:
83: #ifndef _KERNEL
84: # ifdef KERNEL
85: # define _KERNEL
86: # endif
87: #endif
88:
89: #include <sys/param.h>
90: #include <sys/systm.h>
91: #include <sys/timeout.h>
92: #include <sys/mbuf.h>
93: #include <sys/socket.h>
94: #include <sys/socketvar.h>
95: #include <sys/sockio.h>
96: #include <sys/protosw.h>
97: #include <sys/errno.h>
98: #include <sys/time.h>
99: #include <sys/kernel.h>
100: #include <sys/ioctl.h>
101: #include <sys/syslog.h>
102:
103: #include <net/if.h>
104: #include <net/route.h>
105: #include <net/raw_cb.h>
106:
107: #include <netinet/in.h>
108: #include <netinet/in_var.h>
109: #include <netinet/icmp6.h>
110:
111: #include <netinet/ip6.h>
112: #include <netinet6/ip6_var.h>
113: #include <netinet6/ip6_mroute.h>
114: #include <netinet6/pim6.h>
115: #include <netinet6/pim6_var.h>
116: #include <netinet6/nd6.h>
117:
118: static int ip6_mdq(struct mbuf *, struct ifnet *, struct mf6c *);
119: static void phyint_send(struct ip6_hdr *, struct mif6 *, struct mbuf *);
120:
121: static int set_pim6(int *);
122: static int get_pim6(struct mbuf *);
123: static int socket_send(struct socket *, struct mbuf *,
124: struct sockaddr_in6 *);
125: static int register_send(struct ip6_hdr *, struct mif6 *,
126: struct mbuf *);
127:
128: /*
129: * Globals. All but ip6_mrouter, ip6_mrtproto and mrt6stat could be static,
130: * except for netstat or debugging purposes.
131: */
132: struct socket *ip6_mrouter = NULL;
133: int ip6_mrouter_ver = 0;
134: int ip6_mrtproto = IPPROTO_PIM; /* for netstat only */
135: struct mrt6stat mrt6stat;
136:
137: #define NO_RTE_FOUND 0x1
138: #define RTE_FOUND 0x2
139:
140: struct mf6c *mf6ctable[MF6CTBLSIZ];
141: u_char n6expire[MF6CTBLSIZ];
142: struct mif6 mif6table[MAXMIFS];
143: #ifdef MRT6DEBUG
144: u_int mrt6debug = 0; /* debug level */
145: #define DEBUG_MFC 0x02
146: #define DEBUG_FORWARD 0x04
147: #define DEBUG_EXPIRE 0x08
148: #define DEBUG_XMIT 0x10
149: #define DEBUG_REG 0x20
150: #define DEBUG_PIM 0x40
151: #endif
152:
153: static void expire_upcalls(void *);
154: #define EXPIRE_TIMEOUT (hz / 4) /* 4x / second */
155: #define UPCALL_EXPIRE 6 /* number of timeouts */
156:
157: #ifdef INET
158: #ifdef MROUTING
159: extern struct socket *ip_mrouter;
160: #endif
161: #endif
162:
163: /*
164: * 'Interfaces' associated with decapsulator (so we can tell
165: * packets that went through it from ones that get reflected
166: * by a broken gateway). These interfaces are never linked into
167: * the system ifnet list & no routes point to them. I.e., packets
168: * can't be sent this way. They only exist as a placeholder for
169: * multicast source verification.
170: */
171: struct ifnet multicast_register_if;
172:
173: #define ENCAP_HOPS 64
174:
175: /*
176: * Private variables.
177: */
178: static mifi_t nummifs = 0;
179: static mifi_t reg_mif_num = (mifi_t)-1;
180:
181: struct pim6stat pim6stat;
182: static int pim6;
183:
184: /*
185: * Hash function for a source, group entry
186: */
187: #define MF6CHASH(a, g) MF6CHASHMOD((a).s6_addr32[0] ^ (a).s6_addr32[1] ^ \
188: (a).s6_addr32[2] ^ (a).s6_addr32[3] ^ \
189: (g).s6_addr32[0] ^ (g).s6_addr32[1] ^ \
190: (g).s6_addr32[2] ^ (g).s6_addr32[3])
191:
192: /*
193: * Find a route for a given origin IPv6 address and Multicast group address.
194: * Quality of service parameter to be added in the future!!!
195: */
196:
197: #define MF6CFIND(o, g, rt) do { \
198: struct mf6c *_rt = mf6ctable[MF6CHASH(o,g)]; \
199: rt = NULL; \
200: mrt6stat.mrt6s_mfc_lookups++; \
201: while (_rt) { \
202: if (IN6_ARE_ADDR_EQUAL(&_rt->mf6c_origin.sin6_addr, &(o)) && \
203: IN6_ARE_ADDR_EQUAL(&_rt->mf6c_mcastgrp.sin6_addr, &(g)) && \
204: (_rt->mf6c_stall == NULL)) { \
205: rt = _rt; \
206: break; \
207: } \
208: _rt = _rt->mf6c_next; \
209: } \
210: if (rt == NULL) { \
211: mrt6stat.mrt6s_mfc_misses++; \
212: } \
213: } while (0)
214:
215: /*
216: * Macros to compute elapsed time efficiently
217: * Borrowed from Van Jacobson's scheduling code
218: */
219: #define TV_DELTA(a, b, delta) do { \
220: int xxs; \
221: \
222: delta = (a).tv_usec - (b).tv_usec; \
223: if ((xxs = (a).tv_sec - (b).tv_sec)) { \
224: switch (xxs) { \
225: case 2: \
226: delta += 1000000; \
227: /* FALLTHROUGH */ \
228: case 1: \
229: delta += 1000000; \
230: break; \
231: default: \
232: delta += (1000000 * xxs); \
233: } \
234: } \
235: } while (0)
236:
237: #define TV_LT(a, b) (((a).tv_usec < (b).tv_usec && \
238: (a).tv_sec <= (b).tv_sec) || (a).tv_sec < (b).tv_sec)
239:
240: #ifdef UPCALL_TIMING
241: #define UPCALL_MAX 50
242: u_long upcall_data[UPCALL_MAX + 1];
243: static void collate();
244: #endif /* UPCALL_TIMING */
245:
246: static int get_sg_cnt(struct sioc_sg_req6 *);
247: static int get_mif6_cnt(struct sioc_mif_req6 *);
248: static int ip6_mrouter_init(struct socket *, int, int);
249: static int add_m6if(struct mif6ctl *);
250: static int del_m6if(mifi_t *);
251: static int add_m6fc(struct mf6cctl *);
252: static int del_m6fc(struct mf6cctl *);
253:
254: static struct timeout expire_upcalls_ch;
255:
256: /*
257: * Handle MRT setsockopt commands to modify the multicast routing tables.
258: */
259: int
260: ip6_mrouter_set(cmd, so, m)
261: int cmd;
262: struct socket *so;
263: struct mbuf *m;
264: {
265: if (cmd != MRT6_INIT && so != ip6_mrouter)
266: return (EACCES);
267:
268: switch (cmd) {
269: #ifdef MRT6_OINIT
270: case MRT6_OINIT:
271: #endif
272: case MRT6_INIT:
273: if (m == NULL || m->m_len < sizeof(int))
274: return (EINVAL);
275: return (ip6_mrouter_init(so, *mtod(m, int *), cmd));
276: case MRT6_DONE:
277: return (ip6_mrouter_done());
278: case MRT6_ADD_MIF:
279: if (m == NULL || m->m_len < sizeof(struct mif6ctl))
280: return (EINVAL);
281: return (add_m6if(mtod(m, struct mif6ctl *)));
282: case MRT6_DEL_MIF:
283: if (m == NULL || m->m_len < sizeof(mifi_t))
284: return (EINVAL);
285: return (del_m6if(mtod(m, mifi_t *)));
286: case MRT6_ADD_MFC:
287: if (m == NULL || m->m_len < sizeof(struct mf6cctl))
288: return (EINVAL);
289: return (add_m6fc(mtod(m, struct mf6cctl *)));
290: case MRT6_DEL_MFC:
291: if (m == NULL || m->m_len < sizeof(struct mf6cctl))
292: return (EINVAL);
293: return (del_m6fc(mtod(m, struct mf6cctl *)));
294: case MRT6_PIM:
295: if (m == NULL || m->m_len < sizeof(int))
296: return (EINVAL);
297: return (set_pim6(mtod(m, int *)));
298: default:
299: return (EOPNOTSUPP);
300: }
301: }
302:
303: /*
304: * Handle MRT getsockopt commands
305: */
306: int
307: ip6_mrouter_get(cmd, so, m)
308: int cmd;
309: struct socket *so;
310: struct mbuf **m;
311: {
312: struct mbuf *mb;
313:
314: if (so != ip6_mrouter) return EACCES;
315:
316: *m = mb = m_get(M_WAIT, MT_SOOPTS);
317:
318: switch (cmd) {
319: case MRT6_PIM:
320: return get_pim6(mb);
321: default:
322: m_free(mb);
323: return EOPNOTSUPP;
324: }
325: }
326:
327: /*
328: * Handle ioctl commands to obtain information from the cache
329: */
330: int
331: mrt6_ioctl(cmd, data)
332: int cmd;
333: caddr_t data;
334: {
335:
336: switch (cmd) {
337: case SIOCGETSGCNT_IN6:
338: return (get_sg_cnt((struct sioc_sg_req6 *)data));
339: case SIOCGETMIFCNT_IN6:
340: return (get_mif6_cnt((struct sioc_mif_req6 *)data));
341: default:
342: return (EINVAL);
343: }
344: }
345:
346: /*
347: * returns the packet, byte, rpf-failure count for the source group provided
348: */
349: static int
350: get_sg_cnt(req)
351: struct sioc_sg_req6 *req;
352: {
353: struct mf6c *rt;
354: int s;
355:
356: s = splsoftnet();
357:
358: MF6CFIND(req->src.sin6_addr, req->grp.sin6_addr, rt);
359: splx(s);
360: if (rt != NULL) {
361: req->pktcnt = rt->mf6c_pkt_cnt;
362: req->bytecnt = rt->mf6c_byte_cnt;
363: req->wrong_if = rt->mf6c_wrong_if;
364: } else
365: return (ESRCH);
366: #if 0
367: req->pktcnt = req->bytecnt = req->wrong_if = 0xffffffff;
368: #endif
369:
370: return 0;
371: }
372:
373: /*
374: * returns the input and output packet and byte counts on the mif provided
375: */
376: static int
377: get_mif6_cnt(req)
378: struct sioc_mif_req6 *req;
379: {
380: mifi_t mifi = req->mifi;
381:
382: if (mifi >= nummifs)
383: return EINVAL;
384:
385: req->icount = mif6table[mifi].m6_pkt_in;
386: req->ocount = mif6table[mifi].m6_pkt_out;
387: req->ibytes = mif6table[mifi].m6_bytes_in;
388: req->obytes = mif6table[mifi].m6_bytes_out;
389:
390: return 0;
391: }
392:
393: /*
394: * Get PIM processiong global
395: */
396: static int
397: get_pim6(m)
398: struct mbuf *m;
399: {
400: int *i;
401:
402: i = mtod(m, int *);
403:
404: *i = pim6;
405:
406: return 0;
407: }
408:
409: static int
410: set_pim6(i)
411: int *i;
412: {
413: if ((*i != 1) && (*i != 0))
414: return EINVAL;
415:
416: pim6 = *i;
417:
418: return 0;
419: }
420:
421: /*
422: * Enable multicast routing
423: */
424: static int
425: ip6_mrouter_init(so, v, cmd)
426: struct socket *so;
427: int v;
428: int cmd;
429: {
430: #ifdef MRT6DEBUG
431: if (mrt6debug)
432: log(LOG_DEBUG,
433: "ip6_mrouter_init: so_type = %d, pr_protocol = %d\n",
434: so->so_type, so->so_proto->pr_protocol);
435: #endif
436:
437: if (so->so_type != SOCK_RAW ||
438: so->so_proto->pr_protocol != IPPROTO_ICMPV6)
439: return (EOPNOTSUPP);
440:
441: if (v != 1)
442: return (ENOPROTOOPT);
443:
444: if (ip6_mrouter != NULL)
445: return (EADDRINUSE);
446:
447: ip6_mrouter = so;
448: ip6_mrouter_ver = cmd;
449:
450: bzero((caddr_t)mf6ctable, sizeof(mf6ctable));
451: bzero((caddr_t)n6expire, sizeof(n6expire));
452:
453: pim6 = 0;/* used for stubbing out/in pim stuff */
454:
455: timeout_set(&expire_upcalls_ch, expire_upcalls, NULL);
456: timeout_add(&expire_upcalls_ch, EXPIRE_TIMEOUT);
457:
458: #ifdef MRT6DEBUG
459: if (mrt6debug)
460: log(LOG_DEBUG, "ip6_mrouter_init\n");
461: #endif
462:
463: return 0;
464: }
465:
466: /*
467: * Disable multicast routing
468: */
469: int
470: ip6_mrouter_done()
471: {
472: mifi_t mifi;
473: int i;
474: struct ifnet *ifp;
475: struct in6_ifreq ifr;
476: struct mf6c *rt;
477: struct rtdetq *rte;
478: int s;
479:
480: s = splsoftnet();
481:
482: /*
483: * For each phyint in use, disable promiscuous reception of all IPv6
484: * multicasts.
485: */
486: #ifdef INET
487: #ifdef MROUTING
488: /*
489: * If there is still IPv4 multicast routing daemon,
490: * we remain interfaces to receive all muliticasted packets.
491: * XXX: there may be an interface in which the IPv4 multicast
492: * daemon is not interested...
493: */
494: if (!ip_mrouter)
495: #endif
496: #endif
497: {
498: for (mifi = 0; mifi < nummifs; mifi++) {
499: if (mif6table[mifi].m6_ifp &&
500: !(mif6table[mifi].m6_flags & MIFF_REGISTER)) {
501: ifr.ifr_addr.sin6_family = AF_INET6;
502: ifr.ifr_addr.sin6_addr= in6addr_any;
503: ifp = mif6table[mifi].m6_ifp;
504: (*ifp->if_ioctl)(ifp, SIOCDELMULTI,
505: (caddr_t)&ifr);
506: }
507: }
508: }
509: #ifdef notyet
510: bzero((caddr_t)qtable, sizeof(qtable));
511: bzero((caddr_t)tbftable, sizeof(tbftable));
512: #endif
513: bzero((caddr_t)mif6table, sizeof(mif6table));
514: nummifs = 0;
515:
516: pim6 = 0; /* used to stub out/in pim specific code */
517:
518: timeout_del(&expire_upcalls_ch);
519:
520: /*
521: * Free all multicast forwarding cache entries.
522: */
523: for (i = 0; i < MF6CTBLSIZ; i++) {
524: rt = mf6ctable[i];
525: while (rt) {
526: struct mf6c *frt;
527:
528: for (rte = rt->mf6c_stall; rte != NULL; ) {
529: struct rtdetq *n = rte->next;
530:
531: m_free(rte->m);
532: free(rte, M_MRTABLE);
533: rte = n;
534: }
535: frt = rt;
536: rt = rt->mf6c_next;
537: free(frt, M_MRTABLE);
538: }
539: }
540:
541: bzero((caddr_t)mf6ctable, sizeof(mf6ctable));
542:
543: /*
544: * Reset de-encapsulation cache
545: */
546: reg_mif_num = -1;
547:
548: ip6_mrouter = NULL;
549: ip6_mrouter_ver = 0;
550:
551: splx(s);
552:
553: #ifdef MRT6DEBUG
554: if (mrt6debug)
555: log(LOG_DEBUG, "ip6_mrouter_done\n");
556: #endif
557:
558: return 0;
559: }
560:
561: void
562: ip6_mrouter_detach(ifp)
563: struct ifnet *ifp;
564: {
565: struct rtdetq *rte;
566: struct mf6c *mfc;
567: mifi_t mifi;
568: int i;
569:
570: /*
571: * Delete a mif which points to ifp.
572: */
573: for (mifi = 0; mifi < nummifs; mifi++)
574: if (mif6table[mifi].m6_ifp == ifp)
575: del_m6if(&mifi);
576:
577: /*
578: * Clear rte->ifp of cache entries received on ifp.
579: */
580: for (i = 0; i < MF6CTBLSIZ; i++) {
581: if (n6expire[i] == 0)
582: continue;
583:
584: for (mfc = mf6ctable[i]; mfc != NULL; mfc = mfc->mf6c_next) {
585: for (rte = mfc->mf6c_stall; rte != NULL; rte = rte->next) {
586: if (rte->ifp == ifp)
587: rte->ifp = NULL;
588: }
589: }
590: }
591: }
592:
593: /*
594: * Add a mif to the mif table
595: */
596: static int
597: add_m6if(mifcp)
598: struct mif6ctl *mifcp;
599: {
600: struct mif6 *mifp;
601: struct ifnet *ifp;
602: struct in6_ifreq ifr;
603: int error, s;
604: #ifdef notyet
605: struct tbf *m_tbf = tbftable + mifcp->mif6c_mifi;
606: #endif
607:
608: if (mifcp->mif6c_mifi >= MAXMIFS)
609: return EINVAL;
610: mifp = mif6table + mifcp->mif6c_mifi;
611: if (mifp->m6_ifp)
612: return EADDRINUSE; /* XXX: is it appropriate? */
613: if (mifcp->mif6c_pifi == 0 || mifcp->mif6c_pifi >= if_indexlim)
614: return ENXIO;
615: ifp = ifindex2ifnet[mifcp->mif6c_pifi];
616: if (!ifp)
617: return ENXIO;
618:
619: if (mifcp->mif6c_flags & MIFF_REGISTER) {
620: if (reg_mif_num == (mifi_t)-1) {
621: strlcpy(multicast_register_if.if_xname,
622: "register_mif",
623: sizeof multicast_register_if.if_xname); /* XXX */
624: multicast_register_if.if_flags |= IFF_LOOPBACK;
625: multicast_register_if.if_index = mifcp->mif6c_mifi;
626: reg_mif_num = mifcp->mif6c_mifi;
627: }
628:
629: ifp = &multicast_register_if;
630:
631: } /* if REGISTER */
632: else {
633: /* Make sure the interface supports multicast */
634: if ((ifp->if_flags & IFF_MULTICAST) == 0)
635: return EOPNOTSUPP;
636:
637: s = splsoftnet();
638:
639: /*
640: * Enable promiscuous reception of all IPv6 multicasts
641: * from the interface.
642: */
643: ifr.ifr_addr.sin6_family = AF_INET6;
644: ifr.ifr_addr.sin6_addr = in6addr_any;
645: error = (*ifp->if_ioctl)(ifp, SIOCADDMULTI, (caddr_t)&ifr);
646:
647: splx(s);
648: if (error)
649: return error;
650: }
651:
652: s = splsoftnet();
653:
654: mifp->m6_flags = mifcp->mif6c_flags;
655: mifp->m6_ifp = ifp;
656: #ifdef notyet
657: /* scaling up here allows division by 1024 in critical code */
658: mifp->m6_rate_limit = mifcp->mif6c_rate_limit * 1024 / 1000;
659: #endif
660: /* initialize per mif pkt counters */
661: mifp->m6_pkt_in = 0;
662: mifp->m6_pkt_out = 0;
663: mifp->m6_bytes_in = 0;
664: mifp->m6_bytes_out = 0;
665: splx(s);
666:
667: /* Adjust nummifs up if the mifi is higher than nummifs */
668: if (nummifs <= mifcp->mif6c_mifi)
669: nummifs = mifcp->mif6c_mifi + 1;
670:
671: #ifdef MRT6DEBUG
672: if (mrt6debug)
673: log(LOG_DEBUG,
674: "add_mif #%d, phyint %s%d\n",
675: mifcp->mif6c_mifi,
676: ifp->if_name, ifp->if_unit);
677: #endif
678:
679: return 0;
680: }
681:
682: /*
683: * Delete a mif from the mif table
684: */
685: static int
686: del_m6if(mifip)
687: mifi_t *mifip;
688: {
689: struct mif6 *mifp = mif6table + *mifip;
690: mifi_t mifi;
691: struct ifnet *ifp;
692: struct in6_ifreq ifr;
693: int s;
694:
695: if (*mifip >= nummifs)
696: return EINVAL;
697: if (mifp->m6_ifp == NULL)
698: return EINVAL;
699:
700: s = splsoftnet();
701:
702: if (!(mifp->m6_flags & MIFF_REGISTER)) {
703: /*
704: * XXX: what if there is yet IPv4 multicast daemon
705: * using the interface?
706: */
707: ifp = mifp->m6_ifp;
708:
709: ifr.ifr_addr.sin6_family = AF_INET6;
710: ifr.ifr_addr.sin6_addr = in6addr_any;
711: (*ifp->if_ioctl)(ifp, SIOCDELMULTI, (caddr_t)&ifr);
712: }
713:
714: #ifdef notyet
715: bzero((caddr_t)qtable[*mifip], sizeof(qtable[*mifip]));
716: bzero((caddr_t)mifp->m6_tbf, sizeof(*(mifp->m6_tbf)));
717: #endif
718: bzero((caddr_t)mifp, sizeof (*mifp));
719:
720: /* Adjust nummifs down */
721: for (mifi = nummifs; mifi > 0; mifi--)
722: if (mif6table[mifi - 1].m6_ifp)
723: break;
724: nummifs = mifi;
725:
726: splx(s);
727:
728: #ifdef MRT6DEBUG
729: if (mrt6debug)
730: log(LOG_DEBUG, "del_m6if %d, nummifs %d\n", *mifip, nummifs);
731: #endif
732:
733: return 0;
734: }
735:
736: /*
737: * Add an mfc entry
738: */
739: static int
740: add_m6fc(mfccp)
741: struct mf6cctl *mfccp;
742: {
743: struct mf6c *rt;
744: u_long hash;
745: struct rtdetq *rte;
746: u_short nstl;
747: int s;
748:
749: MF6CFIND(mfccp->mf6cc_origin.sin6_addr,
750: mfccp->mf6cc_mcastgrp.sin6_addr, rt);
751:
752: /* If an entry already exists, just update the fields */
753: if (rt) {
754: #ifdef MRT6DEBUG
755: if (mrt6debug & DEBUG_MFC)
756: log(LOG_DEBUG,"add_m6fc update o %s g %s p %x\n",
757: ip6_sprintf(&mfccp->mf6cc_origin.sin6_addr),
758: ip6_sprintf(&mfccp->mf6cc_mcastgrp.sin6_addr),
759: mfccp->mf6cc_parent);
760: #endif
761:
762: s = splsoftnet();
763:
764: rt->mf6c_parent = mfccp->mf6cc_parent;
765: rt->mf6c_ifset = mfccp->mf6cc_ifset;
766: splx(s);
767: return 0;
768: }
769:
770: /*
771: * Find the entry for which the upcall was made and update
772: */
773: s = splsoftnet();
774:
775: hash = MF6CHASH(mfccp->mf6cc_origin.sin6_addr,
776: mfccp->mf6cc_mcastgrp.sin6_addr);
777: for (rt = mf6ctable[hash], nstl = 0; rt; rt = rt->mf6c_next) {
778: if (IN6_ARE_ADDR_EQUAL(&rt->mf6c_origin.sin6_addr,
779: &mfccp->mf6cc_origin.sin6_addr) &&
780: IN6_ARE_ADDR_EQUAL(&rt->mf6c_mcastgrp.sin6_addr,
781: &mfccp->mf6cc_mcastgrp.sin6_addr) &&
782: (rt->mf6c_stall != NULL)) {
783:
784: if (nstl++)
785: log(LOG_ERR,
786: "add_m6fc: %s o %s g %s p %x dbx %p\n",
787: "multiple kernel entries",
788: ip6_sprintf(&mfccp->mf6cc_origin.sin6_addr),
789: ip6_sprintf(&mfccp->mf6cc_mcastgrp.sin6_addr),
790: mfccp->mf6cc_parent, rt->mf6c_stall);
791:
792: #ifdef MRT6DEBUG
793: if (mrt6debug & DEBUG_MFC)
794: log(LOG_DEBUG,
795: "add_m6fc o %s g %s p %x dbg %x\n",
796: ip6_sprintf(&mfccp->mf6cc_origin.sin6_addr),
797: ip6_sprintf(&mfccp->mf6cc_mcastgrp.sin6_addr),
798: mfccp->mf6cc_parent, rt->mf6c_stall);
799: #endif
800:
801: rt->mf6c_origin = mfccp->mf6cc_origin;
802: rt->mf6c_mcastgrp = mfccp->mf6cc_mcastgrp;
803: rt->mf6c_parent = mfccp->mf6cc_parent;
804: rt->mf6c_ifset = mfccp->mf6cc_ifset;
805: /* initialize pkt counters per src-grp */
806: rt->mf6c_pkt_cnt = 0;
807: rt->mf6c_byte_cnt = 0;
808: rt->mf6c_wrong_if = 0;
809:
810: rt->mf6c_expire = 0; /* Don't clean this guy up */
811: n6expire[hash]--;
812:
813: /* free packets Qed at the end of this entry */
814: for (rte = rt->mf6c_stall; rte != NULL; ) {
815: struct rtdetq *n = rte->next;
816: if (rte->ifp) {
817: ip6_mdq(rte->m, rte->ifp, rt);
818: }
819: m_freem(rte->m);
820: #ifdef UPCALL_TIMING
821: collate(&(rte->t));
822: #endif /* UPCALL_TIMING */
823: free(rte, M_MRTABLE);
824: rte = n;
825: }
826: rt->mf6c_stall = NULL;
827: }
828: }
829:
830: /*
831: * It is possible that an entry is being inserted without an upcall
832: */
833: if (nstl == 0) {
834: #ifdef MRT6DEBUG
835: if (mrt6debug & DEBUG_MFC)
836: log(LOG_DEBUG,
837: "add_m6fc no upcall h %d o %s g %s p %x\n",
838: hash,
839: ip6_sprintf(&mfccp->mf6cc_origin.sin6_addr),
840: ip6_sprintf(&mfccp->mf6cc_mcastgrp.sin6_addr),
841: mfccp->mf6cc_parent);
842: #endif
843:
844: for (rt = mf6ctable[hash]; rt; rt = rt->mf6c_next) {
845:
846: if (IN6_ARE_ADDR_EQUAL(&rt->mf6c_origin.sin6_addr,
847: &mfccp->mf6cc_origin.sin6_addr)&&
848: IN6_ARE_ADDR_EQUAL(&rt->mf6c_mcastgrp.sin6_addr,
849: &mfccp->mf6cc_mcastgrp.sin6_addr)) {
850:
851: rt->mf6c_origin = mfccp->mf6cc_origin;
852: rt->mf6c_mcastgrp = mfccp->mf6cc_mcastgrp;
853: rt->mf6c_parent = mfccp->mf6cc_parent;
854: rt->mf6c_ifset = mfccp->mf6cc_ifset;
855: /* initialize pkt counters per src-grp */
856: rt->mf6c_pkt_cnt = 0;
857: rt->mf6c_byte_cnt = 0;
858: rt->mf6c_wrong_if = 0;
859:
860: if (rt->mf6c_expire)
861: n6expire[hash]--;
862: rt->mf6c_expire = 0;
863: }
864: }
865: if (rt == NULL) {
866: /* no upcall, so make a new entry */
867: rt = (struct mf6c *)malloc(sizeof(*rt), M_MRTABLE,
868: M_NOWAIT);
869: if (rt == NULL) {
870: splx(s);
871: return ENOBUFS;
872: }
873:
874: /* insert new entry at head of hash chain */
875: rt->mf6c_origin = mfccp->mf6cc_origin;
876: rt->mf6c_mcastgrp = mfccp->mf6cc_mcastgrp;
877: rt->mf6c_parent = mfccp->mf6cc_parent;
878: rt->mf6c_ifset = mfccp->mf6cc_ifset;
879: /* initialize pkt counters per src-grp */
880: rt->mf6c_pkt_cnt = 0;
881: rt->mf6c_byte_cnt = 0;
882: rt->mf6c_wrong_if = 0;
883: rt->mf6c_expire = 0;
884: rt->mf6c_stall = NULL;
885:
886: /* link into table */
887: rt->mf6c_next = mf6ctable[hash];
888: mf6ctable[hash] = rt;
889: }
890: }
891: splx(s);
892: return 0;
893: }
894:
895: #ifdef UPCALL_TIMING
896: /*
897: * collect delay statistics on the upcalls
898: */
899: static void
900: collate(t)
901: struct timeval *t;
902: {
903: u_long d;
904: struct timeval tp;
905: u_long delta;
906:
907: GET_TIME(tp);
908:
909: if (TV_LT(*t, tp))
910: {
911: TV_DELTA(tp, *t, delta);
912:
913: d = delta >> 10;
914: if (d > UPCALL_MAX)
915: d = UPCALL_MAX;
916:
917: ++upcall_data[d];
918: }
919: }
920: #endif /* UPCALL_TIMING */
921:
922: /*
923: * Delete an mfc entry
924: */
925: static int
926: del_m6fc(mfccp)
927: struct mf6cctl *mfccp;
928: {
929: struct sockaddr_in6 origin;
930: struct sockaddr_in6 mcastgrp;
931: struct mf6c *rt;
932: struct mf6c **nptr;
933: u_long hash;
934: int s;
935:
936: origin = mfccp->mf6cc_origin;
937: mcastgrp = mfccp->mf6cc_mcastgrp;
938: hash = MF6CHASH(origin.sin6_addr, mcastgrp.sin6_addr);
939:
940: #ifdef MRT6DEBUG
941: if (mrt6debug & DEBUG_MFC)
942: log(LOG_DEBUG,"del_m6fc orig %s mcastgrp %s\n",
943: ip6_sprintf(&origin.sin6_addr),
944: ip6_sprintf(&mcastgrp.sin6_addr));
945: #endif
946:
947: s = splsoftnet();
948:
949: nptr = &mf6ctable[hash];
950: while ((rt = *nptr) != NULL) {
951: if (IN6_ARE_ADDR_EQUAL(&origin.sin6_addr,
952: &rt->mf6c_origin.sin6_addr) &&
953: IN6_ARE_ADDR_EQUAL(&mcastgrp.sin6_addr,
954: &rt->mf6c_mcastgrp.sin6_addr) &&
955: rt->mf6c_stall == NULL)
956: break;
957:
958: nptr = &rt->mf6c_next;
959: }
960: if (rt == NULL) {
961: splx(s);
962: return EADDRNOTAVAIL;
963: }
964:
965: *nptr = rt->mf6c_next;
966: free(rt, M_MRTABLE);
967:
968: splx(s);
969:
970: return 0;
971: }
972:
973: static int
974: socket_send(s, mm, src)
975: struct socket *s;
976: struct mbuf *mm;
977: struct sockaddr_in6 *src;
978: {
979: if (s) {
980: if (sbappendaddr(&s->so_rcv,
981: (struct sockaddr *)src,
982: mm, (struct mbuf *)0) != 0) {
983: sorwakeup(s);
984: return 0;
985: }
986: }
987: m_freem(mm);
988: return -1;
989: }
990:
991: /*
992: * IPv6 multicast forwarding function. This function assumes that the packet
993: * pointed to by "ip6" has arrived on (or is about to be sent to) the interface
994: * pointed to by "ifp", and the packet is to be relayed to other networks
995: * that have members of the packet's destination IPv6 multicast group.
996: *
997: * The packet is returned unscathed to the caller, unless it is
998: * erroneous, in which case a non-zero return value tells the caller to
999: * discard it.
1000: */
1001:
1002: int
1003: ip6_mforward(ip6, ifp, m)
1004: struct ip6_hdr *ip6;
1005: struct ifnet *ifp;
1006: struct mbuf *m;
1007: {
1008: struct mf6c *rt;
1009: struct mif6 *mifp;
1010: struct mbuf *mm;
1011: int s;
1012: mifi_t mifi;
1013: struct sockaddr_in6 sin6;
1014:
1015: #ifdef MRT6DEBUG
1016: if (mrt6debug & DEBUG_FORWARD)
1017: log(LOG_DEBUG, "ip6_mforward: src %s, dst %s, ifindex %d\n",
1018: ip6_sprintf(&ip6->ip6_src), ip6_sprintf(&ip6->ip6_dst),
1019: ifp->if_index);
1020: #endif
1021:
1022: /*
1023: * Don't forward a packet with Hop limit of zero or one,
1024: * or a packet destined to a local-only group.
1025: */
1026: if (ip6->ip6_hlim <= 1 || IN6_IS_ADDR_MC_INTFACELOCAL(&ip6->ip6_dst) ||
1027: IN6_IS_ADDR_MC_LINKLOCAL(&ip6->ip6_dst))
1028: return 0;
1029: ip6->ip6_hlim--;
1030:
1031: /*
1032: * Source address check: do not forward packets with unspecified
1033: * source. It was discussed in July 2000, on ipngwg mailing list.
1034: * This is rather more serious than unicast cases, because some
1035: * MLD packets can be sent with the unspecified source address
1036: * (although such packets must normally set 1 to the hop limit field).
1037: */
1038: if (IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_src)) {
1039: ip6stat.ip6s_cantforward++;
1040: if (ip6_log_time + ip6_log_interval < time_second) {
1041: ip6_log_time = time_second;
1042: log(LOG_DEBUG,
1043: "cannot forward "
1044: "from %s to %s nxt %d received on %s\n",
1045: ip6_sprintf(&ip6->ip6_src),
1046: ip6_sprintf(&ip6->ip6_dst),
1047: ip6->ip6_nxt,
1048: m->m_pkthdr.rcvif->if_xname);
1049: }
1050: return 0;
1051: }
1052:
1053: /*
1054: * Determine forwarding mifs from the forwarding cache table
1055: */
1056: s = splsoftnet();
1057: MF6CFIND(ip6->ip6_src, ip6->ip6_dst, rt);
1058:
1059: /* Entry exists, so forward if necessary */
1060: if (rt) {
1061: splx(s);
1062: return (ip6_mdq(m, ifp, rt));
1063: } else {
1064: /*
1065: * If we don't have a route for packet's origin,
1066: * Make a copy of the packet &
1067: * send message to routing daemon
1068: */
1069:
1070: struct mbuf *mb0;
1071: struct rtdetq *rte;
1072: u_long hash;
1073: /* int i, npkts;*/
1074: #ifdef UPCALL_TIMING
1075: struct timeval tp;
1076:
1077: GET_TIME(tp);
1078: #endif /* UPCALL_TIMING */
1079:
1080: mrt6stat.mrt6s_no_route++;
1081: #ifdef MRT6DEBUG
1082: if (mrt6debug & (DEBUG_FORWARD | DEBUG_MFC))
1083: log(LOG_DEBUG, "ip6_mforward: no rte s %s g %s\n",
1084: ip6_sprintf(&ip6->ip6_src),
1085: ip6_sprintf(&ip6->ip6_dst));
1086: #endif
1087:
1088: /*
1089: * Allocate mbufs early so that we don't do extra work if we
1090: * are just going to fail anyway.
1091: */
1092: rte = (struct rtdetq *)malloc(sizeof(*rte), M_MRTABLE,
1093: M_NOWAIT);
1094: if (rte == NULL) {
1095: splx(s);
1096: return ENOBUFS;
1097: }
1098: mb0 = m_copy(m, 0, M_COPYALL);
1099: /*
1100: * Pullup packet header if needed before storing it,
1101: * as other references may modify it in the meantime.
1102: */
1103: if (mb0 &&
1104: (M_READONLY(mb0) || mb0->m_len < sizeof(struct ip6_hdr)))
1105: mb0 = m_pullup(mb0, sizeof(struct ip6_hdr));
1106: if (mb0 == NULL) {
1107: free(rte, M_MRTABLE);
1108: splx(s);
1109: return ENOBUFS;
1110: }
1111:
1112: /* is there an upcall waiting for this packet? */
1113: hash = MF6CHASH(ip6->ip6_src, ip6->ip6_dst);
1114: for (rt = mf6ctable[hash]; rt; rt = rt->mf6c_next) {
1115: if (IN6_ARE_ADDR_EQUAL(&ip6->ip6_src,
1116: &rt->mf6c_origin.sin6_addr) &&
1117: IN6_ARE_ADDR_EQUAL(&ip6->ip6_dst,
1118: &rt->mf6c_mcastgrp.sin6_addr) &&
1119: (rt->mf6c_stall != NULL))
1120: break;
1121: }
1122:
1123: if (rt == NULL) {
1124: struct mrt6msg *im;
1125: #ifdef MRT6_OINIT
1126: struct omrt6msg *oim;
1127: #endif
1128:
1129: /* no upcall, so make a new entry */
1130: rt = (struct mf6c *)malloc(sizeof(*rt), M_MRTABLE,
1131: M_NOWAIT);
1132: if (rt == NULL) {
1133: free(rte, M_MRTABLE);
1134: m_freem(mb0);
1135: splx(s);
1136: return ENOBUFS;
1137: }
1138: /*
1139: * Make a copy of the header to send to the user
1140: * level process
1141: */
1142: mm = m_copy(mb0, 0, sizeof(struct ip6_hdr));
1143:
1144: if (mm == NULL) {
1145: free(rte, M_MRTABLE);
1146: m_freem(mb0);
1147: free(rt, M_MRTABLE);
1148: splx(s);
1149: return ENOBUFS;
1150: }
1151:
1152: /*
1153: * Send message to routing daemon
1154: */
1155: (void)memset(&sin6, 0, sizeof(sin6));
1156: sin6.sin6_len = sizeof(sin6);
1157: sin6.sin6_family = AF_INET6;
1158: sin6.sin6_addr = ip6->ip6_src;
1159:
1160: im = NULL;
1161: #ifdef MRT6_OINIT
1162: oim = NULL;
1163: #endif
1164: switch (ip6_mrouter_ver) {
1165: #ifdef MRT6_OINIT
1166: case MRT6_OINIT:
1167: oim = mtod(mm, struct omrt6msg *);
1168: oim->im6_msgtype = MRT6MSG_NOCACHE;
1169: oim->im6_mbz = 0;
1170: break;
1171: #endif
1172: case MRT6_INIT:
1173: im = mtod(mm, struct mrt6msg *);
1174: im->im6_msgtype = MRT6MSG_NOCACHE;
1175: im->im6_mbz = 0;
1176: break;
1177: default:
1178: free(rte, M_MRTABLE);
1179: m_freem(mb0);
1180: free(rt, M_MRTABLE);
1181: splx(s);
1182: return EINVAL;
1183: }
1184:
1185: #ifdef MRT6DEBUG
1186: if (mrt6debug & DEBUG_FORWARD)
1187: log(LOG_DEBUG,
1188: "getting the iif info in the kernel\n");
1189: #endif
1190:
1191: for (mifp = mif6table, mifi = 0;
1192: mifi < nummifs && mifp->m6_ifp != ifp;
1193: mifp++, mifi++)
1194: ;
1195:
1196: switch (ip6_mrouter_ver) {
1197: #ifdef MRT6_OINIT
1198: case MRT6_OINIT:
1199: oim->im6_mif = mifi;
1200: break;
1201: #endif
1202: case MRT6_INIT:
1203: im->im6_mif = mifi;
1204: break;
1205: }
1206:
1207: if (socket_send(ip6_mrouter, mm, &sin6) < 0) {
1208: log(LOG_WARNING, "ip6_mforward: ip6_mrouter "
1209: "socket queue full\n");
1210: mrt6stat.mrt6s_upq_sockfull++;
1211: free(rte, M_MRTABLE);
1212: m_freem(mb0);
1213: free(rt, M_MRTABLE);
1214: splx(s);
1215: return ENOBUFS;
1216: }
1217:
1218: mrt6stat.mrt6s_upcalls++;
1219:
1220: /* insert new entry at head of hash chain */
1221: bzero(rt, sizeof(*rt));
1222: rt->mf6c_origin.sin6_family = AF_INET6;
1223: rt->mf6c_origin.sin6_len = sizeof(struct sockaddr_in6);
1224: rt->mf6c_origin.sin6_addr = ip6->ip6_src;
1225: rt->mf6c_mcastgrp.sin6_family = AF_INET6;
1226: rt->mf6c_mcastgrp.sin6_len = sizeof(struct sockaddr_in6);
1227: rt->mf6c_mcastgrp.sin6_addr = ip6->ip6_dst;
1228: rt->mf6c_expire = UPCALL_EXPIRE;
1229: n6expire[hash]++;
1230: rt->mf6c_parent = MF6C_INCOMPLETE_PARENT;
1231:
1232: /* link into table */
1233: rt->mf6c_next = mf6ctable[hash];
1234: mf6ctable[hash] = rt;
1235: /* Add this entry to the end of the queue */
1236: rt->mf6c_stall = rte;
1237: } else {
1238: /* determine if q has overflowed */
1239: struct rtdetq **p;
1240: int npkts = 0;
1241:
1242: for (p = &rt->mf6c_stall; *p != NULL; p = &(*p)->next)
1243: if (++npkts > MAX_UPQ6) {
1244: mrt6stat.mrt6s_upq_ovflw++;
1245: free(rte, M_MRTABLE);
1246: m_freem(mb0);
1247: splx(s);
1248: return 0;
1249: }
1250:
1251: /* Add this entry to the end of the queue */
1252: *p = rte;
1253: }
1254:
1255: rte->next = NULL;
1256: rte->m = mb0;
1257: rte->ifp = ifp;
1258: #ifdef UPCALL_TIMING
1259: rte->t = tp;
1260: #endif /* UPCALL_TIMING */
1261:
1262: splx(s);
1263:
1264: return 0;
1265: }
1266: }
1267:
1268: /*
1269: * Clean up cache entries if upcalls are not serviced
1270: * Call from the Slow Timeout mechanism, every half second.
1271: */
1272: static void
1273: expire_upcalls(unused)
1274: void *unused;
1275: {
1276: struct rtdetq *rte;
1277: struct mf6c *mfc, **nptr;
1278: int i;
1279: int s;
1280:
1281: s = splsoftnet();
1282:
1283: for (i = 0; i < MF6CTBLSIZ; i++) {
1284: if (n6expire[i] == 0)
1285: continue;
1286: nptr = &mf6ctable[i];
1287: while ((mfc = *nptr) != NULL) {
1288: rte = mfc->mf6c_stall;
1289: /*
1290: * Skip real cache entries
1291: * Make sure it wasn't marked to not expire (shouldn't happen)
1292: * If it expires now
1293: */
1294: if (rte != NULL &&
1295: mfc->mf6c_expire != 0 &&
1296: --mfc->mf6c_expire == 0) {
1297: #ifdef MRT6DEBUG
1298: if (mrt6debug & DEBUG_EXPIRE)
1299: log(LOG_DEBUG, "expire_upcalls: expiring (%s %s)\n",
1300: ip6_sprintf(&mfc->mf6c_origin.sin6_addr),
1301: ip6_sprintf(&mfc->mf6c_mcastgrp.sin6_addr));
1302: #endif
1303: /*
1304: * drop all the packets
1305: * free the mbuf with the pkt, if, timing info
1306: */
1307: do {
1308: struct rtdetq *n = rte->next;
1309: m_freem(rte->m);
1310: free(rte, M_MRTABLE);
1311: rte = n;
1312: } while (rte != NULL);
1313: mrt6stat.mrt6s_cache_cleanups++;
1314: n6expire[i]--;
1315:
1316: *nptr = mfc->mf6c_next;
1317: free(mfc, M_MRTABLE);
1318: } else {
1319: nptr = &mfc->mf6c_next;
1320: }
1321: }
1322: }
1323: splx(s);
1324: timeout_set(&expire_upcalls_ch, expire_upcalls, NULL);
1325: timeout_add(&expire_upcalls_ch, EXPIRE_TIMEOUT);
1326: }
1327:
1328: /*
1329: * Packet forwarding routine once entry in the cache is made
1330: */
1331: static int
1332: ip6_mdq(m, ifp, rt)
1333: struct mbuf *m;
1334: struct ifnet *ifp;
1335: struct mf6c *rt;
1336: {
1337: struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
1338: mifi_t mifi, iif;
1339: struct mif6 *mifp;
1340: int plen = m->m_pkthdr.len;
1341:
1342: /*
1343: * Macro to send packet on mif. Since RSVP packets don't get counted on
1344: * input, they shouldn't get counted on output, so statistics keeping is
1345: * separate.
1346: */
1347:
1348: #define MC6_SEND(ip6, mifp, m) do { \
1349: if ((mifp)->m6_flags & MIFF_REGISTER) \
1350: register_send((ip6), (mifp), (m)); \
1351: else \
1352: phyint_send((ip6), (mifp), (m)); \
1353: } while (0)
1354:
1355: /*
1356: * Don't forward if it didn't arrive from the parent mif
1357: * for its origin.
1358: */
1359: mifi = rt->mf6c_parent;
1360: if ((mifi >= nummifs) || (mif6table[mifi].m6_ifp != ifp)) {
1361: /* came in the wrong interface */
1362: #ifdef MRT6DEBUG
1363: if (mrt6debug & DEBUG_FORWARD)
1364: log(LOG_DEBUG,
1365: "wrong if: ifid %d mifi %d mififid %x\n",
1366: ifp->if_index, mifi,
1367: mif6table[mifi].m6_ifp ?
1368: mif6table[mifi].m6_ifp->if_index : -1);
1369: #endif
1370: mrt6stat.mrt6s_wrong_if++;
1371: rt->mf6c_wrong_if++;
1372: /*
1373: * If we are doing PIM processing, and we are forwarding
1374: * packets on this interface, send a message to the
1375: * routing daemon.
1376: */
1377: /* have to make sure this is a valid mif */
1378: if (mifi < nummifs && mif6table[mifi].m6_ifp)
1379: if (pim6 && (m->m_flags & M_LOOP) == 0) {
1380: /*
1381: * Check the M_LOOP flag to avoid an
1382: * unnecessary PIM assert.
1383: * XXX: M_LOOP is an ad-hoc hack...
1384: */
1385: struct sockaddr_in6 sin6;
1386:
1387: struct mbuf *mm;
1388: struct mrt6msg *im;
1389: #ifdef MRT6_OINIT
1390: struct omrt6msg *oim;
1391: #endif
1392:
1393: mm = m_copy(m, 0, sizeof(struct ip6_hdr));
1394: if (mm &&
1395: (M_READONLY(mm) ||
1396: mm->m_len < sizeof(struct ip6_hdr)))
1397: mm = m_pullup(mm, sizeof(struct ip6_hdr));
1398: if (mm == NULL)
1399: return ENOBUFS;
1400:
1401: #ifdef MRT6_OINIT
1402: oim = NULL;
1403: #endif
1404: im = NULL;
1405: switch (ip6_mrouter_ver) {
1406: #ifdef MRT6_OINIT
1407: case MRT6_OINIT:
1408: oim = mtod(mm, struct omrt6msg *);
1409: oim->im6_msgtype = MRT6MSG_WRONGMIF;
1410: oim->im6_mbz = 0;
1411: break;
1412: #endif
1413: case MRT6_INIT:
1414: im = mtod(mm, struct mrt6msg *);
1415: im->im6_msgtype = MRT6MSG_WRONGMIF;
1416: im->im6_mbz = 0;
1417: break;
1418: default:
1419: m_freem(mm);
1420: return EINVAL;
1421: }
1422:
1423: for (mifp = mif6table, iif = 0;
1424: iif < nummifs && mifp &&
1425: mifp->m6_ifp != ifp;
1426: mifp++, iif++)
1427: ;
1428:
1429: (void)memset(&sin6, 0, sizeof(sin6));
1430: sin6.sin6_len = sizeof(sin6);
1431: sin6.sin6_family = AF_INET6;
1432: switch (ip6_mrouter_ver) {
1433: #ifdef MRT6_OINIT
1434: case MRT6_OINIT:
1435: oim->im6_mif = iif;
1436: sin6.sin6_addr = oim->im6_src;
1437: break;
1438: #endif
1439: case MRT6_INIT:
1440: im->im6_mif = iif;
1441: sin6.sin6_addr = im->im6_src;
1442: break;
1443: }
1444:
1445: mrt6stat.mrt6s_upcalls++;
1446:
1447: if (socket_send(ip6_mrouter, mm, &sin6) < 0) {
1448: #ifdef MRT6DEBUG
1449: if (mrt6debug)
1450: log(LOG_WARNING, "mdq, ip6_mrouter socket queue full\n");
1451: #endif
1452: ++mrt6stat.mrt6s_upq_sockfull;
1453: return ENOBUFS;
1454: } /* if socket Q full */
1455: } /* if PIM */
1456: return 0;
1457: } /* if wrong iif */
1458:
1459: /* If I sourced this packet, it counts as output, else it was input. */
1460: if (m->m_pkthdr.rcvif == NULL) {
1461: /* XXX: is rcvif really NULL when output?? */
1462: mif6table[mifi].m6_pkt_out++;
1463: mif6table[mifi].m6_bytes_out += plen;
1464: } else {
1465: mif6table[mifi].m6_pkt_in++;
1466: mif6table[mifi].m6_bytes_in += plen;
1467: }
1468: rt->mf6c_pkt_cnt++;
1469: rt->mf6c_byte_cnt += plen;
1470:
1471: /*
1472: * For each mif, forward a copy of the packet if there are group
1473: * members downstream on the interface.
1474: */
1475: for (mifp = mif6table, mifi = 0; mifi < nummifs; mifp++, mifi++)
1476: if (IF_ISSET(mifi, &rt->mf6c_ifset)) {
1477: if (mif6table[mifi].m6_ifp == NULL)
1478: continue;
1479:
1480: /*
1481: * check if the outgoing packet is going to break
1482: * a scope boundary.
1483: * XXX For packets through PIM register tunnel
1484: * interface, we believe a routing daemon.
1485: */
1486: if ((mif6table[rt->mf6c_parent].m6_flags &
1487: MIFF_REGISTER) == 0 &&
1488: (mif6table[mifi].m6_flags & MIFF_REGISTER) == 0 &&
1489: (in6_addr2scopeid(ifp, &ip6->ip6_dst) !=
1490: in6_addr2scopeid(mif6table[mifi].m6_ifp,
1491: &ip6->ip6_dst) ||
1492: in6_addr2scopeid(ifp, &ip6->ip6_src) !=
1493: in6_addr2scopeid(mif6table[mifi].m6_ifp,
1494: &ip6->ip6_src))) {
1495: ip6stat.ip6s_badscope++;
1496: continue;
1497: }
1498:
1499: mifp->m6_pkt_out++;
1500: mifp->m6_bytes_out += plen;
1501: MC6_SEND(ip6, mifp, m);
1502: }
1503: return 0;
1504: }
1505:
1506: static void
1507: phyint_send(ip6, mifp, m)
1508: struct ip6_hdr *ip6;
1509: struct mif6 *mifp;
1510: struct mbuf *m;
1511: {
1512: struct mbuf *mb_copy;
1513: struct ifnet *ifp = mifp->m6_ifp;
1514: int error = 0;
1515: int s = splsoftnet();
1516: static struct route_in6 ro;
1517: struct in6_multi *in6m;
1518: struct sockaddr_in6 *dst6;
1519: u_long linkmtu;
1520:
1521: /*
1522: * Make a new reference to the packet; make sure that
1523: * the IPv6 header is actually copied, not just referenced,
1524: * so that ip6_output() only scribbles on the copy.
1525: */
1526: mb_copy = m_copy(m, 0, M_COPYALL);
1527: if (mb_copy &&
1528: (M_READONLY(mb_copy) || mb_copy->m_len < sizeof(struct ip6_hdr)))
1529: mb_copy = m_pullup(mb_copy, sizeof(struct ip6_hdr));
1530: if (mb_copy == NULL) {
1531: splx(s);
1532: return;
1533: }
1534: /* set MCAST flag to the outgoing packet */
1535: mb_copy->m_flags |= M_MCAST;
1536:
1537: /*
1538: * If we sourced the packet, call ip6_output since we may devide
1539: * the packet into fragments when the packet is too big for the
1540: * outgoing interface.
1541: * Otherwise, we can simply send the packet to the interface
1542: * sending queue.
1543: */
1544: if (m->m_pkthdr.rcvif == NULL) {
1545: struct ip6_moptions im6o;
1546:
1547: im6o.im6o_multicast_ifp = ifp;
1548: /* XXX: ip6_output will override ip6->ip6_hlim */
1549: im6o.im6o_multicast_hlim = ip6->ip6_hlim;
1550: im6o.im6o_multicast_loop = 1;
1551: error = ip6_output(mb_copy, NULL, &ro, IPV6_FORWARDING, &im6o,
1552: NULL, NULL);
1553:
1554: #ifdef MRT6DEBUG
1555: if (mrt6debug & DEBUG_XMIT)
1556: log(LOG_DEBUG, "phyint_send on mif %d err %d\n",
1557: mifp - mif6table, error);
1558: #endif
1559: splx(s);
1560: return;
1561: }
1562:
1563: /*
1564: * If we belong to the destination multicast group
1565: * on the outgoing interface, loop back a copy.
1566: */
1567: dst6 = (struct sockaddr_in6 *)&ro.ro_dst;
1568: IN6_LOOKUP_MULTI(ip6->ip6_dst, ifp, in6m);
1569: if (in6m != NULL) {
1570: dst6->sin6_len = sizeof(struct sockaddr_in6);
1571: dst6->sin6_family = AF_INET6;
1572: dst6->sin6_addr = ip6->ip6_dst;
1573: ip6_mloopback(ifp, m, (struct sockaddr_in6 *)&ro.ro_dst);
1574: }
1575: /*
1576: * Put the packet into the sending queue of the outgoing interface
1577: * if it would fit in the MTU of the interface.
1578: */
1579: linkmtu = IN6_LINKMTU(ifp);
1580: if (mb_copy->m_pkthdr.len <= linkmtu || linkmtu < IPV6_MMTU) {
1581: dst6->sin6_len = sizeof(struct sockaddr_in6);
1582: dst6->sin6_family = AF_INET6;
1583: dst6->sin6_addr = ip6->ip6_dst;
1584: /*
1585: * We just call if_output instead of nd6_output here, since
1586: * we need no ND for a multicast forwarded packet...right?
1587: */
1588: error = (*ifp->if_output)(ifp, mb_copy,
1589: (struct sockaddr *)&ro.ro_dst, NULL);
1590: #ifdef MRT6DEBUG
1591: if (mrt6debug & DEBUG_XMIT)
1592: log(LOG_DEBUG, "phyint_send on mif %d err %d\n",
1593: mifp - mif6table, error);
1594: #endif
1595: } else {
1596: if (ip6_mcast_pmtu)
1597: icmp6_error(mb_copy, ICMP6_PACKET_TOO_BIG, 0, linkmtu);
1598: else {
1599: #ifdef MRT6DEBUG
1600: if (mrt6debug & DEBUG_XMIT)
1601: log(LOG_DEBUG,
1602: "phyint_send: packet too big on %s o %s g %s"
1603: " size %d(discarded)\n",
1604: ifp->if_xname,
1605: ip6_sprintf(&ip6->ip6_src),
1606: ip6_sprintf(&ip6->ip6_dst),
1607: mb_copy->m_pkthdr.len);
1608: #endif /* MRT6DEBUG */
1609: m_freem(mb_copy); /* simply discard the packet */
1610: }
1611: }
1612:
1613: splx(s);
1614: }
1615:
1616: static int
1617: register_send(ip6, mif, m)
1618: struct ip6_hdr *ip6;
1619: struct mif6 *mif;
1620: struct mbuf *m;
1621: {
1622: struct mbuf *mm;
1623: int i, len = m->m_pkthdr.len;
1624: struct sockaddr_in6 sin6;
1625: struct mrt6msg *im6;
1626:
1627: #ifdef MRT6DEBUG
1628: if (mrt6debug)
1629: log(LOG_DEBUG, "** IPv6 register_send **\n src %s dst %s\n",
1630: ip6_sprintf(&ip6->ip6_src), ip6_sprintf(&ip6->ip6_dst));
1631: #endif
1632: ++pim6stat.pim6s_snd_registers;
1633:
1634: /* Make a copy of the packet to send to the user level process */
1635: MGETHDR(mm, M_DONTWAIT, MT_HEADER);
1636: if (mm == NULL)
1637: return ENOBUFS;
1638: mm->m_data += max_linkhdr;
1639: mm->m_len = sizeof(struct ip6_hdr);
1640:
1641: if ((mm->m_next = m_copy(m, 0, M_COPYALL)) == NULL) {
1642: m_freem(mm);
1643: return ENOBUFS;
1644: }
1645: i = MHLEN - M_LEADINGSPACE(mm);
1646: if (i > len)
1647: i = len;
1648: mm = m_pullup(mm, i);
1649: if (mm == NULL)
1650: return ENOBUFS;
1651: /* TODO: check it! */
1652: mm->m_pkthdr.len = len + sizeof(struct ip6_hdr);
1653:
1654: /*
1655: * Send message to routing daemon
1656: */
1657: (void)memset(&sin6, 0, sizeof(sin6));
1658: sin6.sin6_len = sizeof(sin6);
1659: sin6.sin6_family = AF_INET6;
1660: sin6.sin6_addr = ip6->ip6_src;
1661:
1662: im6 = mtod(mm, struct mrt6msg *);
1663: im6->im6_msgtype = MRT6MSG_WHOLEPKT;
1664: im6->im6_mbz = 0;
1665:
1666: im6->im6_mif = mif - mif6table;
1667:
1668: /* iif info is not given for reg. encap.n */
1669: mrt6stat.mrt6s_upcalls++;
1670:
1671: if (socket_send(ip6_mrouter, mm, &sin6) < 0) {
1672: #ifdef MRT6DEBUG
1673: if (mrt6debug)
1674: log(LOG_WARNING,
1675: "register_send: ip6_mrouter socket queue full\n");
1676: #endif
1677: ++mrt6stat.mrt6s_upq_sockfull;
1678: return ENOBUFS;
1679: }
1680: return 0;
1681: }
1682:
1683: /*
1684: * PIM sparse mode hook
1685: * Receives the pim control messages, and passes them up to the listening
1686: * socket, using rip6_input.
1687: * The only message processed is the REGISTER pim message; the pim header
1688: * is stripped off, and the inner packet is passed to register_mforward.
1689: */
1690: int
1691: pim6_input(mp, offp, proto)
1692: struct mbuf **mp;
1693: int *offp, proto;
1694: {
1695: struct pim *pim; /* pointer to a pim struct */
1696: struct ip6_hdr *ip6;
1697: int pimlen;
1698: struct mbuf *m = *mp;
1699: int minlen;
1700: int off = *offp;
1701:
1702: ++pim6stat.pim6s_rcv_total;
1703:
1704: ip6 = mtod(m, struct ip6_hdr *);
1705: pimlen = m->m_pkthdr.len - *offp;
1706:
1707: /*
1708: * Validate lengths
1709: */
1710: if (pimlen < PIM_MINLEN) {
1711: ++pim6stat.pim6s_rcv_tooshort;
1712: #ifdef MRT6DEBUG
1713: if (mrt6debug & DEBUG_PIM)
1714: log(LOG_DEBUG,"pim6_input: PIM packet too short\n");
1715: #endif
1716: m_freem(m);
1717: return (IPPROTO_DONE);
1718: }
1719:
1720: /*
1721: * if the packet is at least as big as a REGISTER, go ahead
1722: * and grab the PIM REGISTER header size, to avoid another
1723: * possible m_pullup() later.
1724: *
1725: * PIM_MINLEN == pimhdr + u_int32 == 8
1726: * PIM6_REG_MINLEN == pimhdr + reghdr + eip6hdr == 4 + 4 + 40
1727: */
1728: minlen = (pimlen >= PIM6_REG_MINLEN) ? PIM6_REG_MINLEN : PIM_MINLEN;
1729:
1730: /*
1731: * Make sure that the IP6 and PIM headers in contiguous memory, and
1732: * possibly the PIM REGISTER header
1733: */
1734: IP6_EXTHDR_GET(pim, struct pim *, m, off, minlen);
1735: if (pim == NULL) {
1736: pim6stat.pim6s_rcv_tooshort++;
1737: return IPPROTO_DONE;
1738: }
1739:
1740: /* PIM version check */
1741: if (pim->pim_ver != PIM_VERSION) {
1742: ++pim6stat.pim6s_rcv_badversion;
1743: #ifdef MRT6DEBUG
1744: log(LOG_ERR,
1745: "pim6_input: incorrect version %d, expecting %d\n",
1746: pim->pim_ver, PIM_VERSION);
1747: #endif
1748: m_freem(m);
1749: return (IPPROTO_DONE);
1750: }
1751:
1752: #define PIM6_CHECKSUM
1753: #ifdef PIM6_CHECKSUM
1754: {
1755: int cksumlen;
1756:
1757: /*
1758: * Validate checksum.
1759: * If PIM REGISTER, exclude the data packet
1760: */
1761: if (pim->pim_type == PIM_REGISTER)
1762: cksumlen = PIM_MINLEN;
1763: else
1764: cksumlen = pimlen;
1765:
1766: if (in6_cksum(m, IPPROTO_PIM, off, cksumlen)) {
1767: ++pim6stat.pim6s_rcv_badsum;
1768: #ifdef MRT6DEBUG
1769: if (mrt6debug & DEBUG_PIM)
1770: log(LOG_DEBUG,
1771: "pim6_input: invalid checksum\n");
1772: #endif
1773: m_freem(m);
1774: return (IPPROTO_DONE);
1775: }
1776: }
1777: #endif /* PIM_CHECKSUM */
1778:
1779: if (pim->pim_type == PIM_REGISTER) {
1780: /*
1781: * since this is a REGISTER, we'll make a copy of the register
1782: * headers ip6+pim+u_int32_t+encap_ip6, to be passed up to the
1783: * routing daemon.
1784: */
1785: static struct sockaddr_in6 dst = { sizeof(dst), AF_INET6 };
1786:
1787: struct mbuf *mcp;
1788: struct ip6_hdr *eip6;
1789: u_int32_t *reghdr;
1790: int rc;
1791:
1792: ++pim6stat.pim6s_rcv_registers;
1793:
1794: if ((reg_mif_num >= nummifs) || (reg_mif_num == (mifi_t) -1)) {
1795: #ifdef MRT6DEBUG
1796: if (mrt6debug & DEBUG_PIM)
1797: log(LOG_DEBUG,
1798: "pim6_input: register mif not set: %d\n",
1799: reg_mif_num);
1800: #endif
1801: m_freem(m);
1802: return (IPPROTO_DONE);
1803: }
1804:
1805: reghdr = (u_int32_t *)(pim + 1);
1806:
1807: if ((ntohl(*reghdr) & PIM_NULL_REGISTER))
1808: goto pim6_input_to_daemon;
1809:
1810: /*
1811: * Validate length
1812: */
1813: if (pimlen < PIM6_REG_MINLEN) {
1814: ++pim6stat.pim6s_rcv_tooshort;
1815: ++pim6stat.pim6s_rcv_badregisters;
1816: #ifdef MRT6DEBUG
1817: log(LOG_ERR,
1818: "pim6_input: register packet size too "
1819: "small %d from %s\n",
1820: pimlen, ip6_sprintf(&ip6->ip6_src));
1821: #endif
1822: m_freem(m);
1823: return (IPPROTO_DONE);
1824: }
1825:
1826: eip6 = (struct ip6_hdr *) (reghdr + 1);
1827: #ifdef MRT6DEBUG
1828: if (mrt6debug & DEBUG_PIM)
1829: log(LOG_DEBUG,
1830: "pim6_input[register], eip6: %s -> %s, "
1831: "eip6 plen %d\n",
1832: ip6_sprintf(&eip6->ip6_src),
1833: ip6_sprintf(&eip6->ip6_dst),
1834: ntohs(eip6->ip6_plen));
1835: #endif
1836:
1837: /* verify the version number of the inner packet */
1838: if ((eip6->ip6_vfc & IPV6_VERSION_MASK) != IPV6_VERSION) {
1839: ++pim6stat.pim6s_rcv_badregisters;
1840: #ifdef MRT6DEBUG
1841: log(LOG_DEBUG, "pim6_input: invalid IP version (%d) "
1842: "of the inner packet\n",
1843: (eip6->ip6_vfc & IPV6_VERSION));
1844: #endif
1845: m_freem(m);
1846: return (IPPROTO_NONE);
1847: }
1848:
1849: /* verify the inner packet is destined to a mcast group */
1850: if (!IN6_IS_ADDR_MULTICAST(&eip6->ip6_dst)) {
1851: ++pim6stat.pim6s_rcv_badregisters;
1852: #ifdef MRT6DEBUG
1853: if (mrt6debug & DEBUG_PIM)
1854: log(LOG_DEBUG,
1855: "pim6_input: inner packet of register "
1856: "is not multicast %s\n",
1857: ip6_sprintf(&eip6->ip6_dst));
1858: #endif
1859: m_freem(m);
1860: return (IPPROTO_DONE);
1861: }
1862:
1863: /*
1864: * make a copy of the whole header to pass to the daemon later.
1865: */
1866: mcp = m_copy(m, 0, off + PIM6_REG_MINLEN);
1867: if (mcp == NULL) {
1868: #ifdef MRT6DEBUG
1869: log(LOG_ERR,
1870: "pim6_input: pim register: "
1871: "could not copy register head\n");
1872: #endif
1873: m_freem(m);
1874: return (IPPROTO_DONE);
1875: }
1876:
1877: /*
1878: * forward the inner ip6 packet; point m_data at the inner ip6.
1879: */
1880: m_adj(m, off + PIM_MINLEN);
1881: #ifdef MRT6DEBUG
1882: if (mrt6debug & DEBUG_PIM) {
1883: log(LOG_DEBUG,
1884: "pim6_input: forwarding decapsulated register: "
1885: "src %s, dst %s, mif %d\n",
1886: ip6_sprintf(&eip6->ip6_src),
1887: ip6_sprintf(&eip6->ip6_dst),
1888: reg_mif_num);
1889: }
1890: #endif
1891:
1892: rc = looutput(mif6table[reg_mif_num].m6_ifp, m,
1893: (struct sockaddr *) &dst,
1894: (struct rtentry *) NULL);
1895:
1896: /* prepare the register head to send to the mrouting daemon */
1897: m = mcp;
1898: }
1899:
1900: /*
1901: * Pass the PIM message up to the daemon; if it is a register message
1902: * pass the 'head' only up to the daemon. This includes the
1903: * encapsulator ip6 header, pim header, register header and the
1904: * encapsulated ip6 header.
1905: */
1906: pim6_input_to_daemon:
1907: rip6_input(&m, offp, proto);
1908: return (IPPROTO_DONE);
1909: }