etherlib.c

vxworks的完整的源代码

    }

/*******************************************************************************
*
* etherAddrResolve - find an Ethernet address for a specified Internet address
*
* This routine uses the Address Resolution Protocol (ARP) and internal ARP
* cache to resolve the Ethernet address of a machine that owns the Internet
* address given in <targetAddr>.
*
* The first argument <pIf> is a pointer to a variable of type `struct ifnet'
* which identifies the network interface through which the ARP request messages
* are to be sent out.  The routine ifunit() is used to retrieve this pointer
* from the system in the following way:
* .CS
*     struct ifnet *pIf;
*     ...
*     pIf = ifunit ("ln0");
* .CE
* If ifunit() returns a non-NULL pointer, it is a valid pointer to
* the named network interface device structure of type `struct ifnet'.
* In the above example, <pIf> will be pointing to the data structure that
* describes the first LANCE network interface device if ifunit() is
* successful.
*
* The six-byte Ethernet address is copied to <eHdr>, if the resolution of
* <targetAddr> is successful.  <eHdr> must point to a buffer of at least
* six bytes.
*
* RETURNS:
* OK if the address is resolved successfully, or ERROR if <eHdr> is NULL,
* <targetAddr> is invalid, or address resolution is unsuccessful.
*
* SEE ALSO:
* etherOutput()
*/

STATUS etherAddrResolve
    (
    struct ifnet        *pIf,           /* interface on which to send ARP req */
    char                *targetAddr,    /* name or Internet address of target */
    char                *eHdr,          /* where to return the Ethernet addr */
    int                 numTries,       /* number of times to try ARPing */
    int                 numTicks        /* number of ticks between ARPing */
    )
    {
    struct sockaddr_in  sockInetAddr;
    unsigned long	addr;
    int			retVal = 0;

    if (eHdr == NULL)		/* user messed up */
        return (ERROR);

    /* the 'targetAddr' can either be the hostname or the actual Internet
     * address.
     */
    if ((addr = (unsigned long) hostGetByName (targetAddr)) == ERROR &&
	(addr = inet_addr (targetAddr)) == ERROR)
	return (ERROR);

    sockInetAddr.sin_len = sizeof(struct sockaddr_in);
    sockInetAddr.sin_family = AF_INET;
    sockInetAddr.sin_addr.s_addr = addr; 

    /* return 0xffffffffffff for broadcast Internet address */

    if (in_broadcast (sockInetAddr.sin_addr, pIf))
	{
        bcopy ((char *) etherbroadcastaddr, eHdr, sizeof (etherbroadcastaddr));

	return (OK);
	}

    /* 
     * Try to resolve the Ethernet address by calling arpresolve() which
     * may send ARP request messages out onto the Ethernet wire.
     */

    while ((numTries == -1 || numTries-- > 0) &&
	   (retVal = arpresolve ((struct arpcom *) pIf, 
				 (struct rtentry *)NULL, 
				 (struct mbuf *) NULL,
				 (struct sockaddr *)&sockInetAddr,
				 (UCHAR *)eHdr))
	   == 0)
    	taskDelay (numTicks);

    if (retVal == 0)		/* unsuccessful resolution */
        return (ERROR);

    return (OK);
    }

/*******************************************************************************
*
* etherTypeGet - get the type from an ethernet packet
*
* This routine returns a short that is the ethertype (defined in RFC
* 1700) from either an 802.3 addressed packet or an RFC 894 packet.
* Most packets are encoded as described in RFC 894 but 802.3 addressing
* is also recognized.
* 
* RETURNS: A USHORT value that is the ethertype, or 0 on error.
*
* SEE ALSO:
* .I "RFC 894, TCP/IP Illustrated,"
* Volume 1, by Richard Stevens.
*/

USHORT etherTypeGet
    (
    char *pPacket		/* pointer to the beginning of the packet */
    )
    {

    ENET_HDR* pEnetHdr;
    struct llc* pLLCHdr;
    USHORT ether_type;

    /* Try for RFC 894 first as it's the most common. */
    pEnetHdr = (ENET_HDR *)pPacket;
    ether_type = ntohs(pEnetHdr->type);

    /* Deal with 802.3 addressing. */

    /* Here is the algorithm. */
    /* If the ether_type is less than the MTU then we know that */
    /* this is an 802.x address from RFC 1700. */
    if (ether_type < ETHERMTU)
	{
	pLLCHdr = (struct llc *) pPacket;

	/* Now it may be IP over 802.x so we check to see if the */
	/* destination SAP is IP, if so we snag the ethertype from the */
	/* proper place. */

	/* Now if it's NOT IP over 802.x then we just used the DSAP as */
	/* the ether_type.  */

	if (pLLCHdr->llc_dsap == LLC_SNAP_LSAP)
	    ether_type = ntohs(pLLCHdr->llc_un.type_snap.ether_type);
	else
	    ether_type = pLLCHdr->llc_dsap;
	}

    /* Finally!  Now, who says we should have standards comittees? */
    /* Wouldn't it be easier, and cheaper just to shoot these losers? */

    return (ether_type);

    }

/******************************************************************************
*
* etherInputHook - the system etherInputHook
*
* This routine multiplexes packets to multiple input hooks.
*
* RETURNS: TRUE if one of the routines that it called returns TRUE indicating
* that the hook routine "ate" the packet, otherwise it returns FALSE.
*
* NOMANUAL
*
*/

LOCAL BOOL etherInputHook
    (
    struct ifnet *pIf, 
    char *buffer, 
    int length
    )
    {

    HOOK_ENTRY *pHookEnt;
    extern LIST inputHookList;

    for (pHookEnt = (HOOK_ENTRY *)lstFirst(&inputHookList); 
         pHookEnt != NULL; pHookEnt = (HOOK_ENTRY *)lstNext(&pHookEnt->node))
	{
        if ((* pHookEnt->routine) (pIf, buffer, length))
            return (TRUE);
	}

    return (FALSE);

    }

/******************************************************************************
*
* etherOutputHook - the system etherOutputHook
*
* This routine is used to multiplex access to output hooks.
*
* RETURNS: TRUE if one of its callee consumed the packet otherwise returns
* FALSE.
*
* NOMANUAL
*/

LOCAL BOOL etherOutputHook
    (
    struct ifnet *pIf, 
    char *buffer, 
    int length
    )
    {

    HOOK_ENTRY* pHookEnt;
    extern LIST outputHookList;

    for (pHookEnt = (HOOK_ENTRY *)lstFirst(&outputHookList); 
         pHookEnt != NULL; pHookEnt = (HOOK_ENTRY *)lstNext(&pHookEnt->node))
	{
        if ((* pHookEnt->routine) (pIf, buffer, length))
            return (TRUE);
	}

    return (FALSE);

    }

LOCAL BOOL endEtherInputHookRtn
    (
    void * 	pCookie,
    long 	type,
    M_BLK_ID 	pMblk, 		/* Received frame (with link-level header). */
    LL_HDR_INFO * pLinkHdrInfo,
    void * 	pSpare 		/* Extra protocol data. Unused. */
    )
    {
    HOOK_ENTRY * pHookEnt = (HOOK_ENTRY*) pSpare;
    char devName[32];
    char packetData [ETHERMTU + SIZEOF_ETHERHEADER];
    struct ifnet fakeIF;
    extern LIST inputHookList;
    int flags;
    int len;
    END_OBJ* pEnd=(END_OBJ*)pCookie;
    int ifHdrLen=0;

    bzero ( (char *)&fakeIF, sizeof (fakeIF));
    fakeIF.if_name = &devName[0];
    strcpy (fakeIF.if_name, pEnd->devObject.name);
    fakeIF.if_unit = pEnd->devObject.unit;
    muxIoctl (pHookEnt->pCookie, EIOCGFLAGS, (caddr_t)&flags);
    fakeIF.if_flags = flags;
    
    /* Get the Link Level header length . */

    if (muxIoctl (pHookEnt->pCookie, EIOCGHDRLEN, (caddr_t)&ifHdrLen) != OK)
        fakeIF.if_hdrlen = 0;
    else
        fakeIF.if_hdrlen = (UCHAR)ifHdrLen;

    len = netMblkToBufCopy(pMblk, (char *)packetData, NULL);
    for (pHookEnt = (HOOK_ENTRY *)lstFirst (&inputHookList); 
         pHookEnt != NULL; pHookEnt = (HOOK_ENTRY *)lstNext (&pHookEnt->node))
        {
        if ( (* pHookEnt->routine) (&fakeIF, packetData, len))
            {
            netMblkClChainFree (pMblk);	/* hook has consumed the packet */
            return (TRUE);
            }
        }
    return (FALSE);
    }

/********************************************************************************
*
* nptEtherInputHookRtn- EtherInputHook Receive Routine
*
* This is the receive routine for the etherInputHook while binding to an NPT 
* device. This is very similar to endEtherInputHook except that it takes a
* different arguments.
*
*/

LOCAL BOOL nptEtherInputHookRtn
    (
    void *      pCallBackId,    /* Sent down in muxTkBind(); same as pSpare 
                                   as in muxBind() 
                                 */
    long        type,           /* SNARF */
    M_BLK_ID    pMblk,          /* Received frame (with link-level header). */
    void *      pSpareData      /* Extra protocol data */
    )
    {
    HOOK_ENTRY * pHookEnt = (HOOK_ENTRY*) pCallBackId;
    char devName[32];
    char packetData [ETHERMTU + SIZEOF_ETHERHEADER];
    struct ifnet fakeIF;
    extern LIST inputHookList;
    int flags;
    int len;
    END_OBJ* pEnd=PCOOKIE_TO_ENDOBJ(pHookEnt->pCookie);
    int ifHdrLen=0;


    bzero ( (char *)&fakeIF, sizeof (fakeIF));
    fakeIF.if_name = &devName[0];
    strcpy (fakeIF.if_name, pEnd->devObject.name);
    fakeIF.if_unit = pEnd->devObject.unit;
    muxIoctl (pHookEnt->pCookie, EIOCGFLAGS, (caddr_t)&flags);
    fakeIF.if_flags = flags;

    /* Get the Link Level header length . */

    if (muxIoctl (pHookEnt->pCookie, EIOCGHDRLEN, (caddr_t)&ifHdrLen) != OK)
        fakeIF.if_hdrlen = 0;
    else
        fakeIF.if_hdrlen = (UCHAR)ifHdrLen;

    len = netMblkToBufCopy(pMblk, (char *)packetData, NULL);
    for (pHookEnt = (HOOK_ENTRY *)lstFirst (&inputHookList);
         pHookEnt != NULL; pHookEnt = (HOOK_ENTRY *)lstNext (&pHookEnt->node))
        {
        if ( (* pHookEnt->routine) (&fakeIF, packetData, len))
            {
            netMblkClChainFree (pMblk); /* hook has consumed the packet */
            return (TRUE);
            }
        }
    return (FALSE);
    }