dhcpcboot.c

VxWorks下DHCP的源代码！

*
* This routine retransmits the current DHCP client message (a discover or
* a request message) when the appropriate timeout interval expires.
* It is called from multiple locations in the finite state machine.
*
* RETURNS: 0 if transmission completed, or negative value on error.
*
* ERRNO: N/A
*
* NOMANUAL
*/

LOCAL int gen_retransmit (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