dhcpcboot.c

VxWorks下DHCP的源代码！

        return (OK);            /* Ignore errors (permits use of IP address). */

    /* Wait one-half second for (unexpected) reply from target IP address. */

    timeout.tv_sec = 0;
    timeout.tv_usec = 500000;

    FD_ZERO (&readFds);
    FD_SET (bpfArpDev, &readFds);

    tmp = select (bpfArpDev + 1, &readFds, NULL, NULL, &timeout);

    /* Disconnect BPF device from input stream until next ARP probe. */

    ioctl (bpfArpDev, BIOCSTOP, 0);

    if (tmp)                    /* ARP reply received? Duplicate IP address. */
        return (ERROR);
    else                        /* Timeout occurred - no ARP reply. Probe succeeded. */
        return (OK);
}

#ifdef DHCPC_DEBUG
/*******************************************************************************
*
* nvttostr - convert NVT ASCII to strings
*
* This routine implements a limited NVT conversion which removes any embedded
* NULL characters from the input string.
*
* RETURNS: N/A
*
* ERRNO: N/A
*
* NOMANUAL
*/

LOCAL int nvttostr (char *nvt, char *str, int length)
{
    FAST int i = 0;
    FAST char *tmp = NULL;

    tmp = str;

    for (i = 0; i < length; i++) {
        if (nvt[i] != '\0') {
            *tmp = nvt[i];
            tmp++;
        }
    }

    str[length] = '\0';
    return (0);
}
#endif

/*******************************************************************************
*
* dhcp_msgtoparam - expand DHCP message into data structure
*
* This routine converts a DHCP message from the transmission format into the
* dhcp_param structure. It copies the core fields directly and multiplexes
* the options to the appropriate handle_* functions.
*
* RETURNS: 0 if conversion successful, or -1 otherwise
*
* ERRNO: N/A
*
* INTERNAL
*
* When calculating the values for the lease timers, floating-point calculations
* can't be used because some boards (notably the SPARC architectures) disable 
* software floating point by default to speed up context switching. These 
* boards abort with an exception when floating point operations are 
* encountered. The error introduced by the integer approximations is not
* significant.
*
* NOMANUAL
*/

LOCAL int dhcp_msgtoparam (struct dhcp *msg, int msglen, struct dhcp_param *parameter)
{
    FAST char *optp = NULL;
    char tag = 0;
    BOOL sname_is_opt = FALSE;
    BOOL file_is_opt = FALSE;
    int err = 0;
    char *endofopt;

    endofopt = &msg->options[msglen - DFLTDHCPLEN + DFLTOPTLEN];

    bzero (parameter->got_option, OPTMASKSIZE);

    for (optp = &msg->options[MAGIC_LEN]; optp <= endofopt; optp++) {
        tag = *optp;

        /* skip the PAD option */

        if (tag == _DHCP_PAD_TAG)
            continue;

        /* stop processing when the END option is encountered */

        if (tag == _DHCP_END_TAG)
            break;

        /* handle the "Option Overload" */
        if (tag == _DHCP_OPT_OVERLOAD_TAG) {
            optp += 2;
            switch (*optp) {
            case FILE_ISOPT:
                file_is_opt = TRUE;
                break;
            case SNAME_ISOPT:
                sname_is_opt = TRUE;
                break;
            case BOTH_AREOPT:
                file_is_opt = sname_is_opt = TRUE;
                break;
            default:
                break;
            }
            continue;
        }

        if ((tag > 0) && (tag < MAXTAGNUM) && (handle_param[(int) tag] != NULL)) {
            if ((err = (*handle_param[(int) tag]) (optp, parameter)) != 0)
                return (err);
            else
                SETBIT (parameter->got_option, tag);
        }

        /* Set the message type tag to distinguish DHCP and BOOTP messages. */
        else if (tag == _DHCP_MSGTYPE_TAG)
            SETBIT (parameter->got_option, tag);

        optp++;
        optp += *optp;
    }

    if (file_is_opt) {
        endofopt = &msg->file[MAX_FILE];
        for (optp = msg->file; optp <= endofopt; optp++) {
            tag = *optp;

            /* skip the PAD option */
            if (tag == _DHCP_PAD_TAG)
                continue;

            /* stop processing when the END option is reached */

            if (tag == _DHCP_END_TAG)
                break;

            if (handle_param[(int) tag] != NULL) {
                if ((err = (*handle_param[(int) tag]) (optp, parameter)) != 0)
                    return (err);
                else
                    SETBIT (parameter->got_option, tag);
            }

            /* Set the message type to distinguish DHCP and BOOTP messages. */

            else if (tag == _DHCP_MSGTYPE_TAG)
                SETBIT (parameter->got_option, tag);

            optp++;
            optp += *optp;
        }
    } else {
        if ((parameter->file = calloc (1, strlen (msg->file) + 1)) == NULL)
            return (-1);
        strcpy (parameter->file, msg->file);
    }


    if (sname_is_opt) {
        endofopt = &msg->sname[MAX_SNAME];
        for (optp = msg->sname; optp <= endofopt; optp++) {
            tag = *optp;

            /* skip the PAD option */

            if (tag == _DHCP_PAD_TAG)
                continue;

            /* stop processing when the END option is reached */

            if (tag == _DHCP_END_TAG)
                break;

            if (handle_param[(int) tag] != NULL) {
                if ((err = (*handle_param[(int) tag]) (optp, parameter)) != 0)
                    return (err);
                else
                    SETBIT (parameter->got_option, tag);
            }

            /* Set the message type to distinguish DHCP and BOOTP messages. */

            else if (tag == _DHCP_MSGTYPE_TAG)
                SETBIT (parameter->got_option, tag);

            optp++;
            optp += *optp;
        }
    } else {
        if ((parameter->sname = calloc (1, strlen (msg->sname) + 1)) == NULL)
            return (-1);
        strcpy (parameter->sname, msg->sname);
    }

    parameter->ciaddr.s_addr = msg->ciaddr.s_addr;
    parameter->yiaddr.s_addr = msg->yiaddr.s_addr;
    parameter->siaddr.s_addr = msg->siaddr.s_addr;
    parameter->giaddr.s_addr = msg->giaddr.s_addr;

    if (ISSET (parameter->got_option, _DHCP_MSGTYPE_TAG))
        parameter->msgtype = DHCP_NATIVE;
    else
        parameter->msgtype = DHCP_BOOTP;

    /* Set lease duration to infinite for BOOTP replies. */
    if (parameter->msgtype == DHCP_BOOTP) {
        parameter->lease_duration = ~0;
        return (0);
    }

    /* Assign any server name provided if 'sname' used for options. */

    if (sname_is_opt) {
        parameter->sname = parameter->temp_sname;
        parameter->temp_sname = NULL;
    }

    /* Assign any bootfile provided if 'file' used for options. */

    if (file_is_opt) {
        if (ISSET (parameter->got_option, _DHCP_BOOTFILE_TAG)) {
            parameter->file = parameter->temp_file;
            parameter->temp_file = NULL;
        }
    }

    if (parameter->dhcp_t1 == 0) {
        /* Timer t1 is half the lease duration - but don't divide. */

        parameter->dhcp_t1 = (parameter->lease_duration) >> 1;
        SETBIT (parameter->got_option, _DHCP_T1_TAG);
    }
    if (parameter->dhcp_t2 == 0) {
        /* Timer T2 is .875 of the lease - but don't use floating point. */

        int tmp = (parameter->lease_duration * 7) >> 3;

        parameter->dhcp_t2 = (unsigned long) tmp;
        SETBIT (parameter->got_option, _DHCP_T2_TAG);
    }

    return (0);
}

/*******************************************************************************
*
* clean_param - clean the parameters data structure
*
* This routine frees all the memory allocated for the storage of parameters
* received from a DHCP server. It is called to remove the unselected offers
* or if an error occurs in the state machine after offers have been received.
*
* RETURNS: 0, always.
*
* ERRNO: N/A
*
* NOMANUAL
*/

LOCAL int clean_param (struct dhcp_param *param)
{
    if (param == NULL)
        return (0);

    if (param->sname != NULL)
        free (param->sname);
    if (param->temp_sname != NULL)
        free (param->temp_sname);
    if (param->file != NULL)
        free (param->file);
    if (param->temp_file != NULL)
        free (param->temp_file);
    if (param->hostname != NULL)
        free (param->hostname);
    if (param->merit_dump != NULL)
        free (param->merit_dump);
    if (param->dns_domain != NULL)
        free (param->dns_domain);
    if (param->root_path != NULL)
        free (param->root_path);
    if (param->extensions_path != NULL)
        free (param->extensions_path);
    if (param->nis_domain != NULL)
        free (param->nis_domain);
    if (param->nb_scope != NULL)
        free (param->nb_scope);
    if (param->errmsg != NULL)
        free (param->errmsg);
    if (param->nisp_domain != NULL)
        free (param->nisp_domain);

    if (param->mtu_plateau_table != NULL) {
        if (param->mtu_plateau_table->shortnum != NULL)
            free (param->mtu_plateau_table->shortnum);
        free (param->mtu_plateau_table);
    }
    if (param->subnet_mask != NULL)
        free (param->subnet_mask);
    if (param->swap_server != NULL)
        free (param->swap_server);
    if (param->brdcast_addr != NULL)
        free (param->brdcast_addr);
    if (param->router != NULL) {
        if (param->router->addr != NULL)
            free (param->router->addr);
        free (param->router);
    }
    if (param->time_server != NULL) {
        if (param->time_server->addr != NULL)
            free (param->time_server->addr);
        free (param->time_server);
    }
    if (param->name_server != NULL) {
        if (param->name_server->addr != NULL)
            free (param->name_server->addr);
        free (param->name_server);
    }
    if (param->dns_server != NULL) {
        if (param->dns_server->addr != NULL)
            free (param->dns_server->addr);
        free (param->dns_server);
    }
    if (param->log_server != NULL) {
        if (param->log_server->addr != NULL)
            free (param->log_server->addr);
        free (param->log_server);
    }
    if (param->cookie_server != NULL) {
        if (param->cookie_server->addr != NULL)
            free (param->cookie_server->addr);
        free (param->cookie_server);
    }
    if (param->lpr_server != NULL) {
        if (param->lpr_server->addr != NULL)
            free (param->lpr_server->addr);
        free (param->lpr_server);
    }
    if (param->impress_server != NULL) {
        if (param->impress_server->addr != NULL)
            free (param->impress_server->addr);
        free (param->impress_server);
    }
    if (param->rls_server != NULL) {
        if (param->rls_server->addr != NULL)
            free (param->rls_server->addr);
        free (param->rls_server);
    }
    if (param->policy_filter != NULL) {
        if (param->policy_filter->addr != NULL)
            free (param->policy_filter->addr);
        free (param->policy_filter);
    }
    if (param->static_route != NULL) {
        if (param->static_route->addr != NULL)
            free (param->static_route->addr);
        free (param->static_route);
    }
    if (param->nis_server != NULL) {
        if (param->nis_server->addr != NULL)
            free (param->nis_server->addr);
        free (param->nis_server);
    }
    if (param->ntp_server != NULL) {
        if (param->ntp_server->addr != NULL)
            free (param->ntp_server->addr);
        free (param->ntp_server);
    }
    if (param->nbn_server != NULL) {
        if (param->nbn_server->addr != NULL)
            free (param->nbn_server->addr);
        free (param->nbn_server);
    }
    if (param->nbdd_server != NULL) {
        if (param->nbdd_server->addr != NULL)
            free (param->nbdd_server->addr);
        free (param->nbdd_server);
    }
    if (param->xfont_server != NULL) {
        if (param->x