bpfproto.c

VXWORKS源代码

/* bpfProto.c - Berkeley Packet Filter (BPF) protocol interface */

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

/*-
 * Copyright (c) 1990, 1991, 1992, 1993, 1994, 1995, 1996
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from the Stanford/CMU enet packet filter,
 * (net/enet.c) distributed as part of 4.3BSD, and code contributed
 * to Berkeley by Steven McCanne and Van Jacobson both of Lawrence
 * Berkeley Laboratory.
 *
 * 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.
 *
 *	@(#)bpf.c	7.5 (Berkeley) 7/15/91
 *
 * static char rcsid[] =
 * "$Header: bpf.c,v 1.67 96/09/26 22:00:52 leres Exp $";
 */

/*
modification history
--------------------
01e,13nov01,wap  added support for NPT Drivers and allow for qtag support.
01d,26jan01,ijm  corrected leak in bpfBsdProtoInput
01c,17nov00,spm  added support for BSD Ethernet devices
01b,26oct00,spm  fixed merge from tor3_x branch and updated mod history
01a,23oct00,niq  created from version 01c of tor3_x branch
*/

#define INCLUDE_IP     /* hack to have ipProto filter out promisc pkts */

/* includes */

#include "vxWorks.h"
#include "stdio.h"
#include "stdlib.h"

#include "lstLib.h"
#include "logLib.h"

#include "netLib.h"
#include "muxLib.h"
#include "muxTkLib.h"
#include "netBufLib.h"
#include "end.h"
#include "etherLib.h"

#include "private/muxLibP.h"    /* PCOOKIE_TO_ENDOBJ conversion macro */

#include "private/bpfLibP.h"
#include "net/bpf.h"

#ifdef INCLUDE_IP
#include "ifLib.h"
#endif

/* defines */


#define BPF_PROTO_NAME "Berkeley Packet Filter"

#define DEBUG

#ifdef DEBUG
#undef LOCAL
#define LOCAL
#endif  /* DEBUG */

/* locals */

LOCAL BOOL bpfProtoInitDone = FALSE;   /* TRUE if BPF MUX proto */
                                       /* has been initialized */
LOCAL LIST lstProtoInUse;    /* attached network interfaces */

LOCAL int bpfDltTbl [] =         /* Translation tbl from m2 ifType to DLT */
    {
	DLT_NULL,
	DLT_NULL,      /* M2_ifType_other */
	DLT_NULL,      /* M2_ifType_regular1822 */
	DLT_NULL,      /* M2_ifType_hdh1822 */
	DLT_AX25,      /* M2_ifType_ddn_x25 */
	DLT_AX25,      /* M2_ifType_rfc877_x25 */
	DLT_EN10MB,    /* M2_ifType_ethernet_csmacd */
	DLT_IEEE802,   /* M2_ifType_iso88023_csmacd */
	DLT_IEEE802,   /* M2_ifType_iso88024_tokenBus */
	DLT_IEEE802,   /* M2_ifType_iso88025_tokenRing */
	DLT_IEEE802,   /* M2_ifType_iso88026_man */
	DLT_NULL,      /* M2_ifType_starLan */
	DLT_PRONET,    /* M2_ifType_proteon_10Mbit */
	DLT_PRONET,    /* M2_ifType_proteon_80Mbit */
	DLT_NULL,      /* M2_ifType_hyperchannel */
	DLT_FDDI,      /* M2_ifType_fddi */
	DLT_NULL,      /* M2_ifType_lapb */
	DLT_NULL,      /* M2_ifType_sdlc */
	DLT_NULL,      /* M2_ifType_ds1 */
	DLT_NULL,      /* M2_ifType_e1 */
	DLT_NULL,      /* M2_ifType_basicISDN */
	DLT_NULL,      /* M2_ifType_primaryISDN */
	DLT_NULL,      /* M2_ifType_propPointToPointSerial */
	DLT_PPP,       /* M2_ifType_ppp */
	DLT_NULL,      /* M2_ifType_softwareLoopback */
	DLT_NULL,      /* M2_ifType_eon */
	DLT_EN3MB,     /* M2_ifType_ethernet_3Mbit */
	DLT_NULL,      /* M2_ifType_nsip */
	DLT_SLIP,      /* M2_ifType_slip */
	DLT_NULL,      /* M2_ifType_ultra */
	DLT_NULL,      /* M2_ifType_ds3 */
	DLT_NULL,      /* M2_ifType_sip */
	DLT_NULL,      /* M2_ifType_frame_relay */
    };

LOCAL int bpfDltTblSize = NELEMENTS (bpfDltTbl);  /* size of BPF DLT   */
                                                  /* translation table */

LOCAL int bpfBsdDevCount = 0;  /* BPF devices attached to BSD devices. */

/* forward declarations */

LOCAL BOOL bpfProtoInput (void * pCookie, long type, M_BLK_ID pMBlk,
			  LL_HDR_INFO * pLlHdrInfo, 
			  void * pProtoCtrl);
LOCAL BOOL bpfBsdProtoInput (struct ifnet * pIf, char * pBuffer, int length);

LOCAL STATUS bpfProtoShutdown (void * pCookie, void * pProtoCtrl);

LOCAL STATUS bpfTkProtoShutdown (void * pProtoCtrl);

LOCAL BOOL bpfTkProtoInput (void * pProtoCtrl, long type, M_BLK_ID pMBlk,
                            void * pSpare);
    /*
     * Called with global BPF lock to prevent conflicts with attach routine
     * and promiscuous setting. This routine removes the last attachment
     * of a BPF device from a network interface and also detaches the
     * corresponding BPF MUX protocols.
     */

STATUS _bpfProtoDetach
    (
    BPF_DEV_CTRL * pBpfDev 	/* BPF device control structure */
    )
    {
    BPF_PROTO_CTRL * pNew;      /* BPF units from other devices, if any. */

    BOOL bsdFlag; 	/* Attached to BSD or END device? */

    bsdFlag = pBpfDev->pNetDev->bsdFlag;

    /*
     * Find a BPF device using the same
     * network interface as this unit.
     */

    for (pNew = (BPF_PROTO_CTRL *)lstFirst (&lstProtoInUse);
         pNew != NULL;
         pNew = (BPF_PROTO_CTRL *)lstNext ((NODE *)pNew))
        {
        if (bsdFlag)
            {
            if (pNew->pCookie == pBpfDev->pNetDev->pCookie)
                break;
            }
        else if (PCOOKIE_TO_ENDOBJ(pNew->pCookie) ==
                    PCOOKIE_TO_ENDOBJ(pBpfDev->pNetDev->pCookie))
            break;
        }

    if (pNew == NULL)    /* No such device attached? (Can't really occur). */
        return (ERROR);

    if (pNew != pBpfDev->pNetDev)
        {
        /*
         * The given BPF unit is part of a BPF device which shares the
         * same network interface as an earlier BPF device. Just remove
         * it from the private list.
         */

        lstDelete (& (pNew->bpfDevList), (NODE *) (pBpfDev->pNetDev));
        }
    else
        {
        /*
         * The given BPF unit is part of the first BPF device which
         * used the network interface. Update the global list if other
         * BPF devices are using the same network interface.
         */

        if (lstCount (& (pNew->bpfDevList)) != 0)
            {
            /* Move the first shared device element to the global list. */

            pNew = (BPF_PROTO_CTRL *)lstGet (& (pBpfDev->pNetDev->bpfDevList));
            if (pNew != NULL)
                {
                lstInsert (&lstProtoInUse, (NODE *) (pBpfDev->pNetDev),
                           (NODE *)pNew);

                /* Move other attached devices to the (new) private list. */

                lstConcat (& (pNew->bpfDevList),
                           & (pBpfDev->pNetDev->bpfDevList));
                }
            }

        /* Remove the (old) root of the private list from the global list. */

        lstDelete (&lstProtoInUse, (NODE *) (pBpfDev->pNetDev));
        }

    /*
     * No BPF units from the old BPF device are using the
     * network interface. Remove any attached MUX protocols.
     * Alternatively, remove the Ethernet input hook if no
     * other BPF devices are using any BSD network interface.
     */

    if (pBpfDev->pNetDev->bsdFlag == TRUE)
        {
        bpfBsdDevCount--;
        if (bpfBsdDevCount == 0)
            etherInputHookDelete (bpfBsdProtoInput, NULL, 0);
        }
    else if (pBpfDev->pNetDev->pCookie != NULL)
        {

        int deviceType = muxTkDrvCheck (pBpfDev->pNetDev->devName);

        if (deviceType != ERROR)
            {
            if ( deviceType == 0 )
                muxUnbind (pBpfDev->pNetDev->pCookie, MUX_PROTO_SNARF,
                       (FUNCPTR) bpfProtoInput);
            else
                muxUnbind (pBpfDev->pNetDev->pCookie, MUX_PROTO_SNARF,
                       (FUNCPTR) bpfTkProtoInput);
            }
        }
    return (OK);
    }

LOCAL STATUS bpfProtoShutdown 
    (
    void * pCookie,
    void * pProtoCtrl
    )
    {
    BPF_PROTO_CTRL * pBpfProto;
    BPF_DEV_CTRL * pBpfDev;

    pBpfProto = (BPF_PROTO_CTRL *) pProtoCtrl;

    for (pBpfDev = (BPF_DEV_CTRL *) lstFirst (& (pBpfProto->bpfUnitList));
         pBpfDev != NULL;
         pBpfDev = (BPF_DEV_CTRL *) lstNext ((NODE *) pBpfDev))
        {
        _bpfDevDetach (pBpfDev);
        }
    
    return (OK);
    }

    /*
     * Check incoming frame against every BPF unit attached to a network
     * device using the MUX/END interface. The BPF device containing the
     * attachment data must still exist or the MUX would not call this
     * routine. Always return FALSE to allow normal stack processing after
     * applying any filters.
     */

LOCAL BOOL bpfProtoInput 
    (
    void * pCookie, 
    long type,
    M_BLK_ID pMBlk,
    LL_HDR_INFO * pLlHdrInfo, 
    void * pProtoCtrl
    )
    {
    BPF_PROTO_CTRL * pNetDev;

    /* Access a BPF unit's attachment to the network interface. */

    pNetDev = (BPF_PROTO_CTRL *)pProtoCtrl;
    if (pNetDev->pCookie != pCookie)
        {
        /* Mismatched binding? Should never occur. */

        return (FALSE);
        }

    /* Apply the current filters and save matching frames. */

    _bpfPacketTap (& (pNetDev->bpfUnitList), type, pMBlk,
                    pLlHdrInfo->dataOffset);

    return (FALSE);
    }

    /*
     * Check incoming frame against any BPF unit attached to the
     * network device using the BSD interface. Always return FALSE
     * to allow normal stack processing after applying any filters.
     */

LOCAL BOOL bpfBsdProtoInput 
    (
    struct ifnet * pIf, 	/* interface which received frame */
    char * pBuffer, 		/* pointer to received frame */
    int length 			/* length of received frame */
    )
    {
    BPF_PROTO_CTRL * pFirst;
    BPF_PROTO_CTRL * pNext;
    M_BLK_ID pMbuf;

    /* Find any BPF units attached to the network interface. */

    for (pFirst = (BPF_PROTO_CTRL *)lstFirst (&lstProtoInUse);
         pFirst != NULL;
         pFirst = (BPF_PROTO_CTRL *)lstNext ((NODE *)pFirst))
        {
        /* Ignore attachments to END network interfaces. */

        if (pFirst->bsdFlag == FALSE)
            continue;

        /* Ignore attachments to different BSD network interfaces. */

        if (pFirst->pCookie == pIf)
            break;
        }

     /*
      * Exit if no BPF device is using this BSD network interface.
      * (This situation can occur frequently since all devices call
      * this routine with incoming data as long as any input hook is
      * installed).
      */

    if (pFirst == NULL)
        return (FALSE);

    /*
     * Build an mBlk chain containing the data.
     * (This step is wasteful since the driver does the same thing,
     * but the Ethernet hook interface doesn't allow access to that
     * mBlk and the BPF implementation requires one).
     */

    pMbuf = bcopy_to_mbufs (pBuffer, length, 0, pIf, NONE);
    if (pMbuf == NULL)
        return (FALSE);

    /* Apply the current filters and save matching frames. */

    _bpfPacketTap (& (pFirst->bpfUnitList), ETHERTYPE_IP, pMbuf,
                    SIZEOF_ETHERHEADER);

    for (pNext = (BPF_PROTO_CTRL *)lstFirst (& (pFirst->bpfDevList));
         pNext != NULL;
         pNext = (BPF_PROTO_CTRL *)lstNext ((NODE *)pNext))
        {
        _bpfPacketTap (& (pNext->bpfUnitList), ETHERTYPE_IP, pMbuf,
                        SIZEOF_ETHERHEADER);
        }

    /* Free the buffer */

    netMblkClChainFree(pMbuf);

    return (FALSE);
    }

/*
 * Make pBpfDev listen on named interface. 
 * Must be called by a routine holding the global BPF lock.
 */

STATUS _bpfProtoAttach
    (
    BPF_DEV_CTRL * pBpfDev,
    char * 	pDevName, 	/* Name of network interface device. */
    int 	devUnit, 	/* Unit number of network interface. */
    struct ifnet * pIf 		/* Interface handle for BSD device. */
    )
    {
    M2_INTERFACETBL m2Tbl;
   
    BPF_DEV_CTRL *   pBpfUnit;

    BPF_PROTO_CTRL * pNetIfCtrl;
    BPF_PROTO_CTRL * pFirst;
    BPF_PROTO_CTRL * pLast = NULL;
    NODE tmpNode;

    /* Check if a BPF device is already attached to the network interface. */

    for (pNetIfCtrl = (BPF_PROTO_CTRL *)lstFirst (&lstProtoInUse);
         pNetIfCtrl != NULL;
         pNetIfCtrl = (BPF_PROTO_CTRL *) lstNext ((NODE *) pNetIfCtrl))
        {
        if (devUnit == pNetIfCtrl->devUnit &&
            strncmp (pDevName, pNetIfCtrl->devName, END_NAME_MAX) == 0)
            break;
        }

    if (pNetIfCtrl == NULL)
        {
        /* Add this BPF unit's attachment data to the global list. */

        pFirst = pBpfDev->pNetIfCtrl;
        if (pFirst == NULL)
            return (ENOBUFS);

        lstAdd (&lstProtoInUse, (NODE *)pFirst);
        pLast = pFirst;
        }
    else