dhcpcstate2.c

vxworks下dhcpc,dhcpr,dhcps库源码

                /* DHCP request sent. Set lease data to execute next state. */

                pLeaseData->prevState = BOUND;
                pLeaseData->currState = RENEWING;

                pLeaseData->initEpoch = curr_epoch;

                /*
                 * Set the retransmission timer to wait for one-half of the 
                 * remaining time before T2 expires, or 60 seconds if T2 
                 * expires in less than one minute.
                 */

                timeout = limit - curr_epoch;
                timeout /= 2;
                if (timeout < 60)
                    timeout = 60;

                /* Set timer for retransmission of request message. */

                wdStart (pLeaseData->timer, sysClkRateGet () * timeout,
                         (FUNCPTR) retrans_renewing, (int) pLeaseData);

                return (OK);
            }
        }                       /* End of timeout processing. */
    } /* End of automatic events. */
    else {
        /* Process user requests. */

        if (pEvent->type == DHCP_USER_RELEASE) {    /* Relinquish lease. */
            release (pLeaseData, TRUE);
            return (DHCPC_DONE);
        }
        if (pEvent->type == DHCP_USER_VERIFY) { /* Verify lease */
            /* Set the lease data to execute verify() routine. */

            pLeaseData->prevState = BOUND;
            pLeaseData->currState = VERIFY;

            return (DHCPC_MORE);
        }
    }
    return (OK);
}

/*******************************************************************************
*
* renewing - Specific lease renewal state of client finite state machine
*
* This routine contains the fifth state of the client finite state machine.
* During this state, a DHCP lease is active. The routine handles all 
* processing after the first lease timer has expired. If the server which 
* issued the corresponding lease acknowledges the request for renewal, 
* processing returns to the bound() routine. If the request is denied, the 
* negotiation process restarts with the init() routine. If a timeout occurs
* before the second lease timer has expired, the DHCP request message is 
* retransmitted. Otherwise, processing continues with the rebinding() routine.
* .IP
* This routine is invoked by the event handler of the client monitor task,
* and should only be called internally. Any arriving DHCP messages containing
* stale offers from earlier states are discarded. User requests generated
* by calls to the dhcpcRelease() and dhcpcVerify() routines are accepted.
*
* RETURNS: OK (processing complete), DHCPC_DONE (remove lease),
*          DHCPC_MORE (continue), or ERROR.
*
* ERRNO: N/A
*
* NOMANUAL
*/

int renewing (EVENT_DATA * pEvent   /* pointer to event descriptor */
    )
{
    char *option = NULL;
    char errmsg[255];
    time_t curr_epoch = 0;
    int timeout = 0;
    int limit;
    int length;
    struct dhcp_param tmpparam;
    int msgtype;

#ifdef DHCPC_DEBUG
    char newAddr[INET_ADDR_LEN];
#endif

    LEASE_DATA *pLeaseData;
    char *pMsgData;

    struct sockaddr_in dest;
    struct ifnet *pIf;

    bzero (errmsg, sizeof (errmsg));

    if (dhcpTime (&curr_epoch) == -1) {
#ifdef DHCPC_DEBUG
        logMsg ("time() error in renewing()\n", 0, 0, 0, 0, 0, 0);
#endif
        return (ERROR);
    }

    /*
     * 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;

    if (pEvent->source == DHCP_AUTO_EVENT) {
        if (pEvent->type == DHCP_TIMEOUT) {
            /*
             * The interval between a timeout event and the entry to the 
             * renewing() routine depends on the workload of the client 
             * monitor task and is completely unpredictable. Either the 
             * entire lease or the second lease timer may have expired 
             * during that time. Also, the final (60 second) retransmission 
             * timeout will always end after timer T2 has expired. If T2
             * has expired but the lease has not, set the lease data to 
             * continue with the rebinding() routine. If the lease has
             * expired, return to the initial state. Otherwise (the most
             * likely case), retransmit the request message since T2 has
             * not expired.
             */

            limit = pLeaseData->dhcpcParam->lease_origin + pLeaseData->dhcpcParam->lease_duration;
            if (curr_epoch >= limit) {
                /* Lease expired before processing started. */

                pLeaseData->prevState = RENEWING;
                pLeaseData->currState = INIT;
                return (DHCPC_MORE);
            }

            limit = pLeaseData->dhcpcParam->lease_origin + pLeaseData->dhcpcParam->dhcp_t2;
            if (limit <= curr_epoch) {
                /* 
                 * Second timer expired: 
                 *     request configuration data from any server. 
                 */

                length = make_request (pLeaseData, REBINDING, TRUE);
                if (length < 0) {
#ifdef DHCPC_DEBUG
                    logMsg ("Error making rebind request. Entering INIT state.\n",
                            0, 0, 0, 0, 0, 0);
#endif
                    pLeaseData->prevState = RENEWING;
                    pLeaseData->currState = INIT;
                    return (DHCPC_MORE);
                }

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

                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 DHCPREQUEST(REBINDING)\n", 0, 0, 0, 0, 0, 0);
#endif
                    pLeaseData->prevState = RENEWING;
                    pLeaseData->currState = INIT;
                    return (DHCPC_MORE);
                }

                /* DHCP request sent. Set lease data to execute next state. */

                pLeaseData->prevState = RENEWING;
                pLeaseData->currState = REBINDING;

                pLeaseData->initEpoch = curr_epoch;

                /*
                 * Set the retransmission timer to wait for one-half of the
                 * remaining time before the lease expires, or 60 seconds if
                 * it expires in less than one minute.
                 */

                timeout = pLeaseData->dhcpcParam->lease_origin +
                    pLeaseData->dhcpcParam->lease_duration - curr_epoch;
                timeout /= 2;
                if (timeout < 60)
                    timeout = 60;

                /* Set timer for retransmission of request message. */

                wdStart (pLeaseData->timer, sysClkRateGet () * timeout,
                         (FUNCPTR) retrans_rebinding, (int) pLeaseData);
            } else {
                /* Transmit lease renewal request to issuing server. */

                length = make_request (pLeaseData, RENEWING, FALSE);

                if (send_unicast (&pLeaseData->dhcpcParam->server_id, dhcpcMsgOut.dhcp, length)
                    < 0) {
#ifdef DHCPC_DEBUG
                    logMsg ("Can't send DHCPREQUEST(RENEWING)\n", 0, 0, 0, 0, 0, 0);
#endif
                    pLeaseData->prevState = RENEWING;
                    pLeaseData->currState = INIT;
                    return (DHCPC_MORE);
                }

                pLeaseData->prevState = RENEWING;
                pLeaseData->currState = RENEWING;
                pLeaseData->initEpoch = curr_epoch;

                /*
                 * Set the retransmission timer to wait for one-half of the
                 * remaining time before T2 expires, or 60 seconds if T2
                 * expires in less than one minute.
                 */

                timeout = limit - curr_epoch;
                timeout /= 2;
                if (timeout < 60)
                    timeout = 60;

                /* Set timer for retransmission of request message. */

                wdStart (pLeaseData->timer, sysClkRateGet () * timeout,
                         (FUNCPTR) retrans_renewing, (int) pLeaseData);
            }
        } /* End of timeout processing. */
        else {
            bzero ((char *) &tmpparam, sizeof (tmpparam));

            /*
             * Process DHCP message stored in receive buffer by monitor task.
             * The 4-byte alignment of the IP header needed by Sun BSP's is
             * guaranteed by the Berkeley Packet Filter during input.
             */

            pMsgData = pLeaseData->msgBuffer;

            align_msg (&dhcpcMsgIn, pMsgData);

            /* Examine type of message. Accept DHCPACK or DHCPNAK replies. */

            option = (char *) pickup_opt (dhcpcMsgIn.dhcp,
                                          DHCPLEN (dhcpcMsgIn.udp), _DHCP_MSGTYPE_TAG);
            if (option == NULL) {
                /*
                 * Message type not found -  ignore untyped DHCP messages, and
                 * any BOOTP replies.
                 */

                return (OK);
            } else {
                msgtype = *OPTBODY (option);
                if (msgtype == DHCPNAK) {
#ifdef DHCPC_DEBUG
                    logMsg ("Got DHCPNAK in renewing()\n", 0, 0, 0, 0, 0, 0);

                    option = (char *) pickup_opt (dhcpcMsgIn.dhcp,
                                                  DHCPLEN (dhcpcMsgIn.udp), _DHCP_ERRMSG_TAG);
                    if (option != NULL &&
                        nvttostr (OPTBODY (option), errmsg, (int) DHCPOPTLEN (option)) == 0)
                        logMsg ("DHCPNAK contains the error message \"%s\"\n",
                                (int) errmsg, 0, 0, 0, 0, 0);
#endif
                    clean_param (pLeaseData->dhcpcParam);
                    free (pLeaseData->dhcpcParam);
                    pLeaseData->dhcpcParam = NULL;

                    pLeaseData->prevState = RENEWING;
                    pLeaseData->currState = INIT;
                    return (DHCPC_MORE);
                } else if (msgtype == DHCPACK) {
                    /* Fill in host requirements defaults. */

                    dhcpcDefaultsSet (&tmpparam);

                    if (dhcp_msgtoparam (dhcpcMsgIn.dhcp,
                                         DHCPLEN (dhcpcMsgIn.udp), &tmpparam) == OK) {
                        merge_param (pLeaseData->dhcpcParam, &tmpparam);
                        *(pLeaseData->dhcpcParam) = tmpparam;
                        pLeaseData->dhcpcParam->lease_origin = pLeaseData->initEpoch;
#ifdef DHCPC_DEBUG
                        inet_ntoa_b (pLeaseData->dhcpcParam->yiaddr, newAddr);
                        logMsg ("Got DHCPACK (IP = %s, duration = %d secs)\n",
                                (int) newAddr, pLeaseData->dhcpcParam->lease_duration, 0, 0, 0, 0);
#endif
                        /* 
                         * Send an ARP reply to update the ARP cache on other
                         * hosts if the assigned IP address was applied to
                         * the underlying network interface.
                         */

                        if (pLeaseData->autoConfig || pLeaseData->leaseType == DHCP_AUTOMATIC)
                            arp_reply (&pLeaseData->dhcpcParam->yiaddr, &pLeaseData->ifData);

                        pLeaseData->prevState = RENEWING;
                        pLeaseData->currState = BOUND;
                    }
                    return (DHCPC_MORE);
                }
            }                   /* End of processing for typed DHCP message. */
        }                       /* End of DHCP message processing. */
    } else {
        /* Process user requests. */

        if (pEvent->type == DHCP_USER_RELEASE) {    /* Relinquish lease. */
            release (pLeaseData, TRUE);
            return (DHCPC_DONE);
        }
        if (pEvent->type == DHCP_USER_VERIFY) { /* Verify lease. */
            /* Set the lease data to execute verify() routine. */

            pLeaseData->prevState = RENEWING;
            pLeaseData->currState = VERIFY;

            return (DHCPC_MORE);
        }
    }
    return (OK);
}


/*******************************************************************************
*
* rebinding - Promiscuous lease renewal state of client finite state machine
*
* This routine contains the sixth state of the client finite state machine.
* During this state, a DHCP lease is active. The routine handles all
* processing after the second lease timer has expired. It accepts
* lease acknowledgements from any DHCP server in response to an earlier
* subnet local broadcast of a lease request. If an acknowlegement is received,
* processing returns to the bound() routine. If a DHCP server explicitly 
* denies the request, the negotiation restarts with the init() routine.
* Otherwise, the broadcast is repeated periodically until the lease expires.
* .IP
* This routine is invoked by the event handler of the client monitor task,
* and should only be called internally. Any arriving DHCP messages containing
* stale offers from earlier states are discarded. User requests generated
* by calls to the dhcpcRelease() and dhcpcVerify() routines are accepted.
*
* RETURNS: OK (processing complete), DHCPC_DONE (remove lease),
*          DHCPC_MORE (continue), or ERROR.
*
* ERRNO: N/A
*
* NOMANUAL
*/

int rebinding (EVENT_DATA * pEvent  /* pointer to event descriptor */
    )
{
    char *option = NULL;
    char errmsg[255];
    time_t curr_epoch = 0;
    int timeout;
    int limit;