dhcpcboot.c

VXWORKS源代码

    (
    void
    )
    {
    time_t	curr_epoch = 0;
    struct sockaddr_in dest;
    BOOL bcastFlag;

    if (dhcpTime (&curr_epoch) == -1)
        return (-1);

    /* Update the appropriate fields in the current DHCP message. */

    if (dhcpcCurrState != REQUESTING)
        dhcpcMsgOut.dhcp->secs = htons (curr_epoch -
                                        dhcpcBootLeaseData.initEpoch);

    dhcpcMsgOut.udp->uh_sum = 0;
    dhcpcMsgOut.udp->uh_sum = udp_cksum (&spudph, (char *)dhcpcMsgOut.udp, 
                                         ntohs (spudph.ulen));

    /*
     * Retransmit the message. Set the flag to use a link-level broadcast
     * address if needed (prevents ARP messages if using Ethernet devices).
     */

    bzero ( (char *)&dest, sizeof (struct sockaddr_in));

    dest.sin_len = sizeof (struct sockaddr_in);
    dest.sin_family = AF_INET;
    dest.sin_addr.s_addr = dhcpcMsgOut.ip->ip_dst.s_addr;

    if (dest.sin_addr.s_addr == 0xffffffff)
        bcastFlag = TRUE;
    else
        bcastFlag = FALSE;

    if (dhcpSend (dhcpcBootLeaseData.ifData.iface, &dest, 
                  sbuf.buf, dhcpcMsgLength, bcastFlag)
           == ERROR)
        return (-2);
    return(0);
    }


/*******************************************************************************
*
* retrans_wait_offer - retransmission in WAIT_OFFER state
*
* This routine retransmits the DHCP discover message when the timeout interval 
* for receiving an initial lease offer expires. It is called in response
* to a watchdog timer at intervals specified by the wait_offer() routine.
*
* RETURNS: N/A
*
* ERRNO: N/A
*
* NOMANUAL
*/

LOCAL void retrans_wait_offer
    (
    int unused 		/* unused watchdog argument */
    )
    {
    int status;

    if (dhcpcCurrState != WAIT_OFFER)
        return;

    /* Construct and send a timeout message to the finite state machine. */

    status = dhcpcEventAdd (DHCP_AUTO_EVENT, DHCP_TIMEOUT, NULL, TRUE);

#ifdef DHCPC_DEBUG
    if (status == ERROR)
        logMsg ("Can't notify state machine\n", 0, 0, 0, 0, 0, 0);
#endif

    return;
    }

/*******************************************************************************
*
* alarm_selecting - signal when collection time expires 
*
* This routine sends a timeout notification to the finite state machine 
* when the interval for collecting additional DHCP offers has expired. It 
* is called in response to a watchdog timer schedule by the selecting()
* routine. The timeout causes the state machine to advance to the REQUESTING
* state.
*
* RETURNS: N/A
*
* ERRNO: N/A
*
* NOMANUAL
*/

LOCAL void alarm_selecting
    (
    int unused 		/* unused watchdog argument */
    )
    {
    int 	status;

    if (dhcpcCurrState == SELECTING) 
        {
        /* Construct and send a timeout message to the finite state machine. */

        status = dhcpcEventAdd (DHCP_AUTO_EVENT, DHCP_TIMEOUT, NULL, TRUE);

#ifdef DHCPC_DEBUG
        if (status == ERROR)
            logMsg ("Can't notify state machine\n", 0, 0, 0, 0, 0, 0);
#endif
        }
    return;
    }

/*******************************************************************************
*
* retrans_requesting - retransmission in requesting state
*
* This routine retransmits the DHCP request message when the timeout interval 
* for receiving a server reply expires. It is called in response to a watchdog 
* timer at intervals specified by the requesting() routine.
*
* RETURNS: N/A
*
* ERRNO: N/A
*
* NOMANUAL
*/

LOCAL void retrans_requesting
    (
    int unused 		/* unused watchdog argument */
    )
    {
    int		status;

    if (dhcpcCurrState != REQUESTING)
        return;

    /* Construct and send a timeout message to the finite state machine. */

    status = dhcpcEventAdd (DHCP_AUTO_EVENT, DHCP_TIMEOUT, NULL, TRUE);

#ifdef DHCPC_DEBUG
    if (status == ERROR)
        logMsg ("Can't notify state machine\n", 0, 0, 0, 0, 0, 0);
#endif

    return;
    }

/*******************************************************************************
*
* dhcpcBootInforming - external configuration state of boot-time state machine
*
* This routine begins the inform message process, which obtains additional
* parameters for a host configured with an external address. This processing
* is isolated from the normal progression through the state machine. Like the
* DHCP discover message, the inform message is the first transmission.
* However, the only valid response is an acknowledgement by a server. As a
* result, the process is a hybrid between the implementations of the initial 
* state and the requesting state which finalizes the lease establishment.
* This routine implements the initial state of the finite state machine for
* an externally assigned IP address.
*
* RETURNS: Next state of state machine, or -1 if error.
*
* ERRNO: N/A
*
* NOMANUAL
*/

LOCAL int dhcpcBootInforming
    (
    void
    )
    {
    struct sockaddr_in 	dest;

    bzero (sbuf.buf, sbuf.size);

#ifdef DHCPC_DEBUG
    logMsg("dhcpc: Entered INFORM state.\n", 0, 0, 0, 0, 0, 0);
#endif

    /* Create and broadcast DHCP INFORM message. */

    dhcpcMsgLength = make_request (dhcpcBootParam, INFORMING);
    if (dhcpcMsgLength < 0)
        {
#ifdef DHCPC_DEBUG
        logMsg ("Error making DHCP inform message. Can't continue.\n",
                0, 0, 0, 0, 0, 0);
#endif
        return (-1);
        }

    dhcpcMsgOut.dhcp->secs = 0;
    dhcpcMsgOut.udp->uh_sum = 0;
    dhcpcMsgOut.udp->uh_sum = udp_cksum (&spudph, (char *)dhcpcMsgOut.udp, 
                                         ntohs (spudph.ulen));

#ifdef DHCPC_DEBUG
    logMsg ("Sending DHCPINFORM\n", 0, 0, 0, 0, 0, 0);
#endif

    /*
     * Retransmit the message using a link-level broadcast address, which
     * prevents ARP messages if using Ethernet devices and allows transmission
     * from interfaces without assigned IP addresses.
     */

    bzero ( (char *)&dest, sizeof (struct sockaddr_in));

    dest.sin_len = sizeof (struct sockaddr_in);
    dest.sin_family = AF_INET;
    dest.sin_addr.s_addr = dhcpcMsgOut.ip->ip_dst.s_addr;

    if (dhcpSend (dhcpcIntface.iface, &dest, sbuf.buf, dhcpcMsgLength, TRUE)
           == ERROR)
        {
#ifdef DHCPC_DEBUG
        logMsg("Can't send DHCPINFORM\n", 0, 0, 0, 0, 0, 0);
#endif
        return (-1);
        }

    /* Set retransmission timer to randomized exponential backoff. */

    dhcpcBootLeaseData.timeout = FIRSTTIMER;
    dhcpcBootLeaseData.numRetry = 0;

    wdStart (dhcpcBootLeaseData.timer, sysClkRateGet() *
                                  SLEEP_RANDOM (dhcpcBootLeaseData.timeout),
             (FUNCPTR)retrans_requesting, 0);

    return (REQUESTING);	/* Next state is REQUESTING */
    }

/*******************************************************************************
*
* dhcpcBootInitState - initial state of boot-time client finite state machine
*
* This routine implements the initial state of the finite state machine. 
* After a random backoff delay, it broadcasts a DHCP discover message. This 
* state may be re-entered after a later state if a recoverable error occurs.
*
* RETURNS: Next state of state machine, or -1 if error.
*
* ERRNO: N/A
*
* NOMANUAL
*/

LOCAL int dhcpcBootInitState
    (
    void
    )
    {
    struct sockaddr_in 	dest;

    bzero (sbuf.buf, sbuf.size);

#ifdef DHCPC_DEBUG
    logMsg("dhcpc: Entered INIT state.\n", 0, 0, 0, 0, 0, 0);
#endif

    /*
     * Set lease to generate newer RFC 2131 messages initially. The client
     * will revert to the older message format if it does not receive a
     * response to the initial set of discover messages. Older servers might
     * ignore messages less than the minimum length obtained with a fixed
     * options field. The older format pads the field to reach that length.
     */

    dhcpcOldFlag = FALSE;

    wdCancel (dhcpcBootLeaseData.timer);	/* Reset watchdog timer. */

    dhcpcMsgLength = make_discover ();    /* Create DHCP_DISCOVER message. */

    /* 
     * Random delay from one to ten seconds to avoid startup congestion.
     * (Delay length specified in RFC 1541).
     *
     */

    taskDelay (sysClkRateGet () * (1 + (rand () % INIT_WAITING)) );

    dhcpcMsgOut.dhcp->secs = 0;
    dhcpcMsgOut.udp->uh_sum = 0;
    dhcpcMsgOut.udp->uh_sum = udp_cksum (&spudph, (char *)dhcpcMsgOut.udp, 
                                         ntohs (spudph.ulen));

#ifdef DHCPC_DEBUG
    logMsg ("Sending DHCPDISCOVER\n", 0, 0, 0, 0, 0, 0);
#endif

    /*
     * Retransmit the message using a link-level broadcast address, which
     * prevents ARP messages if using Ethernet devices and allows transmission
     * from interfaces without assigned IP addresses.
     */

    bzero ( (char *)&dest, sizeof (struct sockaddr_in));

    dest.sin_len = sizeof (struct sockaddr_in);
    dest.sin_family = AF_INET;
    dest.sin_addr.s_addr = dhcpcMsgOut.ip->ip_dst.s_addr;

    if (dhcpSend (dhcpcIntface.iface, &dest, sbuf.buf, dhcpcMsgLength, TRUE)
            == ERROR)
        {
#ifdef DHCPC_DEBUG
        logMsg("Can't send DHCPDISCOVER\n", 0, 0, 0, 0, 0, 0);
#endif
        return (-1);
        }

    dhcpcBootLeaseData.timeout = FIRSTTIMER;
    dhcpcBootLeaseData.numRetry = 0;

    if (dhcpTime (&dhcpcBootLeaseData.initEpoch) == -1)
        {
#ifdef DHCPC_DEBUG
        logMsg ("time() error setting initEpoch\n", 0, 0, 0, 0, 0, 0);
#endif
        return (ERROR);
        }

    /* Set timer to randomized exponential backoff before retransmission. */

    wdStart (dhcpcBootLeaseData.timer, sysClkRateGet() *
                                  SLEEP_RANDOM (dhcpcBootLeaseData.timeout),
             (FUNCPTR)retrans_wait_offer, 0);

    return (WAIT_OFFER);	/* Next state is WAIT_OFFER */
    }

/*******************************************************************************
*
* dhcpcBootWaitOffer - Initial offering state of client finite state machine
*
* This routine implements the initial part of the second state of the finite 
* state machine. It waits until the current timeout value to receive a lease 
* offer from  a DHCP server. If a timeout occurs, the DHCP offer message is 
* retransmitted.
*
* RETURNS: Next state of state machine, or -1 if error.
*
* ERRNO: N/A
*
* NOMANUAL
*/

LOCAL int dhcpcBootWaitOffer
    (
    void
    )
    {
    int			arpans = 0;
    char		errmsg [255];
    char * 		pOption;
    int 		timer = 0;
    int 		retry = 0;
    struct dhcp_param *	pParams = NULL;
    char * 		pMsgData;
    int 		status;
    EVENT_DATA 		msgEvent;

    bzero (errmsg, sizeof (errmsg));

#ifdef DHCPC_DEBUG
    logMsg ("dhcpc: Entered WAIT_OFFER state.\n", 0, 0, 0, 0, 0, 0);
#endif

    if (dhcpcPrevState == INIT) 
        {
        /* Clear any previous parameter settings. */

        if (dhcpcBootParam != NULL)
            {
            clean_param (dhcpcBootParam);
            free (dhcpcBootParam);
            dhcpcBootParam = NULL;
            }
        }

    /* Wait for message or retransmission. */

    semTake (dhcpcEventSem, WAIT_FOREVER); 

    status = rngBufGet (dhcpcEventRing, (char *)&msgEvent, sizeof (msgEvent));
    if (status != sizeof (msgEvent))
        {
        /* Expected event missing or incomplete - remain in current state. */

#ifdef DHCPC_DEBUG
        logMsg ("dhcpWaitOffer: Notification error.\n", 0, 0, 0, 0, 0, 0);
#endif
        return (WAIT_OFFER);
        }

    if (msgEvent.type == DHCP_TIMEOUT)
        {
        /* Handle timeout - no DHCP offers received yet. */

        retry = dhcpcBootLeaseData.numRetry;
        timer = dhcpcBootLeaseData.timeout;

        retry++;
        if (retry == DISCOVER_RETRANS)	
            {
#ifdef DHCPC_DEBUG
            logMsg ("No lease offers received by client.\n", 0, 0, 0, 0, 0, 0);
#endif