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