ip_mroute.c revision 14546
1177633Sdfr/*
2177633Sdfr * IP multicast forwarding procedures
3177633Sdfr *
4177633Sdfr * Written by David Waitzman, BBN Labs, August 1988.
5177633Sdfr * Modified by Steve Deering, Stanford, February 1989.
6177633Sdfr * Modified by Mark J. Steiglitz, Stanford, May, 1991
7177633Sdfr * Modified by Van Jacobson, LBL, January 1993
8177633Sdfr * Modified by Ajit Thyagarajan, PARC, August 1993
9177633Sdfr * Modified by Bill Fenner, PARC, April 1995
10177633Sdfr *
11177633Sdfr * MROUTING Revision: 3.5
12177633Sdfr * $Id: ip_mroute.c,v 1.28 1996/03/02 18:24:10 peter Exp $
13177633Sdfr */
14177633Sdfr
15177633Sdfr#include "opt_mrouting.h"
16177633Sdfr
17177633Sdfr#include <sys/param.h>
18177633Sdfr#include <sys/queue.h>
19177633Sdfr#include <sys/systm.h>
20177633Sdfr#include <sys/mbuf.h>
21177633Sdfr#include <sys/socket.h>
22177633Sdfr#include <sys/socketvar.h>
23177633Sdfr#include <sys/protosw.h>
24177633Sdfr#include <sys/errno.h>
25177633Sdfr#include <sys/time.h>
26177633Sdfr#include <sys/kernel.h>
27177633Sdfr#include <sys/ioctl.h>
28177633Sdfr#include <sys/syslog.h>
29177633Sdfr#include <net/if.h>
30177633Sdfr#include <net/route.h>
31177633Sdfr#include <netinet/in.h>
32177633Sdfr#include <netinet/in_systm.h>
33177633Sdfr#include <netinet/ip.h>
34177633Sdfr#include <netinet/ip_var.h>
35177633Sdfr#include <netinet/in_pcb.h>
36180025Sdfr#include <netinet/in_var.h>
37177633Sdfr#include <netinet/igmp.h>
38177633Sdfr#include <netinet/igmp_var.h>
39177633Sdfr#include <netinet/ip_mroute.h>
40177685Sdfr#include <netinet/udp.h>
41177633Sdfr
42177685Sdfrextern void	rsvp_input __P((struct mbuf *m, int iphlen));
43177633Sdfr
44177633Sdfr#ifndef NTOHL
45177633Sdfr#if BYTE_ORDER != BIG_ENDIAN
46177633Sdfr#define NTOHL(d) ((d) = ntohl((d)))
47177633Sdfr#define NTOHS(d) ((d) = ntohs((u_short)(d)))
48177633Sdfr#define HTONL(d) ((d) = htonl((d)))
49177633Sdfr#define HTONS(d) ((d) = htons((u_short)(d)))
50177633Sdfr#else
51177633Sdfr#define NTOHL(d)
52177633Sdfr#define NTOHS(d)
53177633Sdfr#define HTONL(d)
54177633Sdfr#define HTONS(d)
55180025Sdfr#endif
56180025Sdfr#endif
57180025Sdfr
58180025Sdfr#ifndef MROUTING
59177685Sdfrextern void	ipip_input __P((struct mbuf *m));
60177685Sdfrextern u_long	_ip_mcast_src __P((int vifi));
61177685Sdfrextern int	_ip_mforward __P((struct ip *ip, struct ifnet *ifp,
62177633Sdfr				  struct mbuf *m, struct ip_moptions *imo));
63177633Sdfrextern int	_ip_mrouter_done __P((void));
64177633Sdfrextern int	_ip_mrouter_get __P((int cmd, struct socket *so,
65177633Sdfr				     struct mbuf **m));
66177633Sdfrextern int	_ip_mrouter_set __P((int cmd, struct socket *so,
67177633Sdfr				     struct mbuf *m));
68177633Sdfrextern int	_mrt_ioctl __P((int req, caddr_t data, struct proc *p));
69177633Sdfr
70177633Sdfr/*
71177633Sdfr * Dummy routines and globals used when multicast routing is not compiled in.
72177633Sdfr */
73177633Sdfr
74177633Sdfrstruct socket  *ip_mrouter  = NULL;
75177633Sdfrstatic u_int		ip_mrtproto = 0;
76177633Sdfrstatic struct mrtstat	mrtstat;
77177633Sdfru_int		rsvpdebug = 0;
78177633Sdfr
79177633Sdfrint
80177633Sdfr_ip_mrouter_set(cmd, so, m)
81177633Sdfr	int cmd;
82177633Sdfr	struct socket *so;
83177633Sdfr	struct mbuf *m;
84177633Sdfr{
85177633Sdfr	return(EOPNOTSUPP);
86177633Sdfr}
87177633Sdfr
88177633Sdfrint (*ip_mrouter_set)(int, struct socket *, struct mbuf *) = _ip_mrouter_set;
89177685Sdfr
90177685Sdfr
91177685Sdfrint
92177685Sdfr_ip_mrouter_get(cmd, so, m)
93177685Sdfr	int cmd;
94177685Sdfr	struct socket *so;
95177633Sdfr	struct mbuf **m;
96177685Sdfr{
97177633Sdfr	return(EOPNOTSUPP);
98177633Sdfr}
99177633Sdfr
100177633Sdfrint (*ip_mrouter_get)(int, struct socket *, struct mbuf **) = _ip_mrouter_get;
101177633Sdfr
102177633Sdfrint
103177633Sdfr_ip_mrouter_done()
104177633Sdfr{
105177633Sdfr	return(0);
106177633Sdfr}
107177633Sdfr
108177633Sdfrint (*ip_mrouter_done)(void) = _ip_mrouter_done;
109177633Sdfr
110177633Sdfrint
111177633Sdfr_ip_mforward(ip, ifp, m, imo)
112177633Sdfr	struct ip *ip;
113177633Sdfr	struct ifnet *ifp;
114177633Sdfr	struct mbuf *m;
115177633Sdfr	struct ip_moptions *imo;
116177633Sdfr{
117177633Sdfr	return(0);
118177633Sdfr}
119177633Sdfr
120177633Sdfrint (*ip_mforward)(struct ip *, struct ifnet *, struct mbuf *,
121177633Sdfr		   struct ip_moptions *) = _ip_mforward;
122177633Sdfr
123177633Sdfrint
124177633Sdfr_mrt_ioctl(int req, caddr_t data, struct proc *p)
125177633Sdfr{
126177633Sdfr	return EOPNOTSUPP;
127177633Sdfr}
128177633Sdfr
129177633Sdfrint (*mrt_ioctl)(int, caddr_t, struct proc *) = _mrt_ioctl;
130177633Sdfr
131177633Sdfrvoid
132177633Sdfrrsvp_input(m, iphlen)		/* XXX must fixup manually */
133177633Sdfr	struct mbuf *m;
134177633Sdfr	int iphlen;
135177633Sdfr{
136177633Sdfr    /* Can still get packets with rsvp_on = 0 if there is a local member
137177633Sdfr     * of the group to which the RSVP packet is addressed.  But in this
138177633Sdfr     * case we want to throw the packet away.
139180025Sdfr     */
140177633Sdfr    if (!rsvp_on) {
141180025Sdfr	m_freem(m);
142177633Sdfr	return;
143177633Sdfr    }
144180025Sdfr
145180025Sdfr    if (ip_rsvpd != NULL) {
146180025Sdfr	if (rsvpdebug)
147180025Sdfr	    printf("rsvp_input: Sending packet up old-style socket\n");
148180025Sdfr	rip_input(m);
149180025Sdfr	return;
150180025Sdfr    }
151180025Sdfr    /* Drop the packet */
152180025Sdfr    m_freem(m);
153180025Sdfr}
154180025Sdfr
155180025Sdfrvoid ipip_input(struct mbuf *m) { /* XXX must fixup manually */
156180025Sdfr	rip_input(m);
157180025Sdfr}
158180025Sdfr
159180025Sdfrint (*legal_vif_num)(int) = 0;
160177633Sdfr
161177633Sdfr/*
162177633Sdfr * This should never be called, since IP_MULTICAST_VIF should fail, but
163180025Sdfr * just in case it does get called, the code a little lower in ip_output
164177633Sdfr * will assign the packet a local address.
165180025Sdfr */
166177633Sdfru_long
167177633Sdfr_ip_mcast_src(int vifi) { return INADDR_ANY; }
168177633Sdfru_long (*ip_mcast_src)(int) = _ip_mcast_src;
169180025Sdfr
170180025Sdfrint
171177633Sdfrip_rsvp_vif_init(so, m)
172180025Sdfr    struct socket *so;
173180025Sdfr    struct mbuf *m;
174180025Sdfr{
175180025Sdfr    return(EINVAL);
176180025Sdfr}
177180025Sdfr
178180025Sdfrint
179180025Sdfrip_rsvp_vif_done(so, m)
180180025Sdfr    struct socket *so;
181180025Sdfr    struct mbuf *m;
182180025Sdfr{
183180025Sdfr    return(EINVAL);
184180025Sdfr}
185180025Sdfr
186180025Sdfrvoid
187177633Sdfrip_rsvp_force_done(so)
188177633Sdfr    struct socket *so;
189177633Sdfr{
190177633Sdfr    return;
191177633Sdfr}
192177633Sdfr
193177633Sdfr#else /* MROUTING */
194180025Sdfr
195177633Sdfr#define M_HASCL(m)	((m)->m_flags & M_EXT)
196177633Sdfr
197177633Sdfr#define INSIZ		sizeof(struct in_addr)
198177633Sdfr#define	same(a1, a2) \
199177633Sdfr	(bcmp((caddr_t)(a1), (caddr_t)(a2), INSIZ) == 0)
200177633Sdfr
201177633Sdfr#define MT_MRTABLE MT_RTABLE	/* since nothing else uses it */
202178112Sdfr
203178112Sdfr/*
204178112Sdfr * Globals.  All but ip_mrouter and ip_mrtproto could be static,
205180025Sdfr * except for netstat or debugging purposes.
206180025Sdfr */
207178112Sdfr#ifndef MROUTE_LKM
208177633Sdfrextern void	ipip_input __P((struct mbuf *m, int iphlen));
209177633Sdfrstruct socket  *ip_mrouter  = NULL;
210180025Sdfrstruct mrtstat	mrtstat;
211180025Sdfr
212180025Sdfrint		ip_mrtproto = IGMP_DVMRP;    /* for netstat only */
213177633Sdfr#else /* MROUTE_LKM */
214177633Sdfr#error /* the function definition will have a syntax error */
215177633Sdfrextern void	X_ipip_input __P((struct mbuf *m));
216180025Sdfrextern struct mrtstat mrtstat;
217177633Sdfrstatic int ip_mrtproto;
218177633Sdfr#endif
219180025Sdfr
220177633Sdfr#define NO_RTE_FOUND 	0x1
221179425Sdfr#define RTE_FOUND	0x2
222177633Sdfr
223177633Sdfrstatic struct mbuf    *mfctable[MFCTBLSIZ];
224177633Sdfrstatic u_char		nexpire[MFCTBLSIZ];
225177633Sdfrstatic struct vif	viftable[MAXVIFS];
226177633Sdfrstatic u_int	mrtdebug = 0;	  /* debug level 	*/
227177633Sdfr#define		DEBUG_MFC	0x02
228180025Sdfr#define		DEBUG_FORWARD	0x04
229180025Sdfr#define		DEBUG_EXPIRE	0x08
230177633Sdfr#define		DEBUG_XMIT	0x10
231177633Sdfrstatic u_int  	tbfdebug = 0;     /* tbf debug level 	*/
232177633Sdfrstatic u_int	rsvpdebug = 0;	  /* rsvp debug level   */
233177633Sdfr
234177633Sdfr#define		EXPIRE_TIMEOUT	(hz / 4)	/* 4x / second		*/
235177633Sdfr#define		UPCALL_EXPIRE	6		/* number of timeouts	*/
236177633Sdfr
237177633Sdfr/*
238177633Sdfr * Define the token bucket filter structures
239177633Sdfr * tbftable -> each vif has one of these for storing info
240177633Sdfr */
241177633Sdfr
242177633Sdfrstatic struct tbf tbftable[MAXVIFS];
243180025Sdfr#define		TBF_REPROCESS	(hz / 100)	/* 100x / second */
244180025Sdfr
245177633Sdfr/*
246177633Sdfr * 'Interfaces' associated with decapsulator (so we can tell
247177633Sdfr * packets that went through it from ones that get reflected
248177633Sdfr * by a broken gateway).  These interfaces are never linked into
249177633Sdfr * the system ifnet list & no routes point to them.  I.e., packets
250177633Sdfr * can't be sent this way.  They only exist as a placeholder for
251177633Sdfr * multicast source verification.
252177633Sdfr */
253177633Sdfrstatic struct ifnet multicast_decap_if[MAXVIFS];
254177633Sdfr
255177633Sdfr#define ENCAP_TTL 64
256177633Sdfr#define ENCAP_PROTO IPPROTO_IPIP	/* 4 */
257177633Sdfr
258177633Sdfr/* prototype IP hdr for encapsulated packets */
259177633Sdfrstatic struct ip multicast_encap_iphdr = {
260177633Sdfr#if BYTE_ORDER == LITTLE_ENDIAN
261177633Sdfr	sizeof(struct ip) >> 2, IPVERSION,
262177633Sdfr#else
263177633Sdfr	IPVERSION, sizeof(struct ip) >> 2,
264177633Sdfr#endif
265177633Sdfr	0,				/* tos */
266177633Sdfr	sizeof(struct ip),		/* total length */
267177633Sdfr	0,				/* id */
268177633Sdfr	0,				/* frag offset */
269177633Sdfr	ENCAP_TTL, ENCAP_PROTO,
270177633Sdfr	0,				/* checksum */
271177633Sdfr};
272177633Sdfr
273177633Sdfr/*
274177633Sdfr * Private variables.
275177633Sdfr */
276177633Sdfrstatic vifi_t	   numvifs = 0;
277177633Sdfrstatic int have_encap_tunnel = 0;
278177633Sdfr
279177633Sdfr/*
280177633Sdfr * one-back cache used by ipip_input to locate a tunnel's vif
281177633Sdfr * given a datagram's src ip address.
282177633Sdfr */
283177633Sdfrstatic u_long last_encap_src;
284177633Sdfrstatic struct vif *last_encap_vif;
285177633Sdfr
286177633Sdfrstatic u_long	X_ip_mcast_src __P((int vifi));
287177633Sdfrstatic int	X_ip_mforward __P((struct ip *ip, struct ifnet *ifp, struct mbuf *m, struct ip_moptions *imo));
288177633Sdfrstatic int	X_ip_mrouter_done __P((void));
289177633Sdfrstatic int	X_ip_mrouter_get __P((int cmd, struct socket *so, struct mbuf **m));
290177633Sdfrstatic int	X_ip_mrouter_set __P((int cmd, struct socket *so, struct mbuf *m));
291177633Sdfrstatic int	X_legal_vif_num __P((int vif));
292177633Sdfrstatic int	X_mrt_ioctl __P((int cmd, caddr_t data));
293177633Sdfr
294181683Sdfrstatic int get_sg_cnt(struct sioc_sg_req *);
295181683Sdfrstatic int get_vif_cnt(struct sioc_vif_req *);
296181683Sdfrstatic int ip_mrouter_init(struct socket *, struct mbuf *);
297182154Sdfrstatic int add_vif(struct vifctl *);
298181683Sdfrstatic int del_vif(vifi_t *);
299177633Sdfrstatic int add_mfc(struct mfcctl *);
300177633Sdfrstatic int del_mfc(struct mfcctl *);
301177633Sdfrstatic int socket_send(struct socket *, struct mbuf *, struct sockaddr_in *);
302177633Sdfrstatic int get_version(struct mbuf *);
303177633Sdfrstatic int get_assert(struct mbuf *);
304177633Sdfrstatic int set_assert(int *);
305177633Sdfrstatic void expire_upcalls(void *);
306177633Sdfrstatic int ip_mdq(struct mbuf *, struct ifnet *, struct mfc *,
307177633Sdfr		  vifi_t);
308177633Sdfrstatic void phyint_send(struct ip *, struct vif *, struct mbuf *);
309177633Sdfrstatic void encap_send(struct ip *, struct vif *, struct mbuf *);
310177633Sdfrstatic void tbf_control(struct vif *, struct mbuf *, struct ip *, u_long);
311177633Sdfrstatic void tbf_queue(struct vif *, struct mbuf *);
312177633Sdfrstatic void tbf_process_q(struct vif *);
313177633Sdfrstatic void tbf_reprocess_q(void *);
314177633Sdfrstatic int tbf_dq_sel(struct vif *, struct ip *);
315177633Sdfrstatic void tbf_send_packet(struct vif *, struct mbuf *);
316177633Sdfrstatic void tbf_update_tokens(struct vif *);
317177633Sdfrstatic int priority(struct vif *, struct ip *);
318177633Sdfrvoid multiencap_decap(struct mbuf *);
319177633Sdfr
320177633Sdfr/*
321177633Sdfr * whether or not special PIM assert processing is enabled.
322177633Sdfr */
323177633Sdfrstatic int pim_assert;
324177633Sdfr/*
325177633Sdfr * Rate limit for assert notification messages, in usec
326177633Sdfr */
327177633Sdfr#define ASSERT_MSG_TIME		3000000
328181683Sdfr
329177633Sdfr/*
330177633Sdfr * Hash function for a source, group entry
331177633Sdfr */
332181683Sdfr#define MFCHASH(a, g) MFCHASHMOD(((a) >> 20) ^ ((a) >> 10) ^ (a) ^ \
333177633Sdfr			((g) >> 20) ^ ((g) >> 10) ^ (g))
334177633Sdfr
335181683Sdfr/*
336181683Sdfr * Find a route for a given origin IP address and Multicast group address
337181683Sdfr * Type of service parameter to be added in the future!!!
338181683Sdfr */
339177633Sdfr
340177633Sdfr#define MFCFIND(o, g, rt) { \
341177633Sdfr	register struct mbuf *_mb_rt = mfctable[MFCHASH(o,g)]; \
342177633Sdfr	register struct mfc *_rt = NULL; \
343177633Sdfr	rt = NULL; \
344177633Sdfr	++mrtstat.mrts_mfc_lookups; \
345177633Sdfr	while (_mb_rt) { \
346177633Sdfr		_rt = mtod(_mb_rt, struct mfc *); \
347177633Sdfr		if ((_rt->mfc_origin.s_addr == o) && \
348181683Sdfr		    (_rt->mfc_mcastgrp.s_addr == g) && \
349181683Sdfr		    (_mb_rt->m_act == NULL)) { \
350181683Sdfr			rt = _rt; \
351177633Sdfr			break; \
352181683Sdfr		} \
353177633Sdfr		_mb_rt = _mb_rt->m_next; \
354181683Sdfr	} \
355181683Sdfr	if (rt == NULL) { \
356181683Sdfr		++mrtstat.mrts_mfc_misses; \
357181683Sdfr	} \
358181683Sdfr}
359181683Sdfr
360181683Sdfr
361181683Sdfr/*
362181683Sdfr * Macros to compute elapsed time efficiently
363177633Sdfr * Borrowed from Van Jacobson's scheduling code
364177633Sdfr */
365181683Sdfr#define TV_DELTA(a, b, delta) { \
366181683Sdfr	    register int xxs; \
367181683Sdfr		\
368181683Sdfr	    delta = (a).tv_usec - (b).tv_usec; \
369181683Sdfr	    if ((xxs = (a).tv_sec - (b).tv_sec)) { \
370181683Sdfr	       switch (xxs) { \
371181683Sdfr		      case 2: \
372181683Sdfr			  delta += 1000000; \
373181683Sdfr			      /* fall through */ \
374181683Sdfr		      case 1: \
375181683Sdfr			  delta += 1000000; \
376181683Sdfr			  break; \
377181683Sdfr		      default: \
378181683Sdfr			  delta += (1000000 * xxs); \
379181683Sdfr	       } \
380181683Sdfr	    } \
381181683Sdfr}
382181683Sdfr
383177633Sdfr#define TV_LT(a, b) (((a).tv_usec < (b).tv_usec && \
384181683Sdfr	      (a).tv_sec <= (b).tv_sec) || (a).tv_sec < (b).tv_sec)
385181683Sdfr
386177633Sdfr#ifdef UPCALL_TIMING
387177633Sdfru_long upcall_data[51];
388177633Sdfrstatic void collate(struct timeval *);
389177633Sdfr#endif /* UPCALL_TIMING */
390177633Sdfr
391181683Sdfr
392177633Sdfr/*
393177633Sdfr * Handle MRT setsockopt commands to modify the multicast routing tables.
394177633Sdfr */
395182154Sdfrstatic int
396177633SdfrX_ip_mrouter_set(cmd, so, m)
397177633Sdfr    int cmd;
398177633Sdfr    struct socket *so;
399177633Sdfr    struct mbuf *m;
400177633Sdfr{
401177633Sdfr   if (cmd != MRT_INIT && so != ip_mrouter) return EACCES;
402177633Sdfr
403177633Sdfr    switch (cmd) {
404177633Sdfr	case MRT_INIT:     return ip_mrouter_init(so, m);
405177633Sdfr	case MRT_DONE:     return ip_mrouter_done();
406177633Sdfr	case MRT_ADD_VIF:  return add_vif (mtod(m, struct vifctl *));
407177633Sdfr	case MRT_DEL_VIF:  return del_vif (mtod(m, vifi_t *));
408177633Sdfr	case MRT_ADD_MFC:  return add_mfc (mtod(m, struct mfcctl *));
409177633Sdfr	case MRT_DEL_MFC:  return del_mfc (mtod(m, struct mfcctl *));
410177633Sdfr	case MRT_ASSERT:   return set_assert(mtod(m, int *));
411177633Sdfr	default:             return EOPNOTSUPP;
412177633Sdfr    }
413181683Sdfr}
414181683Sdfr
415181683Sdfr#ifndef MROUTE_LKM
416177633Sdfrint (*ip_mrouter_set)(int, struct socket *, struct mbuf *) = X_ip_mrouter_set;
417181683Sdfr#endif
418181683Sdfr
419181683Sdfr/*
420181683Sdfr * Handle MRT getsockopt commands
421181683Sdfr */
422181683Sdfrstatic int
423181683SdfrX_ip_mrouter_get(cmd, so, m)
424181683Sdfr    int cmd;
425181683Sdfr    struct socket *so;
426181683Sdfr    struct mbuf **m;
427181683Sdfr{
428181683Sdfr    struct mbuf *mb;
429181683Sdfr
430181683Sdfr    if (so != ip_mrouter) return EACCES;
431181683Sdfr
432181683Sdfr    *m = mb = m_get(M_WAIT, MT_SOOPTS);
433181683Sdfr
434181683Sdfr    switch (cmd) {
435181683Sdfr	case MRT_VERSION:   return get_version(mb);
436181683Sdfr	case MRT_ASSERT:    return get_assert(mb);
437181683Sdfr	default:            return EOPNOTSUPP;
438181683Sdfr    }
439181683Sdfr}
440181683Sdfr
441181683Sdfr#ifndef MROUTE_LKM
442181683Sdfrint (*ip_mrouter_get)(int, struct socket *, struct mbuf **) = X_ip_mrouter_get;
443181683Sdfr#endif
444181683Sdfr
445181683Sdfr/*
446181683Sdfr * Handle ioctl commands to obtain information from the cache
447181683Sdfr */
448181683Sdfrstatic int
449178241SdfrX_mrt_ioctl(cmd, data)
450177633Sdfr    int cmd;
451177633Sdfr    caddr_t data;
452177633Sdfr{
453181683Sdfr    int error = 0;
454181683Sdfr
455181683Sdfr    switch (cmd) {
456181683Sdfr	case (SIOCGETVIFCNT):
457181683Sdfr	    return (get_vif_cnt((struct sioc_vif_req *)data));
458181683Sdfr	    break;
459177633Sdfr	case (SIOCGETSGCNT):
460181683Sdfr	    return (get_sg_cnt((struct sioc_sg_req *)data));
461181683Sdfr	    break;
462181683Sdfr	default:
463181683Sdfr	    return (EINVAL);
464181683Sdfr	    break;
465181683Sdfr    }
466181683Sdfr    return error;
467181683Sdfr}
468181683Sdfr
469181683Sdfr#ifndef MROUTE_LKM
470181683Sdfrint (*mrt_ioctl)(int, caddr_t) = X_mrt_ioctl;
471181683Sdfr#endif
472181683Sdfr
473181683Sdfr/*
474181683Sdfr * returns the packet, byte, rpf-failure count for the source group provided
475181683Sdfr */
476181683Sdfrstatic int
477181683Sdfrget_sg_cnt(req)
478181683Sdfr    register struct sioc_sg_req *req;
479181683Sdfr{
480181683Sdfr    register struct mfc *rt;
481181683Sdfr    int s;
482181683Sdfr
483181683Sdfr    s = splnet();
484181683Sdfr    MFCFIND(req->src.s_addr, req->grp.s_addr, rt);
485181683Sdfr    splx(s);
486181683Sdfr    if (rt != NULL) {
487181683Sdfr	req->pktcnt = rt->mfc_pkt_cnt;
488181683Sdfr	req->bytecnt = rt->mfc_byte_cnt;
489177633Sdfr	req->wrong_if = rt->mfc_wrong_if;
490177633Sdfr    } else
491177633Sdfr	req->pktcnt = req->bytecnt = req->wrong_if = 0xffffffff;
492177633Sdfr
493177633Sdfr    return 0;
494177633Sdfr}
495177633Sdfr
496177633Sdfr/*
497177633Sdfr * returns the input and output packet and byte counts on the vif provided
498177633Sdfr */
499177633Sdfrstatic int
500180025Sdfrget_vif_cnt(req)
501177633Sdfr    register struct sioc_vif_req *req;
502177633Sdfr{
503177633Sdfr    register vifi_t vifi = req->vifi;
504177633Sdfr
505177633Sdfr    if (vifi >= numvifs) return EINVAL;
506177633Sdfr
507177633Sdfr    req->icount = viftable[vifi].v_pkt_in;
508177633Sdfr    req->ocount = viftable[vifi].v_pkt_out;
509177633Sdfr    req->ibytes = viftable[vifi].v_bytes_in;
510177633Sdfr    req->obytes = viftable[vifi].v_bytes_out;
511178241Sdfr
512177633Sdfr    return 0;
513177633Sdfr}
514177633Sdfr
515180025Sdfr/*
516180025Sdfr * Enable multicast routing
517177633Sdfr */
518177633Sdfrstatic int
519180025Sdfrip_mrouter_init(so, m)
520177633Sdfr	struct socket *so;
521177633Sdfr	struct mbuf *m;
522177633Sdfr{
523177633Sdfr    int *v;
524177633Sdfr
525177633Sdfr    if (mrtdebug)
526177633Sdfr	log(LOG_DEBUG,"ip_mrouter_init: so_type = %d, pr_protocol = %d\n",
527177633Sdfr		so->so_type, so->so_proto->pr_protocol);
528177633Sdfr
529177633Sdfr    if (so->so_type != SOCK_RAW ||
530177633Sdfr	so->so_proto->pr_protocol != IPPROTO_IGMP) return EOPNOTSUPP;
531177633Sdfr
532177633Sdfr    if (!m || (m->m_len != sizeof(int *)))
533177633Sdfr	return ENOPROTOOPT;
534177633Sdfr
535177633Sdfr    v = mtod(m, int *);
536177633Sdfr    if (*v != 1)
537177633Sdfr	return ENOPROTOOPT;
538180025Sdfr
539177633Sdfr    if (ip_mrouter != NULL) return EADDRINUSE;
540177633Sdfr
541177633Sdfr    ip_mrouter = so;
542177633Sdfr
543177633Sdfr    bzero((caddr_t)mfctable, sizeof(mfctable));
544177633Sdfr    bzero((caddr_t)nexpire, sizeof(nexpire));
545177633Sdfr
546177633Sdfr    pim_assert = 0;
547177633Sdfr
548177633Sdfr    timeout(expire_upcalls, (caddr_t)NULL, EXPIRE_TIMEOUT);
549177633Sdfr
550177633Sdfr    if (mrtdebug)
551177633Sdfr	log(LOG_DEBUG, "ip_mrouter_init\n");
552177633Sdfr
553177633Sdfr    return 0;
554177633Sdfr}
555177633Sdfr
556177633Sdfr/*
557177633Sdfr * Disable multicast routing
558177633Sdfr */
559177633Sdfrstatic int
560177633SdfrX_ip_mrouter_done()
561177633Sdfr{
562177633Sdfr    vifi_t vifi;
563177633Sdfr    int i;
564177633Sdfr    struct ifnet *ifp;
565180025Sdfr    struct ifreq ifr;
566180025Sdfr    struct mbuf *mb_rt;
567177633Sdfr    struct mbuf *m;
568177633Sdfr    struct rtdetq *rte;
569177633Sdfr    int s;
570177633Sdfr
571177633Sdfr    s = splnet();
572177633Sdfr
573177633Sdfr    /*
574177633Sdfr     * For each phyint in use, disable promiscuous reception of all IP
575177633Sdfr     * multicasts.
576177633Sdfr     */
577177633Sdfr    for (vifi = 0; vifi < numvifs; vifi++) {
578177633Sdfr	if (viftable[vifi].v_lcl_addr.s_addr != 0 &&
579177633Sdfr	    !(viftable[vifi].v_flags & VIFF_TUNNEL)) {
580177633Sdfr	    ((struct sockaddr_in *)&(ifr.ifr_addr))->sin_family = AF_INET;
581177633Sdfr	    ((struct sockaddr_in *)&(ifr.ifr_addr))->sin_addr.s_addr
582177633Sdfr								= INADDR_ANY;
583177633Sdfr	    ifp = viftable[vifi].v_ifp;
584177633Sdfr	    (*ifp->if_ioctl)(ifp, SIOCDELMULTI, (caddr_t)&ifr);
585177633Sdfr	}
586177633Sdfr    }
587177633Sdfr    bzero((caddr_t)tbftable, sizeof(tbftable));
588177633Sdfr    bzero((caddr_t)viftable, sizeof(viftable));
589177633Sdfr    numvifs = 0;
590177633Sdfr    pim_assert = 0;
591177633Sdfr
592177633Sdfr    untimeout(expire_upcalls, (caddr_t)NULL);
593177633Sdfr
594177633Sdfr    /*
595177633Sdfr     * Free all multicast forwarding cache entries.
596177633Sdfr     */
597177633Sdfr    for (i = 0; i < MFCTBLSIZ; i++) {
598177633Sdfr	mb_rt = mfctable[i];
599177633Sdfr	while (mb_rt) {
600177633Sdfr	    if (mb_rt->m_act != NULL) {
601177633Sdfr		while (mb_rt->m_act) {
602177633Sdfr		    m = mb_rt->m_act;
603177633Sdfr		    mb_rt->m_act = m->m_act;
604177633Sdfr		    rte = mtod(m, struct rtdetq *);
605177633Sdfr		    m_freem(rte->m);
606177633Sdfr		    m_free(m);
607177633Sdfr		}
608177633Sdfr	    }
609177633Sdfr	    mb_rt = m_free(mb_rt);
610177633Sdfr	}
611177633Sdfr    }
612177633Sdfr
613177633Sdfr    bzero((caddr_t)mfctable, sizeof(mfctable));
614177633Sdfr
615177633Sdfr    /*
616177633Sdfr     * Reset de-encapsulation cache
617177633Sdfr     */
618177633Sdfr    last_encap_src = NULL;
619177633Sdfr    last_encap_vif = NULL;
620177633Sdfr    have_encap_tunnel = 0;
621177633Sdfr
622177633Sdfr    ip_mrouter = NULL;
623177633Sdfr
624177633Sdfr    splx(s);
625177633Sdfr
626177633Sdfr    if (mrtdebug)
627177633Sdfr	log(LOG_DEBUG, "ip_mrouter_done\n");
628177633Sdfr
629177633Sdfr    return 0;
630177633Sdfr}
631177633Sdfr
632177633Sdfr#ifndef MROUTE_LKM
633177633Sdfrint (*ip_mrouter_done)(void) = X_ip_mrouter_done;
634177633Sdfr#endif
635177633Sdfr
636177633Sdfrstatic int
637177633Sdfrget_version(mb)
638180025Sdfr    struct mbuf *mb;
639180025Sdfr{
640177633Sdfr    int *v;
641177633Sdfr
642180025Sdfr    v = mtod(mb, int *);
643177633Sdfr
644180025Sdfr    *v = 0x0305;	/* XXX !!!! */
645180025Sdfr    mb->m_len = sizeof(int);
646180025Sdfr
647180025Sdfr    return 0;
648180025Sdfr}
649180025Sdfr
650180025Sdfr/*
651180025Sdfr * Set PIM assert processing global
652180025Sdfr */
653180025Sdfrstatic int
654180025Sdfrset_assert(i)
655180025Sdfr    int *i;
656180025Sdfr{
657180025Sdfr    if ((*i != 1) && (*i != 0))
658180025Sdfr	return EINVAL;
659180025Sdfr
660180025Sdfr    pim_assert = *i;
661180025Sdfr
662180025Sdfr    return 0;
663180025Sdfr}
664180025Sdfr
665180025Sdfr/*
666180025Sdfr * Get PIM assert processing global
667180025Sdfr */
668180025Sdfrstatic int
669180025Sdfrget_assert(m)
670180025Sdfr    struct mbuf *m;
671180025Sdfr{
672180025Sdfr    int *i;
673180025Sdfr
674180025Sdfr    i = mtod(m, int *);
675180025Sdfr
676180025Sdfr    *i = pim_assert;
677180025Sdfr
678180025Sdfr    return 0;
679180025Sdfr}
680180025Sdfr
681180025Sdfr/*
682180025Sdfr * Add a vif to the vif table
683180025Sdfr */
684180025Sdfrstatic int
685180025Sdfradd_vif(vifcp)
686180025Sdfr    register struct vifctl *vifcp;
687180025Sdfr{
688180025Sdfr    register struct vif *vifp = viftable + vifcp->vifc_vifi;
689180025Sdfr    static struct sockaddr_in sin = {sizeof sin, AF_INET};
690177633Sdfr    struct ifaddr *ifa;
691177633Sdfr    struct ifnet *ifp;
692177633Sdfr    struct ifreq ifr;
693177633Sdfr    int error, s;
694177633Sdfr    struct tbf *v_tbf = tbftable + vifcp->vifc_vifi;
695177633Sdfr
696177633Sdfr    if (vifcp->vifc_vifi >= MAXVIFS)  return EINVAL;
697177633Sdfr    if (vifp->v_lcl_addr.s_addr != 0) return EADDRINUSE;
698177633Sdfr
699177633Sdfr    /* Find the interface with an address in AF_INET family */
700177633Sdfr    sin.sin_addr = vifcp->vifc_lcl_addr;
701177633Sdfr    ifa = ifa_ifwithaddr((struct sockaddr *)&sin);
702177633Sdfr    if (ifa == 0) return EADDRNOTAVAIL;
703177633Sdfr    ifp = ifa->ifa_ifp;
704177633Sdfr
705177633Sdfr    if (vifcp->vifc_flags & VIFF_TUNNEL) {
706177633Sdfr	if ((vifcp->vifc_flags & VIFF_SRCRT) == 0) {
707177633Sdfr		/*
708177633Sdfr		 * An encapsulating tunnel is wanted.  Tell ipip_input() to
709177633Sdfr		 * start paying attention to encapsulated packets.
710177633Sdfr		 */
711177633Sdfr		if (have_encap_tunnel == 0) {
712177633Sdfr			have_encap_tunnel = 1;
713177633Sdfr			for (s = 0; s < MAXVIFS; ++s) {
714180025Sdfr				multicast_decap_if[s].if_name = "mdecap";
715177633Sdfr				multicast_decap_if[s].if_unit = s;
716177633Sdfr			}
717177633Sdfr		}
718177633Sdfr		/*
719177633Sdfr		 * Set interface to fake encapsulator interface
720180025Sdfr		 */
721180025Sdfr		ifp = &multicast_decap_if[vifcp->vifc_vifi];
722180025Sdfr		/*
723177633Sdfr		 * Prepare cached route entry
724180025Sdfr		 */
725180025Sdfr		bzero(&vifp->v_route, sizeof(vifp->v_route));
726180025Sdfr	} else {
727180025Sdfr	    log(LOG_ERR, "source routed tunnels not supported\n");
728180025Sdfr	    return EOPNOTSUPP;
729180025Sdfr	}
730180025Sdfr    } else {
731180025Sdfr	/* Make sure the interface supports multicast */
732177633Sdfr	if ((ifp->if_flags & IFF_MULTICAST) == 0)
733177633Sdfr	    return EOPNOTSUPP;
734177633Sdfr
735177633Sdfr	/* Enable promiscuous reception of all IP multicasts from the if */
736177633Sdfr	((struct sockaddr_in *)&(ifr.ifr_addr))->sin_family = AF_INET;
737177633Sdfr	((struct sockaddr_in *)&(ifr.ifr_addr))->sin_addr.s_addr = INADDR_ANY;
738177633Sdfr	s = splnet();
739177633Sdfr	error = (*ifp->if_ioctl)(ifp, SIOCADDMULTI, (caddr_t)&ifr);
740177633Sdfr	splx(s);
741177633Sdfr	if (error)
742177633Sdfr	    return error;
743177633Sdfr    }
744177633Sdfr
745177633Sdfr    s = splnet();
746177633Sdfr    /* define parameters for the tbf structure */
747177633Sdfr    vifp->v_tbf = v_tbf;
748177633Sdfr    GET_TIME(vifp->v_tbf->tbf_last_pkt_t);
749177633Sdfr    vifp->v_tbf->tbf_n_tok = 0;
750180025Sdfr    vifp->v_tbf->tbf_q_len = 0;
751180025Sdfr    vifp->v_tbf->tbf_max_q_len = MAXQSIZE;
752180025Sdfr    vifp->v_tbf->tbf_q = vifp->v_tbf->tbf_t = NULL;
753180025Sdfr
754180025Sdfr    vifp->v_flags     = vifcp->vifc_flags;
755180025Sdfr    vifp->v_threshold = vifcp->vifc_threshold;
756180025Sdfr    vifp->v_lcl_addr  = vifcp->vifc_lcl_addr;
757180025Sdfr    vifp->v_rmt_addr  = vifcp->vifc_rmt_addr;
758180025Sdfr    vifp->v_ifp       = ifp;
759180025Sdfr    /* scaling up here allows division by 1024 in critical code */
760180025Sdfr    vifp->v_rate_limit= vifcp->vifc_rate_limit * 1024 / 1000;
761180025Sdfr    vifp->v_rsvp_on   = 0;
762180025Sdfr    vifp->v_rsvpd     = NULL;
763180025Sdfr    /* initialize per vif pkt counters */
764177633Sdfr    vifp->v_pkt_in    = 0;
765177633Sdfr    vifp->v_pkt_out   = 0;
766177633Sdfr    vifp->v_bytes_in  = 0;
767177633Sdfr    vifp->v_bytes_out = 0;
768177633Sdfr    splx(s);
769177633Sdfr
770177633Sdfr    /* Adjust numvifs up if the vifi is higher than numvifs */
771177633Sdfr    if (numvifs <= vifcp->vifc_vifi) numvifs = vifcp->vifc_vifi + 1;
772180025Sdfr
773180025Sdfr    if (mrtdebug)
774177633Sdfr	log(LOG_DEBUG, "add_vif #%d, lcladdr %x, %s %x, thresh %x, rate %d\n",
775177633Sdfr	    vifcp->vifc_vifi,
776177633Sdfr	    ntohl(vifcp->vifc_lcl_addr.s_addr),
777180025Sdfr	    (vifcp->vifc_flags & VIFF_TUNNEL) ? "rmtaddr" : "mask",
778180025Sdfr	    ntohl(vifcp->vifc_rmt_addr.s_addr),
779180025Sdfr	    vifcp->vifc_threshold,
780177633Sdfr	    vifcp->vifc_rate_limit);
781180025Sdfr
782180025Sdfr    return 0;
783177633Sdfr}
784177633Sdfr
785177633Sdfr/*
786177633Sdfr * Delete a vif from the vif table
787177633Sdfr */
788177633Sdfrstatic int
789178112Sdfrdel_vif(vifip)
790177633Sdfr    vifi_t *vifip;
791177633Sdfr{
792177633Sdfr    register struct vif *vifp = viftable + *vifip;
793177633Sdfr    register vifi_t vifi;
794180025Sdfr    register struct mbuf *m;
795180025Sdfr    struct ifnet *ifp;
796177633Sdfr    struct ifreq ifr;
797177633Sdfr    int s;
798177633Sdfr
799177633Sdfr    if (*vifip >= numvifs) return EINVAL;
800177633Sdfr    if (vifp->v_lcl_addr.s_addr == 0) return EADDRNOTAVAIL;
801177633Sdfr
802177633Sdfr    s = splnet();
803177633Sdfr
804177633Sdfr    if (!(vifp->v_flags & VIFF_TUNNEL)) {
805178112Sdfr	((struct sockaddr_in *)&(ifr.ifr_addr))->sin_family = AF_INET;
806177633Sdfr	((struct sockaddr_in *)&(ifr.ifr_addr))->sin_addr.s_addr = INADDR_ANY;
807177633Sdfr	ifp = vifp->v_ifp;
808177633Sdfr	(*ifp->if_ioctl)(ifp, SIOCDELMULTI, (caddr_t)&ifr);
809180025Sdfr    }
810180025Sdfr
811180025Sdfr    if (vifp == last_encap_vif) {
812177633Sdfr	last_encap_vif = 0;
813180025Sdfr	last_encap_src = 0;
814180025Sdfr    }
815177633Sdfr
816177633Sdfr    /*
817177633Sdfr     * Free packets queued at the interface
818177633Sdfr     */
819177633Sdfr    while (vifp->v_tbf->tbf_q) {
820177633Sdfr	m = vifp->v_tbf->tbf_q;
821177633Sdfr	vifp->v_tbf->tbf_q = m->m_act;
822177633Sdfr	m_freem(m);
823177633Sdfr    }
824177633Sdfr
825177633Sdfr    bzero((caddr_t)vifp->v_tbf, sizeof(*(vifp->v_tbf)));
826177633Sdfr    bzero((caddr_t)vifp, sizeof (*vifp));
827177633Sdfr
828177633Sdfr    /* Adjust numvifs down */
829177633Sdfr    for (vifi = numvifs; vifi > 0; vifi--)
830177633Sdfr	if (viftable[vifi-1].v_lcl_addr.s_addr != 0) break;
831177633Sdfr    numvifs = vifi;
832177633Sdfr
833177633Sdfr    splx(s);
834177633Sdfr
835177633Sdfr    if (mrtdebug)
836177633Sdfr      log(LOG_DEBUG, "del_vif %d, numvifs %d\n", *vifip, numvifs);
837177633Sdfr
838177633Sdfr    return 0;
839177633Sdfr}
840177633Sdfr
841177633Sdfr/*
842177633Sdfr * Add an mfc entry
843177633Sdfr */
844177633Sdfrstatic int
845177633Sdfradd_mfc(mfccp)
846177633Sdfr    struct mfcctl *mfccp;
847177633Sdfr{
848177633Sdfr    struct mfc *rt;
849177633Sdfr    register struct mbuf *mb_rt;
850177633Sdfr    u_long hash;
851177633Sdfr    struct mbuf *mb_ntry;
852177633Sdfr    struct rtdetq *rte;
853177633Sdfr    register u_short nstl;
854177633Sdfr    int s;
855177633Sdfr    int i;
856177633Sdfr
857177633Sdfr    MFCFIND(mfccp->mfcc_origin.s_addr, mfccp->mfcc_mcastgrp.s_addr, rt);
858177633Sdfr
859177633Sdfr    /* If an entry already exists, just update the fields */
860177633Sdfr    if (rt) {
861177633Sdfr	if (mrtdebug & DEBUG_MFC)
862180025Sdfr	    log(LOG_DEBUG,"add_mfc update o %x g %x p %x\n",
863180025Sdfr		ntohl(mfccp->mfcc_origin.s_addr),
864177633Sdfr		ntohl(mfccp->mfcc_mcastgrp.s_addr),
865177633Sdfr		mfccp->mfcc_parent);
866177633Sdfr
867177633Sdfr	s = splnet();
868177633Sdfr	rt->mfc_parent = mfccp->mfcc_parent;
869177633Sdfr	for (i = 0; i < numvifs; i++)
870178112Sdfr	    rt->mfc_ttls[i] = mfccp->mfcc_ttls[i];
871177633Sdfr	splx(s);
872180025Sdfr	return 0;
873180025Sdfr    }
874180025Sdfr
875180025Sdfr    /*
876177633Sdfr     * Find the entry for which the upcall was made and update
877177633Sdfr     */
878180025Sdfr    s = splnet();
879177633Sdfr    hash = MFCHASH(mfccp->mfcc_origin.s_addr, mfccp->mfcc_mcastgrp.s_addr);
880177633Sdfr    for (mb_rt = mfctable[hash], nstl = 0; mb_rt; mb_rt = mb_rt->m_next) {
881177633Sdfr
882180025Sdfr	rt = mtod(mb_rt, struct mfc *);
883177633Sdfr	if ((rt->mfc_origin.s_addr == mfccp->mfcc_origin.s_addr) &&
884177633Sdfr	    (rt->mfc_mcastgrp.s_addr == mfccp->mfcc_mcastgrp.s_addr) &&
885177633Sdfr	    (mb_rt->m_act != NULL)) {
886177633Sdfr
887177633Sdfr	    if (nstl++)
888177633Sdfr		log(LOG_ERR, "add_mfc %s o %x g %x p %x dbx %x\n",
889177633Sdfr		    "multiple kernel entries",
890180025Sdfr		    ntohl(mfccp->mfcc_origin.s_addr),
891177633Sdfr		    ntohl(mfccp->mfcc_mcastgrp.s_addr),
892180025Sdfr		    mfccp->mfcc_parent, mb_rt->m_act);
893180025Sdfr
894177633Sdfr	    if (mrtdebug & DEBUG_MFC)
895177633Sdfr		log(LOG_DEBUG,"add_mfc o %x g %x p %x dbg %x\n",
896180025Sdfr		    ntohl(mfccp->mfcc_origin.s_addr),
897180025Sdfr		    ntohl(mfccp->mfcc_mcastgrp.s_addr),
898177633Sdfr		    mfccp->mfcc_parent, mb_rt->m_act);
899177633Sdfr
900177633Sdfr	    rt->mfc_origin     = mfccp->mfcc_origin;
901180025Sdfr	    rt->mfc_mcastgrp   = mfccp->mfcc_mcastgrp;
902177633Sdfr	    rt->mfc_parent     = mfccp->mfcc_parent;
903177633Sdfr	    for (i = 0; i < numvifs; i++)
904177633Sdfr		rt->mfc_ttls[i] = mfccp->mfcc_ttls[i];
905177633Sdfr	    /* initialize pkt counters per src-grp */
906177633Sdfr	    rt->mfc_pkt_cnt    = 0;
907177633Sdfr	    rt->mfc_byte_cnt   = 0;
908177633Sdfr	    rt->mfc_wrong_if   = 0;
909177633Sdfr	    rt->mfc_last_assert.tv_sec = rt->mfc_last_assert.tv_usec = 0;
910177633Sdfr
911180025Sdfr	    rt->mfc_expire = 0;	/* Don't clean this guy up */
912177633Sdfr	    nexpire[hash]--;
913180025Sdfr
914180025Sdfr	    /* free packets Qed at the end of this entry */
915180025Sdfr	    while (mb_rt->m_act) {
916180025Sdfr		mb_ntry = mb_rt->m_act;
917180025Sdfr		rte = mtod(mb_ntry, struct rtdetq *);
918180025Sdfr/* #ifdef RSVP_ISI */
919180025Sdfr		ip_mdq(rte->m, rte->ifp, rt, -1);
920177633Sdfr/* #endif */
921177633Sdfr		mb_rt->m_act = mb_ntry->m_act;
922177633Sdfr		m_freem(rte->m);
923180025Sdfr#ifdef UPCALL_TIMING
924180025Sdfr		collate(&(rte->t));
925177633Sdfr#endif /* UPCALL_TIMING */
926180025Sdfr		m_free(mb_ntry);
927177633Sdfr	    }
928180025Sdfr	}
929177633Sdfr    }
930177633Sdfr
931177633Sdfr    /*
932177633Sdfr     * It is possible that an entry is being inserted without an upcall
933177633Sdfr     */
934177633Sdfr    if (nstl == 0) {
935177633Sdfr	if (mrtdebug & DEBUG_MFC)
936177633Sdfr	    log(LOG_DEBUG,"add_mfc no upcall h %d o %x g %x p %x\n",
937177633Sdfr		hash, ntohl(mfccp->mfcc_origin.s_addr),
938177633Sdfr		ntohl(mfccp->mfcc_mcastgrp.s_addr),
939180025Sdfr		mfccp->mfcc_parent);
940180025Sdfr
941180025Sdfr	for (mb_rt = mfctable[hash]; mb_rt; mb_rt = mb_rt->m_next) {
942180025Sdfr
943180025Sdfr	    rt = mtod(mb_rt, struct mfc *);
944177633Sdfr	    if ((rt->mfc_origin.s_addr == mfccp->mfcc_origin.s_addr) &&
945180025Sdfr		(rt->mfc_mcastgrp.s_addr == mfccp->mfcc_mcastgrp.s_addr)) {
946180025Sdfr
947180025Sdfr		rt->mfc_origin     = mfccp->mfcc_origin;
948180025Sdfr		rt->mfc_mcastgrp   = mfccp->mfcc_mcastgrp;
949177633Sdfr		rt->mfc_parent     = mfccp->mfcc_parent;
950177633Sdfr		for (i = 0; i < numvifs; i++)
951180025Sdfr		    rt->mfc_ttls[i] = mfccp->mfcc_ttls[i];
952180025Sdfr		/* initialize pkt counters per src-grp */
953177633Sdfr		rt->mfc_pkt_cnt    = 0;
954177633Sdfr		rt->mfc_byte_cnt   = 0;
955180025Sdfr		rt->mfc_wrong_if   = 0;
956180025Sdfr		rt->mfc_last_assert.tv_sec = rt->mfc_last_assert.tv_usec = 0;
957180025Sdfr		if (rt->mfc_expire)
958180025Sdfr		    nexpire[hash]--;
959177633Sdfr		rt->mfc_expire	   = 0;
960177633Sdfr	    }
961177633Sdfr	}
962177633Sdfr	if (mb_rt == NULL) {
963177633Sdfr	    /* no upcall, so make a new entry */
964177633Sdfr	    MGET(mb_rt, M_DONTWAIT, MT_MRTABLE);
965177633Sdfr	    if (mb_rt == NULL) {
966177633Sdfr		splx(s);
967177633Sdfr		return ENOBUFS;
968177633Sdfr	    }
969177633Sdfr
970177633Sdfr	    rt = mtod(mb_rt, struct mfc *);
971180025Sdfr
972180025Sdfr	    /* insert new entry at head of hash chain */
973180025Sdfr	    rt->mfc_origin     = mfccp->mfcc_origin;
974180025Sdfr	    rt->mfc_mcastgrp   = mfccp->mfcc_mcastgrp;
975180025Sdfr	    rt->mfc_parent     = mfccp->mfcc_parent;
976177633Sdfr	    for (i = 0; i < numvifs; i++)
977177633Sdfr		    rt->mfc_ttls[i] = mfccp->mfcc_ttls[i];
978180025Sdfr	    /* initialize pkt counters per src-grp */
979180025Sdfr	    rt->mfc_pkt_cnt    = 0;
980180025Sdfr	    rt->mfc_byte_cnt   = 0;
981180025Sdfr	    rt->mfc_wrong_if   = 0;
982180025Sdfr	    rt->mfc_last_assert.tv_sec = rt->mfc_last_assert.tv_usec = 0;
983180025Sdfr	    rt->mfc_expire     = 0;
984180025Sdfr
985180025Sdfr	    /* link into table */
986180025Sdfr	    mb_rt->m_next  = mfctable[hash];
987180025Sdfr	    mfctable[hash] = mb_rt;
988180025Sdfr	    mb_rt->m_act = NULL;
989180025Sdfr	}
990180025Sdfr    }
991180025Sdfr    splx(s);
992180025Sdfr    return 0;
993180025Sdfr}
994177633Sdfr
995180025Sdfr#ifdef UPCALL_TIMING
996180025Sdfr/*
997180025Sdfr * collect delay statistics on the upcalls
998177633Sdfr */
999177633Sdfrstatic void collate(t)
1000177633Sdfrregister struct timeval *t;
1001177633Sdfr{
1002177633Sdfr    register u_long d;
1003177633Sdfr    register struct timeval tp;
1004177633Sdfr    register u_long delta;
1005177633Sdfr
1006177633Sdfr    GET_TIME(tp);
1007177633Sdfr
1008180025Sdfr    if (TV_LT(*t, tp))
1009180025Sdfr    {
1010180025Sdfr	TV_DELTA(tp, *t, delta);
1011180025Sdfr
1012177633Sdfr	d = delta >> 10;
1013177633Sdfr	if (d > 50)
1014177633Sdfr	    d = 50;
1015177633Sdfr
1016180025Sdfr	++upcall_data[d];
1017180025Sdfr    }
1018177633Sdfr}
1019177633Sdfr#endif /* UPCALL_TIMING */
1020180025Sdfr
1021180025Sdfr/*
1022180025Sdfr * Delete an mfc entry
1023180025Sdfr */
1024177633Sdfrstatic int
1025177633Sdfrdel_mfc(mfccp)
1026177633Sdfr    struct mfcctl *mfccp;
1027177633Sdfr{
1028177633Sdfr    struct in_addr 	origin;
1029177633Sdfr    struct in_addr 	mcastgrp;
1030177633Sdfr    struct mfc 		*rt;
1031177633Sdfr    struct mbuf 	*mb_rt;
1032177633Sdfr    struct mbuf 	**nptr;
1033177633Sdfr    u_long 		hash;
1034177633Sdfr    int s;
1035177633Sdfr
1036177633Sdfr    origin = mfccp->mfcc_origin;
1037180025Sdfr    mcastgrp = mfccp->mfcc_mcastgrp;
1038180025Sdfr    hash = MFCHASH(origin.s_addr, mcastgrp.s_addr);
1039177633Sdfr
1040180025Sdfr    if (mrtdebug & DEBUG_MFC)
1041177633Sdfr	log(LOG_DEBUG,"del_mfc orig %x mcastgrp %x\n",
1042177633Sdfr	    ntohl(origin.s_addr), ntohl(mcastgrp.s_addr));
1043177633Sdfr
1044177633Sdfr    s = splnet();
1045177633Sdfr
1046180025Sdfr    nptr = &mfctable[hash];
1047180025Sdfr    while ((mb_rt = *nptr) != NULL) {
1048180025Sdfr        rt = mtod(mb_rt, struct mfc *);
1049180025Sdfr	if (origin.s_addr == rt->mfc_origin.s_addr &&
1050180025Sdfr	    mcastgrp.s_addr == rt->mfc_mcastgrp.s_addr &&
1051180025Sdfr	    mb_rt->m_act == NULL)
1052180025Sdfr	    break;
1053180025Sdfr
1054180025Sdfr	nptr = &mb_rt->m_next;
1055180025Sdfr    }
1056177633Sdfr    if (mb_rt == NULL) {
1057177633Sdfr	splx(s);
1058177633Sdfr	return EADDRNOTAVAIL;
1059177633Sdfr    }
1060177633Sdfr
1061177633Sdfr    MFREE(mb_rt, *nptr);
1062177633Sdfr
1063177633Sdfr    splx(s);
1064177633Sdfr
1065177633Sdfr    return 0;
1066177633Sdfr}
1067177633Sdfr
1068177633Sdfr/*
1069177633Sdfr * Send a message to mrouted on the multicast routing socket
1070177633Sdfr */
1071177633Sdfrstatic int
1072177633Sdfrsocket_send(s, mm, src)
1073177633Sdfr	struct socket *s;
1074177633Sdfr	struct mbuf *mm;
1075177633Sdfr	struct sockaddr_in *src;
1076177633Sdfr{
1077177633Sdfr	if (s) {
1078177633Sdfr		if (sbappendaddr(&s->so_rcv,
1079177633Sdfr				 (struct sockaddr *)src,
1080177633Sdfr				 mm, (struct mbuf *)0) != 0) {
1081177633Sdfr			sorwakeup(s);
1082177633Sdfr			return 0;
1083177633Sdfr		}
1084177633Sdfr	}
1085177633Sdfr	m_freem(mm);
1086177633Sdfr	return -1;
1087177633Sdfr}
1088177633Sdfr
1089177633Sdfr/*
1090177633Sdfr * IP multicast forwarding function. This function assumes that the packet
1091177633Sdfr * pointed to by "ip" has arrived on (or is about to be sent to) the interface
1092177633Sdfr * pointed to by "ifp", and the packet is to be relayed to other networks
1093177633Sdfr * that have members of the packet's destination IP multicast group.
1094177633Sdfr *
1095177633Sdfr * The packet is returned unscathed to the caller, unless it is
1096177633Sdfr * erroneous, in which case a non-zero return value tells the caller to
1097177633Sdfr * discard it.
1098178112Sdfr */
1099177633Sdfr
1100177633Sdfr#define IP_HDR_LEN  20	/* # bytes of fixed IP header (excluding options) */
1101177633Sdfr#define TUNNEL_LEN  12  /* # bytes of IP option for tunnel encapsulation  */
1102177633Sdfr
1103177633Sdfrstatic int
1104177633SdfrX_ip_mforward(ip, ifp, m, imo)
1105180025Sdfr    register struct ip *ip;
1106177633Sdfr    struct ifnet *ifp;
1107177633Sdfr    struct mbuf *m;
1108177633Sdfr    struct ip_moptions *imo;
1109177633Sdfr{
1110177633Sdfr    register struct mfc *rt = 0; /* XXX uninit warning */
1111177633Sdfr    register u_char *ipoptions;
1112177633Sdfr    static struct sockaddr_in 	k_igmpsrc	= { sizeof k_igmpsrc, AF_INET };
1113177633Sdfr    static int srctun = 0;
1114177633Sdfr    register struct mbuf *mm;
1115177633Sdfr    int s;
1116177633Sdfr    vifi_t vifi;
1117177633Sdfr    struct vif *vifp;
1118177633Sdfr
1119177633Sdfr    if (mrtdebug & DEBUG_FORWARD)
1120177633Sdfr	log(LOG_DEBUG, "ip_mforward: src %x, dst %x, ifp %x\n",
1121177633Sdfr	    ntohl(ip->ip_src.s_addr), ntohl(ip->ip_dst.s_addr), ifp);
1122177633Sdfr
1123177633Sdfr    if (ip->ip_hl < (IP_HDR_LEN + TUNNEL_LEN) >> 2 ||
1124177633Sdfr	(ipoptions = (u_char *)(ip + 1))[1] != IPOPT_LSRR ) {
1125180025Sdfr	/*
1126180025Sdfr	 * Packet arrived via a physical interface or
1127180025Sdfr	 * an encapsulated tunnel.
1128177633Sdfr	 */
1129180025Sdfr    } else {
1130180025Sdfr	/*
1131180025Sdfr	 * Packet arrived through a source-route tunnel.
1132177633Sdfr	 * Source-route tunnels are no longer supported.
1133177633Sdfr	 */
1134177633Sdfr	if ((srctun++ % 1000) == 0)
1135177633Sdfr	    log(LOG_ERR, "ip_mforward: received source-routed packet from %x\n",
1136177633Sdfr		ntohl(ip->ip_src.s_addr));
1137177633Sdfr
1138177633Sdfr	return 1;
1139177633Sdfr    }
1140177633Sdfr
1141177633Sdfr    if ((imo) && ((vifi = imo->imo_multicast_vif) < numvifs)) {
1142177633Sdfr	if (ip->ip_ttl < 255)
1143177633Sdfr		ip->ip_ttl++;	/* compensate for -1 in *_send routines */
1144177633Sdfr	if (rsvpdebug && ip->ip_p == IPPROTO_RSVP) {
1145177633Sdfr	    vifp = viftable + vifi;
1146177633Sdfr	    printf("Sending IPPROTO_RSVP from %lx to %lx on vif %d (%s%s%d)\n",
1147177633Sdfr		ntohl(ip->ip_src.s_addr), ntohl(ip->ip_dst.s_addr), vifi,
1148177633Sdfr		(vifp->v_flags & VIFF_TUNNEL) ? "tunnel on " : "",
1149177633Sdfr		vifp->v_ifp->if_name, vifp->v_ifp->if_unit);
1150177633Sdfr	}
1151177633Sdfr	return (ip_mdq(m, ifp, rt, vifi));
1152177633Sdfr    }
1153177633Sdfr    if (rsvpdebug && ip->ip_p == IPPROTO_RSVP) {
1154177633Sdfr	printf("Warning: IPPROTO_RSVP from %lx to %lx without vif option\n",
1155177633Sdfr	    ntohl(ip->ip_src.s_addr), ntohl(ip->ip_dst.s_addr));
1156177633Sdfr	if(!imo)
1157177633Sdfr		printf("In fact, no options were specified at all\n");
1158177633Sdfr    }
1159177633Sdfr
1160177633Sdfr    /*
1161177633Sdfr     * Don't forward a packet with time-to-live of zero or one,
1162180025Sdfr     * or a packet destined to a local-only group.
1163178112Sdfr     */
1164180025Sdfr    if (ip->ip_ttl <= 1 ||
1165177633Sdfr	ntohl(ip->ip_dst.s_addr) <= INADDR_MAX_LOCAL_GROUP)
1166177633Sdfr	return 0;
1167177633Sdfr
1168178112Sdfr    /*
1169177633Sdfr     * Determine forwarding vifs from the forwarding cache table
1170177633Sdfr     */
1171177633Sdfr    s = splnet();
1172177633Sdfr    MFCFIND(ip->ip_src.s_addr, ip->ip_dst.s_addr, rt);
1173177633Sdfr
1174177633Sdfr    /* Entry exists, so forward if necessary */
1175177633Sdfr    if (rt != NULL) {
1176177633Sdfr	splx(s);
1177177633Sdfr	return (ip_mdq(m, ifp, rt, -1));
1178180025Sdfr    } else {
1179177633Sdfr	/*
1180180025Sdfr	 * If we don't have a route for packet's origin,
1181180025Sdfr	 * Make a copy of the packet &
1182179425Sdfr	 * send message to routing daemon
1183180025Sdfr	 */
1184179425Sdfr
1185179425Sdfr	register struct mbuf *mb_rt;
1186179425Sdfr	register struct mbuf *mb_ntry;
1187179425Sdfr	register struct mbuf *mb0;
1188179425Sdfr	register struct rtdetq *rte;
1189179425Sdfr	register struct mbuf *rte_m;
1190179425Sdfr	register u_long hash;
1191179425Sdfr	register int npkts;
1192179425Sdfr#ifdef UPCALL_TIMING
1193180025Sdfr	struct timeval tp;
1194180025Sdfr
1195180025Sdfr	GET_TIME(tp);
1196179425Sdfr#endif
1197179425Sdfr
1198180025Sdfr	mrtstat.mrts_no_route++;
1199180025Sdfr	if (mrtdebug & (DEBUG_FORWARD | DEBUG_MFC))
1200180025Sdfr	    log(LOG_DEBUG, "ip_mforward: no rte s %x g %x\n",
1201180025Sdfr		ntohl(ip->ip_src.s_addr),
1202180025Sdfr		ntohl(ip->ip_dst.s_addr));
1203177633Sdfr
1204180025Sdfr	/*
1205180025Sdfr	 * Allocate mbufs early so that we don't do extra work if we are
1206180025Sdfr	 * just going to fail anyway.
1207180025Sdfr	 */
1208180025Sdfr	MGET(mb_ntry, M_DONTWAIT, MT_DATA);
1209180025Sdfr	if (mb_ntry == NULL) {
1210180025Sdfr	    splx(s);
1211180025Sdfr	    return ENOBUFS;
1212180025Sdfr	}
1213180025Sdfr	mb0 = m_copy(m, 0, M_COPYALL);
1214180025Sdfr	if (mb0 == NULL) {
1215180025Sdfr	    m_free(mb_ntry);
1216180025Sdfr	    splx(s);
1217180025Sdfr	    return ENOBUFS;
1218180025Sdfr	}
1219180025Sdfr
1220180025Sdfr	/* is there an upcall waiting for this packet? */
1221180025Sdfr	hash = MFCHASH(ip->ip_src.s_addr, ip->ip_dst.s_addr);
1222180025Sdfr	for (mb_rt = mfctable[hash]; mb_rt; mb_rt = mb_rt->m_next) {
1223180025Sdfr	    rt = mtod(mb_rt, struct mfc *);
1224180025Sdfr	    if ((ip->ip_src.s_addr == rt->mfc_origin.s_addr) &&
1225180025Sdfr		(ip->ip_dst.s_addr == rt->mfc_mcastgrp.s_addr) &&
1226180025Sdfr		(mb_rt->m_act != NULL))
1227180025Sdfr		break;
1228180025Sdfr	}
1229180025Sdfr
1230180025Sdfr	if (mb_rt == NULL) {
1231180025Sdfr	    int hlen = ip->ip_hl << 2;
1232180025Sdfr	    int i;
1233180025Sdfr	    struct igmpmsg *im;
1234180025Sdfr
1235180025Sdfr	    /* no upcall, so make a new entry */
1236180025Sdfr	    MGET(mb_rt, M_DONTWAIT, MT_MRTABLE);
1237180025Sdfr	    if (mb_rt == NULL) {
1238180025Sdfr		m_free(mb_ntry);
1239180025Sdfr		m_freem(mb0);
1240180025Sdfr		splx(s);
1241180025Sdfr		return ENOBUFS;
1242180025Sdfr	    }
1243180025Sdfr	    /* Make a copy of the header to send to the user level process */
1244180025Sdfr	    mm = m_copy(m, 0, hlen);
1245180025Sdfr	    if (mm && (M_HASCL(mm) || mm->m_len < hlen))
1246180025Sdfr		mm = m_pullup(mm, hlen);
1247180025Sdfr	    if (mm == NULL) {
1248180025Sdfr		m_free(mb_ntry);
1249180025Sdfr		m_freem(mb0);
1250180025Sdfr		m_free(mb_rt);
1251180025Sdfr		splx(s);
1252180025Sdfr		return ENOBUFS;
1253180025Sdfr	    }
1254180025Sdfr
1255180025Sdfr	    /*
1256180025Sdfr	     * Send message to routing daemon to install
1257180025Sdfr	     * a route into the kernel table
1258180025Sdfr	     */
1259180025Sdfr	    k_igmpsrc.sin_addr = ip->ip_src;
1260180025Sdfr
1261180025Sdfr	    im = mtod(mm, struct igmpmsg *);
1262180025Sdfr	    im->im_msgtype	= IGMPMSG_NOCACHE;
1263180025Sdfr	    im->im_mbz		= 0;
1264180025Sdfr
1265180025Sdfr	    mrtstat.mrts_upcalls++;
1266180025Sdfr
1267180025Sdfr	    if (socket_send(ip_mrouter, mm, &k_igmpsrc) < 0) {
1268180025Sdfr		log(LOG_WARNING, "ip_mforward: ip_mrouter socket queue full\n");
1269180025Sdfr		++mrtstat.mrts_upq_sockfull;
1270180025Sdfr		m_free(mb_ntry);
1271180025Sdfr		m_freem(mb0);
1272180025Sdfr		m_free(mb_rt);
1273180025Sdfr		splx(s);
1274180025Sdfr		return ENOBUFS;
1275177633Sdfr	    }
1276180025Sdfr
1277180025Sdfr	    rt = mtod(mb_rt, struct mfc *);
1278177633Sdfr
1279180025Sdfr	    /* insert new entry at head of hash chain */
1280180025Sdfr	    rt->mfc_origin.s_addr     = ip->ip_src.s_addr;
1281180025Sdfr	    rt->mfc_mcastgrp.s_addr   = ip->ip_dst.s_addr;
1282180025Sdfr	    rt->mfc_expire	      = UPCALL_EXPIRE;
1283180025Sdfr	    nexpire[hash]++;
1284180025Sdfr	    for (i = 0; i < numvifs; i++)
1285180025Sdfr		rt->mfc_ttls[i] = 0;
1286180025Sdfr	    rt->mfc_parent = -1;
1287180025Sdfr
1288180025Sdfr	    /* link into table */
1289180025Sdfr	    mb_rt->m_next  = mfctable[hash];
1290180025Sdfr	    mfctable[hash] = mb_rt;
1291180025Sdfr	    mb_rt->m_act = NULL;
1292180025Sdfr
1293180025Sdfr	    rte_m = mb_rt;
1294180025Sdfr	} else {
1295180025Sdfr	    /* determine if q has overflowed */
1296180025Sdfr	    for (rte_m = mb_rt, npkts = 0; rte_m->m_act; rte_m = rte_m->m_act)
1297180025Sdfr		npkts++;
1298180025Sdfr
1299180025Sdfr	    if (npkts > MAX_UPQ) {
1300180025Sdfr		mrtstat.mrts_upq_ovflw++;
1301180025Sdfr		m_free(mb_ntry);
1302177633Sdfr		m_freem(mb0);
1303180025Sdfr		splx(s);
1304177633Sdfr		return 0;
1305180025Sdfr	    }
1306180025Sdfr	}
1307180025Sdfr
1308180025Sdfr	mb_ntry->m_act = NULL;
1309180025Sdfr	rte = mtod(mb_ntry, struct rtdetq *);
1310180025Sdfr
1311180025Sdfr	rte->m 			= mb0;
1312180025Sdfr	rte->ifp 		= ifp;
1313180025Sdfr#ifdef UPCALL_TIMING
1314180025Sdfr	rte->t			= tp;
1315180025Sdfr#endif
1316180025Sdfr
1317180025Sdfr	/* Add this entry to the end of the queue */
1318177633Sdfr	rte_m->m_act		= mb_ntry;
1319180025Sdfr
1320177633Sdfr	splx(s);
1321177633Sdfr
1322180025Sdfr	return 0;
1323177633Sdfr    }
1324177633Sdfr}
1325177633Sdfr
1326177633Sdfr#ifndef MROUTE_LKM
1327177633Sdfrint (*ip_mforward)(struct ip *, struct ifnet *, struct mbuf *,
1328177633Sdfr		   struct ip_moptions *) = X_ip_mforward;
1329177633Sdfr#endif
1330177633Sdfr
1331177633Sdfr/*
1332177633Sdfr * Clean up the cache entry if upcall is not serviced
1333177633Sdfr */
1334177633Sdfrstatic void
1335177633Sdfrexpire_upcalls(void *unused)
1336177633Sdfr{
1337177633Sdfr    struct mbuf *mb_rt, *m, **nptr;
1338177633Sdfr    struct rtdetq *rte;
1339177633Sdfr    struct mfc *mfc;
1340177633Sdfr    int i;
1341177633Sdfr    int s;
1342177633Sdfr
1343177633Sdfr    s = splnet();
1344177633Sdfr    for (i = 0; i < MFCTBLSIZ; i++) {
1345177633Sdfr	if (nexpire[i] == 0)
1346177633Sdfr	    continue;
1347177633Sdfr	nptr = &mfctable[i];
1348177633Sdfr	for (mb_rt = *nptr; mb_rt != NULL; mb_rt = *nptr) {
1349177633Sdfr	    mfc = mtod(mb_rt, struct mfc *);
1350177633Sdfr
1351177633Sdfr	    /*
1352177633Sdfr	     * Skip real cache entries
1353177633Sdfr	     * Make sure it wasn't marked to not expire (shouldn't happen)
1354177633Sdfr	     * If it expires now
1355177633Sdfr	     */
1356177633Sdfr	    if (mb_rt->m_act != NULL &&
1357177633Sdfr	        mfc->mfc_expire != 0 &&
1358177633Sdfr		--mfc->mfc_expire == 0) {
1359177633Sdfr		if (mrtdebug & DEBUG_EXPIRE)
1360177633Sdfr		    log(LOG_DEBUG, "expire_upcalls: expiring (%x %x)\n",
1361177633Sdfr			ntohl(mfc->mfc_origin.s_addr),
1362177633Sdfr			ntohl(mfc->mfc_mcastgrp.s_addr));
1363177633Sdfr		/*
1364177633Sdfr		 * drop all the packets
1365177633Sdfr		 * free the mbuf with the pkt, if, timing info
1366177633Sdfr		 */
1367177633Sdfr		while (mb_rt->m_act) {
1368177633Sdfr		    m = mb_rt->m_act;
1369177633Sdfr		    mb_rt->m_act = m->m_act;
1370177633Sdfr
1371177633Sdfr		    rte = mtod(m, struct rtdetq *);
1372177633Sdfr		    m_freem(rte->m);
1373177633Sdfr		    m_free(m);
1374177633Sdfr		}
1375177633Sdfr		++mrtstat.mrts_cache_cleanups;
1376177633Sdfr		nexpire[i]--;
1377177633Sdfr
1378177633Sdfr		MFREE(mb_rt, *nptr);
1379177633Sdfr	    } else {
1380177633Sdfr		nptr = &mb_rt->m_next;
1381177633Sdfr	    }
1382177633Sdfr	}
1383177633Sdfr    }
1384177633Sdfr    splx(s);
1385177633Sdfr    timeout(expire_upcalls, (caddr_t)NULL, EXPIRE_TIMEOUT);
1386177633Sdfr}
1387177633Sdfr
1388177633Sdfr/*
1389177633Sdfr * Packet forwarding routine once entry in the cache is made
1390177633Sdfr */
1391177633Sdfrstatic int
1392177633Sdfrip_mdq(m, ifp, rt, xmt_vif)
1393177633Sdfr    register struct mbuf *m;
1394177633Sdfr    register struct ifnet *ifp;
1395177633Sdfr    register struct mfc *rt;
1396177633Sdfr    register vifi_t xmt_vif;
1397177633Sdfr{
1398177633Sdfr    register struct ip  *ip = mtod(m, struct ip *);
1399177633Sdfr    register vifi_t vifi;
1400177633Sdfr    register struct vif *vifp;
1401177633Sdfr    register int plen = ntohs(ip->ip_len);
1402177633Sdfr
1403177633Sdfr/*
1404177633Sdfr * Macro to send packet on vif.  Since RSVP packets don't get counted on
1405177633Sdfr * input, they shouldn't get counted on output, so statistics keeping is
1406177633Sdfr * seperate.
1407177633Sdfr */
1408177633Sdfr#define MC_SEND(ip,vifp,m) {                             \
1409177633Sdfr                if ((vifp)->v_flags & VIFF_TUNNEL)  	 \
1410177633Sdfr                    encap_send((ip), (vifp), (m));       \
1411177633Sdfr                else                                     \
1412177633Sdfr                    phyint_send((ip), (vifp), (m));      \
1413177633Sdfr}
1414177633Sdfr
1415177633Sdfr    /*
1416177633Sdfr     * If xmt_vif is not -1, send on only the requested vif.
1417177633Sdfr     *
1418177633Sdfr     * (since vifi_t is u_short, -1 becomes MAXUSHORT, which > numvifs.)
1419177633Sdfr     */
1420177633Sdfr    if (xmt_vif < numvifs) {
1421177633Sdfr	MC_SEND(ip, viftable + xmt_vif, m);
1422177633Sdfr	return 1;
1423177633Sdfr    }
1424177633Sdfr
1425177633Sdfr    /*
1426177633Sdfr     * Don't forward if it didn't arrive from the parent vif for its origin.
1427177633Sdfr     */
1428177633Sdfr    vifi = rt->mfc_parent;
1429178033Sdfr    if ((vifi >= numvifs) || (viftable[vifi].v_ifp != ifp)) {
1430177633Sdfr	/* came in the wrong interface */
1431177633Sdfr	if (mrtdebug & DEBUG_FORWARD)
1432177633Sdfr	    log(LOG_DEBUG, "wrong if: ifp %x vifi %d vififp %x\n",
1433177633Sdfr		ifp, vifi, viftable[vifi].v_ifp);
1434177633Sdfr	++mrtstat.mrts_wrong_if;
1435177633Sdfr	++rt->mfc_wrong_if;
1436177633Sdfr	/*
1437177633Sdfr	 * If we are doing PIM assert processing, and we are forwarding
1438177633Sdfr	 * packets on this interface, and it is a broadcast medium
1439177633Sdfr	 * interface (and not a tunnel), send a message to the routing daemon.
1440180025Sdfr	 */
1441180025Sdfr	if (pim_assert && rt->mfc_ttls[vifi] &&
1442180025Sdfr		(ifp->if_flags & IFF_BROADCAST) &&
1443180025Sdfr		!(viftable[vifi].v_flags & VIFF_TUNNEL)) {
1444180069Savatar	    struct sockaddr_in k_igmpsrc;
1445180069Savatar	    struct mbuf *mm;
1446180069Savatar	    struct igmpmsg *im;
1447180069Savatar	    int hlen = ip->ip_hl << 2;
1448177633Sdfr	    struct timeval now;
1449177633Sdfr	    register u_long delta;
1450177633Sdfr
1451177633Sdfr	    GET_TIME(now);
1452177633Sdfr
1453177633Sdfr	    TV_DELTA(rt->mfc_last_assert, now, delta);
1454177633Sdfr
1455177633Sdfr	    if (delta > ASSERT_MSG_TIME) {
1456177633Sdfr		mm = m_copy(m, 0, hlen);
1457177633Sdfr		if (mm && (M_HASCL(mm) || mm->m_len < hlen))
1458177633Sdfr		    mm = m_pullup(mm, hlen);
1459177633Sdfr		if (mm == NULL) {
1460177633Sdfr		    return ENOBUFS;
1461177633Sdfr		}
1462177633Sdfr
1463177633Sdfr		rt->mfc_last_assert = now;
1464177633Sdfr
1465177633Sdfr		im = mtod(mm, struct igmpmsg *);
1466177633Sdfr		im->im_msgtype	= IGMPMSG_WRONGVIF;
1467177633Sdfr		im->im_mbz		= 0;
1468177633Sdfr		im->im_vif		= vifi;
1469177633Sdfr
1470177633Sdfr		k_igmpsrc.sin_addr = im->im_src;
1471177633Sdfr
1472177633Sdfr		socket_send(ip_mrouter, mm, &k_igmpsrc);
1473177633Sdfr	    }
1474177633Sdfr	}
1475177633Sdfr	return 0;
1476177633Sdfr    }
1477180025Sdfr
1478177633Sdfr    /* If I sourced this packet, it counts as output, else it was input. */
1479177633Sdfr    if (ip->ip_src.s_addr == viftable[vifi].v_lcl_addr.s_addr) {
1480177633Sdfr	viftable[vifi].v_pkt_out++;
1481177633Sdfr	viftable[vifi].v_bytes_out += plen;
1482177633Sdfr    } else {
1483177633Sdfr	viftable[vifi].v_pkt_in++;
1484177633Sdfr	viftable[vifi].v_bytes_in += plen;
1485177633Sdfr    }
1486177633Sdfr    rt->mfc_pkt_cnt++;
1487177633Sdfr    rt->mfc_byte_cnt += plen;
1488177633Sdfr
1489180025Sdfr    /*
1490180025Sdfr     * For each vif, decide if a copy of the packet should be forwarded.
1491177633Sdfr     * Forward if:
1492177633Sdfr     *		- the ttl exceeds the vif's threshold
1493177633Sdfr     *		- there are group members downstream on interface
1494177633Sdfr     */
1495177633Sdfr    for (vifp = viftable, vifi = 0; vifi < numvifs; vifp++, vifi++)
1496177633Sdfr	if ((rt->mfc_ttls[vifi] > 0) &&
1497177633Sdfr	    (ip->ip_ttl > rt->mfc_ttls[vifi])) {
1498177633Sdfr	    vifp->v_pkt_out++;
1499177633Sdfr	    vifp->v_bytes_out += plen;
1500177633Sdfr	    MC_SEND(ip, vifp, m);
1501178033Sdfr	}
1502177633Sdfr
1503177633Sdfr    return 0;
1504177633Sdfr}
1505177633Sdfr
1506177633Sdfr/*
1507177633Sdfr * check if a vif number is legal/ok. This is used by ip_output, to export
1508177633Sdfr * numvifs there,
1509177633Sdfr */
1510177633Sdfrstatic int
1511178033SdfrX_legal_vif_num(vif)
1512178033Sdfr    int vif;
1513177633Sdfr{
1514177633Sdfr    if (vif >= 0 && vif < numvifs)
1515177633Sdfr       return(1);
1516177633Sdfr    else
1517177633Sdfr       return(0);
1518177633Sdfr}
1519177633Sdfr
1520177633Sdfr#ifndef MROUTE_LKM
1521177633Sdfrint (*legal_vif_num)(int) = X_legal_vif_num;
1522177633Sdfr#endif
1523177633Sdfr
1524177633Sdfr/*
1525177633Sdfr * Return the local address used by this vif
1526177633Sdfr */
1527177633Sdfrstatic u_long
1528177633SdfrX_ip_mcast_src(vifi)
1529177633Sdfr    int vifi;
1530177633Sdfr{
1531177633Sdfr    if (vifi >= 0 && vifi < numvifs)
1532177633Sdfr	return viftable[vifi].v_lcl_addr.s_addr;
1533177633Sdfr    else
1534177633Sdfr	return INADDR_ANY;
1535177633Sdfr}
1536177633Sdfr
1537177633Sdfr#ifndef MROUTE_LKM
1538177633Sdfru_long (*ip_mcast_src)(int) = X_ip_mcast_src;
1539177633Sdfr#endif
1540177633Sdfr
1541177633Sdfrstatic void
1542180025Sdfrphyint_send(ip, vifp, m)
1543177633Sdfr    struct ip *ip;
1544180025Sdfr    struct vif *vifp;
1545180025Sdfr    struct mbuf *m;
1546180025Sdfr{
1547180025Sdfr    register struct mbuf *mb_copy;
1548180025Sdfr    register int hlen = ip->ip_hl << 2;
1549177633Sdfr
1550177633Sdfr    /*
1551177633Sdfr     * Make a new reference to the packet; make sure that
1552180025Sdfr     * the IP header is actually copied, not just referenced,
1553180025Sdfr     * so that ip_output() only scribbles on the copy.
1554180025Sdfr     */
1555177633Sdfr    mb_copy = m_copy(m, 0, M_COPYALL);
1556177633Sdfr    if (mb_copy && (M_HASCL(mb_copy) || mb_copy->m_len < hlen))
1557177633Sdfr	mb_copy = m_pullup(mb_copy, hlen);
1558177633Sdfr    if (mb_copy == NULL)
1559177633Sdfr	return;
1560180025Sdfr
1561177633Sdfr    if (vifp->v_rate_limit <= 0)
1562177633Sdfr	tbf_send_packet(vifp, mb_copy);
1563180025Sdfr    else
1564177633Sdfr	tbf_control(vifp, mb_copy, mtod(mb_copy, struct ip *), ip->ip_len);
1565177633Sdfr}
1566180025Sdfr
1567180025Sdfrstatic void
1568180025Sdfrencap_send(ip, vifp, m)
1569180025Sdfr    register struct ip *ip;
1570180025Sdfr    register struct vif *vifp;
1571180025Sdfr    register struct mbuf *m;
1572180025Sdfr{
1573180025Sdfr    register struct mbuf *mb_copy;
1574180025Sdfr    register struct ip *ip_copy;
1575180025Sdfr    register int i, len = ip->ip_len;
1576180025Sdfr
1577180025Sdfr    /*
1578180025Sdfr     * copy the old packet & pullup it's IP header into the
1579180025Sdfr     * new mbuf so we can modify it.  Try to fill the new
1580180025Sdfr     * mbuf since if we don't the ethernet driver will.
1581180025Sdfr     */
1582180025Sdfr    MGET(mb_copy, M_DONTWAIT, MT_DATA);
1583180025Sdfr    if (mb_copy == NULL)
1584180025Sdfr	return;
1585180025Sdfr    mb_copy->m_data += 16;
1586180025Sdfr    mb_copy->m_len = sizeof(multicast_encap_iphdr);
1587180025Sdfr
1588180025Sdfr    if ((mb_copy->m_next = m_copy(m, 0, M_COPYALL)) == NULL) {
1589177633Sdfr	m_freem(mb_copy);
1590180025Sdfr	return;
1591180025Sdfr    }
1592180025Sdfr    i = MHLEN - M_LEADINGSPACE(mb_copy);
1593180025Sdfr    if (i > len)
1594180025Sdfr	i = len;
1595180025Sdfr    mb_copy = m_pullup(mb_copy, i);
1596180025Sdfr    if (mb_copy == NULL)
1597180025Sdfr	return;
1598180025Sdfr    mb_copy->m_pkthdr.len = len + sizeof(multicast_encap_iphdr);
1599180025Sdfr
1600180025Sdfr    /*
1601180025Sdfr     * fill in the encapsulating IP header.
1602180025Sdfr     */
1603180025Sdfr    ip_copy = mtod(mb_copy, struct ip *);
1604180025Sdfr    *ip_copy = multicast_encap_iphdr;
1605180025Sdfr    ip_copy->ip_id = htons(ip_id++);
1606180025Sdfr    ip_copy->ip_len += len;
1607180025Sdfr    ip_copy->ip_src = vifp->v_lcl_addr;
1608180025Sdfr    ip_copy->ip_dst = vifp->v_rmt_addr;
1609180025Sdfr
1610180025Sdfr    /*
1611180025Sdfr     * turn the encapsulated IP header back into a valid one.
1612180025Sdfr     */
1613180025Sdfr    ip = (struct ip *)((caddr_t)ip_copy + sizeof(multicast_encap_iphdr));
1614180025Sdfr    --ip->ip_ttl;
1615177633Sdfr    HTONS(ip->ip_len);
1616180025Sdfr    HTONS(ip->ip_off);
1617180025Sdfr    ip->ip_sum = 0;
1618180025Sdfr#if defined(LBL) && !defined(ultrix)
1619180025Sdfr    ip->ip_sum = ~oc_cksum((caddr_t)ip, ip->ip_hl << 2, 0);
1620177633Sdfr#else
1621177633Sdfr    mb_copy->m_data += sizeof(multicast_encap_iphdr);
1622180025Sdfr    ip->ip_sum = in_cksum(mb_copy, ip->ip_hl << 2);
1623180025Sdfr    mb_copy->m_data -= sizeof(multicast_encap_iphdr);
1624177633Sdfr#endif
1625177633Sdfr
1626177633Sdfr    if (vifp->v_rate_limit <= 0)
1627177633Sdfr	tbf_send_packet(vifp, mb_copy);
1628177633Sdfr    else
1629177633Sdfr	tbf_control(vifp, mb_copy, ip, ip_copy->ip_len);
1630177633Sdfr}
1631177633Sdfr
1632177633Sdfr/*
1633177633Sdfr * De-encapsulate a packet and feed it back through ip input (this
1634177633Sdfr * routine is called whenever IP gets a packet with proto type
1635177685Sdfr * ENCAP_PROTO and a local destination address).
1636177633Sdfr */
1637177685Sdfrvoid
1638177685Sdfr#ifdef MROUTE_LKM
1639177685SdfrX_ipip_input(m)
1640177633Sdfr#else
1641177633Sdfripip_input(m, iphlen)
1642177633Sdfr#endif
1643177633Sdfr	register struct mbuf *m;
1644177633Sdfr	int iphlen;
1645177633Sdfr{
1646177633Sdfr    struct ifnet *ifp = m->m_pkthdr.rcvif;
1647177633Sdfr    register struct ip *ip = mtod(m, struct ip *);
1648177633Sdfr    register int hlen = ip->ip_hl << 2;
1649177633Sdfr    register int s;
1650177633Sdfr    register struct ifqueue *ifq;
1651177633Sdfr    register struct vif *vifp;
1652177633Sdfr
1653177633Sdfr    if (!have_encap_tunnel) {
1654177633Sdfr	    rip_input(m);
1655177633Sdfr	    return;
1656177633Sdfr    }
1657177633Sdfr    /*
1658177633Sdfr     * dump the packet if it's not to a multicast destination or if
1659177633Sdfr     * we don't have an encapsulating tunnel with the source.
1660177633Sdfr     * Note:  This code assumes that the remote site IP address
1661177633Sdfr     * uniquely identifies the tunnel (i.e., that this site has
1662177633Sdfr     * at most one tunnel with the remote site).
1663177633Sdfr     */
1664177633Sdfr    if (! IN_MULTICAST(ntohl(((struct ip *)((char *)ip + hlen))->ip_dst.s_addr))) {
1665177633Sdfr	++mrtstat.mrts_bad_tunnel;
1666177633Sdfr	m_freem(m);
1667180025Sdfr	return;
1668180025Sdfr    }
1669180025Sdfr    if (ip->ip_src.s_addr != last_encap_src) {
1670180025Sdfr	register struct vif *vife;
1671177633Sdfr
1672177633Sdfr	vifp = viftable;
1673177633Sdfr	vife = vifp + numvifs;
1674177633Sdfr	last_encap_src = ip->ip_src.s_addr;
1675177633Sdfr	last_encap_vif = 0;
1676177633Sdfr	for ( ; vifp < vife; ++vifp)
1677177633Sdfr	    if (vifp->v_rmt_addr.s_addr == ip->ip_src.s_addr) {
1678177633Sdfr		if ((vifp->v_flags & (VIFF_TUNNEL|VIFF_SRCRT))
1679177633Sdfr		    == VIFF_TUNNEL)
1680177633Sdfr		    last_encap_vif = vifp;
1681177633Sdfr		break;
1682177633Sdfr	    }
1683178112Sdfr    }
1684177633Sdfr    if ((vifp = last_encap_vif) == 0) {
1685177633Sdfr	last_encap_src = 0;
1686177633Sdfr	mrtstat.mrts_cant_tunnel++; /*XXX*/
1687177633Sdfr	m_freem(m);
1688177633Sdfr	if (mrtdebug)
1689177633Sdfr          log(LOG_DEBUG, "ip_mforward: no tunnel with %x\n",
1690177633Sdfr		ntohl(ip->ip_src.s_addr));
1691177633Sdfr	return;
1692177633Sdfr    }
1693177633Sdfr    ifp = vifp->v_ifp;
1694177633Sdfr
1695177633Sdfr    if (hlen > IP_HDR_LEN)
1696177633Sdfr      ip_stripoptions(m, (struct mbuf *) 0);
1697177633Sdfr    m->m_data += IP_HDR_LEN;
1698177633Sdfr    m->m_len -= IP_HDR_LEN;
1699177633Sdfr    m->m_pkthdr.len -= IP_HDR_LEN;
1700177633Sdfr    m->m_pkthdr.rcvif = ifp;
1701177633Sdfr
1702177633Sdfr    ifq = &ipintrq;
1703177633Sdfr    s = splimp();
1704177633Sdfr    if (IF_QFULL(ifq)) {
1705177633Sdfr	IF_DROP(ifq);
1706177633Sdfr	m_freem(m);
1707177633Sdfr    } else {
1708177633Sdfr	IF_ENQUEUE(ifq, m);
1709177633Sdfr	/*
1710177633Sdfr	 * normally we would need a "schednetisr(NETISR_IP)"
1711177633Sdfr	 * here but we were called by ip_input and it is going
1712177633Sdfr	 * to loop back & try to dequeue the packet we just
1713177633Sdfr	 * queued as soon as we return so we avoid the
1714177633Sdfr	 * unnecessary software interrrupt.
1715178112Sdfr	 */
1716177633Sdfr    }
1717177633Sdfr    splx(s);
1718177633Sdfr}
1719177633Sdfr
1720177633Sdfr/*
1721177633Sdfr * Token bucket filter module
1722177633Sdfr */
1723177633Sdfr
1724177633Sdfrstatic void
1725177633Sdfrtbf_control(vifp, m, ip, p_len)
1726177633Sdfr	register struct vif *vifp;
1727177633Sdfr	register struct mbuf *m;
1728177633Sdfr	register struct ip *ip;
1729177633Sdfr	register u_long p_len;
1730177633Sdfr{
1731177633Sdfr    register struct tbf *t = vifp->v_tbf;
1732177633Sdfr
1733177633Sdfr    if (p_len > MAX_BKT_SIZE) {
1734177633Sdfr	/* drop if packet is too large */
1735177633Sdfr	mrtstat.mrts_pkt2large++;
1736178112Sdfr	m_freem(m);
1737178112Sdfr	return;
1738178112Sdfr    }
1739178112Sdfr
1740178112Sdfr    tbf_update_tokens(vifp);
1741178112Sdfr
1742178112Sdfr    /* if there are enough tokens,
1743177633Sdfr     * and the queue is empty,
1744177633Sdfr     * send this packet out
1745177633Sdfr     */
1746177633Sdfr
1747177633Sdfr    if (t->tbf_q_len == 0) {
1748177633Sdfr	/* queue empty, send packet if enough tokens */
1749177633Sdfr	if (p_len <= t->tbf_n_tok) {
1750177633Sdfr	    t->tbf_n_tok -= p_len;
1751177633Sdfr	    tbf_send_packet(vifp, m);
1752177633Sdfr	} else {
1753177633Sdfr	    /* queue packet and timeout till later */
1754178112Sdfr	    tbf_queue(vifp, m);
1755178112Sdfr	    timeout(tbf_reprocess_q, (caddr_t)vifp, TBF_REPROCESS);
1756178112Sdfr	}
1757178112Sdfr    } else if (t->tbf_q_len < t->tbf_max_q_len) {
1758178112Sdfr	/* finite queue length, so queue pkts and process queue */
1759178112Sdfr	tbf_queue(vifp, m);
1760177633Sdfr	tbf_process_q(vifp);
1761177633Sdfr    } else {
1762177633Sdfr	/* queue length too much, try to dq and queue and process */
1763177633Sdfr	if (!tbf_dq_sel(vifp, ip)) {
1764177633Sdfr	    mrtstat.mrts_q_overflow++;
1765177633Sdfr	    m_freem(m);
1766177633Sdfr	    return;
1767177633Sdfr	} else {
1768177633Sdfr	    tbf_queue(vifp, m);
1769177633Sdfr	    tbf_process_q(vifp);
1770177633Sdfr	}
1771177633Sdfr    }
1772177633Sdfr    return;
1773177633Sdfr}
1774177633Sdfr
1775177633Sdfr/*
1776177633Sdfr * adds a packet to the queue at the interface
1777180025Sdfr */
1778180025Sdfrstatic void
1779180025Sdfrtbf_queue(vifp, m)
1780177633Sdfr	register struct vif *vifp;
1781177633Sdfr	register struct mbuf *m;
1782177633Sdfr{
1783177633Sdfr    register int s = splnet();
1784177633Sdfr    register struct tbf *t = vifp->v_tbf;
1785177633Sdfr
1786177633Sdfr    if (t->tbf_t == NULL) {
1787177633Sdfr	/* Queue was empty */
1788180025Sdfr	t->tbf_q = m;
1789177633Sdfr    } else {
1790180025Sdfr	/* Insert at tail */
1791180025Sdfr	t->tbf_t->m_act = m;
1792177633Sdfr    }
1793177633Sdfr
1794180025Sdfr    /* Set new tail pointer */
1795177633Sdfr    t->tbf_t = m;
1796177633Sdfr
1797177633Sdfr#ifdef DIAGNOSTIC
1798177633Sdfr    /* Make sure we didn't get fed a bogus mbuf */
1799177633Sdfr    if (m->m_act)
1800177633Sdfr	panic("tbf_queue: m_act");
1801177633Sdfr#endif
1802177633Sdfr    m->m_act = NULL;
1803177633Sdfr
1804177633Sdfr    t->tbf_q_len++;
1805177633Sdfr
1806177633Sdfr    splx(s);
1807177633Sdfr}
1808177633Sdfr
1809180025Sdfr
1810177633Sdfr/*
1811177633Sdfr * processes the queue at the interface
1812177633Sdfr */
1813177633Sdfrstatic void
1814177633Sdfrtbf_process_q(vifp)
1815177633Sdfr    register struct vif *vifp;
1816177633Sdfr{
1817177633Sdfr    register struct mbuf *m;
1818177633Sdfr    register int len;
1819177633Sdfr    register int s = splnet();
1820177633Sdfr    register struct tbf *t = vifp->v_tbf;
1821177633Sdfr
1822177633Sdfr    /* loop through the queue at the interface and send as many packets
1823177633Sdfr     * as possible
1824177633Sdfr     */
1825177633Sdfr    while (t->tbf_q_len > 0) {
1826177633Sdfr	m = t->tbf_q;
1827177633Sdfr
1828177633Sdfr	len = mtod(m, struct ip *)->ip_len;
1829177633Sdfr
1830177633Sdfr	/* determine if the packet can be sent */
1831177633Sdfr	if (len <= t->tbf_n_tok) {
1832177633Sdfr	    /* if so,
1833177633Sdfr	     * reduce no of tokens, dequeue the packet,
1834177633Sdfr	     * send the packet.
1835177633Sdfr	     */
1836177633Sdfr	    t->tbf_n_tok -= len;
1837177633Sdfr
1838177633Sdfr	    t->tbf_q = m->m_act;
1839177633Sdfr	    if (--t->tbf_q_len == 0)
1840177633Sdfr		t->tbf_t = NULL;
1841177633Sdfr
1842177633Sdfr	    m->m_act = NULL;
1843177633Sdfr	    tbf_send_packet(vifp, m);
1844177633Sdfr
1845177633Sdfr	} else break;
1846177633Sdfr    }
1847177633Sdfr    splx(s);
1848177633Sdfr}
1849177633Sdfr
1850177633Sdfrstatic void
1851177633Sdfrtbf_reprocess_q(xvifp)
1852177633Sdfr	void *xvifp;
1853177633Sdfr{
1854177633Sdfr    register struct vif *vifp = xvifp;
1855177633Sdfr    if (ip_mrouter == NULL)
1856177633Sdfr	return;
1857177633Sdfr
1858177633Sdfr    tbf_update_tokens(vifp);
1859177633Sdfr
1860180025Sdfr    tbf_process_q(vifp);
1861177633Sdfr
1862177633Sdfr    if (vifp->v_tbf->tbf_q_len)
1863177633Sdfr	timeout(tbf_reprocess_q, (caddr_t)vifp, TBF_REPROCESS);
1864177633Sdfr}
1865177633Sdfr
1866177633Sdfr/* function that will selectively discard a member of the queue
1867177633Sdfr * based on the precedence value and the priority
1868180025Sdfr */
1869180025Sdfrstatic int
1870180025Sdfrtbf_dq_sel(vifp, ip)
1871180025Sdfr    register struct vif *vifp;
1872177633Sdfr    register struct ip *ip;
1873177633Sdfr{
1874180025Sdfr    register int s = splnet();
1875177633Sdfr    register u_int p;
1876180025Sdfr    register struct mbuf *m, *last;
1877177633Sdfr    register struct mbuf **np;
1878177633Sdfr    register struct tbf *t = vifp->v_tbf;
1879177633Sdfr
1880177633Sdfr    p = priority(vifp, ip);
1881177633Sdfr
1882177633Sdfr    np = &t->tbf_q;
1883177633Sdfr    last = NULL;
1884177633Sdfr    while ((m = *np) != NULL) {
1885180025Sdfr	if (p > priority(vifp, mtod(m, struct ip *))) {
1886177633Sdfr	    *np = m->m_act;
1887180025Sdfr	    /* If we're removing the last packet, fix the tail pointer */
1888180025Sdfr	    if (m == t->tbf_t)
1889177633Sdfr		t->tbf_t = last;
1890177633Sdfr	    m_freem(m);
1891180025Sdfr	    /* it's impossible for the queue to be empty, but
1892177633Sdfr	     * we check anyway. */
1893177633Sdfr	    if (--t->tbf_q_len == 0)
1894177633Sdfr		t->tbf_t = NULL;
1895177633Sdfr	    splx(s);
1896177633Sdfr	    mrtstat.mrts_drop_sel++;
1897177633Sdfr	    return(1);
1898179488Sdfr	}
1899179488Sdfr	np = &m->m_act;
1900179488Sdfr	last = m;
1901179488Sdfr    }
1902179488Sdfr    splx(s);
1903179488Sdfr    return(0);
1904180025Sdfr}
1905179488Sdfr
1906179488Sdfrstatic void
1907177633Sdfrtbf_send_packet(vifp, m)
1908177633Sdfr    register struct vif *vifp;
1909177633Sdfr    register struct mbuf *m;
1910177633Sdfr{
1911177633Sdfr    struct ip_moptions imo;
1912177633Sdfr    int error;
1913177633Sdfr    int s = splnet();
1914177633Sdfr
1915180025Sdfr    if (vifp->v_flags & VIFF_TUNNEL) {
1916177633Sdfr	/* If tunnel options */
1917177633Sdfr	ip_output(m, (struct mbuf *)0, (struct route *)0,
1918177633Sdfr		  IP_FORWARDING, (struct ip_moptions *)0);
1919177633Sdfr    } else {
1920177633Sdfr	imo.imo_multicast_ifp  = vifp->v_ifp;
1921177633Sdfr	imo.imo_multicast_ttl  = mtod(m, struct ip *)->ip_ttl - 1;
1922177633Sdfr	imo.imo_multicast_loop = 1;
1923177633Sdfr	imo.imo_multicast_vif  = -1;
1924177633Sdfr
1925177633Sdfr	error = ip_output(m, (struct mbuf *)0, (struct route *)0,
1926177633Sdfr			  IP_FORWARDING, &imo);
1927177633Sdfr
1928177633Sdfr	if (mrtdebug & DEBUG_XMIT)
1929177633Sdfr	    log(LOG_DEBUG, "phyint_send on vif %d err %d\n",
1930177633Sdfr		vifp - viftable, error);
1931177633Sdfr    }
1932177633Sdfr    splx(s);
1933177633Sdfr}
1934177633Sdfr
1935180025Sdfr/* determine the current time and then
1936177633Sdfr * the elapsed time (between the last time and time now)
1937177633Sdfr * in milliseconds & update the no. of tokens in the bucket
1938177633Sdfr */
1939177633Sdfrstatic void
1940180025Sdfrtbf_update_tokens(vifp)
1941180025Sdfr    register struct vif *vifp;
1942177633Sdfr{
1943177633Sdfr    struct timeval tp;
1944177633Sdfr    register u_long tm;
1945177633Sdfr    register int s = splnet();
1946177633Sdfr    register struct tbf *t = vifp->v_tbf;
1947177633Sdfr
1948177633Sdfr    GET_TIME(tp);
1949177633Sdfr
1950177633Sdfr    TV_DELTA(tp, t->tbf_last_pkt_t, tm);
1951177633Sdfr
1952177633Sdfr    /*
1953177633Sdfr     * This formula is actually
1954177633Sdfr     * "time in seconds" * "bytes/second".
1955177633Sdfr     *
1956177633Sdfr     * (tm / 1000000) * (v_rate_limit * 1000 * (1000/1024) / 8)
1957177633Sdfr     *
1958177633Sdfr     * The (1000/1024) was introduced in add_vif to optimize
1959177633Sdfr     * this divide into a shift.
1960177633Sdfr     */
1961177633Sdfr    t->tbf_n_tok += tm * vifp->v_rate_limit / 1024 / 8;
1962177633Sdfr    t->tbf_last_pkt_t = tp;
1963180025Sdfr
1964177633Sdfr    if (t->tbf_n_tok > MAX_BKT_SIZE)
1965177633Sdfr	t->tbf_n_tok = MAX_BKT_SIZE;
1966177633Sdfr
1967177633Sdfr    splx(s);
1968177633Sdfr}
1969177633Sdfr
1970177633Sdfrstatic int
1971177633Sdfrpriority(vifp, ip)
1972177633Sdfr    register struct vif *vifp;
1973177633Sdfr    register struct ip *ip;
1974180025Sdfr{
1975177633Sdfr    register int prio;
1976177633Sdfr
1977177633Sdfr    /* temporary hack; may add general packet classifier some day */
1978177633Sdfr
1979177633Sdfr    /*
1980177633Sdfr     * The UDP port space is divided up into four priority ranges:
1981177633Sdfr     * [0, 16384)     : unclassified - lowest priority
1982177633Sdfr     * [16384, 32768) : audio - highest priority
1983177633Sdfr     * [32768, 49152) : whiteboard - medium priority
1984177633Sdfr     * [49152, 65536) : video - low priority
1985177633Sdfr     */
1986177633Sdfr    if (ip->ip_p == IPPROTO_UDP) {
1987177633Sdfr	struct udphdr *udp = (struct udphdr *)(((char *)ip) + (ip->ip_hl << 2));
1988177633Sdfr	switch (ntohs(udp->uh_dport) & 0xc000) {
1989177633Sdfr	    case 0x4000:
1990177633Sdfr		prio = 70;
1991177633Sdfr		break;
1992177633Sdfr	    case 0x8000:
1993177633Sdfr		prio = 60;
1994177633Sdfr		break;
1995177633Sdfr	    case 0xc000:
1996177633Sdfr		prio = 55;
1997177633Sdfr		break;
1998177633Sdfr	    default:
1999177633Sdfr		prio = 50;
2000177633Sdfr		break;
2001177633Sdfr	}
2002177633Sdfr	if (tbfdebug > 1)
2003177633Sdfr		log(LOG_DEBUG, "port %x prio%d\n", ntohs(udp->uh_dport), prio);
2004177633Sdfr    } else {
2005177633Sdfr	    prio = 50;
2006177633Sdfr    }
2007177633Sdfr    return prio;
2008177633Sdfr}
2009177633Sdfr
2010180025Sdfr/*
2011177633Sdfr * End of token bucket filter modifications
2012177633Sdfr */
2013177633Sdfr
2014177633Sdfrint
2015177633Sdfrip_rsvp_vif_init(so, m)
2016177633Sdfr    struct socket *so;
2017177633Sdfr    struct mbuf *m;
2018177633Sdfr{
2019177633Sdfr    int i;
2020177633Sdfr    register int s;
2021177633Sdfr
2022177633Sdfr    if (rsvpdebug)
2023177633Sdfr	printf("ip_rsvp_vif_init: so_type = %d, pr_protocol = %d\n",
2024177633Sdfr	       so->so_type, so->so_proto->pr_protocol);
2025177633Sdfr
2026177633Sdfr    if (so->so_type != SOCK_RAW || so->so_proto->pr_protocol != IPPROTO_RSVP)
2027177633Sdfr	return EOPNOTSUPP;
2028177633Sdfr
2029177633Sdfr    /* Check mbuf. */
2030177633Sdfr    if (m == NULL || m->m_len != sizeof(int)) {
2031177633Sdfr	return EINVAL;
2032177633Sdfr    }
2033177633Sdfr    i = *(mtod(m, int *));
2034177633Sdfr
2035177633Sdfr    if (rsvpdebug)
2036177633Sdfr	printf("ip_rsvp_vif_init: vif = %d rsvp_on = %d\n",i,rsvp_on);
2037177633Sdfr
2038177633Sdfr    s = splnet();
2039177633Sdfr
2040177633Sdfr    /* Check vif. */
2041177633Sdfr    if (!legal_vif_num(i)) {
2042177633Sdfr	splx(s);
2043177633Sdfr	return EADDRNOTAVAIL;
2044177633Sdfr    }
2045177633Sdfr
2046177633Sdfr    /* Check if socket is available. */
2047177633Sdfr    if (viftable[i].v_rsvpd != NULL) {
2048177633Sdfr	splx(s);
2049177633Sdfr	return EADDRINUSE;
2050177633Sdfr    }
2051180025Sdfr
2052180025Sdfr    viftable[i].v_rsvpd = so;
2053180025Sdfr    /* This may seem silly, but we need to be sure we don't over-increment
2054180025Sdfr     * the RSVP counter, in case something slips up.
2055177633Sdfr     */
2056177633Sdfr    if (!viftable[i].v_rsvp_on) {
2057180025Sdfr	viftable[i].v_rsvp_on = 1;
2058180025Sdfr	rsvp_on++;
2059180025Sdfr    }
2060177633Sdfr
2061177633Sdfr    splx(s);
2062177633Sdfr    return 0;
2063177633Sdfr}
2064177633Sdfr
2065177633Sdfrint
2066177633Sdfrip_rsvp_vif_done(so, m)
2067177633Sdfr    struct socket *so;
2068177633Sdfr    struct mbuf *m;
2069180025Sdfr{
2070177633Sdfr	int i;
2071180025Sdfr	register int s;
2072180025Sdfr
2073177633Sdfr    if (rsvpdebug)
2074177633Sdfr	printf("ip_rsvp_vif_done: so_type = %d, pr_protocol = %d\n",
2075180025Sdfr	       so->so_type, so->so_proto->pr_protocol);
2076177633Sdfr
2077177633Sdfr    if (so->so_type != SOCK_RAW || so->so_proto->pr_protocol != IPPROTO_RSVP)
2078177633Sdfr	return EOPNOTSUPP;
2079177633Sdfr
2080177633Sdfr    /* Check mbuf. */
2081177633Sdfr    if (m == NULL || m->m_len != sizeof(int)) {
2082177633Sdfr	    return EINVAL;
2083177633Sdfr    }
2084177633Sdfr    i = *(mtod(m, int *));
2085177633Sdfr
2086177633Sdfr    s = splnet();
2087177633Sdfr
2088177633Sdfr    /* Check vif. */
2089177633Sdfr    if (!legal_vif_num(i)) {
2090180025Sdfr	splx(s);
2091177633Sdfr        return EADDRNOTAVAIL;
2092177633Sdfr    }
2093177633Sdfr
2094177633Sdfr    if (rsvpdebug)
2095177633Sdfr	printf("ip_rsvp_vif_done: v_rsvpd = %p so = %p\n",
2096177633Sdfr	       viftable[i].v_rsvpd, so);
2097177633Sdfr
2098177633Sdfr    viftable[i].v_rsvpd = NULL;
2099177633Sdfr    /* This may seem silly, but we need to be sure we don't over-decrement
2100177633Sdfr     * the RSVP counter, in case something slips up.
2101177633Sdfr     */
2102177633Sdfr    if (viftable[i].v_rsvp_on) {
2103177633Sdfr	viftable[i].v_rsvp_on = 0;
2104177633Sdfr	rsvp_on--;
2105177633Sdfr    }
2106177633Sdfr
2107177633Sdfr    splx(s);
2108177633Sdfr    return 0;
2109177633Sdfr}
2110177633Sdfr
2111177633Sdfrvoid
2112177633Sdfrip_rsvp_force_done(so)
2113177633Sdfr    struct socket *so;
2114177633Sdfr{
2115177633Sdfr    int vifi;
2116177633Sdfr    register int s;
2117177633Sdfr
2118177633Sdfr    /* Don't bother if it is not the right type of socket. */
2119177633Sdfr    if (so->so_type != SOCK_RAW || so->so_proto->pr_protocol != IPPROTO_RSVP)
2120177633Sdfr	return;
2121177633Sdfr
2122177633Sdfr    s = splnet();
2123177633Sdfr
2124177633Sdfr    /* The socket may be attached to more than one vif...this
2125177633Sdfr     * is perfectly legal.
2126177633Sdfr     */
2127177633Sdfr    for (vifi = 0; vifi < numvifs; vifi++) {
2128177633Sdfr	if (viftable[vifi].v_rsvpd == so) {
2129177633Sdfr	    viftable[vifi].v_rsvpd = NULL;
2130177633Sdfr	    /* This may seem silly, but we need to be sure we don't
2131177633Sdfr	     * over-decrement the RSVP counter, in case something slips up.
2132177633Sdfr	     */
2133177633Sdfr	    if (viftable[vifi].v_rsvp_on) {
2134177633Sdfr		viftable[vifi].v_rsvp_on = 0;
2135177633Sdfr		rsvp_on--;
2136177633Sdfr	    }
2137177633Sdfr	}
2138177633Sdfr    }
2139177633Sdfr
2140177633Sdfr    splx(s);
2141177633Sdfr    return;
2142180025Sdfr}
2143180025Sdfr
2144180025Sdfrvoid
2145180025Sdfrrsvp_input(m, iphlen)
2146177633Sdfr	struct mbuf *m;
2147177633Sdfr	int iphlen;
2148180025Sdfr{
2149180025Sdfr    int vifi;
2150180025Sdfr    register struct ip *ip = mtod(m, struct ip *);
2151177633Sdfr    static struct sockaddr_in rsvp_src = { sizeof rsvp_src, AF_INET };
2152177633Sdfr    register int s;
2153177633Sdfr    struct ifnet *ifp;
2154177633Sdfr
2155177633Sdfr    if (rsvpdebug)
2156177633Sdfr	printf("rsvp_input: rsvp_on %d\n",rsvp_on);
2157177633Sdfr
2158177633Sdfr    /* Can still get packets with rsvp_on = 0 if there is a local member
2159180025Sdfr     * of the group to which the RSVP packet is addressed.  But in this
2160177633Sdfr     * case we want to throw the packet away.
2161180025Sdfr     */
2162180025Sdfr    if (!rsvp_on) {
2163177633Sdfr	m_freem(m);
2164177633Sdfr	return;
2165180025Sdfr    }
2166177633Sdfr
2167177633Sdfr    /* If the old-style non-vif-associated socket is set, then use
2168177633Sdfr     * it and ignore the new ones.
2169177633Sdfr     */
2170177633Sdfr    if (ip_rsvpd != NULL) {
2171177633Sdfr	if (rsvpdebug)
2172177633Sdfr	    printf("rsvp_input: Sending packet up old-style socket\n");
2173177633Sdfr	rip_input(m);
2174177633Sdfr	return;
2175177633Sdfr    }
2176177633Sdfr
2177177633Sdfr    s = splnet();
2178177633Sdfr
2179177633Sdfr    if (rsvpdebug)
2180180025Sdfr	printf("rsvp_input: check vifs\n");
2181177633Sdfr
2182177633Sdfr#ifdef DIAGNOSTIC
2183177633Sdfr    if (!(m->m_flags & M_PKTHDR))
2184177633Sdfr	    panic("rsvp_input no hdr");
2185177633Sdfr#endif
2186177633Sdfr
2187177633Sdfr    ifp = m->m_pkthdr.rcvif;
2188177633Sdfr    /* Find which vif the packet arrived on. */
2189177633Sdfr    for (vifi = 0; vifi < numvifs; vifi++) {
2190177633Sdfr	if (viftable[vifi].v_ifp == ifp)
2191177633Sdfr 		break;
2192177633Sdfr 	}
2193177633Sdfr
2194177633Sdfr    if (vifi == numvifs) {
2195177633Sdfr	/* Can't find vif packet arrived on. Drop packet. */
2196177633Sdfr	if (rsvpdebug)
2197177633Sdfr	    printf("rsvp_input: Can't find vif for packet...dropping it.\n");
2198177633Sdfr	m_freem(m);
2199177633Sdfr	splx(s);
2200177633Sdfr	return;
2201177633Sdfr    }
2202177633Sdfr
2203177633Sdfr    if (rsvpdebug)
2204177633Sdfr	printf("rsvp_input: check socket\n");
2205180025Sdfr
2206180025Sdfr    if (viftable[vifi].v_rsvpd == NULL) {
2207180025Sdfr	/* drop packet, since there is no specific socket for this
2208180025Sdfr	 * interface */
2209180025Sdfr	    if (rsvpdebug)
2210177633Sdfr		    printf("rsvp_input: No socket defined for vif %d\n",vifi);
2211180025Sdfr	    m_freem(m);
2212180025Sdfr	    splx(s);
2213180025Sdfr	    return;
2214180025Sdfr    }
2215180025Sdfr    rsvp_src.sin_addr = ip->ip_src;
2216180025Sdfr
2217180025Sdfr    if (rsvpdebug && m)
2218180025Sdfr	printf("rsvp_input: m->m_len = %d, sbspace() = %ld\n",
2219180025Sdfr	       m->m_len,sbspace(&(viftable[vifi].v_rsvpd->so_rcv)));
2220180025Sdfr
2221180025Sdfr    if (socket_send(viftable[vifi].v_rsvpd, m, &rsvp_src) < 0)
2222180025Sdfr	if (rsvpdebug)
2223180025Sdfr	    printf("rsvp_input: Failed to append to socket\n");
2224180025Sdfr    else
2225180025Sdfr	if (rsvpdebug)
2226180025Sdfr	    printf("rsvp_input: send packet up\n");
2227180025Sdfr
2228180025Sdfr    splx(s);
2229180025Sdfr}
2230180025Sdfr
2231180025Sdfr#ifdef MROUTE_LKM
2232180025Sdfr#include <sys/conf.h>
2233180025Sdfr#include <sys/exec.h>
2234180025Sdfr#include <sys/sysent.h>
2235180025Sdfr#include <sys/lkm.h>
2236180025Sdfr
2237180025SdfrMOD_MISC("ip_mroute_mod")
2238180025Sdfr
2239180025Sdfrstatic int
2240180025Sdfrip_mroute_mod_handle(struct lkm_table *lkmtp, int cmd)
2241180025Sdfr{
2242180025Sdfr	int i;
2243180025Sdfr	struct lkm_misc	*args = lkmtp->private.lkm_misc;
2244180025Sdfr	int err = 0;
2245180025Sdfr
2246180025Sdfr	switch(cmd) {
2247180025Sdfr		static int (*old_ip_mrouter_cmd)();
2248180025Sdfr		static int (*old_ip_mrouter_done)();
2249180025Sdfr		static int (*old_ip_mforward)();
2250180025Sdfr		static int (*old_mrt_ioctl)();
2251180025Sdfr		static void (*old_proto4_input)();
2252180025Sdfr		static int (*old_legal_vif_num)();
2253177633Sdfr		extern struct protosw inetsw[];
2254177633Sdfr
2255177633Sdfr	case LKM_E_LOAD:
2256177633Sdfr		if(lkmexists(lkmtp) || ip_mrtproto)
2257177633Sdfr		  return(EEXIST);
2258177633Sdfr		old_ip_mrouter_cmd = ip_mrouter_cmd;
2259177633Sdfr		ip_mrouter_cmd = X_ip_mrouter_cmd;
2260177633Sdfr		old_ip_mrouter_done = ip_mrouter_done;
2261177633Sdfr		ip_mrouter_done = X_ip_mrouter_done;
2262180025Sdfr		old_ip_mforward = ip_mforward;
2263177633Sdfr		ip_mforward = X_ip_mforward;
2264177633Sdfr		old_mrt_ioctl = mrt_ioctl;
2265177633Sdfr		mrt_ioctl = X_mrt_ioctl;
2266177633Sdfr              old_proto4_input = inetsw[ip_protox[ENCAP_PROTO]].pr_input;
2267177662Sdfr              inetsw[ip_protox[ENCAP_PROTO]].pr_input = X_ipip_input;
2268177662Sdfr		old_legal_vif_num = legal_vif_num;
2269177662Sdfr		legal_vif_num = X_legal_vif_num;
2270177662Sdfr		ip_mrtproto = IGMP_DVMRP;
2271177662Sdfr
2272177662Sdfr		printf("\nIP multicast routing loaded\n");
2273177662Sdfr		break;
2274177662Sdfr
2275177662Sdfr	case LKM_E_UNLOAD:
2276177662Sdfr		if (ip_mrouter)
2277177662Sdfr		  return EINVAL;
2278177662Sdfr
2279177662Sdfr		ip_mrouter_cmd = old_ip_mrouter_cmd;
2280177662Sdfr		ip_mrouter_done = old_ip_mrouter_done;
2281177662Sdfr		ip_mforward = old_ip_mforward;
2282177662Sdfr		mrt_ioctl = old_mrt_ioctl;
2283177662Sdfr              inetsw[ip_protox[ENCAP_PROTO]].pr_input = old_proto4_input;
2284180217Sdfr		legal_vif_num = old_legal_vif_num;
2285177662Sdfr		ip_mrtproto = 0;
2286		break;
2287
2288	default:
2289		err = EINVAL;
2290		break;
2291	}
2292
2293	return(err);
2294}
2295
2296int
2297ip_mroute_mod(struct lkm_table *lkmtp, int cmd, int ver) {
2298	DISPATCH(lkmtp, cmd, ver, ip_mroute_mod_handle, ip_mroute_mod_handle,
2299		 nosys);
2300}
2301
2302#endif /* MROUTE_LKM */
2303#endif /* MROUTING */
2304