dhcp-option-convert.c

this is sample about DHCP-agent

    return int8_to_string_proc(data, num, ";");
}

static char *int16_to_internal_string(void *data, size_t num)
{
    return int16_to_string_proc(data, num, ";");
}

static char *int32_to_internal_string(void *data, size_t num)
{
    return int32_to_string_proc(data, num, ";");
}

static char *int_list_to_internal_string(void *list_data, size_t size, uint8_t sign)
{
    return int_list_to_string_proc(list_data, size, sign, ";");
}

static char *ip_addr_list_to_internal_string(void *data)
{
    return ip_addr_list_to_string_proc(data, ";", 0);
}

static char *ip_addr_to_internal_string(void *data)
{
    return ip_addr_to_string_proc(data, 0);
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * *
 * public interface.                                 *
 *                                                   *
 * This is where all the above routines are called   *
 * to create a dhcp option, or extract data          *
 * from a dhcp option.                               * 
 * * * * * * * * * * * * * * * * * * * * * * * * * * */

/* * * * * * * * * * * * * * * * * * *
 * from network data to dhcp option  *
 * * * * * * * * * * * * * * * * * * */

int dhcp_opt_from_network_uint8(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    if(len != sizeof(uint8_t))
        return 1;

    opt->val = uint8_copy_from_network(data, 1);
    opt->num = 1;

    return 0;
}

int dhcp_opt_from_network_uint16(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    if(len != sizeof(uint16_t))
        return 1;

    opt->val = uint16_copy_from_network(data, 1);
    opt->num = 1;

    return 0;
}

int dhcp_opt_from_network_uint32(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    if(len != sizeof(uint32_t))
        return 1;

    opt->val = uint32_copy_from_network(data, 1);
    opt->num = 1;

    return 0;
}

int dhcp_opt_from_network_int8(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    if(len != sizeof(int8_t))
        return 1;

    opt->val = int8_copy_from_network(data, 1);
    opt->num = 1;

    return 0;
}

int dhcp_opt_from_network_int16(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    if(len != sizeof(int16_t))
        return 1;

    opt->val = int16_copy_from_network(data, 1);
    opt->num = 1;

    return 0;
}

int dhcp_opt_from_network_int32(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    if(len != sizeof(int32_t))
        return 1;

    opt->val = int32_copy_from_network(data, 1);
    opt->num = 1;

    return 0;
}

int dhcp_opt_from_network_list_uint8(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    list_t *uint8_list;

    uint8_list = int_list_from_network_proc(data, len, sizeof(uint8_t), 0);

    if(uint8_list == NULL)
        return 1;

    opt->val = uint8_list;
    opt->num = len/sizeof(uint8_t);

    return 0;
}

int dhcp_opt_from_network_list_uint16(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
   list_t *uint16_list;

    uint16_list = int_list_from_network_proc(data, len, sizeof(uint16_t), 0);

    if(uint16_list == NULL)
        return 1;

    opt->val = uint16_list;
    opt->num = len/sizeof(uint16_t);

    return 0;
}

int dhcp_opt_from_network_list_uint32(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
   list_t *uint32_list;

   uint32_list = int_list_from_network_proc(data, len, sizeof(uint32_t), 0);

   if(uint32_list == NULL)
       return 1;

   opt->val = uint32_list;
   opt->num = len/sizeof(uint32_t);

   return 0;
}

int dhcp_opt_from_network_list_int8(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    list_t *int8_list;

    int8_list = int_list_from_network_proc(data, len, sizeof(int8_t), 1);

    if(int8_list == NULL)
        return 1;

    opt->val = int8_list;
    opt->num = len/sizeof(int8_t);

    return 0;        
}

int dhcp_opt_from_network_list_int16(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    list_t *int16_list;

    int16_list = int_list_from_network_proc(data, len, sizeof(int16_t), 1);

    if(int16_list == NULL)
        return 1;

    opt->val = int16_list;
    opt->num = len/sizeof(int16_t);

    return 0;        
}

int dhcp_opt_from_network_list_int32(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    list_t *int32_list;

    int32_list = int_list_from_network_proc(data, len, sizeof(int32_t), 1);

    if(int32_list == NULL)
        return 1;

    opt->val = int32_list;
    opt->num = len/sizeof(int32_t);

    return 0;        
}

int dhcp_opt_from_network_ip_addr(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    uint8_t *datum;

    datum = uint8_copy_from_network(data, IP_ADDR_LEN);

    opt->val = datum;
    opt->num = 1;

    return 0;
}

int dhcp_opt_from_network_array_uint8(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    size_t num;

    num = (len/sizeof(uint8_t));
    opt->val = uint8_copy_from_network(data, num);
    opt->num = num;

    return 0;
}

int dhcp_opt_from_network_array_uint16(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    size_t num;

    if(len%sizeof(uint16_t))
        return 1;

    num = (len/sizeof(uint16_t));
    opt->val = uint16_copy_from_network(data, num);
    opt->num = num;

    return 0;
}

int dhcp_opt_from_network_array_uint32(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    size_t num;

    if(len%sizeof(uint32_t))
        return 1;

    num = (len/sizeof(uint32_t));
    opt->val = uint32_copy_from_network(data, num);
    opt->num = num;

    return 0;
}

int dhcp_opt_from_network_array_int8(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    size_t num;

    num = (len/sizeof(int8_t));
    opt->val = int8_copy_from_network(data, num);
    opt->num = num;

    return 0;
}

int dhcp_opt_from_network_array_int16(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    size_t num;

    if(len%sizeof(int16_t))
        return 1;

    num = (len/sizeof(int16_t));
    opt->val = int16_copy_from_network(data, num);
    opt->num = num;

    return 0;
}

int dhcp_opt_from_network_array_int32(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    size_t num;

    if(len%sizeof(int32_t))
        return 1;

    num = (len/sizeof(int32_t));
    opt->val = int32_copy_from_network(data, num);
    opt->num = num;

    return 0;
}

int dhcp_opt_from_network_ip_addr_pair(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    /* this is handled the same as converting a list of unsigned 32 bit integer. */
    return dhcp_opt_from_network_list_ip_addr(opt, data, len);
}

int dhcp_opt_from_network_list_ip_addr(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    list_t *address_list;
    void *datum;
    size_t num = 0;

    if(len%sizeof(ip_addr_t))
        return 1;

    address_list = list_create();

    while(len) {

        datum = uint8_copy_from_network(data, IP_ADDR_LEN);
        list_add(address_list, datum);

        data += sizeof(ip_addr_t);
        len -= sizeof(ip_addr_t);
        num++;
    }

    opt->val = address_list;
    opt->num = num;

    return 0;
}

int dhcp_opt_from_network_list_ip_addr_pair(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    /* this is handled the same as converting a list of addresses. */
    return dhcp_opt_from_network_list_ip_addr(opt, data, len);
}

int dhcp_opt_from_network_string(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    size_t string_len;
    uint8_t null_flag;
    int8_t *new_string;

    /* Make a copy. One issue we have is the use of the null
     * character half way through the string. Do we care? Yes we
     * do. Our internal string routines may use nulls as
     * sentinels. If this breaks things that's too bad. */

    /* Read up to a null or the end. If a null is present set a flag
     * so we don't null terminate. */

    null_flag = 0;
    for(string_len = 0; string_len < len; string_len++) {
        if(data[string_len] == 0) {
            null_flag = 1;
            break;
        }
    }

    if(null_flag) {

        new_string = xmalloc(sizeof(int8_t) * string_len);
        memcpy(new_string, data, string_len);
        opt->num = (string_len - 1);

    } else {

        new_string = xmalloc(sizeof(int8_t) * (string_len + 1));
        memcpy(new_string, data, string_len);
        new_string[string_len] = 0;
        opt->num = string_len;

    }

    opt->val = new_string;

    return 0;
}

int dhcp_opt_from_network_nvt_string(dhcp_opt_t *opt, const uint8_t *data, size_t len)
{
    /* make sure it is seven bit clean (NVT) */
    if(!is_seven_bit_clean(data, len))  {
        return 1;
    }

    /* then we can just call the copy from network string routine. */
    return dhcp_opt_from_network_string(opt, data, len);
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * dhcp_opt from internal string conversion routines.  *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * */

int dhcp_opt_from_internal_string_uint8(dhcp_opt_t *opt, const char *input)
{
    opt->val = internal_string_uint8_to_internal(input);
    opt->num = 1;

    return 0;
}

int dhcp_opt_from_internal_string_uint16(dhcp_opt_t *opt, const char *input)
{
    opt->val = internal_string_uint16_to_internal(input);
    opt->num = 1;

    return 0;
}

int dhcp_opt_from_internal_string_uint32(dhcp_opt_t *opt, const char *input)
{
    opt->val = internal_string_uint32_to_internal(input);
    opt->num = 1;

    return 0;
}

int dhcp_opt_from_internal_string_int8(dhcp_opt_t *opt, const char *input)
{
    opt->val = internal_string_int8_to_internal(input);
    opt->num = 1;

    return 0;
}

int dhcp_opt_from_internal_string_int16(dhcp_opt_t *opt, const char *input)
{
    opt->val = internal_string_int16_to_internal(input);
    opt->num = 1;

    return 0;
}

int dhcp_opt_from_internal_string_int32(dhcp_opt_t *opt, const char *input)
{
    opt->val = internal_string_int32_to_internal(input);
    opt->num = 1;

    return 0;
}

static int dhcp_opt_from_internal_string_list_int_proc(dhcp_opt_t *opt, const char *input,
                                                        size_t size, uint8_t sign)
{
    char *string_copy;
    size_t count;

    string_copy = xstrdup(input);
    count = count_internal_string_atoms_and_mark(string_copy);

    opt->val = internal_string_to_list_int_proc(string_copy, count, size, sign);
    opt->num = count;

    xfree(string_copy);
    return 0;
}

static int dhcp_opt_from_internal_string_array_int_proc(dhcp_opt_t *opt, const char *input,
                                                        size_t size, uint8_t sign)
{
    char *string_copy;
    size_t count;

    string_copy = xstrdup(input);
    count = count_internal_string_atoms_and_mark(string_copy);

    opt->val = internal_string_to_array_int_proc(string_copy, count, size, sign);
    opt->num = count;

    xfree(string_copy);
    return 0;
}

int dhcp_opt_from_internal_string_array_uint8(dhcp_opt_t *opt, const char *input)
{
    return dhcp_opt_from_internal_string_array_int_proc(opt, input, sizeof(uint8_t), 0);
}

int dhcp_opt_from_internal_string_array_uint16(dhcp_opt_t *opt, const char *input)
{
    return dhcp_opt_from_internal_string_array_int_proc(opt, input, sizeof(uint16_t), 0);
}

int dhcp_opt_from_internal_string_array_uint32(dhcp_opt_t *opt, const char *input)
{
    return dhcp_opt_from_internal_string_array_int_proc(opt, input, sizeof(uint32_t), 0);
}

int dhcp_opt_from_internal_string_array_int8(dhcp_opt_t *opt, const char *input)
{
    return dhcp_opt_from_internal_string_array_int_proc(opt, input, sizeof(int8_t), 1);
}

int dhcp_opt_from_internal_string_array_int16(dhcp_opt_t *opt, const char *input)
{
    return dhcp_opt_from_internal_string_array_int_proc(opt, input, sizeof(int16_t), 1);
}

int dhcp_opt_from_internal_string_array_int32(dhcp_opt_t *opt, const char *input)
{
    return dhcp_opt_from_internal_string_array_int_proc(opt, input, sizeof(int32_t), 1);
}

int dhcp_opt_from_internal_string_list_uint8(dhcp_opt_t *opt, const char *input)
{
    return dhcp_opt_from_internal_string_list_int_proc(opt, input, sizeof(uint8_t), 0);
}

int dhcp_opt_from_internal_string_list_uint16(dhcp_opt_t *opt, const char *input)
{
    return dhcp_opt_from_internal_string_list_int_proc(opt, input, sizeof(uint16_t), 0);
}

int dhcp_opt_from_internal_string_list_uint32(dhcp_opt_t *opt, const char *input)
{
    return dhcp_opt_from_internal_string_list_int_proc(opt, input, sizeof(uint32_t), 0);
}

int dhcp_opt_from_internal_string_list_int8(dhcp_opt_t *opt, const char *input)
{
    return dhcp_opt_from_internal_string_list_int_proc(opt, input, sizeof(int8_t), 1);
}

int dhcp_opt_from_internal_string_list_int16(dhcp_opt_t *opt, const char *input)
{
    return dhcp_opt_from_internal_string_list_int_proc(opt, input, sizeof(int16_t), 1);
}

int dhcp_opt_from_internal_string_list_int32(dhcp_opt_t *opt, const char *input)
{
    return dhcp_opt_from_internal_string_list_int_proc(opt, input, sizeof(int32_t), 1);
}

int dhcp_opt_from_internal_string_ip_addr(dhcp_opt_t *opt, const char *input)
{
    opt->val = internal_string_ip_addr_to_internal(input);
    opt->num = 1;

    return 0;
}

int dhcp_opt_from_internal_string_ip_addr_pair(dhcp_opt_t *opt, const char *input)
{
    char *string_copy;
    size_t count;

    string_copy = xstrdup(input);
    count = count_internal_string_atoms_and_mark(string_copy);

    opt->val = internal_string_list_ip_addr_to_internal(string_copy, count);
    opt->num = count;

    xfree(string_copy);
    return 0;
}

int dhcp_opt_from_internal_string_list_ip_addr(dhcp_opt_t *opt, const char *input)
{
    return dhcp_opt_from_internal_string_ip_addr_pair(opt, input);
}

int dhcp_opt_from_internal_string_list_ip_addr_pair(dhcp_opt_t *opt, const char *input)
{
    return dhcp_opt_from_internal_string_ip_addr_pair(opt, input);
}

int dhcp_opt_from_internal_string_string(dhcp_opt_t *opt, const char *input)
{
    opt->val = xstrdup(input);
    opt->num = strlen(input);

    return 0;
}

int dhcp_opt_from_internal_string_nvt_string(dhcp_opt_t *opt, const char *input)
{
    if(!is_seven_bit_clean(input, strlen(input)))  {
        return 1;
    }

    return dhcp_opt_from_internal_string_string(opt, input);
}

/* * * * * * * * * * * * * * * * * * * * * * * * * *
 * dhcp_opt from user string conversion routines:  *