#endif    return;}/********************************************************************************* retrans_requesting - signal when reception interval for initial reply expires** This routine sends a timeout notification to the client monitor task when* the interval for receiving a server reply to a lease request expires. It* is called at interrupt level by a watchdog timer. The monitor task will * eventually execute the REQUESTING state to process the timeout event and * retransmit the DHCP request message.** RETURNS: N/A** ERRNO: N/A** NOMANUAL*/void retrans_requesting (LEASE_DATA * pLeaseData    /* lease-specific status information */    ){    /*      * Ignore the timeout if a state transition occurred during      * the scheduled timer interval.     */    if (pLeaseData->currState != REQUESTING)        return;    /* Construct and send a timeout message to the lease monitor task. */    dhcpcEventAdd (DHCP_AUTO_EVENT, DHCP_TIMEOUT, pLeaseData, TRUE);#ifdef DHCPC_DEBUG    logMsg ("retransmit DHCPREQUEST(REQUESTING)\n", 0, 0, 0, 0, 0, 0);#endif    return;}/********************************************************************************* inform - external configuration state of client finite 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.** The routine implements the initial state of the finite state machine for an* externally assigned IP address. It is invoked by the event handler of the* client monitor task, and should only be called internally.** RETURNS: OK (processing completes), DHCPC_DONE (remove lease), or ERROR.** ERRNO: N/A** NOMANUAL*/int inform (EVENT_DATA * pEvent /* pointer to event descriptor */    ){    LEASE_DATA *pLeaseData = NULL;    struct sockaddr_in dest;    struct ifnet *pIf;    int length;                 /* Amount of data in message */    if (pEvent->source == DHCP_AUTO_EVENT) {        /*         * Received DHCP messages or timeouts can only reach this         * routine when repeating the DHCP INFORM message exchange.         * Ignore these stale notifications.         */        return (OK);    }    bzero (sbuf.buf, sbuf.size);#ifdef DHCPC_DEBUG    logMsg ("dhcpc: Entered INFORM state.\n", 0, 0, 0, 0, 0, 0);#endif    /*     * Use the cookie to access the lease-specific data structures. For now,     * just typecast the cookie. This translation could be replaced with a more     * sophisticated lookup at some point.     */    pLeaseData = (LEASE_DATA *) pEvent->leaseId;    wdCancel (pLeaseData->timer);   /* Reset watchdog timer. */    /*     * The DHCP_USER_RELEASE event occurs in response to the dhcpcRelease()     * or dhcpcShutdown() call. Remove all data structures for this lease.     */    if (pEvent->type == DHCP_USER_RELEASE) {        dhcpcLeaseCleanup (pLeaseData);        return (DHCPC_DONE);    }    /*     * Set lease to generate newer RFC 2131 messages. Older servers might     * ignore messages if their length is less than the minimum length     * obtained with a fixed options field, but will not recognize an     * inform message anyway.     */    pLeaseData->oldFlag = FALSE;    /* Create DHCP INFORM message and assign new transaction ID. */    length = make_request (pLeaseData, INFORMING, TRUE);    if (length < 0) {#ifdef DHCPC_DEBUG        logMsg ("Error making DHCP inform message. Can't continue.\n", 0, 0, 0, 0, 0, 0);#endif        return (ERROR);    }    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    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;    pIf = pLeaseData->ifData.iface;    if (dhcpSend (pIf, &dest, sbuf.buf, length, TRUE) == ERROR) {#ifdef DHCPC_DEBUG        logMsg ("Can't send DHCPINFORM.\n", 0, 0, 0, 0, 0, 0);#endif        return (ERROR);    }    /* Set lease data to execute next state and start retransmission timer. */    pLeaseData->prevState = INFORMING;    pLeaseData->currState = REQUESTING;    pLeaseData->timeout = FIRSTTIMER;    pLeaseData->numRetry = 0;    wdStart (pLeaseData->timer, sysClkRateGet () *             SLEEP_RANDOM (pLeaseData->timeout), (FUNCPTR) retrans_requesting, (int) pLeaseData);    return (OK);                /* Next state is REQUESTING */}/********************************************************************************* init - initial state of client finite state machine** This routine implements the initial state of the finite state machine. * After a random backoff delay, it resets the network interface if necessary* and transmits the DHCP discover message. This state may be repeated after a * later state if a lease is not renewed or a recoverable error occurs. It * could also be executed following unrecoverable errors. The routine is * invoked by the event handler of the client monitor task, and should only be * called internally.** RETURNS: OK (processing completes), DHCPC_DONE (remove lease), or ERROR.** ERRNO: N/A** NOMANUAL*/int init (EVENT_DATA * pEvent   /* pointer to event descriptor */    ){    LEASE_DATA *pLeaseData = NULL;    STATUS result;    struct sockaddr_in dest;    struct ifnet *pIf;    int length;    bzero (sbuf.buf, sbuf.size);#ifdef DHCPC_DEBUG    logMsg ("dhcpc: Entered INIT state.\n", 0, 0, 0, 0, 0, 0);#endif    /*     * Use the cookie to access the lease-specific data structures. For now,     * just typecast the cookie. This translation could be replaced with a more     * sophisticated lookup at some point.     */    pLeaseData = (LEASE_DATA *) pEvent->leaseId;    wdCancel (pLeaseData->timer);   /* Reset watchdog timer. */    /*     * The DHCP_USER_RELEASE event occurs in response to the dhcpcRelease()     * or dhcpcShutdown() call. Remove all data structures for this lease.     */    if (pEvent->type == DHCP_USER_RELEASE) {        dhcpcLeaseCleanup (pLeaseData);        return (DHCPC_DONE);    }    /*      * Unrecoverable errors are only removed when the dhcpcBind() call sets     * the state indicators to INIT_REBOOT. Ignore all other events until then.     */    if (pLeaseData->prevState == DHCPC_ERROR)        return (OK);    semTake (dhcpcMutexSem, WAIT_FOREVER);  /* Reset status indicator. */    pLeaseData->leaseGood = FALSE;    semGive (dhcpcMutexSem);    /*     * 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.     */    pLeaseData->oldFlag = FALSE;    /* Create DHCP_DISCOVER message and assign new transaction ID. */    length = make_discover (pLeaseData, TRUE);    /*      * Random delay from one to ten seconds to avoid startup congestion.     * (Delay length specified in RFC 1541).     *     */    taskDelay (sysClkRateGet () * (1 + (rand () % INIT_WAITING)));    /*      * If an event notification hook is present, send a notification of     * the lease expiration when appropriate. (None is needed after a reboot).     */    if (pLeaseData->eventHookRtn != NULL) {        if (pLeaseData->prevState != REBOOTING && pLeaseData->prevState != INIT_REBOOT)            result = (*pLeaseData->eventHookRtn) (DHCPC_LEASE_INVALID, pEvent->leaseId);    }    /*      * Reset the network interface if it used the address     * information provided by the indicated lease.     */    if (pLeaseData->autoConfig || pLeaseData->leaseType == DHCP_AUTOMATIC) {        reset_if (&pLeaseData->ifData);    }    dhcpcMsgOut.dhcp->secs = 0;    dhcpcMsgOut.udp->uh_sum = 0;    dhcpcMsgOut.udp->uh_sum = udp_cksum (&spudph, (char *) dhcpcMsgOut.udp, ntohs (spudph.ulen));    if (dhcpTime (&pLeaseData->initEpoch) == -1) {#ifdef DHCPC_DEBUG        logMsg ("time() error setting initEpoch\n", 0, 0, 0, 0, 0, 0);#endif        return (ERROR);    }#ifdef DHCPC_DEBUG    logMsg ("Sending DHCPDISCOVER\n", 0, 0, 0, 0, 0, 0);#endif    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;    pIf = pLeaseData->ifData.iface;    if (dhcpSend (pIf, &dest, sbuf.buf, length, TRUE) == ERROR) {#ifdef DHCPC_DEBUG        logMsg ("Can't send DHCPDISCOVER\n", 0, 0, 0, 0, 0, 0);#endif        return (ERROR);    }    /* Set lease data to execute next state and start retransmission timer. */    pLeaseData->prevState = INIT;    pLeaseData->currState = WAIT_OFFER;    pLeaseData->timeout = FIRSTTIMER;    pLeaseData->numRetry = 0;    wdStart (pLeaseData->timer, sysClkRateGet () *             SLEEP_RANDOM (pLeaseData->timeout), (FUNCPTR) retrans_wait_offer, (int) pLeaseData);    return (OK);                /* Next state is WAIT_OFFER */}/********************************************************************************* wait_offer - Initial offering state of client finite state machine** This routine contains the initial part of the second state of the finite * state machine. It handles all processing until an acceptable DHCP offer is * received. If a timeout occurred, it retransmits the DHCP discover message. * Otherwise, it evaluates the parameters contained in the received DHCP offer. * If the minimum requirements are met, processing will continue with the * selecting() routine. If no offer is received before the retransmission* limit is reached, the negotiation process fails.* .IP* This routine is invoked by the event handler of the client monitor task, * and should only be called internally. Any user requests generated by * incorrect calls or delayed responses to the dhcpcBind() and dhcpcVerify()* routines are ignored.** RETURNS: OK (processing completes), DHCPC_DONE (remove lease), or ERROR.** ERRNO: N/A** NOMANUAL*/int wait_offer (EVENT_DATA * pEvent /* pointer to event descriptor */    ){    char errmsg[255];    char *option;    int timer = 0;    int retry = 0;    struct dhcp_param *pParams = NULL;    LEASE_DATA *pLeaseData = NULL;    char *pMsgData;    int length;    /*     * Use the cookie to access the lease-specific data structures. For now,     * just typecast the cookie. This translation could be replaced with a more