rtsock.c

VXWORKS源代码

/* rtsock.c - routines for routing sockets */

/* Copyright 1990 - 2001 Wind River Systems, Inc. */
#include "copyright_wrs.h"

/*
 * 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.
 *
 *	@(#)rtsock.c	8.6 (Berkeley) 2/11/95
 */

/*
modification history
--------------------
01g,12oct01,rae  merge from truestack ver 01u, base o1f (SPR #70185 ROUTER_STACK)
01f,26aug98,n_s  added return val check for MALLOC in route_usrreq. spr #22238.
01e,04dec97,vin  moved back m_copyback and m_copydata from uipc_mbuf.c as
		 these are only used in rt_sock. Ifdefed m_copyback and
                 m_copydata in uipc_mbuf.c these need some rework so that
                 they can be tied up efficiently with the new buffering scheme.
01d,01jul97,vin  added rtSockInit, removed route_init from routedomain, it is
		 called from netLibInit. Added route message hooks for
                 scalability.
01c,05dec96,vin  changed malloc(..) to MALLOC(..) to use only network buffers,
		 changed free(..) to FREE(..).
01b,22nov96,vin  added cluster support replaced m_get(..) with mBufClGet(..).
		 m_gethdr(..) with mHdrClGet(..), moved m_copyback(..) to 
		 uipc_mbuf.c
01a,03mar96,vin  created from BSD4.4lite2.
*/

#include "net/systm.h"
#include "net/mbuf.h"
#include "sys/socket.h"
#include "net/socketvar.h"
#include "net/domain.h"
#include "net/protosw.h"
#include "net/unixLib.h"

#include "net/if.h"
#include "net/route.h"
#include "net/raw_cb.h"
#include "netinet/in.h"

#include "routeEnhLib.h"

#ifdef WV_INSTRUMENTATION
#ifdef INCLUDE_WVNET
#include "wvNetLib.h"
#endif
#endif

#ifdef ROUTER_STACK
#define SOCKADDR_IN(s) (((struct sockaddr_in*)(s))->sin_addr.s_addr)
#endif

struct walkarg {
	int	w_op, w_arg, w_given, w_needed, w_tmemsize;
	caddr_t	w_where, w_tmem;
};

#ifndef VIRTUAL_STACK
    /*
     * This global counts the number of routing socket listeners
     * for a particular family. It is not used outside this module.
     */

struct  route_cb route_cb;
#endif

static struct	sockaddr route_dst = { 2, PF_ROUTE, };
static struct	sockaddr route_src = { 2, PF_ROUTE, };

#ifndef VIRTUAL_STACK
    /*
     * The following protocol structure is the only global in this module
     * which differs between virtual stacks. It limits the routing messages
     * based on the associated address family, if a specific protocol value
     * is chosen during the socket creation.
     *
     * The source address variable above is read, but never altered. It
     * is the preassigned remote address for all routing sockets, which
     * disables the use of any alternatives when writing to a socket and
     * limits the delivery of any routing message to members of the routing
     * socket family.
     *
     * Since the bind operation is not supported, a local address can't be
     * assigned to a routing socket. As a result, the preceding destination
     * address variable, although passed to the routine which sends routing
     * messages to any listening sockets, is never actually used.
     */ 
     
static struct	sockproto route_proto = { PF_ROUTE, };
#endif /* VIRTUAL_STACK */

#ifdef ROUTER_STACK
IMPORT void routeIfStatusUpdate (struct ifnet *);
IMPORT void routeIfAddressUpdate (int, struct ifaddr *, struct rtentry *);
IMPORT void routeMissUpdate (int, struct rt_addrinfo *, int, int);
#endif /* ROUTER_STACK */

IMPORT int rt_fixdelete (struct radix_node *, void *);
struct mbuf *
		rt_msg1 (int, struct rt_addrinfo *);
static int	rt_msg2 (int, struct rt_addrinfo *, caddr_t, 
			 struct walkarg *);
static void	rt_xaddrs (caddr_t, caddr_t, struct rt_addrinfo *);

static int	route_usrreq (struct socket *, int, struct mbuf *,
                              struct mbuf *, struct mbuf *);
void	rt_ifmsg (struct ifnet *);
void	rt_missmsg (int, struct rt_addrinfo *, int, int);
void	rt_newaddrmsg (int, struct ifaddr *, int, struct rtentry *);
static int	route_output (struct mbuf *, struct socket *);
static void	rt_setmetrics (u_long, struct rt_metrics *,
                               struct rt_metrics *);

static void	m_copyback (struct mbuf *, int, int, caddr_t);
static void 	m_copydata(struct mbuf *, int, int, caddr_t);

#ifdef ROUTER_STACK
LOCAL int routeGatewayFetch (struct rtentry *, struct rt_msghdr *);
LOCAL ROUTE_ENTRY * routeMatch (struct rtentry *, short, struct sockaddr *);
#endif /* ROUTER_STACK */

#ifdef WV_INSTRUMENTATION
#ifdef INCLUDE_WVNET
    /* Set common fields of event identifiers for this module. */

LOCAL UCHAR wvNetModuleId = WV_NET_RTSOCK_MODULE;   /* Value for rtsock.c */
LOCAL UCHAR wvNetLocalFilter = WV_NET_NONE;     /* Available event filter */

LOCAL ULONG wvNetEventId;       /* Event identifier: see wvNetLib.h */
#endif    /* INCLUDE_WVNET */
#endif

/* 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]


/*******************************************************************************
* rtSockInit - intialize route sockets
*
* This function initializes the route msg hooks used in various places in the
* system. The hooks are provided to scale out route sockets. The same hooks
* also generate the internal callback messages for the router stack product.
*
* The domain_init entry point of the route socket domain calls this function.
*
* RETURNS: N/A
*
* NOMANUAL
*/

LOCAL void rtSockInit (void)
    {
#ifdef WV_INSTRUMENTATION
#ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
    WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_VERBOSE, 36, 8,
                     WV_NETEVENT_RTSOCKINIT_START)
#endif  /* INCLUDE_WVNET */
#endif

    /* Set the function hooks for receiving status changes from the stack. */

#ifdef ROUTER_STACK
    rtIfaceMsgHook = routeIfStatusUpdate;
    rtNewAddrMsgHook = routeIfAddressUpdate;
    rtMissMsgHook = routeMissUpdate;
#else
    rtIfaceMsgHook = rt_ifmsg;
    rtNewAddrMsgHook = rt_newaddrmsg;
    rtMissMsgHook = rt_missmsg;
#endif /* ROUTER_STACK */

    raw_init ();     			 /* initialize the raw control block */
    }
    
/*ARGSUSED*/
static int
route_usrreq(so, req, m, nam, control)
	register struct socket *so;
	int req;
	struct mbuf *m, *nam, *control;
{
	register int error = 0;
	register struct rawcb *rp = sotorawcb(so);
	int s;

#ifdef WV_INSTRUMENTATION
#ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
    WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_INFO, 21, 6,
                     WV_NETEVENT_ROUTEREQ_START, so->so_fd, req)
#endif  /* INCLUDE_WVNET */
#endif

	if (req == PRU_ATTACH) {
		MALLOC(rp, struct rawcb *, sizeof(*rp), MT_PCB, M_WAIT);
		if (rp == (struct rawcb *) NULL)
		    {
		    return (ENOBUFS);
		    }
		if ((so->so_pcb = (caddr_t)rp))
			bzero(so->so_pcb, sizeof(*rp));

	}
	if (req == PRU_DETACH && rp) {
		int af = rp->rcb_proto.sp_protocol;
		if (af == AF_INET)
			route_cb.ip_count--;
		else if (af == AF_NS)
			route_cb.ns_count--;
		else if (af == AF_ISO)
			route_cb.iso_count--;
		route_cb.any_count--;
	}
	s = splnet();
	error = raw_usrreq(so, req, m, nam, control);
	rp = sotorawcb(so);
	if (req == PRU_ATTACH && rp) {
		int af = rp->rcb_proto.sp_protocol;
		if (error) {
			FREE(rp, MT_PCB);
			splx(s);
			return (error);
		}
		if (af == AF_INET)
			route_cb.ip_count++;
		else if (af == AF_NS)
			route_cb.ns_count++;
		else if (af == AF_ISO)
			route_cb.iso_count++;
		rp->rcb_faddr = &route_src;
		route_cb.any_count++;
		soisconnected(so);
		so->so_options |= SO_USELOOPBACK;
	}
	splx(s);
	return (error);
}

/*ARGSUSED*/
static int
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;
	struct radix_node_head *rnh;
	struct rt_addrinfo info;
	int len, error = 0;
	struct ifnet *ifp = 0;
	struct ifaddr *ifa = 0;

#ifdef ROUTER_STACK
        struct sockaddr * pGateway = 0;
        short             protoId = 0;
        ROUTE_ENTRY *     pRoute = NULL;
#endif

#define senderr(e) { error = e; goto flush;}

#ifdef WV_INSTRUMENTATION
#ifdef INCLUDE_WVNET    /* WV_NET_NOTICE event */
    WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_NOTICE, 5, 5, 
                     WV_NETEVENT_RTOUTPUT_START, so->so_fd)
#endif  /* INCLUDE_WVNET */
#endif

	if (m == 0 || ((m->m_len < sizeof(long)) &&
		       (m = m_pullup(m, sizeof(long))) == 0))
            {
#ifdef WV_INSTRUMENTATION
#ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
            WV_NET_EVENT_1 (NET_AUX_EVENT, WV_NET_EMERGENCY, 24, 1, 
                            WV_NETEVENT_RTOUT_BADMSG, WV_NET_SEND,
                            so->so_fd)
#endif  /* INCLUDE_WVNET */
#endif

            return (ENOBUFS);
            }

	if ((m->m_flags & M_PKTHDR) == 0)
            {
#ifdef WV_INSTRUMENTATION
#ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
            WV_NET_EVENT_1 (NET_AUX_EVENT, WV_NET_EMERGENCY, 25, 2, 
                            WV_NETEVENT_RTOUT_PANIC, WV_NET_SEND,
                            so->so_fd)
#endif  /* INCLUDE_WVNET */
#endif

            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);
	}
	info.rti_addrs = rtm->rtm_addrs;
	rt_xaddrs((caddr_t)(rtm + 1), len + (caddr_t)rtm, &info);
	if (dst == 0)
		senderr(EINVAL);
	if (genmask) {
		struct radix_node *t;
		t = rn_addmask((caddr_t)genmask, 0, 1);
		if (t && Bcmp(genmask, t->rn_key, *(u_char *)genmask) == 0)
			genmask = (struct sockaddr *)(t->rn_key);
		else
			senderr(ENOBUFS);
	}
	switch (rtm->rtm_type) {

	case RTM_ADD:
		if (gate == 0)
			senderr(EINVAL);

                /*
                 * Create the new route using the default weight value.
                 * Report the change using direct callbacks, but do not
                 * generate a routing socket message to avoid duplicates.
                 */

                error = rtrequestAddEqui(dst, netmask, gate, rtm->rtm_flags,
					 M2_ipRouteProto_other, 0, TRUE,
                                         FALSE, (ROUTE_ENTRY **) &saved_nrt);
		if (error == 0 && saved_nrt) {
			rt_setmetrics(rtm->rtm_inits,
				&rtm->rtm_rmx, &saved_nrt->rt_rmx);

#ifdef ROUTER_STACK
                        /* Set the initial weight value, if any. */

                        if (rtm->rtm_inits & RTV_WEIGHT)
                            saved_nrt->rt_rmx.weight = rtm->rtm_rmx.weight;
#endif

			saved_nrt->rt_refcnt--;
			saved_nrt->rt_genmask = genmask;

#ifdef ROUTER_STACK
                /* Use different message type for additional routes. */

                if ( ((ROUTE_ENTRY *)saved_nrt)->primaryRouteFlag == FALSE)
                    rtm->rtm_type = RTM_ADDEXTRA;
#endif
		}
		break;

	case RTM_DELETE:
                /*
                 * Delete the matching route entry. Report the change using
                 * direct callbacks, but do not generate a routing socket
                 * message to avoid duplicates.
                 */

                error = rtrequestDelEqui(dst, netmask, gate, rtm->rtm_flags,
					 M2_ipRouteProto_other, TRUE, FALSE,
					 (ROUTE_ENTRY **) &saved_nrt);
		if (error == 0) {
			(rt = saved_nrt)->rt_refcnt++;

#ifdef ROUTER_STACK
                /* Use different message type for additional routes. */

                if ( ((ROUTE_ENTRY *)saved_nrt)->primaryRouteFlag == FALSE)
                    rtm->rtm_type = RTM_DELEXTRA;
#endif

			goto report;
		}
		break;

	case RTM_GET:
	case RTM_CHANGE:
	case RTM_LOCK:
#ifdef ROUTER_STACK
        case RTM_NEWCHANGE:
        case RTM_NEWGET:
        case RTM_GETALL:
#endif
		if ((rnh = rt_tables[dst->sa_family]) == 0) {
			senderr(EAFNOSUPPORT);
		} else if ((rt = (struct rtentry *)
				rnh->rnh_lookup(dst, netmask, rnh)))
			rt->rt_refcnt++;
		else
			senderr(ESRCH);

#ifdef ROUTER_STACK
		switch(rtm->rtm_type) {

                case RTM_GETALL:
                    /*
                     * Create a message containing information about all
                     * routes with the matching destination and netmask.
                     */

                    len = routeGatewayFetch (rt, NULL);
                    if (len > rtm->rtm_msglen)
                        {
                        struct rt_msghdr * pNewMessage;
                        R_Malloc(pNewMessage, struct rt_msghdr *, len);
	                if (pNewMessage == NULL)
                            senderr(ENOBUFS);
                        Free(rtm);
                        rtm = pNewMessage;
			}
                    routeGatewayFetch (rt, rtm);
                    break;

                case RTM_NEWCHANGE:
		case RTM_NEWGET:

                    /*
                     * If the search command specifies a gateway address, use
                     * that value and the included protocol ID (if any) to
                     * select a matching entry from any duplicate routes.
                     */

                    pGateway = gate;
                    if (gate)
                        {
                        protoId = RT_PROTO_GET (gate);
                        pRoute = routeMatch (rt, protoId, gate);
                        if (pRoute)
                            {
                            /*
                             * Matching entry found. Increase the
                             * reference count for the exact match.
                             */

                            pRoute->rtEntry.rt_refcnt++;
                            }     
                        else
                            senderr(ESRCH);
                        }
                    break;
                }
#endif

		switch(rtm->rtm_type) {

		case RTM_GET:
#ifdef ROUTER_STACK
                case RTM_NEWGET:
                        if (pGateway)
                            {
                            /* The command used the gateway address to get
                             * an exact match. Use that entry instead of
                             * the original reference to the primary route.
                             */ 

                            rtfree (rt);
                            rt = (struct rtentry *)pRoute;
                            }
#endif
		report:
			dst = rt_key(rt);
			gate = rt->rt_gateway;
			netmask = rt_mask(rt);
			genmask = rt->rt_genmask;
			if ((rtm->rtm_addrs & (RTA_IFP | RTA_IFA))) {
				if ((ifp = rt->rt_ifp)) {
					ifpaddr = ifp->if_addrlist->ifa_addr;
					ifaaddr = rt->rt_ifa->ifa_addr;
					if (ifp->if_flags & IFF_POINTOPOINT)
						brdaddr = rt->rt_ifa->ifa_dstaddr;
					else
						brdaddr = 0;
					rtm->rtm_index = ifp->if_index;
				} else {
					ifpaddr = 0;
					ifaaddr = 0;
			    }
			}
			len = rt_msg2(rtm->rtm_type, &info, (caddr_t)0,
				(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);