dhcpc_subr.c

VXWORKS源代码

    tmp = str;

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

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

/*******************************************************************************
*
* align_msg - set the buffer pointers to access message components
*
* This routine sets the pointers in the given message descriptor
* structure to access the various components of a received DHCP
* message. It is used internally by the state machine for incoming
* data stored from the BPF device. 
*
* RETURNS: N/A
*
* ERRNO:   N/A
*
* NOMANUAL
*/

void align_msg
    (
    struct msg * 	rmsg, 	/* Components of received message */
    char * 		rbuf 	/* Received IP packet */
    )
    {
    rmsg->ip = (struct ip *) rbuf;

    if ( (ntohs (rmsg->ip->ip_off) & 0x1fff) == 0 &&
        ntohs (rmsg->ip->ip_len) >= (DFLTDHCPLEN - DFLTOPTLEN + 4) + UDPHL 
				     + IPHL)
        {
#if BSD<44
        rmsg->udp = (struct udphdr *)&rbuf [ (rmsg->ip->ip_v_hl & 0xf) * WORD];
        rmsg->dhcp = (struct dhcp *)&rbuf [ (rmsg->ip->ip_v_hl & 0xf) * WORD +
                                           UDPHL];
#else
        rmsg->udp = (struct udphdr *) &rbuf [rmsg->ip->ip_hl * WORD];
        rmsg->dhcp = (struct dhcp *) &rbuf [rmsg->ip->ip_hl * WORD +
                                            UDPHL];
#endif
        }
    else
        {
        rmsg->udp = NULL;
        rmsg->dhcp = NULL;
        }

    return;
    }

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

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

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)