![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ip_mroute.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 ip_mroute.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: * IP multicast forwarding procedures
24: *
25: * Written by David Waitzman, BBN Labs, August 1988.
26: * Modified by Steve Deering, Stanford, February 1989.
27: * Modified by Mark J. Steiglitz, Stanford, May, 1991
28: * Modified by Van Jacobson, LBL, January 1993
29: * Modified by Ajit Thyagarajan, PARC, August 1993
30: * Modified by Bill Fenner, PARC, April 1995
31: *
32: * MROUTING Revision: 3.5
33: */
34:
35: #if ISFB31
36: #include "opt_mrouting.h"
37: #else
38: #define MROUTE_LKM 0
39: #endif
40:
41: #include <sys/param.h>
42: #include <sys/systm.h>
43: #include <sys/malloc.h>
44: #include <sys/mbuf.h>
45: #include <sys/socket.h>
46: #include <sys/socketvar.h>
47: #include <sys/protosw.h>
48: #include <sys/time.h>
49: #include <sys/kernel.h>
50: #include <sys/sockio.h>
51: #include <sys/syslog.h>
52: #include <net/if.h>
53: #include <net/route.h>
54: #include <netinet/in.h>
55: #include <netinet/in_systm.h>
56: #include <netinet/ip.h>
57: #include <netinet/ip_var.h>
58: #include <netinet/in_var.h>
59: #include <netinet/igmp.h>
60: #include <netinet/ip_mroute.h>
61: #include <netinet/udp.h>
62:
63: #if !MROUTING
64: extern u_long _ip_mcast_src __P((int vifi));
65: extern int _ip_mforward __P((struct ip *ip, struct ifnet *ifp,
66: struct mbuf *m, struct ip_moptions *imo));
67: extern int _ip_mrouter_done __P((void));
68: extern int _ip_mrouter_get __P((struct socket *so, struct sockopt *sopt));
69: extern int _ip_mrouter_set __P((struct socket *so, struct sockopt *sopt));
70: extern int _mrt_ioctl __P((int req, caddr_t data, struct proc *p));
71:
72: /*
73: * Dummy routines and globals used when multicast routing is not compiled in.
74: */
75:
76: struct socket *ip_mrouter = NULL;
77: u_int rsvpdebug = 0;
78:
79: int
80: _ip_mrouter_set(so, sopt)
81: struct socket *so;
82: struct sockopt *sopt;
83: {
84: return(EOPNOTSUPP);
85: }
86:
87: int (*ip_mrouter_set)(struct socket *, struct sockopt *) = _ip_mrouter_set;
88:
89:
90: int
91: _ip_mrouter_get(so, sopt)
92: struct socket *so;
93: struct sockopt *sopt;
94: {
95: return(EOPNOTSUPP);
96: }
97:
98: int (*ip_mrouter_get)(struct socket *, struct sockopt *) = _ip_mrouter_get;
99:
100: int
101: _ip_mrouter_done()
102: {
103: return(0);
104: }
105:
106: int (*ip_mrouter_done)(void) = _ip_mrouter_done;
107:
108: int
109: _ip_mforward(ip, ifp, m, imo)
110: struct ip *ip;
111: struct ifnet *ifp;
112: struct mbuf *m;
113: struct ip_moptions *imo;
114: {
115: return(0);
116: }
117:
118: int (*ip_mforward)(struct ip *, struct ifnet *, struct mbuf *,
119: struct ip_moptions *) = _ip_mforward;
120:
121: int
122: _mrt_ioctl(int req, caddr_t data, struct proc *p)
123: {
124: return EOPNOTSUPP;
125: }
126:
127: int (*mrt_ioctl)(int, caddr_t, struct proc *) = _mrt_ioctl;
128:
129: void
130: rsvp_input(m, iphlen) /* XXX must fixup manually */
131: struct mbuf *m;
132: int iphlen;
133: {
134: /* Can still get packets with rsvp_on = 0 if there is a local member
135: * of the group to which the RSVP packet is addressed. But in this
136: * case we want to throw the packet away.
137: */
138: if (!rsvp_on) {
139: m_freem(m);
140: return;
141: }
142:
143: if (ip_rsvpd != NULL) {
144: if (rsvpdebug)
145: printf("rsvp_input: Sending packet up old-style socket\n");
146: rip_input(m, iphlen);
147: return;
148: }
149: /* Drop the packet */
150: m_freem(m);
151: }
152:
153: void ipip_input(struct mbuf *m, int iphlen) { /* XXX must fixup manually */
154: rip_input(m, iphlen);
155: }
156:
157: int (*legal_vif_num)(int) = 0;
158:
159: /*
160: * This should never be called, since IP_MULTICAST_VIF should fail, but
161: * just in case it does get called, the code a little lower in ip_output
162: * will assign the packet a local address.
163: */
164: u_long
165: _ip_mcast_src(int vifi) { return INADDR_ANY; }
166: u_long (*ip_mcast_src)(int) = _ip_mcast_src;
167:
168: int
169: ip_rsvp_vif_init(so, sopt)
170: struct socket *so;
171: struct sockopt *sopt;
172: {
173: return(EINVAL);
174: }
175:
176: int
177: ip_rsvp_vif_done(so, sopt)
178: struct socket *so;
179: struct sockopt *sopt;
180: {
181: return(EINVAL);
182: }
183:
184: void
185: ip_rsvp_force_done(so)
186: struct socket *so;
187: {
188: return;
189: }
190:
191: #else /* MROUTING */
192:
193: #define M_HASCL(m) ((m)->m_flags & M_EXT)
194:
195: #define INSIZ sizeof(struct in_addr)
196: #define same(a1, a2) \
197: (bcmp((caddr_t)(a1), (caddr_t)(a2), INSIZ) == 0)
198:
199: static MALLOC_DEFINE(M_MRTABLE, "mroutetbl", "multicast routing tables");
200:
201: /*
202: * Globals. All but ip_mrouter and ip_mrtproto could be static,
203: * except for netstat or debugging purposes.
204: */
205: #if !MROUTE_LKM
206: struct socket *ip_mrouter = NULL;
207: static struct mrtstat mrtstat;
208: #else /* MROUTE_LKM */
209: extern void X_ipip_input __P((struct mbuf *m, int iphlen));
210: extern struct mrtstat mrtstat;
211: static int ip_mrtproto;
212: #endif
213:
214: #define NO_RTE_FOUND 0x1
215: #define RTE_FOUND 0x2
216:
217: static struct mfc *mfctable[MFCTBLSIZ];
218: static u_char nexpire[MFCTBLSIZ];
219: static struct vif viftable[MAXVIFS];
220: static u_int mrtdebug = 0; /* debug level */
221: #define DEBUG_MFC 0x02
222: #define DEBUG_FORWARD 0x04
223: #define DEBUG_EXPIRE 0x08
224: #define DEBUG_XMIT 0x10
225: static u_int tbfdebug = 0; /* tbf debug level */
226: static u_int rsvpdebug = 0; /* rsvp debug level */
227:
228:
229:
230: #define EXPIRE_TIMEOUT (hz / 4) /* 4x / second */
231: #define UPCALL_EXPIRE 6 /* number of timeouts */
232:
233: /*
234: * Define the token bucket filter structures
235: * tbftable -> each vif has one of these for storing info
236: */
237:
238: static struct tbf tbftable[MAXVIFS];
239: #define TBF_REPROCESS (hz / 100) /* 100x / second */
240:
241: /*
242: * 'Interfaces' associated with decapsulator (so we can tell
243: * packets that went through it from ones that get reflected
244: * by a broken gateway). These interfaces are never linked into
245: * the system ifnet list & no routes point to them. I.e., packets
246: * can't be sent this way. They only exist as a placeholder for
247: * multicast source verification.
248: */
249: static struct ifnet multicast_decap_if[MAXVIFS];
250:
251: #define ENCAP_TTL 64
252: #define ENCAP_PROTO IPPROTO_IPIP /* 4 */
253:
254: /* prototype IP hdr for encapsulated packets */
255: static struct ip multicast_encap_iphdr = {
256: #if BYTE_ORDER == LITTLE_ENDIAN
257: sizeof(struct ip) >> 2, IPVERSION,
258: #else
259: IPVERSION, sizeof(struct ip) >> 2,
260: #endif
261: 0, /* tos */
262: sizeof(struct ip), /* total length */
263: 0, /* id */
264: 0, /* frag offset */
265: ENCAP_TTL, ENCAP_PROTO,
266: 0, /* checksum */
267: };
268:
269: /*
270: * Private variables.
271: */
272: static vifi_t numvifs = 0;
273: static int have_encap_tunnel = 0;
274:
275: /*
276: * one-back cache used by ipip_input to locate a tunnel's vif
277: * given a datagram's src ip address.
278: */
279: static u_long last_encap_src;
280: static struct vif *last_encap_vif;
281:
282: static u_long X_ip_mcast_src __P((int vifi));
283: static int X_ip_mforward __P((struct ip *ip, struct ifnet *ifp, struct mbuf *m, struct ip_moptions *imo));
284: static int X_ip_mrouter_done __P((void));
285: static int X_ip_mrouter_get __P((struct socket *so, struct sockopt *m));
286: static int X_ip_mrouter_set __P((struct socket *so, struct sockopt *m));
287: static int X_legal_vif_num __P((int vif));
288: static int X_mrt_ioctl __P((int cmd, caddr_t data));
289:
290: static int get_sg_cnt(struct sioc_sg_req *);
291: static int get_vif_cnt(struct sioc_vif_req *);
292: static int ip_mrouter_init(struct socket *, int);
293: static int add_vif(struct vifctl *);
294: static int del_vif(vifi_t);
295: static int add_mfc(struct mfcctl *);
296: static int del_mfc(struct mfcctl *);
297: static int socket_send(struct socket *, struct mbuf *, struct sockaddr_in *);
298: static int set_assert(int);
299: static void expire_upcalls(void *);
300: static int ip_mdq(struct mbuf *, struct ifnet *, struct mfc *,
301: vifi_t);
302: static void phyint_send(struct ip *, struct vif *, struct mbuf *);
303: static void encap_send(struct ip *, struct vif *, struct mbuf *);
304: static void tbf_control(struct vif *, struct mbuf *, struct ip *, u_long);
305: static void tbf_queue(struct vif *, struct mbuf *);
306: static void tbf_process_q(struct vif *);
307: static void tbf_reprocess_q(void *);
308: static int tbf_dq_sel(struct vif *, struct ip *);
309: static void tbf_send_packet(struct vif *, struct mbuf *);
310: static void tbf_update_tokens(struct vif *);
311: static int priority(struct vif *, struct ip *);
312: void multiencap_decap(struct mbuf *);
313:
314: /*
315: * whether or not special PIM assert processing is enabled.
316: */
317: static int pim_assert;
318: /*
319: * Rate limit for assert notification messages, in usec
320: */
321: #define ASSERT_MSG_TIME 3000000
322:
323: /*
324: * Hash function for a source, group entry
325: */
326: #define MFCHASH(a, g) MFCHASHMOD(((a) >> 20) ^ ((a) >> 10) ^ (a) ^ \
327: ((g) >> 20) ^ ((g) >> 10) ^ (g))
328:
329: /*
330: * Find a route for a given origin IP address and Multicast group address
331: * Type of service parameter to be added in the future!!!
332: */
333:
334: #define MFCFIND(o, g, rt) { \
335: register struct mfc *_rt = mfctable[MFCHASH(o,g)]; \
336: rt = NULL; \
337: ++mrtstat.mrts_mfc_lookups; \
338: while (_rt) { \
339: if ((_rt->mfc_origin.s_addr == o) && \
340: (_rt->mfc_mcastgrp.s_addr == g) && \
341: (_rt->mfc_stall == NULL)) { \
342: rt = _rt; \
343: break; \
344: } \
345: _rt = _rt->mfc_next; \
346: } \
347: if (rt == NULL) { \
348: ++mrtstat.mrts_mfc_misses; \
349: } \
350: }
351:
352:
353: /*
354: * Macros to compute elapsed time efficiently
355: * Borrowed from Van Jacobson's scheduling code
356: */
357: #define TV_DELTA(a, b, delta) { \
358: register int xxs; \
359: \
360: delta = (a).tv_usec - (b).tv_usec; \
361: if ((xxs = (a).tv_sec - (b).tv_sec)) { \
362: switch (xxs) { \
363: case 2: \
364: delta += 1000000; \
365: /* fall through */ \
366: case 1: \
367: delta += 1000000; \
368: break; \
369: default: \
370: delta += (1000000 * xxs); \
371: } \
372: } \
373: }
374:
375: #define TV_LT(a, b) (((a).tv_usec < (b).tv_usec && \
376: (a).tv_sec <= (b).tv_sec) || (a).tv_sec < (b).tv_sec)
377:
378: #if UPCALL_TIMING
379: u_long upcall_data[51];
380: static void collate(struct timeval *);
381: #endif /* UPCALL_TIMING */
382:
383:
384: /*
385: * Handle MRT setsockopt commands to modify the multicast routing tables.
386: */
387: static int
388: X_ip_mrouter_set(so, sopt)
389: struct socket *so;
390: struct sockopt *sopt;
391: {
392: int error, optval;
393: vifi_t vifi;
394: struct vifctl vifc;
395: struct mfcctl mfc;
396:
397: if (so != ip_mrouter && sopt->sopt_name != MRT_INIT)
398: return (EPERM);
399:
400: error = 0;
401: switch (sopt->sopt_name) {
402: case MRT_INIT:
403: error = sooptcopyin(sopt, &optval, sizeof optval,
404: sizeof optval);
405: if (error)
406: break;
407: error = ip_mrouter_init(so, optval);
408: break;
409:
410: case MRT_DONE:
411: error = ip_mrouter_done();
412: break;
413:
414: case MRT_ADD_VIF:
415: error = sooptcopyin(sopt, &vifc, sizeof vifc, sizeof vifc);
416: if (error)
417: break;
418: error = add_vif(&vifc);
419: break;
420:
421: case MRT_DEL_VIF:
422: error = sooptcopyin(sopt, &vifi, sizeof vifi, sizeof vifi);
423: if (error)
424: break;
425: error = del_vif(vifi);
426: break;
427:
428: case MRT_ADD_MFC:
429: case MRT_DEL_MFC:
430: error = sooptcopyin(sopt, &mfc, sizeof mfc, sizeof mfc);
431: if (error)
432: break;
433: if (sopt->sopt_name == MRT_ADD_MFC)
434: error = add_mfc(&mfc);
435: else
436: error = del_mfc(&mfc);
437: break;
438:
439: case MRT_ASSERT:
440: error = sooptcopyin(sopt, &optval, sizeof optval,
441: sizeof optval);
442: if (error)
443: break;
444: set_assert(optval);
445: break;
446:
447: default:
448: error = EOPNOTSUPP;
449: break;
450: }
451: return (error);
452: }
453:
454: #if !MROUTE_LKM
455: int (*ip_mrouter_set)(struct socket *, struct sockopt *) = X_ip_mrouter_set;
456: #endif
457:
458: /*
459: * Handle MRT getsockopt commands
460: */
461: static int
462: X_ip_mrouter_get(so, sopt)
463: struct socket *so;
464: struct sockopt *sopt;
465: {
466: int error;
467: static int version = 0x0305; /* !!! why is this here? XXX */
468:
469: switch (sopt->sopt_name) {
470: case MRT_VERSION:
471: error = sooptcopyout(sopt, &version, sizeof version);
472: break;
473:
474: case MRT_ASSERT:
475: error = sooptcopyout(sopt, &pim_assert, sizeof pim_assert);
476: break;
477: default:
478: error = EOPNOTSUPP;
479: break;
480: }
481: return (error);
482: }
483:
484: #if !MROUTE_LKM
485: int (*ip_mrouter_get)(struct socket *, struct sockopt *) = X_ip_mrouter_get;
486: #endif
487:
488: /*
489: * Handle ioctl commands to obtain information from the cache
490: */
491: static int
492: X_mrt_ioctl(cmd, data)
493: int cmd;
494: caddr_t data;
495: {
496: int error = 0;
497:
498: switch (cmd) {
499: case (SIOCGETVIFCNT):
500: return (get_vif_cnt((struct sioc_vif_req *)data));
501: break;
502: case (SIOCGETSGCNT):
503: return (get_sg_cnt((struct sioc_sg_req *)data));
504: break;
505: default:
506: return (EINVAL);
507: break;
508: }
509: return error;
510: }
511:
512: #if !MROUTE_LKM
513: int (*mrt_ioctl)(int, caddr_t) = X_mrt_ioctl;
514: #endif
515:
516: /*
517: * returns the packet, byte, rpf-failure count for the source group provided
518: */
519: static int
520: get_sg_cnt(req)
521: register struct sioc_sg_req *req;
522: {
523: register struct mfc *rt;
524: int s;
525:
526: s = splnet();
527: MFCFIND(req->src.s_addr, req->grp.s_addr, rt);
528: splx(s);
529: if (rt != NULL) {
530: req->pktcnt = rt->mfc_pkt_cnt;
531: req->bytecnt = rt->mfc_byte_cnt;
532: req->wrong_if = rt->mfc_wrong_if;
533: } else
534: req->pktcnt = req->bytecnt = req->wrong_if = 0xffffffff;
535:
536: return 0;
537: }
538:
539: /*
540: * returns the input and output packet and byte counts on the vif provided
541: */
542: static int
543: get_vif_cnt(req)
544: register struct sioc_vif_req *req;
545: {
546: register vifi_t vifi = req->vifi;
547:
548: if (vifi >= numvifs) return EINVAL;
549:
550: req->icount = viftable[vifi].v_pkt_in;
551: req->ocount = viftable[vifi].v_pkt_out;
552: req->ibytes = viftable[vifi].v_bytes_in;
553: req->obytes = viftable[vifi].v_bytes_out;
554:
555: return 0;
556: }
557:
558: /*
559: * Enable multicast routing
560: */
561: static int
562: ip_mrouter_init(so, version)
563: struct socket *so;
564: int version;
565: {
566: if (mrtdebug)
567: log(LOG_DEBUG,"ip_mrouter_init: so_type = %d, pr_protocol = %d\n",
568: so->so_type, so->so_proto->pr_protocol);
569:
570: if (so->so_type != SOCK_RAW ||
571: so->so_proto->pr_protocol != IPPROTO_IGMP) return EOPNOTSUPP;
572:
573: if (version != 1)
574: return ENOPROTOOPT;
575:
576: if (ip_mrouter != NULL) return EADDRINUSE;
577:
578: ip_mrouter = so;
579:
580: bzero((caddr_t)mfctable, sizeof(mfctable));
581: bzero((caddr_t)nexpire, sizeof(nexpire));
582:
583: pim_assert = 0;
584:
585: timeout(expire_upcalls, (caddr_t)NULL, EXPIRE_TIMEOUT);
586:
587: if (mrtdebug)
588: log(LOG_DEBUG, "ip_mrouter_init\n");
589:
590: return 0;
591: }
592:
593: /*
594: * Disable multicast routing
595: */
596: static int
597: X_ip_mrouter_done()
598: {
599: vifi_t vifi;
600: int i;
601: struct ifnet *ifp;
602: struct ifreq ifr;
603: struct mfc *rt;
604: struct rtdetq *rte;
605: int s;
606:
607: s = splnet();
608:
609: /*
610: * For each phyint in use, disable promiscuous reception of all IP
611: * multicasts.
612: */
613: for (vifi = 0; vifi < numvifs; vifi++) {
614: if (viftable[vifi].v_lcl_addr.s_addr != 0 &&
615: !(viftable[vifi].v_flags & VIFF_TUNNEL)) {
616: ((struct sockaddr_in *)&(ifr.ifr_addr))->sin_family = AF_INET;
617: ((struct sockaddr_in *)&(ifr.ifr_addr))->sin_addr.s_addr
618: = INADDR_ANY;
619: ifp = viftable[vifi].v_ifp;
620: if_allmulti(ifp, 0);
621: }
622: }
623: bzero((caddr_t)tbftable, sizeof(tbftable));
624: bzero((caddr_t)viftable, sizeof(viftable));
625: numvifs = 0;
626: pim_assert = 0;
627:
628: untimeout(expire_upcalls, (caddr_t)NULL);
629:
630: /*
631: * Free all multicast forwarding cache entries.
632: */
633: for (i = 0; i < MFCTBLSIZ; i++) {
634: for (rt = mfctable[i]; rt != NULL; ) {
635: struct mfc *nr = rt->mfc_next;
636:
637: for (rte = rt->mfc_stall; rte != NULL; ) {
638: struct rtdetq *n = rte->next;
639:
640: m_freem(rte->m);
641: FREE(rte, M_MRTABLE);
642: rte = n;
643: }
644: FREE(rt, M_MRTABLE);
645: rt = nr;
646: }
647: }
648:
649: bzero((caddr_t)mfctable, sizeof(mfctable));
650:
651: /*
652: * Reset de-encapsulation cache
653: */
654: last_encap_src = 0;
655: last_encap_vif = NULL;
656: have_encap_tunnel = 0;
657:
658: ip_mrouter = NULL;
659:
660: splx(s);
661:
662: if (mrtdebug)
663: log(LOG_DEBUG, "ip_mrouter_done\n");
664:
665: return 0;
666: }
667:
668: #if !MROUTE_LKM
669: int (*ip_mrouter_done)(void) = X_ip_mrouter_done;
670: #endif
671:
672: /*
673: * Set PIM assert processing global
674: */
675: static int
676: set_assert(i)
677: int i;
678: {
679: if ((i != 1) && (i != 0))
680: return EINVAL;
681:
682: pim_assert = i;
683:
684: return 0;
685: }
686:
687: /*
688: * Add a vif to the vif table
689: */
690: static int
691: add_vif(vifcp)
692: register struct vifctl *vifcp;
693: {
694: register struct vif *vifp = viftable + vifcp->vifc_vifi;
695: static struct sockaddr_in sin = {sizeof sin, AF_INET};
696: struct ifaddr *ifa;
697: struct ifnet *ifp;
698: int error, s;
699: struct tbf *v_tbf = tbftable + vifcp->vifc_vifi;
700:
701: if (vifcp->vifc_vifi >= MAXVIFS) return EINVAL;
702: if (vifp->v_lcl_addr.s_addr != 0) return EADDRINUSE;
703:
704: /* Find the interface with an address in AF_INET family */
705: sin.sin_addr = vifcp->vifc_lcl_addr;
706: ifa = ifa_ifwithaddr((struct sockaddr *)&sin);
707: if (ifa == 0) return EADDRNOTAVAIL;
708: ifp = ifa->ifa_ifp;
709:
710: if (vifcp->vifc_flags & VIFF_TUNNEL) {
711: if ((vifcp->vifc_flags & VIFF_SRCRT) == 0) {
712: /*
713: * An encapsulating tunnel is wanted. Tell ipip_input() to
714: * start paying attention to encapsulated packets.
715: */
716: if (have_encap_tunnel == 0) {
717: have_encap_tunnel = 1;
718: for (s = 0; s < MAXVIFS; ++s) {
719: multicast_decap_if[s].if_name = "mdecap";
720: multicast_decap_if[s].if_unit = s;
721: multicast_decap_if[s].if_family = APPLE_IF_FAM_MDECAP;
722: }
723: }
724: /*
725: * Set interface to fake encapsulator interface
726: */
727: ifp = &multicast_decap_if[vifcp->vifc_vifi];
728: /*
729: * Prepare cached route entry
730: */
731: bzero(&vifp->v_route, sizeof(vifp->v_route));
732: } else {
733: log(LOG_ERR, "source routed tunnels not supported\n");
734: return EOPNOTSUPP;
735: }
736: } else {
737: /* Make sure the interface supports multicast */
738: if ((ifp->if_flags & IFF_MULTICAST) == 0)
739: return EOPNOTSUPP;
740:
741: /* Enable promiscuous reception of all IP multicasts from the if */
742: s = splnet();
743: error = if_allmulti(ifp, 1);
744: splx(s);
745: if (error)
746: return error;
747: }
748:
749: s = splnet();
750: /* define parameters for the tbf structure */
751: vifp->v_tbf = v_tbf;
752: GET_TIME(vifp->v_tbf->tbf_last_pkt_t);
753: vifp->v_tbf->tbf_n_tok = 0;
754: vifp->v_tbf->tbf_q_len = 0;
755: vifp->v_tbf->tbf_max_q_len = MAXQSIZE;
756: vifp->v_tbf->tbf_q = vifp->v_tbf->tbf_t = NULL;
757:
758: vifp->v_flags = vifcp->vifc_flags;
759: vifp->v_threshold = vifcp->vifc_threshold;
760: vifp->v_lcl_addr = vifcp->vifc_lcl_addr;
761: vifp->v_rmt_addr = vifcp->vifc_rmt_addr;
762: vifp->v_ifp = ifp;
763: /* scaling up here allows division by 1024 in critical code */
764: vifp->v_rate_limit= vifcp->vifc_rate_limit * 1024 / 1000;
765: vifp->v_rsvp_on = 0;
766: vifp->v_rsvpd = NULL;
767: /* initialize per vif pkt counters */
768: vifp->v_pkt_in = 0;
769: vifp->v_pkt_out = 0;
770: vifp->v_bytes_in = 0;
771: vifp->v_bytes_out = 0;
772: splx(s);
773:
774: /* Adjust numvifs up if the vifi is higher than numvifs */
775: if (numvifs <= vifcp->vifc_vifi) numvifs = vifcp->vifc_vifi + 1;
776:
777: if (mrtdebug)
778: log(LOG_DEBUG, "add_vif #%d, lcladdr %lx, %s %lx, thresh %x, rate %d\n",
779: vifcp->vifc_vifi,
780: (u_long)ntohl(vifcp->vifc_lcl_addr.s_addr),
781: (vifcp->vifc_flags & VIFF_TUNNEL) ? "rmtaddr" : "mask",
782: (u_long)ntohl(vifcp->vifc_rmt_addr.s_addr),
783: vifcp->vifc_threshold,
784: vifcp->vifc_rate_limit);
785:
786: return 0;
787: }
788:
789: /*
790: * Delete a vif from the vif table
791: */
792: static int
793: del_vif(vifi)
794: vifi_t vifi;
795: {
796: register struct vif *vifp = &viftable[vifi];
797: register struct mbuf *m;
798: struct ifnet *ifp;
799: struct ifreq ifr;
800: int s;
801:
802: if (vifi >= numvifs) return EINVAL;
803: if (vifp->v_lcl_addr.s_addr == 0) return EADDRNOTAVAIL;
804:
805: s = splnet();
806:
807: if (!(vifp->v_flags & VIFF_TUNNEL)) {
808: ((struct sockaddr_in *)&(ifr.ifr_addr))->sin_family = AF_INET;
809: ((struct sockaddr_in *)&(ifr.ifr_addr))->sin_addr.s_addr = INADDR_ANY;
810: ifp = vifp->v_ifp;
811: if_allmulti(ifp, 0);
812: }
813:
814: if (vifp == last_encap_vif) {
815: last_encap_vif = 0;
816: last_encap_src = 0;
817: }
818:
819: /*
820: * Free packets queued at the interface
821: */
822: while (vifp->v_tbf->tbf_q) {
823: m = vifp->v_tbf->tbf_q;
824: vifp->v_tbf->tbf_q = m->m_act;
825: m_freem(m);
826: }
827:
828: bzero((caddr_t)vifp->v_tbf, sizeof(*(vifp->v_tbf)));
829: bzero((caddr_t)vifp, sizeof (*vifp));
830:
831: if (mrtdebug)
832: log(LOG_DEBUG, "del_vif %d, numvifs %d\n", vifi, numvifs);
833:
834: /* Adjust numvifs down */
835: for (vifi = numvifs; vifi > 0; vifi--)
836: if (viftable[vifi-1].v_lcl_addr.s_addr != 0) break;
837: numvifs = vifi;
838:
839: splx(s);
840:
841: return 0;
842: }
843:
844: /*
845: * Add an mfc entry
846: */
847: static int
848: add_mfc(mfccp)
849: struct mfcctl *mfccp;
850: {
851: struct mfc *rt;
852: u_long hash;
853: struct rtdetq *rte;
854: register u_short nstl;
855: int s;
856: int i;
857:
858: MFCFIND(mfccp->mfcc_origin.s_addr, mfccp->mfcc_mcastgrp.s_addr, rt);
859:
860: /* If an entry already exists, just update the fields */
861: if (rt) {
862: if (mrtdebug & DEBUG_MFC)
863: log(LOG_DEBUG,"add_mfc update o %lx g %lx p %x\n",
864: (u_long)ntohl(mfccp->mfcc_origin.s_addr),
865: (u_long)ntohl(mfccp->mfcc_mcastgrp.s_addr),
866: mfccp->mfcc_parent);
867:
868: s = splnet();
869: rt->mfc_parent = mfccp->mfcc_parent;
870: for (i = 0; i < numvifs; i++)
871: rt->mfc_ttls[i] = mfccp->mfcc_ttls[i];
872: splx(s);
873: return 0;
874: }
875:
876: /*
877: * Find the entry for which the upcall was made and update
878: */
879: s = splnet();
880: hash = MFCHASH(mfccp->mfcc_origin.s_addr, mfccp->mfcc_mcastgrp.s_addr);
881: for (rt = mfctable[hash], nstl = 0; rt; rt = rt->mfc_next) {
882:
883: if ((rt->mfc_origin.s_addr == mfccp->mfcc_origin.s_addr) &&
884: (rt->mfc_mcastgrp.s_addr == mfccp->mfcc_mcastgrp.s_addr) &&
885: (rt->mfc_stall != NULL)) {
886:
887: if (nstl++)
888: log(LOG_ERR, "add_mfc %s o %lx g %lx p %x dbx %p\n",
889: "multiple kernel entries",
890: (u_long)ntohl(mfccp->mfcc_origin.s_addr),
891: (u_long)ntohl(mfccp->mfcc_mcastgrp.s_addr),
892: mfccp->mfcc_parent, (void *)rt->mfc_stall);
893:
894: if (mrtdebug & DEBUG_MFC)
895: log(LOG_DEBUG,"add_mfc o %lx g %lx p %x dbg %p\n",
896: (u_long)ntohl(mfccp->mfcc_origin.s_addr),
897: (u_long)ntohl(mfccp->mfcc_mcastgrp.s_addr),
898: mfccp->mfcc_parent, (void *)rt->mfc_stall);
899:
900: rt->mfc_origin = mfccp->mfcc_origin;
901: rt->mfc_mcastgrp = mfccp->mfcc_mcastgrp;
902: rt->mfc_parent = mfccp->mfcc_parent;
903: for (i = 0; i < numvifs; i++)
904: rt->mfc_ttls[i] = mfccp->mfcc_ttls[i];
905: /* initialize pkt counters per src-grp */
906: rt->mfc_pkt_cnt = 0;
907: rt->mfc_byte_cnt = 0;
908: rt->mfc_wrong_if = 0;
909: rt->mfc_last_assert.tv_sec = rt->mfc_last_assert.tv_usec = 0;
910:
911: rt->mfc_expire = 0; /* Don't clean this guy up */
912: nexpire[hash]--;
913:
914: /* free packets Qed at the end of this entry */
915: for (rte = rt->mfc_stall; rte != NULL; ) {
916: struct rtdetq *n = rte->next;
917:
918: ip_mdq(rte->m, rte->ifp, rt, -1);
919: m_freem(rte->m);
920: #if UPCALL_TIMING
921: collate(&(rte->t));
922: #endif /* UPCALL_TIMING */
923: FREE(rte, M_MRTABLE);
924: rte = n;
925: }
926: rt->mfc_stall = NULL;
927: }
928: }
929:
930: /*
931: * It is possible that an entry is being inserted without an upcall
932: */
933: if (nstl == 0) {
934: if (mrtdebug & DEBUG_MFC)
935: log(LOG_DEBUG,"add_mfc no upcall h %lu o %lx g %lx p %x\n",
936: hash, (u_long)ntohl(mfccp->mfcc_origin.s_addr),
937: (u_long)ntohl(mfccp->mfcc_mcastgrp.s_addr),
938: mfccp->mfcc_parent);
939:
940: for (rt = mfctable[hash]; rt != NULL; rt = rt->mfc_next) {
941:
942: if ((rt->mfc_origin.s_addr == mfccp->mfcc_origin.s_addr) &&
943: (rt->mfc_mcastgrp.s_addr == mfccp->mfcc_mcastgrp.s_addr)) {
944:
945: rt->mfc_origin = mfccp->mfcc_origin;
946: rt->mfc_mcastgrp = mfccp->mfcc_mcastgrp;
947: rt->mfc_parent = mfccp->mfcc_parent;
948: for (i = 0; i < numvifs; i++)
949: rt->mfc_ttls[i] = mfccp->mfcc_ttls[i];
950: /* initialize pkt counters per src-grp */
951: rt->mfc_pkt_cnt = 0;
952: rt->mfc_byte_cnt = 0;
953: rt->mfc_wrong_if = 0;
954: rt->mfc_last_assert.tv_sec = rt->mfc_last_assert.tv_usec = 0;
955: if (rt->mfc_expire)
956: nexpire[hash]--;
957: rt->mfc_expire = 0;
958: }
959: }
960: if (rt == NULL) {
961: /* no upcall, so make a new entry */
962: rt = (struct mfc *) _MALLOC(sizeof(*rt), M_MRTABLE, M_NOWAIT);
963: if (rt == NULL) {
964: splx(s);
965: return ENOBUFS;
966: }
967:
968: /* insert new entry at head of hash chain */
969: rt->mfc_origin = mfccp->mfcc_origin;
970: rt->mfc_mcastgrp = mfccp->mfcc_mcastgrp;
971: rt->mfc_parent = mfccp->mfcc_parent;
972: for (i = 0; i < numvifs; i++)
973: rt->mfc_ttls[i] = mfccp->mfcc_ttls[i];
974: /* initialize pkt counters per src-grp */
975: rt->mfc_pkt_cnt = 0;
976: rt->mfc_byte_cnt = 0;
977: rt->mfc_wrong_if = 0;
978: rt->mfc_last_assert.tv_sec = rt->mfc_last_assert.tv_usec = 0;
979: rt->mfc_expire = 0;
980: rt->mfc_stall = NULL;
981:
982: /* link into table */
983: rt->mfc_next = mfctable[hash];
984: mfctable[hash] = rt;
985: }
986: }
987: splx(s);
988: return 0;
989: }
990:
991: #if UPCALL_TIMING
992: /*
993: * collect delay statistics on the upcalls
994: */
995: static void collate(t)
996: register struct timeval *t;
997: {
998: register u_long d;
999: register struct timeval tp;
1000: register u_long delta;
1001:
1002: GET_TIME(tp);
1003:
1004: if (TV_LT(*t, tp))
1005: {
1006: TV_DELTA(tp, *t, delta);
1007:
1008: d = delta >> 10;
1009: if (d > 50)
1010: d = 50;
1011:
1012: ++upcall_data[d];
1013: }
1014: }
1015: #endif /* UPCALL_TIMING */
1016:
1017: /*
1018: * Delete an mfc entry
1019: */
1020: static int
1021: del_mfc(mfccp)
1022: struct mfcctl *mfccp;
1023: {
1024: struct in_addr origin;
1025: struct in_addr mcastgrp;
1026: struct mfc *rt;
1027: struct mfc **nptr;
1028: u_long hash;
1029: int s;
1030:
1031: origin = mfccp->mfcc_origin;
1032: mcastgrp = mfccp->mfcc_mcastgrp;
1033: hash = MFCHASH(origin.s_addr, mcastgrp.s_addr);
1034:
1035: if (mrtdebug & DEBUG_MFC)
1036: log(LOG_DEBUG,"del_mfc orig %lx mcastgrp %lx\n",
1037: (u_long)ntohl(origin.s_addr), (u_long)ntohl(mcastgrp.s_addr));
1038:
1039: s = splnet();
1040:
1041: nptr = &mfctable[hash];
1042: while ((rt = *nptr) != NULL) {
1043: if (origin.s_addr == rt->mfc_origin.s_addr &&
1044: mcastgrp.s_addr == rt->mfc_mcastgrp.s_addr &&
1045: rt->mfc_stall == NULL)
1046: break;
1047:
1048: nptr = &rt->mfc_next;
1049: }
1050: if (rt == NULL) {
1051: splx(s);
1052: return EADDRNOTAVAIL;
1053: }
1054:
1055: *nptr = rt->mfc_next;
1056: FREE(rt, M_MRTABLE);
1057:
1058: splx(s);
1059:
1060: return 0;
1061: }
1062:
1063: /*
1064: * Send a message to mrouted on the multicast routing socket
1065: */
1066: static int
1067: socket_send(s, mm, src)
1068: struct socket *s;
1069: struct mbuf *mm;
1070: struct sockaddr_in *src;
1071: {
1072: if (s) {
1073: if (sbappendaddr(&s->so_rcv,
1074: (struct sockaddr *)src,
1075: mm, (struct mbuf *)0) != 0) {
1076: sorwakeup(s);
1077: return 0;
1078: }
1079: }
1080: m_freem(mm);
1081: return -1;
1082: }
1083:
1084: /*
1085: * IP multicast forwarding function. This function assumes that the packet
1086: * pointed to by "ip" has arrived on (or is about to be sent to) the interface
1087: * pointed to by "ifp", and the packet is to be relayed to other networks
1088: * that have members of the packet's destination IP multicast group.
1089: *
1090: * The packet is returned unscathed to the caller, unless it is
1091: * erroneous, in which case a non-zero return value tells the caller to
1092: * discard it.
1093: */
1094:
1095: #define IP_HDR_LEN 20 /* # bytes of fixed IP header (excluding options) */
1096: #define TUNNEL_LEN 12 /* # bytes of IP option for tunnel encapsulation */
1097:
1098: static int
1099: X_ip_mforward(ip, ifp, m, imo)
1100: register struct ip *ip;
1101: struct ifnet *ifp;
1102: struct mbuf *m;
1103: struct ip_moptions *imo;
1104: {
1105: register struct mfc *rt;
1106: register u_char *ipoptions;
1107: static struct sockaddr_in k_igmpsrc = { sizeof k_igmpsrc, AF_INET };
1108: static int srctun = 0;
1109: register struct mbuf *mm;
1110: int s;
1111: vifi_t vifi;
1112: struct vif *vifp;
1113:
1114: if (mrtdebug & DEBUG_FORWARD)
1115: log(LOG_DEBUG, "ip_mforward: src %lx, dst %lx, ifp %p\n",
1116: (u_long)ntohl(ip->ip_src.s_addr), (u_long)ntohl(ip->ip_dst.s_addr),
1117: (void *)ifp);
1118:
1119: if (ip->ip_hl < (IP_HDR_LEN + TUNNEL_LEN) >> 2 ||
1120: (ipoptions = (u_char *)(ip + 1))[1] != IPOPT_LSRR ) {
1121: /*
1122: * Packet arrived via a physical interface or
1123: * an encapsulated tunnel.
1124: */
1125: } else {
1126: /*
1127: * Packet arrived through a source-route tunnel.
1128: * Source-route tunnels are no longer supported.
1129: */
1130: if ((srctun++ % 1000) == 0)
1131: log(LOG_ERR,
1132: "ip_mforward: received source-routed packet from %lx\n",
1133: (u_long)ntohl(ip->ip_src.s_addr));
1134:
1135: return 1;
1136: }
1137:
1138: if ((imo) && ((vifi = imo->imo_multicast_vif) < numvifs)) {
1139: if (ip->ip_ttl < 255)
1140: ip->ip_ttl++; /* compensate for -1 in *_send routines */
1141: if (rsvpdebug && ip->ip_p == IPPROTO_RSVP) {
1142: vifp = viftable + vifi;
1143: printf("Sending IPPROTO_RSVP from %lx to %lx on vif %d (%s%s%d)\n",
1144: ntohl(ip->ip_src.s_addr), ntohl(ip->ip_dst.s_addr), vifi,
1145: (vifp->v_flags & VIFF_TUNNEL) ? "tunnel on " : "",
1146: vifp->v_ifp->if_name, vifp->v_ifp->if_unit);
1147: }
1148: return (ip_mdq(m, ifp, NULL, vifi));
1149: }
1150: if (rsvpdebug && ip->ip_p == IPPROTO_RSVP) {
1151: printf("Warning: IPPROTO_RSVP from %lx to %lx without vif option\n",
1152: ntohl(ip->ip_src.s_addr), ntohl(ip->ip_dst.s_addr));
1153: if(!imo)
1154: printf("In fact, no options were specified at all\n");
1155: }
1156:
1157: /*
1158: * Don't forward a packet with time-to-live of zero or one,
1159: * or a packet destined to a local-only group.
1160: */
1161: if (ip->ip_ttl <= 1 ||
1162: ntohl(ip->ip_dst.s_addr) <= INADDR_MAX_LOCAL_GROUP)
1163: return 0;
1164:
1165: /*
1166: * Determine forwarding vifs from the forwarding cache table
1167: */
1168: s = splnet();
1169: MFCFIND(ip->ip_src.s_addr, ip->ip_dst.s_addr, rt);
1170:
1171: /* Entry exists, so forward if necessary */
1172: if (rt != NULL) {
1173: splx(s);
1174: return (ip_mdq(m, ifp, rt, -1));
1175: } else {
1176: /*
1177: * If we don't have a route for packet's origin,
1178: * Make a copy of the packet &
1179: * send message to routing daemon
1180: */
1181:
1182: register struct mbuf *mb0;
1183: register struct rtdetq *rte;
1184: register u_long hash;
1185: int hlen = ip->ip_hl << 2;
1186: #if UPCALL_TIMING
1187: struct timeval tp;
1188:
1189: GET_TIME(tp);
1190: #endif
1191:
1192: mrtstat.mrts_no_route++;
1193: if (mrtdebug & (DEBUG_FORWARD | DEBUG_MFC))
1194: log(LOG_DEBUG, "ip_mforward: no rte s %lx g %lx\n",
1195: (u_long)ntohl(ip->ip_src.s_addr),
1196: (u_long)ntohl(ip->ip_dst.s_addr));
1197:
1198: /*
1199: * Allocate mbufs early so that we don't do extra work if we are
1200: * just going to fail anyway. Make sure to pullup the header so
1201: * that other people can't step on it.
1202: */
1203: rte = (struct rtdetq *) _MALLOC((sizeof *rte), M_MRTABLE, M_NOWAIT);
1204: if (rte == NULL) {
1205: splx(s);
1206: return ENOBUFS;
1207: }
1208: mb0 = m_copy(m, 0, M_COPYALL);
1209: if (mb0 && (M_HASCL(mb0) || mb0->m_len < hlen))
1210: mb0 = m_pullup(mb0, hlen);
1211: if (mb0 == NULL) {
1212: FREE(rte, M_MRTABLE);
1213: splx(s);
1214: return ENOBUFS;
1215: }
1216:
1217: /* is there an upcall waiting for this packet? */
1218: hash = MFCHASH(ip->ip_src.s_addr, ip->ip_dst.s_addr);
1219: for (rt = mfctable[hash]; rt; rt = rt->mfc_next) {
1220: if ((ip->ip_src.s_addr == rt->mfc_origin.s_addr) &&
1221: (ip->ip_dst.s_addr == rt->mfc_mcastgrp.s_addr) &&
1222: (rt->mfc_stall != NULL))
1223: break;
1224: }
1225:
1226: if (rt == NULL) {
1227: int i;
1228: struct igmpmsg *im;
1229:
1230: /* no upcall, so make a new entry */
1231: rt = (struct mfc *) _MALLOC(sizeof(*rt), M_MRTABLE, M_NOWAIT);
1232: if (rt == NULL) {
1233: FREE(rte, M_MRTABLE);
1234: m_freem(mb0);
1235: splx(s);
1236: return ENOBUFS;
1237: }
1238: /* Make a copy of the header to send to the user level process */
1239: mm = m_copy(mb0, 0, hlen);
1240: if (mm == NULL) {
1241: FREE(rte, M_MRTABLE);
1242: m_freem(mb0);
1243: FREE(rt, M_MRTABLE);
1244: splx(s);
1245: return ENOBUFS;
1246: }
1247:
1248: /*
1249: * Send message to routing daemon to install
1250: * a route into the kernel table
1251: */
1252: k_igmpsrc.sin_addr = ip->ip_src;
1253:
1254: im = mtod(mm, struct igmpmsg *);
1255: im->im_msgtype = IGMPMSG_NOCACHE;
1256: im->im_mbz = 0;
1257:
1258: mrtstat.mrts_upcalls++;
1259:
1260: if (socket_send(ip_mrouter, mm, &k_igmpsrc) < 0) {
1261: log(LOG_WARNING, "ip_mforward: ip_mrouter socket queue full\n");
1262: ++mrtstat.mrts_upq_sockfull;
1263: FREE(rte, M_MRTABLE);
1264: m_freem(mb0);
1265: FREE(rt, M_MRTABLE);
1266: splx(s);
1267: return ENOBUFS;
1268: }
1269:
1270: /* insert new entry at head of hash chain */
1271: rt->mfc_origin.s_addr = ip->ip_src.s_addr;
1272: rt->mfc_mcastgrp.s_addr = ip->ip_dst.s_addr;
1273: rt->mfc_expire = UPCALL_EXPIRE;
1274: nexpire[hash]++;
1275: for (i = 0; i < numvifs; i++)
1276: rt->mfc_ttls[i] = 0;
1277: rt->mfc_parent = -1;
1278:
1279: /* link into table */
1280: rt->mfc_next = mfctable[hash];
1281: mfctable[hash] = rt;
1282: rt->mfc_stall = rte;
1283:
1284: } else {
1285: /* determine if q has overflowed */
1286: int npkts = 0;
1287: struct rtdetq **p;
1288:
1289: for (p = &rt->mfc_stall; *p != NULL; p = &(*p)->next)
1290: npkts++;
1291:
1292: if (npkts > MAX_UPQ) {
1293: mrtstat.mrts_upq_ovflw++;
1294: FREE(rte, M_MRTABLE);
1295: m_freem(mb0);
1296: splx(s);
1297: return 0;
1298: }
1299:
1300: /* Add this entry to the end of the queue */
1301: *p = rte;
1302: }
1303:
1304: rte->m = mb0;
1305: rte->ifp = ifp;
1306: #if UPCALL_TIMING
1307: rte->t = tp;
1308: #endif
1309: rte->next = NULL;
1310:
1311: splx(s);
1312:
1313: return 0;
1314: }
1315: }
1316:
1317: #if !MROUTE_LKM
1318: int (*ip_mforward)(struct ip *, struct ifnet *, struct mbuf *,
1319: struct ip_moptions *) = X_ip_mforward;
1320: #endif
1321:
1322: /*
1323: * Clean up the cache entry if upcall is not serviced
1324: */
1325: static void
1326: expire_upcalls(void *unused)
1327: {
1328: struct rtdetq *rte;
1329: struct mfc *mfc, **nptr;
1330: int i;
1331: int s;
1332:
1333: s = splnet();
1334: for (i = 0; i < MFCTBLSIZ; i++) {
1335: if (nexpire[i] == 0)
1336: continue;
1337: nptr = &mfctable[i];
1338: for (mfc = *nptr; mfc != NULL; mfc = *nptr) {
1339: /*
1340: * Skip real cache entries
1341: * Make sure it wasn't marked to not expire (shouldn't happen)
1342: * If it expires now
1343: */
1344: if (mfc->mfc_stall != NULL &&
1345: mfc->mfc_expire != 0 &&
1346: --mfc->mfc_expire == 0) {
1347: if (mrtdebug & DEBUG_EXPIRE)
1348: log(LOG_DEBUG, "expire_upcalls: expiring (%lx %lx)\n",
1349: (u_long)ntohl(mfc->mfc_origin.s_addr),
1350: (u_long)ntohl(mfc->mfc_mcastgrp.s_addr));
1351: /*
1352: * drop all the packets
1353: * free the mbuf with the pkt, if, timing info
1354: */
1355: for (rte = mfc->mfc_stall; rte; ) {
1356: struct rtdetq *n = rte->next;
1357:
1358: m_freem(rte->m);
1359: FREE(rte, M_MRTABLE);
1360: rte = n;
1361: }
1362: ++mrtstat.mrts_cache_cleanups;
1363: nexpire[i]--;
1364:
1365: *nptr = mfc->mfc_next;
1366: FREE(mfc, M_MRTABLE);
1367: } else {
1368: nptr = &mfc->mfc_next;
1369: }
1370: }
1371: }
1372: splx(s);
1373: timeout(expire_upcalls, (caddr_t)NULL, EXPIRE_TIMEOUT);
1374: }
1375:
1376: /*
1377: * Packet forwarding routine once entry in the cache is made
1378: */
1379: static int
1380: ip_mdq(m, ifp, rt, xmt_vif)
1381: register struct mbuf *m;
1382: register struct ifnet *ifp;
1383: register struct mfc *rt;
1384: register vifi_t xmt_vif;
1385: {
1386: register struct ip *ip = mtod(m, struct ip *);
1387: register vifi_t vifi;
1388: register struct vif *vifp;
1389: register int plen = ip->ip_len;
1390:
1391: /*
1392: * Macro to send packet on vif. Since RSVP packets don't get counted on
1393: * input, they shouldn't get counted on output, so statistics keeping is
1394: * seperate.
1395: */
1396: #define MC_SEND(ip,vifp,m) { \
1397: if ((vifp)->v_flags & VIFF_TUNNEL) \
1398: encap_send((ip), (vifp), (m)); \
1399: else \
1400: phyint_send((ip), (vifp), (m)); \
1401: }
1402:
1403: /*
1404: * If xmt_vif is not -1, send on only the requested vif.
1405: *
1406: * (since vifi_t is u_short, -1 becomes MAXUSHORT, which > numvifs.)
1407: */
1408: if (xmt_vif < numvifs) {
1409: MC_SEND(ip, viftable + xmt_vif, m);
1410: return 1;
1411: }
1412:
1413: /*
1414: * Don't forward if it didn't arrive from the parent vif for its origin.
1415: */
1416: vifi = rt->mfc_parent;
1417: if ((vifi >= numvifs) || (viftable[vifi].v_ifp != ifp)) {
1418: /* came in the wrong interface */
1419: if (mrtdebug & DEBUG_FORWARD)
1420: log(LOG_DEBUG, "wrong if: ifp %p vifi %d vififp %p\n",
1421: (void *)ifp, vifi, (void *)viftable[vifi].v_ifp);
1422: ++mrtstat.mrts_wrong_if;
1423: ++rt->mfc_wrong_if;
1424: /*
1425: * If we are doing PIM assert processing, and we are forwarding
1426: * packets on this interface, and it is a broadcast medium
1427: * interface (and not a tunnel), send a message to the routing daemon.
1428: */
1429: if (pim_assert && rt->mfc_ttls[vifi] &&
1430: (ifp->if_flags & IFF_BROADCAST) &&
1431: !(viftable[vifi].v_flags & VIFF_TUNNEL)) {
1432: struct sockaddr_in k_igmpsrc;
1433: struct mbuf *mm;
1434: struct igmpmsg *im;
1435: int hlen = ip->ip_hl << 2;
1436: struct timeval now;
1437: register u_long delta;
1438:
1439: GET_TIME(now);
1440:
1441: TV_DELTA(rt->mfc_last_assert, now, delta);
1442:
1443: if (delta > ASSERT_MSG_TIME) {
1444: mm = m_copy(m, 0, hlen);
1445: if (mm && (M_HASCL(mm) || mm->m_len < hlen))
1446: mm = m_pullup(mm, hlen);
1447: if (mm == NULL) {
1448: return ENOBUFS;
1449: }
1450:
1451: rt->mfc_last_assert = now;
1452:
1453: im = mtod(mm, struct igmpmsg *);
1454: im->im_msgtype = IGMPMSG_WRONGVIF;
1455: im->im_mbz = 0;
1456: im->im_vif = vifi;
1457:
1458: k_igmpsrc.sin_addr = im->im_src;
1459:
1460: socket_send(ip_mrouter, mm, &k_igmpsrc);
1461: }
1462: }
1463: return 0;
1464: }
1465:
1466: /* If I sourced this packet, it counts as output, else it was input. */
1467: if (ip->ip_src.s_addr == viftable[vifi].v_lcl_addr.s_addr) {
1468: viftable[vifi].v_pkt_out++;
1469: viftable[vifi].v_bytes_out += plen;
1470: } else {
1471: viftable[vifi].v_pkt_in++;
1472: viftable[vifi].v_bytes_in += plen;
1473: }
1474: rt->mfc_pkt_cnt++;
1475: rt->mfc_byte_cnt += plen;
1476:
1477: /*
1478: * For each vif, decide if a copy of the packet should be forwarded.
1479: * Forward if:
1480: * - the ttl exceeds the vif's threshold
1481: * - there are group members downstream on interface
1482: */
1483: for (vifp = viftable, vifi = 0; vifi < numvifs; vifp++, vifi++)
1484: if ((rt->mfc_ttls[vifi] > 0) &&
1485: (ip->ip_ttl > rt->mfc_ttls[vifi])) {
1486: vifp->v_pkt_out++;
1487: vifp->v_bytes_out += plen;
1488: MC_SEND(ip, vifp, m);
1489: }
1490:
1491: return 0;
1492: }
1493:
1494: /*
1495: * check if a vif number is legal/ok. This is used by ip_output, to export
1496: * numvifs there,
1497: */
1498: static int
1499: X_legal_vif_num(vif)
1500: int vif;
1501: {
1502: if (vif >= 0 && vif < numvifs)
1503: return(1);
1504: else
1505: return(0);
1506: }
1507:
1508: #if !MROUTE_LKM
1509: int (*legal_vif_num)(int) = X_legal_vif_num;
1510: #endif
1511:
1512: /*
1513: * Return the local address used by this vif
1514: */
1515: static u_long
1516: X_ip_mcast_src(vifi)
1517: int vifi;
1518: {
1519: if (vifi >= 0 && vifi < numvifs)
1520: return viftable[vifi].v_lcl_addr.s_addr;
1521: else
1522: return INADDR_ANY;
1523: }
1524:
1525: #if !MROUTE_LKM
1526: u_long (*ip_mcast_src)(int) = X_ip_mcast_src;
1527: #endif
1528:
1529: static void
1530: phyint_send(ip, vifp, m)
1531: struct ip *ip;
1532: struct vif *vifp;
1533: struct mbuf *m;
1534: {
1535: register struct mbuf *mb_copy;
1536: register int hlen = ip->ip_hl << 2;
1537:
1538: /*
1539: * Make a new reference to the packet; make sure that
1540: * the IP header is actually copied, not just referenced,
1541: * so that ip_output() only scribbles on the copy.
1542: */
1543: mb_copy = m_copy(m, 0, M_COPYALL);
1544: if (mb_copy && (M_HASCL(mb_copy) || mb_copy->m_len < hlen))
1545: mb_copy = m_pullup(mb_copy, hlen);
1546: if (mb_copy == NULL)
1547: return;
1548:
1549: if (vifp->v_rate_limit == 0)
1550: tbf_send_packet(vifp, mb_copy);
1551: else
1552: tbf_control(vifp, mb_copy, mtod(mb_copy, struct ip *), ip->ip_len);
1553: }
1554:
1555: static void
1556: encap_send(ip, vifp, m)
1557: register struct ip *ip;
1558: register struct vif *vifp;
1559: register struct mbuf *m;
1560: {
1561: register struct mbuf *mb_copy;
1562: register struct ip *ip_copy;
1563: register int i, len = ip->ip_len;
1564:
1565: /*
1566: * copy the old packet & pullup its IP header into the
1567: * new mbuf so we can modify it. Try to fill the new
1568: * mbuf since if we don't the ethernet driver will.
1569: */
1570: MGETHDR(mb_copy, M_DONTWAIT, MT_HEADER);
1571: if (mb_copy == NULL)
1572: return;
1573: mb_copy->m_data += max_linkhdr;
1574: mb_copy->m_len = sizeof(multicast_encap_iphdr);
1575:
1576: if ((mb_copy->m_next = m_copy(m, 0, M_COPYALL)) == NULL) {
1577: m_freem(mb_copy);
1578: return;
1579: }
1580: i = MHLEN - M_LEADINGSPACE(mb_copy);
1581: if (i > len)
1582: i = len;
1583: mb_copy = m_pullup(mb_copy, i);
1584: if (mb_copy == NULL)
1585: return;
1586: mb_copy->m_pkthdr.len = len + sizeof(multicast_encap_iphdr);
1587:
1588: /*
1589: * fill in the encapsulating IP header.
1590: */
1591: ip_copy = mtod(mb_copy, struct ip *);
1592: *ip_copy = multicast_encap_iphdr;
1593: ip_copy->ip_id = htons(ip_id++);
1594: ip_copy->ip_len += len;
1595: ip_copy->ip_src = vifp->v_lcl_addr;
1596: ip_copy->ip_dst = vifp->v_rmt_addr;
1597:
1598: /*
1599: * turn the encapsulated IP header back into a valid one.
1600: */
1601: ip = (struct ip *)((caddr_t)ip_copy + sizeof(multicast_encap_iphdr));
1602: --ip->ip_ttl;
1603: HTONS(ip->ip_len);
1604: HTONS(ip->ip_off);
1605: ip->ip_sum = 0;
1606: mb_copy->m_data += sizeof(multicast_encap_iphdr);
1607: ip->ip_sum = in_cksum(mb_copy, ip->ip_hl << 2);
1608: mb_copy->m_data -= sizeof(multicast_encap_iphdr);
1609:
1610: if (vifp->v_rate_limit == 0)
1611: tbf_send_packet(vifp, mb_copy);
1612: else
1613: tbf_control(vifp, mb_copy, ip, ip_copy->ip_len);
1614: }
1615:
1616: /*
1617: * De-encapsulate a packet and feed it back through ip input (this
1618: * routine is called whenever IP gets a packet with proto type
1619: * ENCAP_PROTO and a local destination address).
1620: */
1621: void
1622: #if MROUTE_LKM
1623: X_ipip_input(m, iphlen)
1624: #else
1625: ipip_input(m, iphlen)
1626: #endif
1627: register struct mbuf *m;
1628: int iphlen;
1629: {
1630: struct ifnet *ifp = m->m_pkthdr.rcvif;
1631: register struct ip *ip = mtod(m, struct ip *);
1632: register int hlen = ip->ip_hl << 2;
1633: register int s;
1634: register struct ifqueue *ifq;
1635: register struct vif *vifp;
1636:
1637: if (!have_encap_tunnel) {
1638: rip_input(m, iphlen);
1639: return;
1640: }
1641: /*
1642: * dump the packet if it's not to a multicast destination or if
1643: * we don't have an encapsulating tunnel with the source.
1644: * Note: This code assumes that the remote site IP address
1645: * uniquely identifies the tunnel (i.e., that this site has
1646: * at most one tunnel with the remote site).
1647: */
1648: if (! IN_MULTICAST(ntohl(((struct ip *)((char *)ip + hlen))->ip_dst.s_addr))) {
1649: ++mrtstat.mrts_bad_tunnel;
1650: m_freem(m);
1651: return;
1652: }
1653: if (ip->ip_src.s_addr != last_encap_src) {
1654: register struct vif *vife;
1655:
1656: vifp = viftable;
1657: vife = vifp + numvifs;
1658: last_encap_src = ip->ip_src.s_addr;
1659: last_encap_vif = 0;
1660: for ( ; vifp < vife; ++vifp)
1661: if (vifp->v_rmt_addr.s_addr == ip->ip_src.s_addr) {
1662: if ((vifp->v_flags & (VIFF_TUNNEL|VIFF_SRCRT))
1663: == VIFF_TUNNEL)
1664: last_encap_vif = vifp;
1665: break;
1666: }
1667: }
1668: if ((vifp = last_encap_vif) == 0) {
1669: last_encap_src = 0;
1670: mrtstat.mrts_cant_tunnel++; /*XXX*/
1671: m_freem(m);
1672: if (mrtdebug)
1673: log(LOG_DEBUG, "ip_mforward: no tunnel with %lx\n",
1674: (u_long)ntohl(ip->ip_src.s_addr));
1675: return;
1676: }
1677: ifp = vifp->v_ifp;
1678:
1679: if (hlen > IP_HDR_LEN)
1680: ip_stripoptions(m, (struct mbuf *) 0);
1681: m->m_data += IP_HDR_LEN;
1682: m->m_len -= IP_HDR_LEN;
1683: m->m_pkthdr.len -= IP_HDR_LEN;
1684: m->m_pkthdr.rcvif = ifp;
1685:
1686: ifq = &ipintrq;
1687: s = splimp();
1688: if (IF_QFULL(ifq)) {
1689: IF_DROP(ifq);
1690: m_freem(m);
1691: } else {
1692: IF_ENQUEUE(ifq, m);
1693: /*
1694: * normally we would need a "schednetisr(NETISR_IP)"
1695: * here but we were called by ip_input and it is going
1696: * to loop back & try to dequeue the packet we just
1697: * queued as soon as we return so we avoid the
1698: * unnecessary software interrrupt.
1699: */
1700: }
1701: splx(s);
1702: }
1703:
1704: /*
1705: * Token bucket filter module
1706: */
1707:
1708: static void
1709: tbf_control(vifp, m, ip, p_len)
1710: register struct vif *vifp;
1711: register struct mbuf *m;
1712: register struct ip *ip;
1713: register u_long p_len;
1714: {
1715: register struct tbf *t = vifp->v_tbf;
1716:
1717: if (p_len > MAX_BKT_SIZE) {
1718: /* drop if packet is too large */
1719: mrtstat.mrts_pkt2large++;
1720: m_freem(m);
1721: return;
1722: }
1723:
1724: tbf_update_tokens(vifp);
1725:
1726: /* if there are enough tokens,
1727: * and the queue is empty,
1728: * send this packet out
1729: */
1730:
1731: if (t->tbf_q_len == 0) {
1732: /* queue empty, send packet if enough tokens */
1733: if (p_len <= t->tbf_n_tok) {
1734: t->tbf_n_tok -= p_len;
1735: tbf_send_packet(vifp, m);
1736: } else {
1737: /* queue packet and timeout till later */
1738: tbf_queue(vifp, m);
1739: timeout(tbf_reprocess_q, (caddr_t)vifp, TBF_REPROCESS);
1740: }
1741: } else if (t->tbf_q_len < t->tbf_max_q_len) {
1742: /* finite queue length, so queue pkts and process queue */
1743: tbf_queue(vifp, m);
1744: tbf_process_q(vifp);
1745: } else {
1746: /* queue length too much, try to dq and queue and process */
1747: if (!tbf_dq_sel(vifp, ip)) {
1748: mrtstat.mrts_q_overflow++;
1749: m_freem(m);
1750: return;
1751: } else {
1752: tbf_queue(vifp, m);
1753: tbf_process_q(vifp);
1754: }
1755: }
1756: return;
1757: }
1758:
1759: /*
1760: * adds a packet to the queue at the interface
1761: */
1762: static void
1763: tbf_queue(vifp, m)
1764: register struct vif *vifp;
1765: register struct mbuf *m;
1766: {
1767: register int s = splnet();
1768: register struct tbf *t = vifp->v_tbf;
1769:
1770: if (t->tbf_t == NULL) {
1771: /* Queue was empty */
1772: t->tbf_q = m;
1773: } else {
1774: /* Insert at tail */
1775: t->tbf_t->m_act = m;
1776: }
1777:
1778: /* Set new tail pointer */
1779: t->tbf_t = m;
1780:
1781: #if DIAGNOSTIC
1782: /* Make sure we didn't get fed a bogus mbuf */
1783: if (m->m_act)
1784: panic("tbf_queue: m_act");
1785: #endif
1786: m->m_act = NULL;
1787:
1788: t->tbf_q_len++;
1789:
1790: splx(s);
1791: }
1792:
1793:
1794: /*
1795: * processes the queue at the interface
1796: */
1797: static void
1798: tbf_process_q(vifp)
1799: register struct vif *vifp;
1800: {
1801: register struct mbuf *m;
1802: register int len;
1803: register int s = splnet();
1804: register struct tbf *t = vifp->v_tbf;
1805:
1806: /* loop through the queue at the interface and send as many packets
1807: * as possible
1808: */
1809: while (t->tbf_q_len > 0) {
1810: m = t->tbf_q;
1811:
1812: len = mtod(m, struct ip *)->ip_len;
1813:
1814: /* determine if the packet can be sent */
1815: if (len <= t->tbf_n_tok) {
1816: /* if so,
1817: * reduce no of tokens, dequeue the packet,
1818: * send the packet.
1819: */
1820: t->tbf_n_tok -= len;
1821:
1822: t->tbf_q = m->m_act;
1823: if (--t->tbf_q_len == 0)
1824: t->tbf_t = NULL;
1825:
1826: m->m_act = NULL;
1827: tbf_send_packet(vifp, m);
1828:
1829: } else break;
1830: }
1831: splx(s);
1832: }
1833:
1834: static void
1835: tbf_reprocess_q(xvifp)
1836: void *xvifp;
1837: {
1838: register struct vif *vifp = xvifp;
1839: if (ip_mrouter == NULL)
1840: return;
1841:
1842: tbf_update_tokens(vifp);
1843:
1844: tbf_process_q(vifp);
1845:
1846: if (vifp->v_tbf->tbf_q_len)
1847: timeout(tbf_reprocess_q, (caddr_t)vifp, TBF_REPROCESS);
1848: }
1849:
1850: /* function that will selectively discard a member of the queue
1851: * based on the precedence value and the priority
1852: */
1853: static int
1854: tbf_dq_sel(vifp, ip)
1855: register struct vif *vifp;
1856: register struct ip *ip;
1857: {
1858: register int s = splnet();
1859: register u_int p;
1860: register struct mbuf *m, *last;
1861: register struct mbuf **np;
1862: register struct tbf *t = vifp->v_tbf;
1863:
1864: p = priority(vifp, ip);
1865:
1866: np = &t->tbf_q;
1867: last = NULL;
1868: while ((m = *np) != NULL) {
1869: if (p > priority(vifp, mtod(m, struct ip *))) {
1870: *np = m->m_act;
1871: /* If we're removing the last packet, fix the tail pointer */
1872: if (m == t->tbf_t)
1873: t->tbf_t = last;
1874: m_freem(m);
1875: /* it's impossible for the queue to be empty, but
1876: * we check anyway. */
1877: if (--t->tbf_q_len == 0)
1878: t->tbf_t = NULL;
1879: splx(s);
1880: mrtstat.mrts_drop_sel++;
1881: return(1);
1882: }
1883: np = &m->m_act;
1884: last = m;
1885: }
1886: splx(s);
1887: return(0);
1888: }
1889:
1890: static void
1891: tbf_send_packet(vifp, m)
1892: register struct vif *vifp;
1893: register struct mbuf *m;
1894: {
1895: struct ip_moptions imo;
1896: int error;
1897: static struct route ro;
1898: int s = splnet();
1899:
1900: if (vifp->v_flags & VIFF_TUNNEL) {
1901: /* If tunnel options */
1902: ip_output(m, (struct mbuf *)0, &vifp->v_route,
1903: IP_FORWARDING, (struct ip_moptions *)0);
1904: } else {
1905: imo.imo_multicast_ifp = vifp->v_ifp;
1906: imo.imo_multicast_ttl = mtod(m, struct ip *)->ip_ttl - 1;
1907: imo.imo_multicast_loop = 1;
1908: imo.imo_multicast_vif = -1;
1909:
1910: /*
1911: * Re-entrancy should not be a problem here, because
1912: * the packets that we send out and are looped back at us
1913: * should get rejected because they appear to come from
1914: * the loopback interface, thus preventing looping.
1915: */
1916: error = ip_output(m, (struct mbuf *)0, &ro,
1917: IP_FORWARDING, &imo);
1918:
1919: if (mrtdebug & DEBUG_XMIT)
1920: log(LOG_DEBUG, "phyint_send on vif %d err %d\n",
1921: vifp - viftable, error);
1922: }
1923: splx(s);
1924: }
1925:
1926: /* determine the current time and then
1927: * the elapsed time (between the last time and time now)
1928: * in milliseconds & update the no. of tokens in the bucket
1929: */
1930: static void
1931: tbf_update_tokens(vifp)
1932: register struct vif *vifp;
1933: {
1934: struct timeval tp;
1935: register u_long tm;
1936: register int s = splnet();
1937: register struct tbf *t = vifp->v_tbf;
1938:
1939: GET_TIME(tp);
1940:
1941: TV_DELTA(tp, t->tbf_last_pkt_t, tm);
1942:
1943: /*
1944: * This formula is actually
1945: * "time in seconds" * "bytes/second".
1946: *
1947: * (tm / 1000000) * (v_rate_limit * 1000 * (1000/1024) / 8)
1948: *
1949: * The (1000/1024) was introduced in add_vif to optimize
1950: * this divide into a shift.
1951: */
1952: t->tbf_n_tok += tm * vifp->v_rate_limit / 1024 / 8;
1953: t->tbf_last_pkt_t = tp;
1954:
1955: if (t->tbf_n_tok > MAX_BKT_SIZE)
1956: t->tbf_n_tok = MAX_BKT_SIZE;
1957:
1958: splx(s);
1959: }
1960:
1961: static int
1962: priority(vifp, ip)
1963: register struct vif *vifp;
1964: register struct ip *ip;
1965: {
1966: register int prio;
1967:
1968: /* temporary hack; may add general packet classifier some day */
1969:
1970: /*
1971: * The UDP port space is divided up into four priority ranges:
1972: * [0, 16384) : unclassified - lowest priority
1973: * [16384, 32768) : audio - highest priority
1974: * [32768, 49152) : whiteboard - medium priority
1975: * [49152, 65536) : video - low priority
1976: */
1977: if (ip->ip_p == IPPROTO_UDP) {
1978: struct udphdr *udp = (struct udphdr *)(((char *)ip) + (ip->ip_hl << 2));
1979: switch (ntohs(udp->uh_dport) & 0xc000) {
1980: case 0x4000:
1981: prio = 70;
1982: break;
1983: case 0x8000:
1984: prio = 60;
1985: break;
1986: case 0xc000:
1987: prio = 55;
1988: break;
1989: default:
1990: prio = 50;
1991: break;
1992: }
1993: if (tbfdebug > 1)
1994: log(LOG_DEBUG, "port %x prio%d\n", ntohs(udp->uh_dport), prio);
1995: } else {
1996: prio = 50;
1997: }
1998: return prio;
1999: }
2000:
2001: /*
2002: * End of token bucket filter modifications
2003: */
2004:
2005: int
2006: ip_rsvp_vif_init(so, sopt)
2007: struct socket *so;
2008: struct sockopt *sopt;
2009: {
2010: int error, i, s;
2011:
2012: if (rsvpdebug)
2013: printf("ip_rsvp_vif_init: so_type = %d, pr_protocol = %d\n",
2014: so->so_type, so->so_proto->pr_protocol);
2015:
2016: if (so->so_type != SOCK_RAW || so->so_proto->pr_protocol != IPPROTO_RSVP)
2017: return EOPNOTSUPP;
2018:
2019: /* Check mbuf. */
2020: error = sooptcopyin(sopt, &i, sizeof i, sizeof i);
2021: if (error)
2022: return (error);
2023:
2024: if (rsvpdebug)
2025: printf("ip_rsvp_vif_init: vif = %d rsvp_on = %d\n", i, rsvp_on);
2026:
2027: s = splnet();
2028:
2029: /* Check vif. */
2030: if (!legal_vif_num(i)) {
2031: splx(s);
2032: return EADDRNOTAVAIL;
2033: }
2034:
2035: /* Check if socket is available. */
2036: if (viftable[i].v_rsvpd != NULL) {
2037: splx(s);
2038: return EADDRINUSE;
2039: }
2040:
2041: viftable[i].v_rsvpd = so;
2042: /* This may seem silly, but we need to be sure we don't over-increment
2043: * the RSVP counter, in case something slips up.
2044: */
2045: if (!viftable[i].v_rsvp_on) {
2046: viftable[i].v_rsvp_on = 1;
2047: rsvp_on++;
2048: }
2049:
2050: splx(s);
2051: return 0;
2052: }
2053:
2054: int
2055: ip_rsvp_vif_done(so, sopt)
2056: struct socket *so;
2057: struct sockopt *sopt;
2058: {
2059: int error, i, s;
2060:
2061: if (rsvpdebug)
2062: printf("ip_rsvp_vif_done: so_type = %d, pr_protocol = %d\n",
2063: so->so_type, so->so_proto->pr_protocol);
2064:
2065: if (so->so_type != SOCK_RAW ||
2066: so->so_proto->pr_protocol != IPPROTO_RSVP)
2067: return EOPNOTSUPP;
2068:
2069: error = sooptcopyin(sopt, &i, sizeof i, sizeof i);
2070: if (error)
2071: return (error);
2072:
2073: s = splnet();
2074:
2075: /* Check vif. */
2076: if (!legal_vif_num(i)) {
2077: splx(s);
2078: return EADDRNOTAVAIL;
2079: }
2080:
2081: if (rsvpdebug)
2082: printf("ip_rsvp_vif_done: v_rsvpd = %p so = %p\n",
2083: viftable[i].v_rsvpd, so);
2084:
2085: viftable[i].v_rsvpd = NULL;
2086: /*
2087: * This may seem silly, but we need to be sure we don't over-decrement
2088: * the RSVP counter, in case something slips up.
2089: */
2090: if (viftable[i].v_rsvp_on) {
2091: viftable[i].v_rsvp_on = 0;
2092: rsvp_on--;
2093: }
2094:
2095: splx(s);
2096: return 0;
2097: }
2098:
2099: void
2100: ip_rsvp_force_done(so)
2101: struct socket *so;
2102: {
2103: int vifi;
2104: register int s;
2105:
2106: /* Don't bother if it is not the right type of socket. */
2107: if (so->so_type != SOCK_RAW || so->so_proto->pr_protocol != IPPROTO_RSVP)
2108: return;
2109:
2110: s = splnet();
2111:
2112: /* The socket may be attached to more than one vif...this
2113: * is perfectly legal.
2114: */
2115: for (vifi = 0; vifi < numvifs; vifi++) {
2116: if (viftable[vifi].v_rsvpd == so) {
2117: viftable[vifi].v_rsvpd = NULL;
2118: /* This may seem silly, but we need to be sure we don't
2119: * over-decrement the RSVP counter, in case something slips up.
2120: */
2121: if (viftable[vifi].v_rsvp_on) {
2122: viftable[vifi].v_rsvp_on = 0;
2123: rsvp_on--;
2124: }
2125: }
2126: }
2127:
2128: splx(s);
2129: return;
2130: }
2131:
2132: void
2133: rsvp_input(m, iphlen)
2134: struct mbuf *m;
2135: int iphlen;
2136: {
2137: int vifi;
2138: register struct ip *ip = mtod(m, struct ip *);
2139: static struct sockaddr_in rsvp_src = { sizeof rsvp_src, AF_INET };
2140: register int s;
2141: struct ifnet *ifp;
2142:
2143: if (rsvpdebug)
2144: printf("rsvp_input: rsvp_on %d\n",rsvp_on);
2145:
2146: /* Can still get packets with rsvp_on = 0 if there is a local member
2147: * of the group to which the RSVP packet is addressed. But in this
2148: * case we want to throw the packet away.
2149: */
2150: if (!rsvp_on) {
2151: m_freem(m);
2152: return;
2153: }
2154:
2155: /* If the old-style non-vif-associated socket is set, then use
2156: * it and ignore the new ones.
2157: */
2158: if (ip_rsvpd != NULL) {
2159: if (rsvpdebug)
2160: printf("rsvp_input: Sending packet up old-style socket\n");
2161: rip_input(m, iphlen);
2162: return;
2163: }
2164:
2165: s = splnet();
2166:
2167: if (rsvpdebug)
2168: printf("rsvp_input: check vifs\n");
2169:
2170: #if DIAGNOSTIC
2171: if (!(m->m_flags & M_PKTHDR))
2172: panic("rsvp_input no hdr");
2173: #endif
2174:
2175: ifp = m->m_pkthdr.rcvif;
2176: /* Find which vif the packet arrived on. */
2177: for (vifi = 0; vifi < numvifs; vifi++) {
2178: if (viftable[vifi].v_ifp == ifp)
2179: break;
2180: }
2181:
2182: if (vifi == numvifs) {
2183: /* Can't find vif packet arrived on. Drop packet. */
2184: if (rsvpdebug)
2185: printf("rsvp_input: Can't find vif for packet...dropping it.\n");
2186: m_freem(m);
2187: splx(s);
2188: return;
2189: }
2190:
2191: if (rsvpdebug)
2192: printf("rsvp_input: check socket\n");
2193:
2194: if (viftable[vifi].v_rsvpd == NULL) {
2195: /* drop packet, since there is no specific socket for this
2196: * interface */
2197: if (rsvpdebug)
2198: printf("rsvp_input: No socket defined for vif %d\n",vifi);
2199: m_freem(m);
2200: splx(s);
2201: return;
2202: }
2203: rsvp_src.sin_addr = ip->ip_src;
2204:
2205: if (rsvpdebug && m)
2206: printf("rsvp_input: m->m_len = %d, sbspace() = %ld\n",
2207: m->m_len,sbspace(&(viftable[vifi].v_rsvpd->so_rcv)));
2208:
2209: if (socket_send(viftable[vifi].v_rsvpd, m, &rsvp_src) < 0)
2210: if (rsvpdebug)
2211: printf("rsvp_input: Failed to append to socket\n");
2212: else
2213: if (rsvpdebug)
2214: printf("rsvp_input: send packet up\n");
2215:
2216: splx(s);
2217: }
2218:
2219: #if MROUTE_LKM
2220: #include <sys/conf.h>
2221: #include <sys/exec.h>
2222: #include <sys/sysent.h>
2223: #include <sys/lkm.h>
2224:
2225: MOD_MISC("ip_mroute_mod")
2226:
2227: static int
2228: ip_mroute_mod_handle(struct lkm_table *lkmtp, int cmd)
2229: {
2230: int i;
2231: struct lkm_misc *args = lkmtp->private.lkm_misc;
2232: int err = 0;
2233:
2234: switch(cmd) {
2235: static int (*old_ip_mrouter_cmd)();
2236: static int (*old_ip_mrouter_done)();
2237: static int (*old_ip_mforward)();
2238: static int (*old_mrt_ioctl)();
2239: static void (*old_proto4_input)();
2240: static int (*old_legal_vif_num)();
2241: extern struct protosw inetsw[];
2242:
2243: case LKM_E_LOAD:
2244: if(lkmexists(lkmtp) || ip_mrtproto)
2245: return(EEXIST);
2246: old_ip_mrouter_cmd = ip_mrouter_cmd;
2247: ip_mrouter_cmd = X_ip_mrouter_cmd;
2248: old_ip_mrouter_done = ip_mrouter_done;
2249: ip_mrouter_done = X_ip_mrouter_done;
2250: old_ip_mforward = ip_mforward;
2251: ip_mforward = X_ip_mforward;
2252: old_mrt_ioctl = mrt_ioctl;
2253: mrt_ioctl = X_mrt_ioctl;
2254: old_proto4_input = ip_protox[ENCAP_PROTO]->pr_input;
2255: ip_protox[ENCAP_PROTO]->pr_input = X_ipip_input;
2256: old_legal_vif_num = legal_vif_num;
2257: legal_vif_num = X_legal_vif_num;
2258: ip_mrtproto = IGMP_DVMRP;
2259:
2260: printf("\nIP multicast routing loaded\n");
2261: break;
2262:
2263: case LKM_E_UNLOAD:
2264: if (ip_mrouter)
2265: return EINVAL;
2266:
2267: ip_mrouter_cmd = old_ip_mrouter_cmd;
2268: ip_mrouter_done = old_ip_mrouter_done;
2269: ip_mforward = old_ip_mforward;
2270: mrt_ioctl = old_mrt_ioctl;
2271: ip_protox[ENCAP_PROTO]->pr_input = old_proto4_input;
2272: legal_vif_num = old_legal_vif_num;
2273: ip_mrtproto = 0;
2274: break;
2275:
2276: default:
2277: err = EINVAL;
2278: break;
2279: }
2280:
2281: return(err);
2282: }
2283:
2284: int
2285: ip_mroute_mod(struct lkm_table *lkmtp, int cmd, int ver) {
2286: DISPATCH(lkmtp, cmd, ver, ip_mroute_mod_handle, ip_mroute_mod_handle,
2287: nosys);
2288: }
2289:
2290: #endif /* MROUTE_LKM */
2291: #endif /* MROUTING */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.