arplib.c

vxworks的完整的源代码

    if (arpCmd (SIOCDARP, &hostAddr, (u_char *) NULL, (int *) NULL) == ERROR)
	{
        errno = S_arpLib_INVALID_HOST;    /* No such entry in table. */
	return (ERROR);
	}

    return (OK);
    }

/*******************************************************************************
*
* arpCmd - issues an ARP command
*
* This routine generates the low-level ioctl call for an ARP command. Expected
* values for the <cmd> parameter are SIOCSARP, SIOCGARP, or SIOCDARP. 
* The <pIpAddr> parameter specifies the IP address of the host. The
* <pHwAddr> pointer provides the corresponding link-level address in
* binary form. That parameter is only used with SIOCSARP, and is limited
* to the 6-byte maximum required for Ethernet addresses. The <pFlags> 
* argument provides any flag settings for the entry.
*
* RETURNS: OK, or ERROR if unsuccessful.
*
* NOMANUAL
*
* INTERNAL
* This routine should be LOCAL, but it is also used by the proxy ARP
* library. That library should call the ioctl interface directly instead
* to avoid the overhead created by the additional routines in this
* module which it does not use.
*/

STATUS arpCmd
    (
    int                 cmd,			/* arp command		*/
    struct in_addr *    pIpAddr,		/* ip address		*/
    u_char *            pHwAddr,		/* hardware address	*/
    int *               pFlags			/* arp flags 		*/
    )

    {
    struct arpreq       arpRequest;		/* arp request struct	*/
    STATUS              status = ERROR;		/* return status 	*/
    int                 sock;			/* socket 		*/

    /* fill in arp request structure */

    bzero ((caddr_t) &arpRequest, sizeof (struct arpreq));
    arpRequest.arp_pa.sa_family = AF_INET;
    ((struct sockaddr_in *)
	&(arpRequest.arp_pa))->sin_addr.s_addr = pIpAddr->s_addr;
    arpRequest.arp_ha.sa_family = AF_UNSPEC;

    if (pHwAddr != NULL)
        bcopy ((caddr_t) pHwAddr ,(caddr_t) arpRequest.arp_ha.sa_data,
	       ENET_SIZE);

    if (pFlags != NULL)
    	arpRequest.arp_flags = *pFlags;

    if ((sock = socket (AF_INET, SOCK_RAW, 0)) != ERROR)
        {
        if ((status = ioctl (sock, cmd, (int) &arpRequest)) == OK)

	    {
    	    if (pHwAddr != NULL)
        	bcopy ((caddr_t) arpRequest.arp_ha.sa_data, (caddr_t) pHwAddr,
			ENET_SIZE);

	    if (pFlags != NULL)
    		*pFlags = arpRequest.arp_flags;
	    }
        close (sock);
        }

    return (status);
    }

/*******************************************************************************
*
* arpFlush - flush all entries in the system ARP table
*
* This routine flushes all non-permanent entries in the ARP cache.
*
* RETURNS: N/A
*/

void arpFlush (void)

    {
    register struct llinfo_arp *la;
    FAST struct rtentry * 	pRoute; 
    int				s;

#ifdef VIRTUAL_STACK
    virtualStackIdCheck();
    la = _llinfo_arp.la_next;
#else
    la = llinfo_arp.la_next;
#endif /* VIRTUAL_STACK */

    s = splnet ();

#ifdef VIRTUAL_STACK
    while (la != &_llinfo_arp) 
#else
    while (la != &llinfo_arp) 
#endif
	{
	pRoute = la->la_rt; 
	la = la->la_next;

	/* if entry permanent */
	if ((pRoute->rt_rmx.rmx_expire == 0) || (pRoute->rt_flags == 0))
	    continue;

	arptfree(la->la_prev); /* timer has expired; clear */
	}

    splx (s);
    }


/*******************************************************************************
*
* etherAsciiToEnet - convert Ethernet address
*
* This routine converts an Ethernet address in ascii format to its normal
* 48 bit format.  <asciiAddr> is the string Ethernet address which has the form
* "x:x:x:x:x:x" where x is a hexadecimal number between 0 and ff.  <retEnet> is
* where the Ethernet address gets returned.   This routine is similar to the
* UNIX call ether_aton.
*
* RETURNS: OK, or ERROR if unsuccessful.
*
* ERRNO: S_arpLib_INVALID_ENET_ADDRESS
*/

LOCAL STATUS etherAsciiToEnet
    (
    char *		asciiAddr,		/* enet addr in ascii	*/
    u_char *		retEnet			/* return enet addr	*/
    )

    {
    int			enet [ENET_SIZE];	/* Ethernet address     */
    int			ix;			/* index variable	*/

    if (sscanf (asciiAddr, "%x:%x:%x:%x:%x:%x", &enet [0],
		&enet [1], &enet [2], &enet [3], &enet [4],
		&enet [5]) != ENET_SIZE)
	{
	printf ("arp: invalid Ethernet address %s\n", asciiAddr);
	errno = S_arpLib_INVALID_ENET_ADDRESS;
	return (ERROR);
	}

    for (ix = 0; ix < ENET_SIZE; ix++)
	retEnet [ix] = (u_char) enet [ix];

   return (OK);
   }

/*******************************************************************************
*
* arpResolve - resolve a hardware address for a specified Internet address
*
* This routine uses the Address Resolution Protocol (ARP) and internal ARP
* cache to resolve the hardware address of a machine that owns the Internet
* address given in <targetAddr>.
*
* The hardware address is copied to <pHwAddr> as network byte order, if the
* resolution of <targetAddr> is successful.  <pHwAddr> must point to a buffer
* which is large enough to receive the address.
*
* NOTE: RFC 1122 prohibits sending more than one arp request per second.  Any
* numTicks value that would result in a shorter time than this is ignored.
*
* RETURNS:
* OK if the address is resolved successfully, or ERROR if <pHwAddr> is NULL,
* <targetAddr> is invalid, or address resolution is unsuccessful.
*
* ERRNO:
*  S_arpLib_INVALID_ARGUMENT
*  S_arpLib_INVALID_HOST
*
*/

STATUS arpResolve
    (
    char                *targetAddr,  /* name or Internet address of target */
    char                *pHwAddr,     /* where to return the H/W address */
    int                 numTries,     /* number of times to try ARPing (-1 means try
                                         forever) */
    int                 numTicks      /* number of ticks between ARPs */
    )
    {
    struct ifnet *	pIf = NULL;
    struct sockaddr_in  sockInetAddr;
    struct rtentry *	pRt;
    unsigned long	addr;
    int			retVal = 0;

    if (pHwAddr == NULL || numTries < -1 || numTries == 0)     /* user messed up */
	{
	errno = S_arpLib_INVALID_ARGUMENT;
        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)
	{
	errno = S_arpLib_INVALID_HOST;
	return (ERROR);
	}

    bzero ((caddr_t)&sockInetAddr, sizeof (sockInetAddr));
    sockInetAddr.sin_len = sizeof(struct sockaddr_in);
    sockInetAddr.sin_family = AF_INET;
    sockInetAddr.sin_addr.s_addr = addr; 

    /*
     * Get associated local interface's ifnet. This search also
     * clones an empty ARP entry from the interface route if one
     * does not already exist.
     */

    pRt = rtalloc1 ( (struct sockaddr *)&sockInetAddr, 1);
    if (pRt == NULL)
	{
	errno = S_arpLib_INVALID_HOST;
	return (ERROR);
	}

    pIf = pRt->rt_ifp;
    if (pIf == NULL)
	{
        rtfree (pRt);
	errno = S_arpLib_INVALID_HOST;
	return (ERROR);
	}

    /* return 0xffffffffffff for broadcast Internet address */

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

        rtfree (pRt);

	return (OK);
	}

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

    while ((numTries == -1 || numTries-- > 0) &&
	   (retVal = arpresolve ((struct arpcom *) pIf, 
				 (struct rtentry *)pRt, 
				 (struct mbuf *) NULL,
				 (struct sockaddr *)&sockInetAddr,
				 (UCHAR *)pHwAddr))
	   == 0)
    	if (numTries)           /* don't delay after last arp */
            taskDelay (numTicks);

    rtfree (pRt);

    if (retVal == 0)		/* unsuccessful resolution */
	{
	errno = S_arpLib_INVALID_HOST;
        return (ERROR);
	}

    return (OK);
    }