dhcp-option-convert.c

this is sample about DHCP-agent

 * * * * * * * * * * * * * * * * * * * * * * * * * */

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * all these routines can be wrapped around the internal       *
 * routines. we just need to take them from list format to an  *
 * internal string format which is fairly easy.                *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

static int dhcp_opt_from_user_string_proc(dhcp_opt_t *opt, list_t *input_list, int (*convert)(dhcp_opt_t *opt, const char *string))
{
    const char *input_string;

    input_string = list_first(input_list);

    if(input_string == NULL)  {
        return 1;
    }

    return convert(opt, input_string);
}

static int dhcp_opt_from_user_string_group_proc(dhcp_opt_t *opt, list_t *input_list, 
                                                int (*convert)(dhcp_opt_t *opt, const char *string))
{
    stringbuffer_t *sb;
    const char *input_string;
    int retval;

    sb = stringbuffer_create();

    list_rewind(input_list);
    while((input_string = list_next(input_list)) != NULL)  {

        stringbuffer_aprintf(sb, "%s;", input_string);
    }

    retval = convert(opt, stringbuffer_getstring(sb));

    stringbuffer_destroy(sb);
    return retval;
    
}

/* integer values. */
int dhcp_opt_from_user_string_uint8(dhcp_opt_t *opt, list_t *input_list)
{
    return dhcp_opt_from_user_string_proc(opt, input_list, dhcp_opt_from_internal_string_uint8);
}

int dhcp_opt_from_user_string_uint16(dhcp_opt_t *opt, list_t *input_list)
{
    return dhcp_opt_from_user_string_proc(opt, input_list, dhcp_opt_from_internal_string_uint16);
}

int dhcp_opt_from_user_string_uint32(dhcp_opt_t *opt, list_t *input_list)
{
    return dhcp_opt_from_user_string_proc(opt, input_list, dhcp_opt_from_internal_string_uint32);
}

int dhcp_opt_from_user_string_int8(dhcp_opt_t *opt, list_t *input_list)
{
    return dhcp_opt_from_user_string_proc(opt, input_list, dhcp_opt_from_internal_string_int8);
}

int dhcp_opt_from_user_string_int16(dhcp_opt_t *opt, list_t *input_list)
{
    return dhcp_opt_from_user_string_proc(opt, input_list, dhcp_opt_from_internal_string_int16);
}

int dhcp_opt_from_user_string_int32(dhcp_opt_t *opt, list_t *input_list)
{
    return dhcp_opt_from_user_string_proc(opt, input_list, dhcp_opt_from_internal_string_int32);
}

int dhcp_opt_from_user_string_list_uint8(dhcp_opt_t *opt, list_t *input_list)
{
    return dhcp_opt_from_user_string_group_proc(opt, input_list, dhcp_opt_from_internal_string_list_uint8);
}

int dhcp_opt_from_user_string_list_uint16(dhcp_opt_t *opt,list_t *input_list)
{
    return dhcp_opt_from_user_string_group_proc(opt, input_list, dhcp_opt_from_internal_string_list_uint16);
}

int dhcp_opt_from_user_string_list_uint32(dhcp_opt_t *opt,list_t *input_list)
{
    return dhcp_opt_from_user_string_group_proc(opt, input_list, dhcp_opt_from_internal_string_list_uint32);
}

int dhcp_opt_from_user_string_list_int8(dhcp_opt_t *opt,list_t *input_list)
{
    return dhcp_opt_from_user_string_group_proc(opt, input_list, dhcp_opt_from_internal_string_list_int8);
}

int dhcp_opt_from_user_string_list_int16(dhcp_opt_t *opt,list_t *input_list)
{
    return dhcp_opt_from_user_string_group_proc(opt, input_list, dhcp_opt_from_internal_string_list_int16);
}

int dhcp_opt_from_user_string_list_int32(dhcp_opt_t *opt,list_t *input_list)
{
    return dhcp_opt_from_user_string_group_proc(opt, input_list, dhcp_opt_from_internal_string_list_int32);
}

/* arrays of integer values. */
int dhcp_opt_from_user_string_array_uint8(dhcp_opt_t *opt, list_t *input_list)
{
    return dhcp_opt_from_user_string_group_proc(opt, input_list, dhcp_opt_from_internal_string_array_uint8);
}

int dhcp_opt_from_user_string_array_uint16(dhcp_opt_t *opt, list_t *input_list)
{
    return dhcp_opt_from_user_string_group_proc(opt, input_list, dhcp_opt_from_internal_string_array_uint16);
}

int dhcp_opt_from_user_string_array_uint32(dhcp_opt_t *opt, list_t *input_list)
{
    return dhcp_opt_from_user_string_group_proc(opt, input_list, dhcp_opt_from_internal_string_array_uint32);
}

int dhcp_opt_from_user_string_array_int8(dhcp_opt_t *opt, list_t *input_list)
{
    return dhcp_opt_from_user_string_group_proc(opt, input_list, dhcp_opt_from_internal_string_array_int8);
}

int dhcp_opt_from_user_string_array_int16(dhcp_opt_t *opt, list_t *input_list)
{
    return dhcp_opt_from_user_string_group_proc(opt, input_list, dhcp_opt_from_internal_string_array_int16);
}

int dhcp_opt_from_user_string_array_int32(dhcp_opt_t *opt, list_t *input_list)
{
    return dhcp_opt_from_user_string_group_proc(opt, input_list, dhcp_opt_from_internal_string_array_int32);
}

/* ip address and ip address pairs. */
int dhcp_opt_from_user_string_ip_addr(dhcp_opt_t *opt, list_t *input_list)
{
    return dhcp_opt_from_user_string_proc(opt, input_list, dhcp_opt_from_internal_string_ip_addr);
}

int dhcp_opt_from_user_string_ip_addr_pair(dhcp_opt_t *opt, list_t *input_list)
{
    return dhcp_opt_from_user_string_group_proc(opt, input_list, dhcp_opt_from_internal_string_ip_addr_pair);
}

/* list of addresses and ip address pairs. */
int dhcp_opt_from_user_string_list_ip_addr(dhcp_opt_t *opt, list_t *input_list)
{
    return dhcp_opt_from_user_string_group_proc(opt, input_list, dhcp_opt_from_internal_string_list_ip_addr);
}

int dhcp_opt_from_user_string_list_ip_addr_pair(dhcp_opt_t *opt, list_t *input_list)
{
    return dhcp_opt_from_user_string_group_proc(opt, input_list, dhcp_opt_from_internal_string_list_ip_addr_pair);
}

/* strings. */
int dhcp_opt_from_user_string_nvt_string(dhcp_opt_t *opt, list_t *input_list)
{
    return dhcp_opt_from_user_string_proc(opt, input_list, dhcp_opt_from_internal_string_nvt_string);
}

int dhcp_opt_from_user_string_string(dhcp_opt_t *opt, list_t *input_list)
{
    return dhcp_opt_from_user_string_proc(opt, input_list, dhcp_opt_from_internal_string_string);
}

/* * * * * * * * * * * * * * * *
 * dhcp_opt to network data.   *
 * * * * * * * * * * * * * * * */

void *dhcp_opt_to_network_uint8(dhcp_opt_t *opt)
{
    return uint8_copy_to_network(opt->val, 1);
}

void *dhcp_opt_to_network_uint16(dhcp_opt_t *opt)
{
    return uint16_copy_to_network(opt->val, 1);
}

void *dhcp_opt_to_network_uint32(dhcp_opt_t *opt)
{
    return uint32_copy_to_network(opt->val, 1);
}

void *dhcp_opt_to_network_int8(dhcp_opt_t *opt)
{
    return int8_copy_to_network(opt->val, 1);
}

void *dhcp_opt_to_network_int16(dhcp_opt_t *opt)
{
    return int16_copy_to_network(opt->val, 1);
}

void *dhcp_opt_to_network_int32(dhcp_opt_t *opt)
{
    return int32_copy_to_network(opt->val, 1);
}

void *dhcp_opt_to_network_list_uint8(dhcp_opt_t *opt)
{
    return int_list_copy_to_network(opt->val, sizeof(uint8_t), 0);
}

void *dhcp_opt_to_network_list_uint16(dhcp_opt_t *opt)
{
    return int_list_copy_to_network(opt->val, sizeof(uint16_t), 0);
}

void *dhcp_opt_to_network_list_uint32(dhcp_opt_t *opt)
{
    return int_list_copy_to_network(opt->val, sizeof(uint32_t), 0);
}

void *dhcp_opt_to_network_list_int8(dhcp_opt_t *opt)
{
    return int_list_copy_to_network(opt->val, sizeof(int8_t), 1);
}

void *dhcp_opt_to_network_list_int16(dhcp_opt_t *opt)
{
    return int_list_copy_to_network(opt->val, sizeof(int16_t), 1);
}

void *dhcp_opt_to_network_list_int32(dhcp_opt_t *opt)
{
    return int_list_copy_to_network(opt->val, sizeof(int32_t), 1);
}

void *dhcp_opt_to_network_array_uint8(dhcp_opt_t *opt)
{
    return uint8_copy_to_network(opt->val, opt->num);
}

void *dhcp_opt_to_network_array_uint16(dhcp_opt_t *opt)
{
    return uint16_copy_to_network(opt->val, opt->num);
}

void *dhcp_opt_to_network_array_uint32(dhcp_opt_t *opt)
{
    return uint32_copy_to_network(opt->val, opt->num);
}

void *dhcp_opt_to_network_array_int8(dhcp_opt_t *opt)
{
    return int8_copy_to_network(opt->val, opt->num);
}

void *dhcp_opt_to_network_array_int16(dhcp_opt_t *opt)
{
    return int16_copy_to_network(opt->val, opt->num);
}

void *dhcp_opt_to_network_array_int32(dhcp_opt_t *opt)
{
    return int32_copy_to_network(opt->val, opt->num);
}

void *dhcp_opt_to_network_ip_addr(dhcp_opt_t *opt)
{
    return uint8_copy_to_network(opt->val, IP_ADDR_LEN);
}

void *dhcp_opt_to_network_ip_addr_pair(dhcp_opt_t *opt)
{
    return dhcp_opt_to_network_list_ip_addr(opt);
}

void *dhcp_opt_to_network_list_ip_addr_pair(dhcp_opt_t *opt)
{
    return dhcp_opt_to_network_list_ip_addr(opt);
}

void *dhcp_opt_to_network_list_ip_addr(dhcp_opt_t *opt)
{
    list_t *list;
    ip_addr_t *ip_address;
    ip_addr_t *data;
    size_t i;

    /* take a list of ip addresses and create an array of them.
     * that's all we're really doing. */

    list = opt->val;
    list_rewind(list);

    data = xmalloc(IP_ADDR_LEN * list_get_len(list));

    i = 0;
    while((ip_address = list_next(list)) != NULL)  {
        memcpy(&data[i], ip_address, IP_ADDR_LEN);
        i++;
    }

    return data;
}

void *dhcp_opt_to_network_nvt_string(dhcp_opt_t *opt)
{
    /* do not incorporate a terminating NULL.  we may need to
     * create seperate to network converters for any options
     * which require a terminating null. */

    /* FIXME: find out if any options require a terminating NULL. */

    int8_t *network_str, *str;

    str = opt->val;
    network_str = xmalloc(sizeof(int8_t) * opt->num);
    memcpy(network_str, str, opt->num);

    return network_str;
}

void *dhcp_opt_to_network_string(dhcp_opt_t *opt)
{
    return dhcp_opt_to_network_nvt_string(opt);
}

/* * * * * * * * * * * * * * * *
 * dhcp_opt to user string.    *
 * * * * * * * * * * * * * * * */

char *dhcp_opt_to_user_string_uint8(dhcp_opt_t *opt)
{
    return uint8_to_user_string(opt->val, opt->num);
}

char *dhcp_opt_to_user_string_uint16(dhcp_opt_t *opt)
{
    return uint16_to_user_string(opt->val, opt->num);
}

char *dhcp_opt_to_user_string_uint32(dhcp_opt_t *opt)
{
    return uint32_to_user_string(opt->val, opt->num);
}

char *dhcp_opt_to_user_string_int8(dhcp_opt_t *opt)
{
    return int8_to_user_string(opt->val, opt->num);
}

char *dhcp_opt_to_user_string_int16(dhcp_opt_t *opt)
{
    return int16_to_user_string(opt->val, opt->num);
}

char *dhcp_opt_to_user_string_int32(dhcp_opt_t *opt)
{
    return int32_to_user_string(opt->val, opt->num);
}

char *dhcp_opt_to_user_string_list_uint8(dhcp_opt_t *opt)
{
    return int_list_to_user_string(opt->val, sizeof(uint8_t), 0);
}

char *dhcp_opt_to_user_string_list_uint16(dhcp_opt_t *opt)
{
    return int_list_to_user_string(opt->val, sizeof(uint16_t), 0);
}

char *dhcp_opt_to_user_string_list_uint32(dhcp_opt_t *opt)
{
    return int_list_to_user_string(opt->val, sizeof(uint32_t), 0);
}

char *dhcp_opt_to_user_string_list_int8(dhcp_opt_t *opt)
{
    return int_list_to_user_string(opt->val, sizeof(int8_t), 1);
}

char *dhcp_opt_to_user_string_list_int16(dhcp_opt_t *opt)
{
    return int_list_to_user_string(opt->val, sizeof(int16_t), 1);
}

char *dhcp_opt_to_user_string_list_int32(dhcp_opt_t *opt)
{
    return int_list_to_user_string(opt->val, sizeof(int32_t), 1);
}

char *dhcp_opt_to_user_string_array_uint8(dhcp_opt_t *opt)
{
    return uint8_to_user_string(opt->val, opt->num);
}

char *dhcp_opt_to_user_string_array_uint16(dhcp_opt_t *opt)
{
    return uint16_to_user_string(opt->val, opt->num);
}

char *dhcp_opt_to_user_string_array_uint32(dhcp_opt_t *opt)
{
    return uint32_to_user_string(opt->val, opt->num);
}

char *dhcp_opt_to_user_string_array_int8(dhcp_opt_t *opt)
{
    return int8_to_user_string(opt->val, opt->num);
}

char *dhcp_opt_to_user_string_array_int16(dhcp_opt_t *opt)
{    
    return int16_to_user_string(opt->val, opt->num);
}

char *dhcp_opt_to_user_string_array_int32(dhcp_opt_t *opt)
{
    return int32_to_user_string(opt->val, opt->num);
}

char *dhcp_opt_to_user_string_ip_addr(dhcp_opt_t *opt)
{
    return ip_addr_to_user_string(opt->val);
}

char *dhcp_opt_to_user_string_ip_addr_pair(dhcp_opt_t *opt)
{
    return ip_addr_list_to_user_string(opt->val);
}

char *dhcp_opt_to_user_string_list_ip_addr(dhcp_opt_t *opt)
{
    return ip_addr_list_to_user_string(opt->val);
}

char *dhcp_opt_to_user_string_list_ip_addr_pair(dhcp_opt_t *opt)
{
    return ip_addr_list_to_user_string(opt->val);
}

char *dhcp_opt_to_user_string_nvt_string(dhcp_opt_t *opt)
{
    return xstrdup((char *)opt->val);
}

char *dhcp_opt_to_user_string_string(dhcp_opt_t *opt)
{
    return xstrdup((char *)opt->val);
}

/* * * * * * * * * * * * * * * * * *
 * dhcp_opt to internal string.    *
 * * * * * * * * * * * * * * * * * */

char *dhcp_opt_to_internal_string_uint8(dhcp_opt_t *opt)
{
    return uint8_to_internal_string(opt->val, opt->num);
}

char *dhcp_opt_to_internal_string_uint16(dhcp_opt_t *opt)
{
    return uint16_to_internal_string(opt->val, opt->num);
}

char *dhcp_opt_to_internal_string_uint32(dhcp_opt_t *opt)
{
    return uint32_to_internal_string(opt->val, opt->num);
}

char *dhcp_opt_to_internal_string_int8(dhcp_opt_t *opt)
{
    return int8_to_internal_string(opt->val, opt->num);
}

char *dhcp_opt_to_internal_string_int16(dhcp_opt_t *opt)
{
    return int16_to_internal_string(opt->val, opt->num);
}

char *dhcp_opt_to_internal_string_int32(dhcp_opt_t *opt)
{
    return int32_to_internal_string(opt->val, opt->num);
}

char *dhcp_opt_to_internal_string_list_uint8(dhcp_opt_t *opt)
{
    return int_list_to_internal_string(opt->val, sizeof(uint8_t), 0);
}

char *dhcp_opt_to_internal_string_list_uint16(dhcp_opt_t *opt)
{
    return int_list_to_internal_string(opt->val, sizeof(uint16_t), 0);
}

char *dhcp_opt_to_internal_string_list_uint32(dhcp_opt_t *opt)
{
    return int_list_to_internal_string(opt->val, sizeof(uint32_t), 0);
}

char *dhcp_opt_to_internal_string_list_int8(dhcp_opt_t *opt)
{
    return int_list_to_internal_string(opt->val, sizeof(int8_t), 1);
}

char *dhcp_opt_to_internal_string_list_int16(dhcp_opt_t *opt)
{
    return int_list_to_internal_string(opt->val, sizeof(int16_t), 1);
}

char *dhcp_opt_to_internal_string_list_int32(dhcp_opt_t *opt)
{
    return int_list_to_internal_string(opt->val, sizeof(int32_t), 1);
}

char *dhcp_opt_to_internal_string_array_uint8(dhcp_opt_t *opt)
{
    return uint8_to_internal_string(opt->val, opt->num);
}

char *dhcp_opt_to_internal_string_array_uint16(dhcp_opt_t *opt)
{
    return uint16_to_internal_string(opt->val, opt->num);
}

char *dhcp_opt_to_internal_string_array_uint32(dhcp_opt_t *opt)
{
    return uint32_to_internal_string(opt->val, opt->num);
}

char *dhcp_opt_to_internal_string_array_int8(dhcp_opt_t *opt)
{
    return int8_to_internal_string(opt->val, opt->num);
}

char *dhcp_opt_to_internal_string_array_int16(dhcp_opt_t *opt)
{    
    return int16_to_internal_string(opt->val, opt->num);
}

char *dhcp_opt_to_internal_string_array_int32(dhcp_opt_t *opt)
{
    return int32_to_internal_string(opt->val, opt->num);
}

char *dhcp_opt_to_internal_string_ip_addr(dhcp_opt_t *opt)
{
    return ip_addr_to_internal_string(opt->val);
}

char *dhcp_opt_to_internal_string_ip_addr_pair(dhcp_opt_t *opt)
{
    return ip_addr_list_to_internal_string(opt->val);
}

char *dhcp_opt_to_internal_string_list_ip_addr(dhcp_opt_t *opt)
{
    return ip_addr_list_to_internal_string(opt->val);
}

char *dhcp_opt_to_internal_string_list_ip_addr_pair(dhcp_opt_t *opt)
{
    return ip_addr_list_to_internal_string(opt->val);
}

char *dhcp_opt_to_internal_string_nvt_string(dhcp_opt_t *opt)
{
    return xstrdup((char *)opt->val);
}

char *dhcp_opt_to_internal_string_string(dhcp_opt_t *opt)
{
    return xstrdup((char *)opt->val);
}