1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 1988, 1991, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
|
|
* must display the following acknowledgement:
|
|
|
|
* This product includes software developed by the University of
|
|
|
|
* California, Berkeley and its contributors.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
2001-10-17 11:23:59 +00:00
|
|
|
* @(#)rtsock.c 8.7 (Berkeley) 10/12/95
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
1997-04-27 20:01:29 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
2002-04-30 01:54:54 +00:00
|
|
|
#include <sys/domain.h>
|
1995-05-11 00:13:26 +00:00
|
|
|
#include <sys/kernel.h>
|
2002-04-30 01:54:54 +00:00
|
|
|
#include <sys/jail.h>
|
1997-09-02 01:19:47 +00:00
|
|
|
#include <sys/malloc.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/mbuf.h>
|
2002-04-30 01:54:54 +00:00
|
|
|
#include <sys/proc.h>
|
|
|
|
#include <sys/protosw.h>
|
|
|
|
#include <sys/signalvar.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/socketvar.h>
|
2002-04-30 01:54:54 +00:00
|
|
|
#include <sys/sysctl.h>
|
|
|
|
#include <sys/systm.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
#include <net/if.h>
|
|
|
|
#include <net/raw_cb.h>
|
2002-04-30 01:54:54 +00:00
|
|
|
#include <net/route.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1997-10-12 20:26:33 +00:00
|
|
|
MALLOC_DEFINE(M_RTABLE, "routetbl", "routing tables");
|
|
|
|
|
1995-11-16 19:00:27 +00:00
|
|
|
static struct sockaddr route_dst = { 2, PF_ROUTE, };
|
|
|
|
static struct sockaddr route_src = { 2, PF_ROUTE, };
|
1997-07-18 11:44:24 +00:00
|
|
|
static struct sockaddr sa_zero = { sizeof(sa_zero), AF_INET, };
|
1995-11-16 19:00:27 +00:00
|
|
|
static struct sockproto route_proto = { PF_ROUTE, };
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
struct walkarg {
|
1995-11-16 19:00:27 +00:00
|
|
|
int w_tmemsize;
|
|
|
|
int w_op, w_arg;
|
|
|
|
caddr_t w_tmem;
|
|
|
|
struct sysctl_req *w_req;
|
1994-05-24 10:09:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct mbuf *
|
2002-03-19 21:54:18 +00:00
|
|
|
rt_msg1(int, struct rt_addrinfo *);
|
|
|
|
static int rt_msg2(int, struct rt_addrinfo *, caddr_t, struct walkarg *);
|
|
|
|
static int rt_xaddrs(caddr_t, caddr_t, struct rt_addrinfo *);
|
|
|
|
static int sysctl_dumpentry(struct radix_node *rn, void *vw);
|
|
|
|
static int sysctl_iflist(int af, struct walkarg *w);
|
|
|
|
static int route_output(struct mbuf *, struct socket *);
|
|
|
|
static void rt_setmetrics(u_long, struct rt_metrics *, struct rt_metrics *);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/* Sleazy use of local variables throughout file, warning!!!! */
|
|
|
|
#define dst info.rti_info[RTAX_DST]
|
|
|
|
#define gate info.rti_info[RTAX_GATEWAY]
|
|
|
|
#define netmask info.rti_info[RTAX_NETMASK]
|
|
|
|
#define genmask info.rti_info[RTAX_GENMASK]
|
|
|
|
#define ifpaddr info.rti_info[RTAX_IFP]
|
|
|
|
#define ifaaddr info.rti_info[RTAX_IFA]
|
|
|
|
#define brdaddr info.rti_info[RTAX_BRD]
|
|
|
|
|
1997-04-27 20:01:29 +00:00
|
|
|
/*
|
|
|
|
* It really doesn't make any sense at all for this code to share much
|
|
|
|
* with raw_usrreq.c, since its functionality is so restricted. XXX
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
rts_abort(struct socket *so)
|
|
|
|
{
|
|
|
|
int s, error;
|
|
|
|
s = splnet();
|
|
|
|
error = raw_usrreqs.pru_abort(so);
|
|
|
|
splx(s);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* pru_accept is EOPNOTSUPP */
|
|
|
|
|
1995-11-16 19:00:27 +00:00
|
|
|
static int
|
2001-09-12 08:38:13 +00:00
|
|
|
rts_attach(struct socket *so, int proto, struct thread *td)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1997-04-27 20:01:29 +00:00
|
|
|
struct rawcb *rp;
|
|
|
|
int s, error;
|
|
|
|
|
|
|
|
if (sotorawcb(so) != 0)
|
|
|
|
return EISCONN; /* XXX panic? */
|
2000-12-08 21:51:06 +00:00
|
|
|
/* XXX */
|
|
|
|
MALLOC(rp, struct rawcb *, sizeof *rp, M_PCB, M_WAITOK | M_ZERO);
|
1997-04-27 20:01:29 +00:00
|
|
|
if (rp == 0)
|
|
|
|
return ENOBUFS;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The splnet() is necessary to block protocols from sending
|
|
|
|
* error notifications (like RTM_REDIRECT or RTM_LOSING) while
|
|
|
|
* this PCB is extant but incompletely initialized.
|
|
|
|
* Probably we should try to do more of this work beforehand and
|
|
|
|
* eliminate the spl.
|
|
|
|
*/
|
|
|
|
s = splnet();
|
|
|
|
so->so_pcb = (caddr_t)rp;
|
2001-08-31 12:31:09 +00:00
|
|
|
error = raw_attach(so, proto);
|
1997-04-27 20:01:29 +00:00
|
|
|
rp = sotorawcb(so);
|
|
|
|
if (error) {
|
|
|
|
splx(s);
|
2001-08-02 19:56:29 +00:00
|
|
|
so->so_pcb = NULL;
|
1997-04-27 20:01:29 +00:00
|
|
|
free(rp, M_PCB);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
switch(rp->rcb_proto.sp_protocol) {
|
|
|
|
case AF_INET:
|
|
|
|
route_cb.ip_count++;
|
|
|
|
break;
|
2000-01-28 20:10:51 +00:00
|
|
|
case AF_INET6:
|
|
|
|
route_cb.ip6_count++;
|
|
|
|
break;
|
1997-04-27 20:01:29 +00:00
|
|
|
case AF_IPX:
|
|
|
|
route_cb.ipx_count++;
|
|
|
|
break;
|
|
|
|
case AF_NS:
|
|
|
|
route_cb.ns_count++;
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1997-04-27 20:01:29 +00:00
|
|
|
rp->rcb_faddr = &route_src;
|
|
|
|
route_cb.any_count++;
|
2002-06-18 07:42:02 +00:00
|
|
|
soisconnected(so);
|
1997-04-27 20:01:29 +00:00
|
|
|
so->so_options |= SO_USELOOPBACK;
|
|
|
|
splx(s);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2001-09-12 08:38:13 +00:00
|
|
|
rts_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
|
1997-04-27 20:01:29 +00:00
|
|
|
{
|
|
|
|
int s, error;
|
|
|
|
s = splnet();
|
2001-09-12 08:38:13 +00:00
|
|
|
error = raw_usrreqs.pru_bind(so, nam, td); /* xxx just EINVAL */
|
1997-04-27 20:01:29 +00:00
|
|
|
splx(s);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2001-09-12 08:38:13 +00:00
|
|
|
rts_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
|
1997-04-27 20:01:29 +00:00
|
|
|
{
|
|
|
|
int s, error;
|
|
|
|
s = splnet();
|
2001-09-12 08:38:13 +00:00
|
|
|
error = raw_usrreqs.pru_connect(so, nam, td); /* XXX just EINVAL */
|
1997-04-27 20:01:29 +00:00
|
|
|
splx(s);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* pru_connect2 is EOPNOTSUPP */
|
|
|
|
/* pru_control is EOPNOTSUPP */
|
|
|
|
|
|
|
|
static int
|
|
|
|
rts_detach(struct socket *so)
|
|
|
|
{
|
|
|
|
struct rawcb *rp = sotorawcb(so);
|
|
|
|
int s, error;
|
|
|
|
|
|
|
|
s = splnet();
|
|
|
|
if (rp != 0) {
|
|
|
|
switch(rp->rcb_proto.sp_protocol) {
|
|
|
|
case AF_INET:
|
1994-05-24 10:09:53 +00:00
|
|
|
route_cb.ip_count--;
|
1997-04-27 20:01:29 +00:00
|
|
|
break;
|
2000-01-28 20:10:51 +00:00
|
|
|
case AF_INET6:
|
|
|
|
route_cb.ip6_count--;
|
|
|
|
break;
|
1997-04-27 20:01:29 +00:00
|
|
|
case AF_IPX:
|
1995-10-26 20:31:59 +00:00
|
|
|
route_cb.ipx_count--;
|
1997-04-27 20:01:29 +00:00
|
|
|
break;
|
|
|
|
case AF_NS:
|
1994-05-24 10:09:53 +00:00
|
|
|
route_cb.ns_count--;
|
1997-04-27 20:01:29 +00:00
|
|
|
break;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
route_cb.any_count--;
|
|
|
|
}
|
1997-04-27 20:01:29 +00:00
|
|
|
error = raw_usrreqs.pru_detach(so);
|
|
|
|
splx(s);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
rts_disconnect(struct socket *so)
|
|
|
|
{
|
|
|
|
int s, error;
|
1994-05-24 10:09:53 +00:00
|
|
|
s = splnet();
|
1997-04-27 20:01:29 +00:00
|
|
|
error = raw_usrreqs.pru_disconnect(so);
|
1994-05-24 10:09:53 +00:00
|
|
|
splx(s);
|
1997-04-27 20:01:29 +00:00
|
|
|
return error;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1997-04-27 20:01:29 +00:00
|
|
|
/* pru_listen is EOPNOTSUPP */
|
|
|
|
|
|
|
|
static int
|
1997-08-16 19:16:27 +00:00
|
|
|
rts_peeraddr(struct socket *so, struct sockaddr **nam)
|
1997-04-27 20:01:29 +00:00
|
|
|
{
|
|
|
|
int s, error;
|
|
|
|
s = splnet();
|
|
|
|
error = raw_usrreqs.pru_peeraddr(so, nam);
|
|
|
|
splx(s);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* pru_rcvd is EOPNOTSUPP */
|
|
|
|
/* pru_rcvoob is EOPNOTSUPP */
|
|
|
|
|
|
|
|
static int
|
1997-08-16 19:16:27 +00:00
|
|
|
rts_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam,
|
2001-09-12 08:38:13 +00:00
|
|
|
struct mbuf *control, struct thread *td)
|
1997-04-27 20:01:29 +00:00
|
|
|
{
|
|
|
|
int s, error;
|
|
|
|
s = splnet();
|
2001-09-12 08:38:13 +00:00
|
|
|
error = raw_usrreqs.pru_send(so, flags, m, nam, control, td);
|
1997-04-27 20:01:29 +00:00
|
|
|
splx(s);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* pru_sense is null */
|
|
|
|
|
|
|
|
static int
|
|
|
|
rts_shutdown(struct socket *so)
|
|
|
|
{
|
|
|
|
int s, error;
|
|
|
|
s = splnet();
|
|
|
|
error = raw_usrreqs.pru_shutdown(so);
|
|
|
|
splx(s);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
1997-08-16 19:16:27 +00:00
|
|
|
rts_sockaddr(struct socket *so, struct sockaddr **nam)
|
1997-04-27 20:01:29 +00:00
|
|
|
{
|
|
|
|
int s, error;
|
|
|
|
s = splnet();
|
|
|
|
error = raw_usrreqs.pru_sockaddr(so, nam);
|
|
|
|
splx(s);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct pr_usrreqs route_usrreqs = {
|
|
|
|
rts_abort, pru_accept_notsupp, rts_attach, rts_bind, rts_connect,
|
|
|
|
pru_connect2_notsupp, pru_control_notsupp, rts_detach, rts_disconnect,
|
|
|
|
pru_listen_notsupp, rts_peeraddr, pru_rcvd_notsupp, pru_rcvoob_notsupp,
|
|
|
|
rts_send, pru_sense_null, rts_shutdown, rts_sockaddr,
|
1997-09-14 03:10:42 +00:00
|
|
|
sosend, soreceive, sopoll
|
1997-04-27 20:01:29 +00:00
|
|
|
};
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*ARGSUSED*/
|
1995-11-16 19:00:27 +00:00
|
|
|
static int
|
1994-05-24 10:09:53 +00:00
|
|
|
route_output(m, so)
|
|
|
|
register struct mbuf *m;
|
|
|
|
struct socket *so;
|
|
|
|
{
|
|
|
|
register struct rt_msghdr *rtm = 0;
|
|
|
|
register struct rtentry *rt = 0;
|
|
|
|
struct rtentry *saved_nrt = 0;
|
1995-05-10 16:48:52 +00:00
|
|
|
struct radix_node_head *rnh;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct rt_addrinfo info;
|
|
|
|
int len, error = 0;
|
|
|
|
struct ifnet *ifp = 0;
|
|
|
|
struct ifaddr *ifa = 0;
|
|
|
|
|
|
|
|
#define senderr(e) { error = e; goto flush;}
|
|
|
|
if (m == 0 || ((m->m_len < sizeof(long)) &&
|
|
|
|
(m = m_pullup(m, sizeof(long))) == 0))
|
|
|
|
return (ENOBUFS);
|
|
|
|
if ((m->m_flags & M_PKTHDR) == 0)
|
|
|
|
panic("route_output");
|
|
|
|
len = m->m_pkthdr.len;
|
|
|
|
if (len < sizeof(*rtm) ||
|
|
|
|
len != mtod(m, struct rt_msghdr *)->rtm_msglen) {
|
|
|
|
dst = 0;
|
|
|
|
senderr(EINVAL);
|
|
|
|
}
|
|
|
|
R_Malloc(rtm, struct rt_msghdr *, len);
|
|
|
|
if (rtm == 0) {
|
|
|
|
dst = 0;
|
|
|
|
senderr(ENOBUFS);
|
|
|
|
}
|
|
|
|
m_copydata(m, 0, len, (caddr_t)rtm);
|
|
|
|
if (rtm->rtm_version != RTM_VERSION) {
|
|
|
|
dst = 0;
|
|
|
|
senderr(EPROTONOSUPPORT);
|
|
|
|
}
|
|
|
|
rtm->rtm_pid = curproc->p_pid;
|
2001-10-17 18:07:05 +00:00
|
|
|
bzero(&info, sizeof(info));
|
1994-05-24 10:09:53 +00:00
|
|
|
info.rti_addrs = rtm->rtm_addrs;
|
1997-07-18 11:44:24 +00:00
|
|
|
if (rt_xaddrs((caddr_t)(rtm + 1), len + (caddr_t)rtm, &info)) {
|
|
|
|
dst = 0;
|
|
|
|
senderr(EINVAL);
|
|
|
|
}
|
2001-10-17 18:07:05 +00:00
|
|
|
info.rti_flags = rtm->rtm_flags;
|
1995-10-13 16:01:59 +00:00
|
|
|
if (dst == 0 || (dst->sa_family >= AF_MAX)
|
|
|
|
|| (gate != 0 && (gate->sa_family >= AF_MAX)))
|
1994-05-24 10:09:53 +00:00
|
|
|
senderr(EINVAL);
|
|
|
|
if (genmask) {
|
|
|
|
struct radix_node *t;
|
1995-05-10 16:48:52 +00:00
|
|
|
t = rn_addmask((caddr_t)genmask, 0, 1);
|
1999-12-28 08:38:01 +00:00
|
|
|
if (t && Bcmp((caddr_t *)genmask + 1, (caddr_t *)t->rn_key + 1,
|
|
|
|
*(u_char *)t->rn_key - 1) == 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
genmask = (struct sockaddr *)(t->rn_key);
|
|
|
|
else
|
|
|
|
senderr(ENOBUFS);
|
|
|
|
}
|
2001-08-31 12:31:09 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Verify that the caller has the appropriate privilege; RTM_GET
|
|
|
|
* is the only operation the non-superuser is allowed.
|
|
|
|
*/
|
2002-04-01 21:31:13 +00:00
|
|
|
if (rtm->rtm_type != RTM_GET && (error = suser(curthread)) != 0)
|
2001-09-20 08:25:25 +00:00
|
|
|
senderr(error);
|
2001-08-31 12:31:09 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
switch (rtm->rtm_type) {
|
|
|
|
|
|
|
|
case RTM_ADD:
|
|
|
|
if (gate == 0)
|
|
|
|
senderr(EINVAL);
|
2001-10-17 18:07:05 +00:00
|
|
|
error = rtrequest1(RTM_ADD, &info, &saved_nrt);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (error == 0 && saved_nrt) {
|
|
|
|
rt_setmetrics(rtm->rtm_inits,
|
|
|
|
&rtm->rtm_rmx, &saved_nrt->rt_rmx);
|
1997-10-31 08:53:13 +00:00
|
|
|
saved_nrt->rt_rmx.rmx_locks &= ~(rtm->rtm_inits);
|
|
|
|
saved_nrt->rt_rmx.rmx_locks |=
|
|
|
|
(rtm->rtm_inits & rtm->rtm_rmx.rmx_locks);
|
1994-05-24 10:09:53 +00:00
|
|
|
saved_nrt->rt_refcnt--;
|
|
|
|
saved_nrt->rt_genmask = genmask;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case RTM_DELETE:
|
2001-10-17 18:07:05 +00:00
|
|
|
error = rtrequest1(RTM_DELETE, &info, &saved_nrt);
|
1995-05-10 16:48:52 +00:00
|
|
|
if (error == 0) {
|
1995-05-15 22:57:53 +00:00
|
|
|
if ((rt = saved_nrt))
|
1995-05-10 16:48:52 +00:00
|
|
|
rt->rt_refcnt++;
|
|
|
|
goto report;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case RTM_GET:
|
|
|
|
case RTM_CHANGE:
|
|
|
|
case RTM_LOCK:
|
1995-05-10 16:48:52 +00:00
|
|
|
if ((rnh = rt_tables[dst->sa_family]) == 0) {
|
|
|
|
senderr(EAFNOSUPPORT);
|
1999-01-27 22:42:27 +00:00
|
|
|
} else if ((rt = (struct rtentry *)
|
|
|
|
rnh->rnh_lookup(dst, netmask, rnh)) != NULL)
|
1995-05-10 16:48:52 +00:00
|
|
|
rt->rt_refcnt++;
|
|
|
|
else
|
1994-05-24 10:09:53 +00:00
|
|
|
senderr(ESRCH);
|
|
|
|
switch(rtm->rtm_type) {
|
|
|
|
|
|
|
|
case RTM_GET:
|
1995-05-10 16:48:52 +00:00
|
|
|
report:
|
1994-05-24 10:09:53 +00:00
|
|
|
dst = rt_key(rt);
|
|
|
|
gate = rt->rt_gateway;
|
|
|
|
netmask = rt_mask(rt);
|
|
|
|
genmask = rt->rt_genmask;
|
|
|
|
if (rtm->rtm_addrs & (RTA_IFP | RTA_IFA)) {
|
1994-10-08 22:38:27 +00:00
|
|
|
ifp = rt->rt_ifp;
|
|
|
|
if (ifp) {
|
2001-02-03 11:46:35 +00:00
|
|
|
ifpaddr = TAILQ_FIRST(&ifp->if_addrhead)->ifa_addr;
|
1994-05-24 10:09:53 +00:00
|
|
|
ifaaddr = rt->rt_ifa->ifa_addr;
|
2001-10-17 11:23:59 +00:00
|
|
|
if (ifp->if_flags & IFF_POINTOPOINT)
|
|
|
|
brdaddr = rt->rt_ifa->ifa_dstaddr;
|
1994-05-24 10:09:53 +00:00
|
|
|
rtm->rtm_index = ifp->if_index;
|
|
|
|
} else {
|
|
|
|
ifpaddr = 0;
|
|
|
|
ifaaddr = 0;
|
2002-10-01 15:48:31 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1995-05-10 16:48:52 +00:00
|
|
|
len = rt_msg2(rtm->rtm_type, &info, (caddr_t)0,
|
1994-05-24 10:09:53 +00:00
|
|
|
(struct walkarg *)0);
|
|
|
|
if (len > rtm->rtm_msglen) {
|
|
|
|
struct rt_msghdr *new_rtm;
|
|
|
|
R_Malloc(new_rtm, struct rt_msghdr *, len);
|
|
|
|
if (new_rtm == 0)
|
|
|
|
senderr(ENOBUFS);
|
|
|
|
Bcopy(rtm, new_rtm, rtm->rtm_msglen);
|
|
|
|
Free(rtm); rtm = new_rtm;
|
|
|
|
}
|
1995-05-10 16:48:52 +00:00
|
|
|
(void)rt_msg2(rtm->rtm_type, &info, (caddr_t)rtm,
|
1994-05-24 10:09:53 +00:00
|
|
|
(struct walkarg *)0);
|
|
|
|
rtm->rtm_flags = rt->rt_flags;
|
|
|
|
rtm->rtm_rmx = rt->rt_rmx;
|
|
|
|
rtm->rtm_addrs = info.rti_addrs;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case RTM_CHANGE:
|
|
|
|
/* new gateway could require new ifaddr, ifp;
|
|
|
|
flags may also be different; ifp may be specified
|
|
|
|
by ll sockaddr when protocol address is ambiguous */
|
2002-12-22 05:35:03 +00:00
|
|
|
/* compare two sockaddr structures */
|
|
|
|
#define sa_equal(a1, a2) (bcmp((a1), (a2), (a1)->sa_len) == 0)
|
2001-12-19 16:03:27 +00:00
|
|
|
if ((rt->rt_flags & RTF_GATEWAY && gate != NULL) ||
|
|
|
|
ifpaddr != NULL ||
|
|
|
|
(ifaaddr != NULL &&
|
2002-12-22 05:35:03 +00:00
|
|
|
!sa_equal(ifaaddr, rt->rt_ifa->ifa_addr))) {
|
2001-12-19 16:03:27 +00:00
|
|
|
if ((error = rt_getifa(&info)) != 0)
|
|
|
|
senderr(error);
|
|
|
|
}
|
2001-10-17 18:07:05 +00:00
|
|
|
if (gate != NULL &&
|
|
|
|
(error = rt_setgate(rt, rt_key(rt), gate)) != 0)
|
|
|
|
senderr(error);
|
|
|
|
if ((ifa = info.rti_ifa) != NULL) {
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct ifaddr *oifa = rt->rt_ifa;
|
|
|
|
if (oifa != ifa) {
|
2002-12-18 11:46:59 +00:00
|
|
|
if (oifa) {
|
|
|
|
if (oifa->ifa_rtrequest)
|
|
|
|
oifa->ifa_rtrequest(RTM_DELETE, rt,
|
|
|
|
&info);
|
2002-12-20 11:21:07 +00:00
|
|
|
IFAFREE(oifa);
|
2002-12-18 11:46:59 +00:00
|
|
|
}
|
|
|
|
IFAREF(ifa);
|
1994-05-24 10:09:53 +00:00
|
|
|
rt->rt_ifa = ifa;
|
2001-10-17 18:07:05 +00:00
|
|
|
rt->rt_ifp = info.rti_ifp;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
rt_setmetrics(rtm->rtm_inits, &rtm->rtm_rmx,
|
|
|
|
&rt->rt_rmx);
|
|
|
|
if (rt->rt_ifa && rt->rt_ifa->ifa_rtrequest)
|
2001-10-17 18:07:05 +00:00
|
|
|
rt->rt_ifa->ifa_rtrequest(RTM_ADD, rt, &info);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (genmask)
|
|
|
|
rt->rt_genmask = genmask;
|
2002-08-25 13:23:09 +00:00
|
|
|
/* FALLTHROUGH */
|
1994-05-24 10:09:53 +00:00
|
|
|
case RTM_LOCK:
|
|
|
|
rt->rt_rmx.rmx_locks &= ~(rtm->rtm_inits);
|
|
|
|
rt->rt_rmx.rmx_locks |=
|
|
|
|
(rtm->rtm_inits & rtm->rtm_rmx.rmx_locks);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
senderr(EOPNOTSUPP);
|
|
|
|
}
|
|
|
|
|
|
|
|
flush:
|
|
|
|
if (rtm) {
|
|
|
|
if (error)
|
|
|
|
rtm->rtm_errno = error;
|
1995-05-30 08:16:23 +00:00
|
|
|
else
|
1994-05-24 10:09:53 +00:00
|
|
|
rtm->rtm_flags |= RTF_DONE;
|
|
|
|
}
|
|
|
|
if (rt)
|
|
|
|
rtfree(rt);
|
|
|
|
{
|
|
|
|
register struct rawcb *rp = 0;
|
|
|
|
/*
|
|
|
|
* Check to see if we don't want our own messages.
|
|
|
|
*/
|
|
|
|
if ((so->so_options & SO_USELOOPBACK) == 0) {
|
|
|
|
if (route_cb.any_count <= 1) {
|
|
|
|
if (rtm)
|
|
|
|
Free(rtm);
|
|
|
|
m_freem(m);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
/* There is another listener, so construct message */
|
|
|
|
rp = sotorawcb(so);
|
2002-05-31 11:52:35 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
if (rtm) {
|
|
|
|
m_copyback(m, 0, rtm->rtm_msglen, (caddr_t)rtm);
|
2001-07-04 11:29:55 +00:00
|
|
|
if (m->m_pkthdr.len < rtm->rtm_msglen) {
|
|
|
|
m_freem(m);
|
|
|
|
m = NULL;
|
|
|
|
} else if (m->m_pkthdr.len > rtm->rtm_msglen)
|
|
|
|
m_adj(m, rtm->rtm_msglen - m->m_pkthdr.len);
|
1994-05-24 10:09:53 +00:00
|
|
|
Free(rtm);
|
|
|
|
}
|
|
|
|
if (rp)
|
|
|
|
rp->rcb_proto.sp_family = 0; /* Avoid us */
|
|
|
|
if (dst)
|
|
|
|
route_proto.sp_protocol = dst->sa_family;
|
2001-07-04 11:29:55 +00:00
|
|
|
if (m)
|
|
|
|
raw_input(m, &route_proto, &route_src, &route_dst);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (rp)
|
|
|
|
rp->rcb_proto.sp_family = PF_ROUTE;
|
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1995-11-16 19:00:27 +00:00
|
|
|
static void
|
1994-05-24 10:09:53 +00:00
|
|
|
rt_setmetrics(which, in, out)
|
|
|
|
u_long which;
|
|
|
|
register struct rt_metrics *in, *out;
|
|
|
|
{
|
|
|
|
#define metric(f, e) if (which & (f)) out->e = in->e;
|
|
|
|
metric(RTV_RPIPE, rmx_recvpipe);
|
|
|
|
metric(RTV_SPIPE, rmx_sendpipe);
|
|
|
|
metric(RTV_SSTHRESH, rmx_ssthresh);
|
|
|
|
metric(RTV_RTT, rmx_rtt);
|
|
|
|
metric(RTV_RTTVAR, rmx_rttvar);
|
|
|
|
metric(RTV_HOPCOUNT, rmx_hopcount);
|
|
|
|
metric(RTV_MTU, rmx_mtu);
|
|
|
|
metric(RTV_EXPIRE, rmx_expire);
|
|
|
|
#undef metric
|
|
|
|
}
|
|
|
|
|
|
|
|
#define ROUNDUP(a) \
|
|
|
|
((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
|
|
|
|
#define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len))
|
|
|
|
|
1997-07-18 11:44:24 +00:00
|
|
|
|
1997-07-15 23:25:32 +00:00
|
|
|
/*
|
|
|
|
* Extract the addresses of the passed sockaddrs.
|
|
|
|
* Do a little sanity checking so as to avoid bad memory references.
|
1997-07-18 11:44:24 +00:00
|
|
|
* This data is derived straight from userland.
|
1997-07-15 23:25:32 +00:00
|
|
|
*/
|
1997-07-18 11:44:24 +00:00
|
|
|
static int
|
1994-05-24 10:09:53 +00:00
|
|
|
rt_xaddrs(cp, cplim, rtinfo)
|
|
|
|
register caddr_t cp, cplim;
|
|
|
|
register struct rt_addrinfo *rtinfo;
|
|
|
|
{
|
|
|
|
register struct sockaddr *sa;
|
|
|
|
register int i;
|
|
|
|
|
1997-07-18 11:44:24 +00:00
|
|
|
for (i = 0; (i < RTAX_MAX) && (cp < cplim); i++) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((rtinfo->rti_addrs & (1 << i)) == 0)
|
|
|
|
continue;
|
1997-07-16 14:55:14 +00:00
|
|
|
sa = (struct sockaddr *)cp;
|
1997-07-15 23:25:32 +00:00
|
|
|
/*
|
1997-07-18 11:44:24 +00:00
|
|
|
* It won't fit.
|
1997-07-15 23:25:32 +00:00
|
|
|
*/
|
1997-07-18 11:44:24 +00:00
|
|
|
if ( (cp + sa->sa_len) > cplim ) {
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
1997-07-17 09:21:34 +00:00
|
|
|
|
1997-07-15 23:25:32 +00:00
|
|
|
/*
|
|
|
|
* there are no more.. quit now
|
|
|
|
* If there are more bits, they are in error.
|
|
|
|
* I've seen this. route(1) can evidently generate these.
|
|
|
|
* This causes kernel to core dump.
|
1997-07-18 11:44:24 +00:00
|
|
|
* for compatibility, If we see this, point to a safe address.
|
1997-07-15 23:25:32 +00:00
|
|
|
*/
|
1997-07-18 11:44:24 +00:00
|
|
|
if (sa->sa_len == 0) {
|
|
|
|
rtinfo->rti_info[i] = &sa_zero;
|
|
|
|
return (0); /* should be EINVAL but for compat */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* accept it */
|
|
|
|
rtinfo->rti_info[i] = sa;
|
|
|
|
ADVANCE(cp, sa);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1997-07-18 11:44:24 +00:00
|
|
|
return (0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct mbuf *
|
|
|
|
rt_msg1(type, rtinfo)
|
|
|
|
int type;
|
|
|
|
register struct rt_addrinfo *rtinfo;
|
|
|
|
{
|
|
|
|
register struct rt_msghdr *rtm;
|
|
|
|
register struct mbuf *m;
|
|
|
|
register int i;
|
|
|
|
register struct sockaddr *sa;
|
|
|
|
int len, dlen;
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
|
|
|
|
case RTM_DELADDR:
|
|
|
|
case RTM_NEWADDR:
|
|
|
|
len = sizeof(struct ifa_msghdr);
|
|
|
|
break;
|
|
|
|
|
1997-01-13 21:26:53 +00:00
|
|
|
case RTM_DELMADDR:
|
|
|
|
case RTM_NEWMADDR:
|
|
|
|
len = sizeof(struct ifma_msghdr);
|
|
|
|
break;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
case RTM_IFINFO:
|
|
|
|
len = sizeof(struct if_msghdr);
|
|
|
|
break;
|
|
|
|
|
2002-01-18 14:33:04 +00:00
|
|
|
case RTM_IFANNOUNCE:
|
|
|
|
len = sizeof(struct if_announcemsghdr);
|
|
|
|
break;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
default:
|
|
|
|
len = sizeof(struct rt_msghdr);
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
if (len > MCLBYTES)
|
1994-05-24 10:09:53 +00:00
|
|
|
panic("rt_msg1");
|
2001-06-11 12:39:29 +00:00
|
|
|
m = m_gethdr(M_DONTWAIT, MT_DATA);
|
|
|
|
if (m && len > MHLEN) {
|
|
|
|
MCLGET(m, M_DONTWAIT);
|
|
|
|
if ((m->m_flags & M_EXT) == 0) {
|
|
|
|
m_free(m);
|
|
|
|
m = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (m == 0)
|
|
|
|
return (m);
|
1994-05-24 10:09:53 +00:00
|
|
|
m->m_pkthdr.len = m->m_len = len;
|
|
|
|
m->m_pkthdr.rcvif = 0;
|
|
|
|
rtm = mtod(m, struct rt_msghdr *);
|
|
|
|
bzero((caddr_t)rtm, len);
|
|
|
|
for (i = 0; i < RTAX_MAX; i++) {
|
|
|
|
if ((sa = rtinfo->rti_info[i]) == NULL)
|
|
|
|
continue;
|
|
|
|
rtinfo->rti_addrs |= (1 << i);
|
|
|
|
dlen = ROUNDUP(sa->sa_len);
|
|
|
|
m_copyback(m, len, dlen, (caddr_t)sa);
|
|
|
|
len += dlen;
|
|
|
|
}
|
|
|
|
if (m->m_pkthdr.len != len) {
|
|
|
|
m_freem(m);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
rtm->rtm_msglen = len;
|
|
|
|
rtm->rtm_version = RTM_VERSION;
|
|
|
|
rtm->rtm_type = type;
|
|
|
|
return (m);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
rt_msg2(type, rtinfo, cp, w)
|
|
|
|
int type;
|
|
|
|
register struct rt_addrinfo *rtinfo;
|
|
|
|
caddr_t cp;
|
|
|
|
struct walkarg *w;
|
|
|
|
{
|
|
|
|
register int i;
|
|
|
|
int len, dlen, second_time = 0;
|
|
|
|
caddr_t cp0;
|
|
|
|
|
|
|
|
rtinfo->rti_addrs = 0;
|
|
|
|
again:
|
|
|
|
switch (type) {
|
|
|
|
|
|
|
|
case RTM_DELADDR:
|
|
|
|
case RTM_NEWADDR:
|
|
|
|
len = sizeof(struct ifa_msghdr);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case RTM_IFINFO:
|
|
|
|
len = sizeof(struct if_msghdr);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
len = sizeof(struct rt_msghdr);
|
|
|
|
}
|
1994-10-08 22:38:27 +00:00
|
|
|
cp0 = cp;
|
|
|
|
if (cp0)
|
1994-05-24 10:09:53 +00:00
|
|
|
cp += len;
|
|
|
|
for (i = 0; i < RTAX_MAX; i++) {
|
|
|
|
register struct sockaddr *sa;
|
|
|
|
|
|
|
|
if ((sa = rtinfo->rti_info[i]) == 0)
|
|
|
|
continue;
|
|
|
|
rtinfo->rti_addrs |= (1 << i);
|
|
|
|
dlen = ROUNDUP(sa->sa_len);
|
|
|
|
if (cp) {
|
|
|
|
bcopy((caddr_t)sa, cp, (unsigned)dlen);
|
|
|
|
cp += dlen;
|
|
|
|
}
|
|
|
|
len += dlen;
|
|
|
|
}
|
2002-01-27 20:39:01 +00:00
|
|
|
len = ALIGN(len);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (cp == 0 && w != NULL && !second_time) {
|
|
|
|
register struct walkarg *rw = w;
|
|
|
|
|
1995-11-16 19:00:27 +00:00
|
|
|
if (rw->w_req) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if (rw->w_tmemsize < len) {
|
|
|
|
if (rw->w_tmem)
|
|
|
|
free(rw->w_tmem, M_RTABLE);
|
1994-10-08 22:38:27 +00:00
|
|
|
rw->w_tmem = (caddr_t)
|
|
|
|
malloc(len, M_RTABLE, M_NOWAIT);
|
|
|
|
if (rw->w_tmem)
|
1994-05-24 10:09:53 +00:00
|
|
|
rw->w_tmemsize = len;
|
|
|
|
}
|
|
|
|
if (rw->w_tmem) {
|
|
|
|
cp = rw->w_tmem;
|
|
|
|
second_time = 1;
|
|
|
|
goto again;
|
1995-11-16 19:00:27 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (cp) {
|
|
|
|
register struct rt_msghdr *rtm = (struct rt_msghdr *)cp0;
|
|
|
|
|
|
|
|
rtm->rtm_version = RTM_VERSION;
|
|
|
|
rtm->rtm_type = type;
|
|
|
|
rtm->rtm_msglen = len;
|
|
|
|
}
|
|
|
|
return (len);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This routine is called to generate a message from the routing
|
|
|
|
* socket indicating that a redirect has occured, a routing lookup
|
|
|
|
* has failed, or that a protocol has detected timeouts to a particular
|
|
|
|
* destination.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
rt_missmsg(type, rtinfo, flags, error)
|
|
|
|
int type, flags, error;
|
|
|
|
register struct rt_addrinfo *rtinfo;
|
|
|
|
{
|
|
|
|
register struct rt_msghdr *rtm;
|
|
|
|
register struct mbuf *m;
|
|
|
|
struct sockaddr *sa = rtinfo->rti_info[RTAX_DST];
|
|
|
|
|
|
|
|
if (route_cb.any_count == 0)
|
|
|
|
return;
|
|
|
|
m = rt_msg1(type, rtinfo);
|
|
|
|
if (m == 0)
|
|
|
|
return;
|
|
|
|
rtm = mtod(m, struct rt_msghdr *);
|
|
|
|
rtm->rtm_flags = RTF_DONE | flags;
|
|
|
|
rtm->rtm_errno = error;
|
|
|
|
rtm->rtm_addrs = rtinfo->rti_addrs;
|
|
|
|
route_proto.sp_protocol = sa ? sa->sa_family : 0;
|
|
|
|
raw_input(m, &route_proto, &route_src, &route_dst);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This routine is called to generate a message from the routing
|
|
|
|
* socket indicating that the status of a network interface has changed.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
rt_ifmsg(ifp)
|
|
|
|
register struct ifnet *ifp;
|
|
|
|
{
|
|
|
|
register struct if_msghdr *ifm;
|
|
|
|
struct mbuf *m;
|
|
|
|
struct rt_addrinfo info;
|
|
|
|
|
|
|
|
if (route_cb.any_count == 0)
|
|
|
|
return;
|
|
|
|
bzero((caddr_t)&info, sizeof(info));
|
|
|
|
m = rt_msg1(RTM_IFINFO, &info);
|
|
|
|
if (m == 0)
|
|
|
|
return;
|
|
|
|
ifm = mtod(m, struct if_msghdr *);
|
|
|
|
ifm->ifm_index = ifp->if_index;
|
2002-08-18 07:05:00 +00:00
|
|
|
ifm->ifm_flags = ifp->if_flags;
|
1994-05-24 10:09:53 +00:00
|
|
|
ifm->ifm_data = ifp->if_data;
|
|
|
|
ifm->ifm_addrs = 0;
|
|
|
|
route_proto.sp_protocol = 0;
|
|
|
|
raw_input(m, &route_proto, &route_src, &route_dst);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is called to generate messages from the routing socket
|
|
|
|
* indicating a network interface has had addresses associated with it.
|
|
|
|
* if we ever reverse the logic and replace messages TO the routing
|
|
|
|
* socket indicate a request to configure interfaces, then it will
|
|
|
|
* be unnecessary as the routing socket will automatically generate
|
|
|
|
* copies of it.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
rt_newaddrmsg(cmd, ifa, error, rt)
|
|
|
|
int cmd, error;
|
|
|
|
register struct ifaddr *ifa;
|
|
|
|
register struct rtentry *rt;
|
|
|
|
{
|
|
|
|
struct rt_addrinfo info;
|
1994-05-25 09:21:21 +00:00
|
|
|
struct sockaddr *sa = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
int pass;
|
1994-05-25 09:21:21 +00:00
|
|
|
struct mbuf *m = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct ifnet *ifp = ifa->ifa_ifp;
|
|
|
|
|
|
|
|
if (route_cb.any_count == 0)
|
|
|
|
return;
|
|
|
|
for (pass = 1; pass < 3; pass++) {
|
|
|
|
bzero((caddr_t)&info, sizeof(info));
|
|
|
|
if ((cmd == RTM_ADD && pass == 1) ||
|
|
|
|
(cmd == RTM_DELETE && pass == 2)) {
|
|
|
|
register struct ifa_msghdr *ifam;
|
|
|
|
int ncmd = cmd == RTM_ADD ? RTM_NEWADDR : RTM_DELADDR;
|
|
|
|
|
|
|
|
ifaaddr = sa = ifa->ifa_addr;
|
2001-02-03 11:46:35 +00:00
|
|
|
ifpaddr = TAILQ_FIRST(&ifp->if_addrhead)->ifa_addr;
|
1994-05-24 10:09:53 +00:00
|
|
|
netmask = ifa->ifa_netmask;
|
|
|
|
brdaddr = ifa->ifa_dstaddr;
|
|
|
|
if ((m = rt_msg1(ncmd, &info)) == NULL)
|
|
|
|
continue;
|
|
|
|
ifam = mtod(m, struct ifa_msghdr *);
|
|
|
|
ifam->ifam_index = ifp->if_index;
|
|
|
|
ifam->ifam_metric = ifa->ifa_metric;
|
|
|
|
ifam->ifam_flags = ifa->ifa_flags;
|
|
|
|
ifam->ifam_addrs = info.rti_addrs;
|
|
|
|
}
|
|
|
|
if ((cmd == RTM_ADD && pass == 2) ||
|
|
|
|
(cmd == RTM_DELETE && pass == 1)) {
|
|
|
|
register struct rt_msghdr *rtm;
|
1995-05-30 08:16:23 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
if (rt == 0)
|
|
|
|
continue;
|
|
|
|
netmask = rt_mask(rt);
|
|
|
|
dst = sa = rt_key(rt);
|
|
|
|
gate = rt->rt_gateway;
|
|
|
|
if ((m = rt_msg1(cmd, &info)) == NULL)
|
|
|
|
continue;
|
|
|
|
rtm = mtod(m, struct rt_msghdr *);
|
|
|
|
rtm->rtm_index = ifp->if_index;
|
|
|
|
rtm->rtm_flags |= rt->rt_flags;
|
|
|
|
rtm->rtm_errno = error;
|
|
|
|
rtm->rtm_addrs = info.rti_addrs;
|
|
|
|
}
|
|
|
|
route_proto.sp_protocol = sa ? sa->sa_family : 0;
|
|
|
|
raw_input(m, &route_proto, &route_src, &route_dst);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1997-01-13 21:26:53 +00:00
|
|
|
/*
|
|
|
|
* This is the analogue to the rt_newaddrmsg which performs the same
|
|
|
|
* function but for multicast group memberhips. This is easier since
|
|
|
|
* there is no route state to worry about.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
rt_newmaddrmsg(cmd, ifma)
|
|
|
|
int cmd;
|
|
|
|
struct ifmultiaddr *ifma;
|
|
|
|
{
|
|
|
|
struct rt_addrinfo info;
|
|
|
|
struct mbuf *m = 0;
|
|
|
|
struct ifnet *ifp = ifma->ifma_ifp;
|
|
|
|
struct ifma_msghdr *ifmam;
|
|
|
|
|
|
|
|
if (route_cb.any_count == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
bzero((caddr_t)&info, sizeof(info));
|
|
|
|
ifaaddr = ifma->ifma_addr;
|
2001-02-03 11:46:35 +00:00
|
|
|
if (ifp && TAILQ_FIRST(&ifp->if_addrhead))
|
|
|
|
ifpaddr = TAILQ_FIRST(&ifp->if_addrhead)->ifa_addr;
|
2000-07-25 11:21:01 +00:00
|
|
|
else
|
|
|
|
ifpaddr = NULL;
|
1997-01-13 21:26:53 +00:00
|
|
|
/*
|
|
|
|
* If a link-layer address is present, present it as a ``gateway''
|
|
|
|
* (similarly to how ARP entries, e.g., are presented).
|
|
|
|
*/
|
|
|
|
gate = ifma->ifma_lladdr;
|
|
|
|
if ((m = rt_msg1(cmd, &info)) == NULL)
|
|
|
|
return;
|
|
|
|
ifmam = mtod(m, struct ifma_msghdr *);
|
|
|
|
ifmam->ifmam_index = ifp->if_index;
|
|
|
|
ifmam->ifmam_addrs = info.rti_addrs;
|
|
|
|
route_proto.sp_protocol = ifma->ifma_addr->sa_family;
|
|
|
|
raw_input(m, &route_proto, &route_src, &route_dst);
|
|
|
|
}
|
1995-11-16 19:00:27 +00:00
|
|
|
|
2002-01-18 14:33:04 +00:00
|
|
|
/*
|
|
|
|
* This is called to generate routing socket messages indicating
|
|
|
|
* network interface arrival and departure.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
rt_ifannouncemsg(ifp, what)
|
|
|
|
struct ifnet *ifp;
|
|
|
|
int what;
|
|
|
|
{
|
|
|
|
struct if_announcemsghdr *ifan;
|
|
|
|
struct mbuf *m;
|
|
|
|
struct rt_addrinfo info;
|
|
|
|
|
|
|
|
if (route_cb.any_count == 0)
|
|
|
|
return;
|
|
|
|
bzero((caddr_t)&info, sizeof(info));
|
|
|
|
m = rt_msg1(RTM_IFANNOUNCE, &info);
|
|
|
|
if (m == NULL)
|
|
|
|
return;
|
|
|
|
ifan = mtod(m, struct if_announcemsghdr *);
|
|
|
|
ifan->ifan_index = ifp->if_index;
|
|
|
|
snprintf(ifan->ifan_name, sizeof(ifan->ifan_name),
|
|
|
|
"%s%d", ifp->if_name, ifp->if_unit);
|
|
|
|
ifan->ifan_what = what;
|
|
|
|
route_proto.sp_protocol = 0;
|
|
|
|
raw_input(m, &route_proto, &route_src, &route_dst);
|
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* This is used in dumping the kernel table via sysctl().
|
|
|
|
*/
|
2002-09-28 17:15:38 +00:00
|
|
|
static int
|
1995-10-09 04:06:28 +00:00
|
|
|
sysctl_dumpentry(rn, vw)
|
1994-05-24 10:09:53 +00:00
|
|
|
struct radix_node *rn;
|
1995-10-09 04:06:28 +00:00
|
|
|
void *vw;
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1995-10-09 04:06:28 +00:00
|
|
|
register struct walkarg *w = vw;
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct rtentry *rt = (struct rtentry *)rn;
|
|
|
|
int error = 0, size;
|
|
|
|
struct rt_addrinfo info;
|
|
|
|
|
|
|
|
if (w->w_op == NET_RT_FLAGS && !(rt->rt_flags & w->w_arg))
|
|
|
|
return 0;
|
|
|
|
bzero((caddr_t)&info, sizeof(info));
|
|
|
|
dst = rt_key(rt);
|
|
|
|
gate = rt->rt_gateway;
|
|
|
|
netmask = rt_mask(rt);
|
|
|
|
genmask = rt->rt_genmask;
|
2001-10-17 11:23:59 +00:00
|
|
|
if (rt->rt_ifp) {
|
|
|
|
ifpaddr = TAILQ_FIRST(&rt->rt_ifp->if_addrhead)->ifa_addr;
|
|
|
|
ifaaddr = rt->rt_ifa->ifa_addr;
|
|
|
|
if (rt->rt_ifp->if_flags & IFF_POINTOPOINT)
|
|
|
|
brdaddr = rt->rt_ifa->ifa_dstaddr;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
size = rt_msg2(RTM_GET, &info, 0, w);
|
1995-11-16 19:00:27 +00:00
|
|
|
if (w->w_req && w->w_tmem) {
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct rt_msghdr *rtm = (struct rt_msghdr *)w->w_tmem;
|
|
|
|
|
|
|
|
rtm->rtm_flags = rt->rt_flags;
|
|
|
|
rtm->rtm_use = rt->rt_use;
|
|
|
|
rtm->rtm_rmx = rt->rt_rmx;
|
|
|
|
rtm->rtm_index = rt->rt_ifp->if_index;
|
|
|
|
rtm->rtm_errno = rtm->rtm_pid = rtm->rtm_seq = 0;
|
|
|
|
rtm->rtm_addrs = info.rti_addrs;
|
1995-11-16 19:00:27 +00:00
|
|
|
error = SYSCTL_OUT(w->w_req, (caddr_t)rtm, size);
|
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2002-09-28 17:15:38 +00:00
|
|
|
static int
|
1994-05-24 10:09:53 +00:00
|
|
|
sysctl_iflist(af, w)
|
|
|
|
int af;
|
|
|
|
register struct walkarg *w;
|
|
|
|
{
|
|
|
|
register struct ifnet *ifp;
|
|
|
|
register struct ifaddr *ifa;
|
|
|
|
struct rt_addrinfo info;
|
|
|
|
int len, error = 0;
|
|
|
|
|
|
|
|
bzero((caddr_t)&info, sizeof(info));
|
2002-12-22 05:35:03 +00:00
|
|
|
/* IFNET_RLOCK(); */ /* could sleep XXX */
|
2001-02-04 13:13:25 +00:00
|
|
|
TAILQ_FOREACH(ifp, &ifnet, if_link) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if (w->w_arg && w->w_arg != ifp->if_index)
|
|
|
|
continue;
|
2001-02-03 11:46:35 +00:00
|
|
|
ifa = TAILQ_FIRST(&ifp->if_addrhead);
|
1994-05-24 10:09:53 +00:00
|
|
|
ifpaddr = ifa->ifa_addr;
|
|
|
|
len = rt_msg2(RTM_IFINFO, &info, (caddr_t)0, w);
|
|
|
|
ifpaddr = 0;
|
1995-11-16 19:00:27 +00:00
|
|
|
if (w->w_req && w->w_tmem) {
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct if_msghdr *ifm;
|
|
|
|
|
|
|
|
ifm = (struct if_msghdr *)w->w_tmem;
|
|
|
|
ifm->ifm_index = ifp->if_index;
|
2002-08-18 07:05:00 +00:00
|
|
|
ifm->ifm_flags = ifp->if_flags;
|
1994-05-24 10:09:53 +00:00
|
|
|
ifm->ifm_data = ifp->if_data;
|
|
|
|
ifm->ifm_addrs = info.rti_addrs;
|
1995-11-16 19:00:27 +00:00
|
|
|
error = SYSCTL_OUT(w->w_req,(caddr_t)ifm, len);
|
1994-10-08 22:38:27 +00:00
|
|
|
if (error)
|
2001-09-29 05:08:04 +00:00
|
|
|
goto done;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2001-02-03 11:46:35 +00:00
|
|
|
while ((ifa = TAILQ_NEXT(ifa, ifa_link)) != 0) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if (af && af != ifa->ifa_addr->sa_family)
|
|
|
|
continue;
|
2002-02-27 18:32:23 +00:00
|
|
|
if (jailed(curthread->td_ucred) &&
|
|
|
|
prison_if(curthread->td_ucred, ifa->ifa_addr))
|
This Implements the mumbled about "Jail" feature.
This is a seriously beefed up chroot kind of thing. The process
is jailed along the same lines as a chroot does it, but with
additional tough restrictions imposed on what the superuser can do.
For all I know, it is safe to hand over the root bit inside a
prison to the customer living in that prison, this is what
it was developed for in fact: "real virtual servers".
Each prison has an ip number associated with it, which all IP
communications will be coerced to use and each prison has its own
hostname.
Needless to say, you need more RAM this way, but the advantage is
that each customer can run their own particular version of apache
and not stomp on the toes of their neighbors.
It generally does what one would expect, but setting up a jail
still takes a little knowledge.
A few notes:
I have no scripts for setting up a jail, don't ask me for them.
The IP number should be an alias on one of the interfaces.
mount a /proc in each jail, it will make ps more useable.
/proc/<pid>/status tells the hostname of the prison for
jailed processes.
Quotas are only sensible if you have a mountpoint per prison.
There are no privisions for stopping resource-hogging.
Some "#ifdef INET" and similar may be missing (send patches!)
If somebody wants to take it from here and develop it into
more of a "virtual machine" they should be most welcome!
Tools, comments, patches & documentation most welcome.
Have fun...
Sponsored by: http://www.rndassociates.com/
Run for almost a year by: http://www.servetheweb.com/
1999-04-28 11:38:52 +00:00
|
|
|
continue;
|
1994-05-24 10:09:53 +00:00
|
|
|
ifaaddr = ifa->ifa_addr;
|
|
|
|
netmask = ifa->ifa_netmask;
|
|
|
|
brdaddr = ifa->ifa_dstaddr;
|
|
|
|
len = rt_msg2(RTM_NEWADDR, &info, 0, w);
|
1995-11-16 19:00:27 +00:00
|
|
|
if (w->w_req && w->w_tmem) {
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct ifa_msghdr *ifam;
|
|
|
|
|
|
|
|
ifam = (struct ifa_msghdr *)w->w_tmem;
|
|
|
|
ifam->ifam_index = ifa->ifa_ifp->if_index;
|
|
|
|
ifam->ifam_flags = ifa->ifa_flags;
|
|
|
|
ifam->ifam_metric = ifa->ifa_metric;
|
|
|
|
ifam->ifam_addrs = info.rti_addrs;
|
1995-11-16 19:00:27 +00:00
|
|
|
error = SYSCTL_OUT(w->w_req, w->w_tmem, len);
|
1994-10-08 22:38:27 +00:00
|
|
|
if (error)
|
2001-09-29 05:08:04 +00:00
|
|
|
goto done;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
ifaaddr = netmask = brdaddr = 0;
|
|
|
|
}
|
2001-09-29 05:08:04 +00:00
|
|
|
done:
|
2002-12-22 05:35:03 +00:00
|
|
|
/* IFNET_RUNLOCK(); */ /* XXX */
|
2001-09-29 05:08:04 +00:00
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1995-11-16 19:00:27 +00:00
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_rtsock(SYSCTL_HANDLER_ARGS)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
1995-11-16 19:00:27 +00:00
|
|
|
int *name = (int *)arg1;
|
|
|
|
u_int namelen = arg2;
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct radix_node_head *rnh;
|
|
|
|
int i, s, error = EINVAL;
|
|
|
|
u_char af;
|
|
|
|
struct walkarg w;
|
|
|
|
|
1995-11-16 19:00:27 +00:00
|
|
|
name ++;
|
|
|
|
namelen--;
|
|
|
|
if (req->newptr)
|
1994-05-24 10:09:53 +00:00
|
|
|
return (EPERM);
|
|
|
|
if (namelen != 3)
|
2002-01-25 00:50:49 +00:00
|
|
|
return ((namelen < 3) ? EISDIR : ENOTDIR);
|
1994-05-24 10:09:53 +00:00
|
|
|
af = name[0];
|
|
|
|
Bzero(&w, sizeof(w));
|
|
|
|
w.w_op = name[1];
|
|
|
|
w.w_arg = name[2];
|
1995-11-16 19:00:27 +00:00
|
|
|
w.w_req = req;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
s = splnet();
|
|
|
|
switch (w.w_op) {
|
|
|
|
|
|
|
|
case NET_RT_DUMP:
|
|
|
|
case NET_RT_FLAGS:
|
|
|
|
for (i = 1; i <= AF_MAX; i++)
|
|
|
|
if ((rnh = rt_tables[i]) && (af == 0 || af == i) &&
|
|
|
|
(error = rnh->rnh_walktree(rnh,
|
|
|
|
sysctl_dumpentry, &w)))
|
|
|
|
break;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NET_RT_IFLIST:
|
|
|
|
error = sysctl_iflist(af, &w);
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
if (w.w_tmem)
|
|
|
|
free(w.w_tmem, M_RTABLE);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1997-04-27 20:01:29 +00:00
|
|
|
SYSCTL_NODE(_net, PF_ROUTE, routetable, CTLFLAG_RD, sysctl_rtsock, "");
|
1995-11-16 19:00:27 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Definitions of protocols supported in the ROUTE domain.
|
|
|
|
*/
|
|
|
|
|
1995-11-16 19:00:27 +00:00
|
|
|
extern struct domain routedomain; /* or at least forward */
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1995-11-16 19:00:27 +00:00
|
|
|
static struct protosw routesw[] = {
|
1994-05-24 10:09:53 +00:00
|
|
|
{ SOCK_RAW, &routedomain, 0, PR_ATOMIC|PR_ADDR,
|
1996-05-08 04:29:08 +00:00
|
|
|
0, route_output, raw_ctlinput, 0,
|
1997-04-27 20:01:29 +00:00
|
|
|
0,
|
|
|
|
raw_init, 0, 0, 0,
|
|
|
|
&route_usrreqs
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
1995-11-16 19:00:27 +00:00
|
|
|
static struct domain routedomain =
|
1999-04-29 03:22:19 +00:00
|
|
|
{ PF_ROUTE, "route", 0, 0, 0,
|
1994-05-24 10:09:53 +00:00
|
|
|
routesw, &routesw[sizeof(routesw)/sizeof(routesw[0])] };
|
1995-05-10 16:48:52 +00:00
|
|
|
|
1995-05-11 00:13:26 +00:00
|
|
|
DOMAIN_SET(route);
|