udp_usrreq.c

VXWORKS源代码

/* udp_usrreq.c - UDP protocol routines */

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

/*
 * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995
 *	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.
 *
 *	@(#)udp_usrreq.c	8.6 (Berkeley) 5/23/95
 */

/*
modification history
--------------------
03g,12oct01,rae  merge from truestack ver 03k, base 03f (SPR #65887 etc.)
03f,31aug98,n_s  added udp_hlen validty check to udp_input (). spr #6263.
03e,05oct97,vin  added fast multicasting.
03d,31mar97,vin  modified for hash look ups for pcbs(FREEBSD 2.2.1).
03c,20jan97,vin  replace icmp_error with _icmpErrorHook for scalability, 
		 added new udpDoCkSumRcv variable, fixed bugs mentioned
		 in Stevens VOLII chapter 23, pg772 & pg774.
03b,22nov96,vin  added cluster support replaced m_get(..) with mBufClGet(..).
03a,03mar96,vin  created from BSD4.4 stuff,integrated with 02r of udp_usrreq.c.
*/

/*
DESCRIPTION
*/

#include "vxWorks.h"
#include "net/mbuf.h"
#include "net/protosw.h"
#include "sys/socket.h"
#include "net/socketvar.h"
#include "errno.h"

#include "net/if.h"
#include "net/route.h"

#include "netinet/in.h"
#include "netinet/in_pcb.h"
#include "netinet/in_systm.h"
#include "netinet/ip.h"
#include "netinet/ip_var.h"
#include "netinet/in_var.h"
#include "netinet/ip_icmp.h"
#include "netinet/udp.h"
#include "netinet/udp_var.h"
#include "net/systm.h"
#include "stdio.h"

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

#ifdef VIRTUAL_STACK
#include "netinet/vsLib.h"
#endif

/*
 * UDP protocol implementation.
 * Per RFC 768, August, 1980.
 */

#ifndef UDBHASHSIZE
#define UDBHASHSIZE 64
#endif

#ifndef VIRTUAL_STACK

#ifndef	COMPAT_42
int	udpcksum 	= 1;	/* turn on send checksum by default */
int	udpDoCkSumRcv	= 1;	/* turn on recv checksum by default */
#else
int	udpcksum 	= 0;		/* XXX */
int	udpDoCkSumRcv	= 0;
#endif

/* externs */
extern VOIDFUNCPTR _icmpErrorHook;

/* globals */

struct  inpcbhead udb;          /* from udp_var.h */
struct  inpcbinfo udbinfo;
struct  udpstat udpstat;	/* global udp statistics structure */
struct  sockaddr_in udp_in = { sizeof(udp_in), AF_INET };
struct	inpcb * udp_last_inpcb = NULL;	/* last PCB cache for fast look up */
int	udp_ttl = UDP_TTL;
u_long	udp_sendspace = 9216;		/* really max datagram size */
u_long	udp_recvspace = 40 * (1024 + sizeof(struct sockaddr_in));
					/* 40 1K datagrams */
u_short	udp_pcbhashsize = UDBHASHSIZE; 	/* size of hash table */

#endif    /* VIRTUAL_STACK */

/* locals */

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

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

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

/* forward declarations */

static	void udp_detach (struct inpcb *);
static	void udp_notify (struct inpcb *, int);
static	struct mbuf *udp_saveopt (caddr_t, int, int);

void
udp_init()
{
#ifdef WV_INSTRUMENTATION
#ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
    WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_VERBOSE, 43, 16,
                     WV_NETEVENT_UDPINIT_START)
#endif  /* INCLUDE_WVNET */
#endif

	LIST_INIT(&udb);
	udbinfo.listhead = &udb;

#ifdef VIRTUAL_STACK
        udp_in.sin_len     = sizeof(udp_in);
        udp_in.sin_family  = AF_INET;
        udp_last_inpcb     = NULL;
        udp_ttl            = UDP_TTL;
        udp_sendspace      = 9216;
        udp_recvspace      = 40 * (1024 + sizeof (struct sockaddr_in));
        udp_pcbhashsize    = UDBHASHSIZE;

#ifndef	COMPAT_42
        udpcksum 	   = 1;	/* turn on send checksum by default */
        udpDoCkSumRcv	   = 1;	/* turn on recv checksum by default */
#else
        udpcksum 	   = 0;		/* XXX */
        udpDoCkSumRcv	   = 0;
#endif    /* COMPAT_42 */

#endif    /* VIRTUAL_STACK */

	udbinfo.hashbase = hashinit(udp_pcbhashsize, MT_PCB, &udbinfo.hashmask);
}

void
udp_input(m, iphlen)
	register struct mbuf *m;
	int iphlen;
{
	register struct ip *ip;
	register struct udphdr *uh;
	register struct inpcb *inp;
	struct mbuf *opts = 0;
	int len;
	struct ip save_ip;

#ifdef WV_INSTRUMENTATION
#ifdef INCLUDE_WVNET    /* WV_NET_NOTICE event */
    WV_NET_EVENT_0 (NET_CORE_EVENT, WV_NET_NOTICE, 21, 10,
                    WV_NETEVENT_UDPIN_START, WV_NET_RECV)
#endif  /* INCLUDE_WVNET */
#endif

	udpstat.udps_ipackets++;

	/*
	 * Strip IP options, if any; should skip this,
	 * make available to user, and use on returned packets,
	 * but we don't yet have a way to check the checksum
	 * with options still present.
	 */
	if (iphlen > sizeof (struct ip)) {
		ip_stripoptions(m, (struct mbuf *)0);
		iphlen = sizeof(struct ip);
	}

	/*
	 * Get IP and UDP header together in first mbuf.
	 */
	ip = mtod(m, struct ip *);
	if (m->m_len < iphlen + sizeof(struct udphdr)) {
		if ((m = m_pullup(m, iphlen + sizeof(struct udphdr))) == 0) {
			udpstat.udps_hdrops++;
#ifdef WV_INSTRUMENTATION
#ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
            WV_NET_EVENT_0 (NET_CORE_EVENT, WV_NET_WARNING, 14, 4,
                            WV_NETEVENT_UDPIN_SHORTPKTHDR, WV_NET_RECV)
#endif  /* INCLUDE_WVNET */
#endif

			return;
		}
		ip = mtod(m, struct ip *);
	}
	uh = (struct udphdr *)((caddr_t)ip + iphlen);

	/*
	 * Make mbuf data length reflect UDP length.
	 * If not enough data to reflect UDP length, drop.
	 */
	len = ntohs((u_short)uh->uh_ulen);

	if (len < sizeof (struct udphdr))
	    {
	    udpstat.udps_badlen++;
	    goto bad;
	    }

	if (ip->ip_len != len) {
		if (len > ip->ip_len) {
#ifdef WV_INSTRUMENTATION
#ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
            WV_NET_EVENT_0 (NET_CORE_EVENT, WV_NET_WARNING, 15, 5,
                            WV_NETEVENT_UDPIN_BADLEN, WV_NET_RECV)
#endif  /* INCLUDE_WVNET */
#endif

			udpstat.udps_badlen++;
			goto bad;
		}
		m_adj(m, len - ip->ip_len);
		/* ip->ip_len = len; */
	}
	/*
	 * Save a copy of the IP header in case we want restore it
	 * for sending an ICMP error message in response.
	 */
	save_ip = *ip;

	/*
	 * Checksum extended UDP header and data.
	 */
	if (udpDoCkSumRcv && uh->uh_sum) {
		((struct ipovly *)ip)->ih_next = 0;
		((struct ipovly *)ip)->ih_prev = 0;
		((struct ipovly *)ip)->ih_x1 = 0;
		((struct ipovly *)ip)->ih_len = uh->uh_ulen;
		if ((uh->uh_sum = in_cksum(m, len + sizeof (struct ip)))) {
#ifdef WV_INSTRUMENTATION
#ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
            WV_NET_EVENT_0 (NET_CORE_EVENT, WV_NET_WARNING, 16, 6,
                            WV_NETEVENT_UDPIN_BADSUM, WV_NET_RECV)
#endif  /* INCLUDE_WVNET */
#endif

			udpstat.udps_badsum++;
			m_freem(m);
			return;
		}
	}

        if(IN_MULTICAST(ntohl(ip->ip_dst.s_addr)))
            {
            IN_MULTI * 	pInMulti;
            M_BLK_ID	pInPcbMblk;

            IN_LOOKUP_MULTI(ip->ip_dst, m->m_pkthdr.rcvif, pInMulti);

            /* give the packet to all pcbs registered */

            if (pInMulti != NULL)
                {
		struct socket *last;
		/*
		 * Construct sockaddr format source address.
		 */
		udp_in.sin_port = uh->uh_sport;
		udp_in.sin_addr = ip->ip_src;
		m->m_len -= sizeof (struct udpiphdr);
		m->m_data += sizeof (struct udpiphdr);
		/*
		 * give the datagrams to all the pcbs 
		 * 
		 */
		last = NULL;
		for (pInPcbMblk = pInMulti->pInPcbMblk; pInPcbMblk != NULL;
                     pInPcbMblk = pInPcbMblk->mBlkHdr.mNext)
                    {
                    inp = mtod (pInPcbMblk, struct inpcb *);
                    if (inp->inp_lport != uh->uh_dport)
                        continue;
                    if (inp->inp_laddr.s_addr != INADDR_ANY)
                        if (inp->inp_laddr.s_addr != ip->ip_dst.s_addr)
                            continue;
                    if (inp->inp_faddr.s_addr != INADDR_ANY)
                        if (inp->inp_faddr.s_addr != ip->ip_src.s_addr ||
                            inp->inp_fport != uh->uh_sport)
                            continue;

                    if (last != NULL)
                        {
                        struct mbuf *n;

                        if ((n = m_copy(m, 0, M_COPYALL)) != NULL)
                            {
#ifdef WV_INSTRUMENTATION
#ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
                WV_NET_PORTIN_EVENT_4 (NET_CORE_EVENT, WV_NET_INFO, 56, 18,
                                       uh->uh_sport, uh->uh_dport,
                                       WV_NETEVENT_UDPIN_PCBGOOD, WV_NET_RECV,
                                       ip->ip_src.s_addr, uh->uh_sport,
                                       last->so_fd, uh->uh_dport)
#endif  /* INCLUDE_WVNET */
#endif

                            if (sbappendaddr(&last->so_rcv,
                                             (struct sockaddr *)&udp_in,
                                             n, (struct mbuf *)0) == 0)
                                {
#ifdef WV_INSTRUMENTATION
#ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
                WV_NET_PORTIN_EVENT_1 (NET_CORE_EVENT, WV_NET_WARNING, 17, 7,
                                       uh->uh_sport, uh->uh_dport,
                                       WV_NETEVENT_UDPIN_FULLSOCK, WV_NET_RECV,
                                       last->so_fd)
#endif  /* INCLUDE_WVNET */
#endif

                                m_freem(n);
                                udpstat.udps_fullsock++;
                                }
                            else
                                sorwakeup(last);
                            }
                        }
                    last = inp->inp_socket;
                    /*
                     * Don't look for additional matches if this one does
                     * not have either the SO_REUSEPORT or SO_REUSEADDR
                     * socket options set.  This heuristic avoids searching
                     * through all pcbs in the common case of a non-shared
                     * port.  It assumes that an application will never
                     * clear these options after setting them.
                     */
                    if ((last->so_options & (SO_REUSEPORT|SO_REUSEADDR)) == 0)
                        break;
                    }

		if (last == NULL)