dhcp-option-convert.c

this is sample about DHCP-agent

            case sizeof(int8_t):
                int8_ptr = data;
                sscanf(ptr, "%"SCNi8, (int8_ptr + i));
                break;

            case sizeof(int16_t):
                int16_ptr = data;
                sscanf(ptr, "%"SCNi16, (int16_ptr + i));
                break;

            case sizeof(int32_t):
                int32_ptr = data;
                sscanf(ptr, "%"SCNi32, (int32_ptr + i));
                break;

            default:
                FATAL_MESSAGE("illegal size passed. this is a bug report me.");
                exit(1);
            }

        } else {

            switch(size) {

            case sizeof(uint8_t):
                uint8_ptr = data;
                sscanf(ptr, "%"SCNu8, (uint8_ptr + i));
                break;

            case sizeof(uint16_t):
                uint16_ptr = data;
                sscanf(ptr, "%"SCNu16, (uint16_ptr + i));
                break;

            case sizeof(uint32_t):
                uint32_ptr = data;
                sscanf(ptr, "%"SCNu32, (uint32_ptr + i));
                break;

            default:
                FATAL_MESSAGE("illegal size passed. this is a bug report me.");
                exit(1);
            }
        }

        for(;*ptr;ptr++); /* skip. */
        ptr++;
    }

    return data;
}

static list_t *internal_string_to_list_int_proc(const char *input, size_t count, size_t size, uint8_t sign)
{
    list_t *data_list;
    size_t i;
    const char *ptr;

    uint8_t  *uint8_data;
    uint16_t *uint16_data;
    uint32_t *uint32_data;

    int8_t  *int8_data;
    int16_t *int16_data;
    int32_t *int32_data;

    data_list = list_create();
    ptr = input;
    i = 0;

    while(i < count)  {

        if(sign) {

            switch(size) {

            case sizeof(int8_t):
                int8_data = xmalloc(sizeof(int8_t));
                sscanf(ptr, "%"SCNi8, int8_data);
                list_add(data_list, int8_data);

                break;

            case sizeof(int16_t):
                int16_data = xmalloc(sizeof(int16_t));
                sscanf(ptr, "%"SCNi16, int16_data);
                list_add(data_list, int16_data);

                break;

            case sizeof(int32_t):
                int32_data = xmalloc(sizeof(int32_t));
                sscanf(ptr, "%"SCNi32, int32_data);
                list_add(data_list, int32_data);

                break;

            default:
                FATAL_MESSAGE("illegal size passed. this is a bug report me.");
                exit(1);
            }

        } else {

            switch(size) {

            case sizeof(uint8_t):
                uint8_data = xmalloc(sizeof(uint8_t));
                sscanf(ptr, "%"SCNu8, uint8_data);
                list_add(data_list, uint8_data);

                break;

            case sizeof(uint16_t):
                uint16_data = xmalloc(sizeof(uint16_t));
                sscanf(ptr, "%"SCNu16, uint16_data);
                list_add(data_list, uint16_data);

                break;

            case sizeof(uint32_t):
                uint32_data = xmalloc(sizeof(uint32_t));
                sscanf(ptr, "%"SCNu32, uint32_data);
                list_add(data_list, uint32_data);

                break;

            default:
                FATAL_MESSAGE("illegal size passed. this is a bug report me.");
                exit(1);
            }
        }

        for(;*ptr;ptr++); /* skip. */
        ptr++;
    }

    return data_list;
}

static ip_addr_t *internal_string_ip_addr_to_internal(const char *input)
{
    ip_addr_t *ip_addr;
    in_addr_t in_addr;

    ip_addr = xmalloc(sizeof(ip_addr_t));
    in_addr = inet_addr(input);
    memcpy(ip_addr, &in_addr, IP_ADDR_LEN);

    return ip_addr;
}

static list_t *internal_string_list_ip_addr_to_internal(const char *input, size_t count)
{
    list_t *ip_addr_list;
    ip_addr_t *ip_addr;
    const char *ptr;
    size_t i;

    ip_addr_list = list_create();

    i = 0;
    ptr = input;

    while(i < count)  {

        ip_addr  = internal_string_ip_addr_to_internal(ptr);
        list_add(ip_addr_list, ip_addr);

        for(;*ptr;ptr++) /* skip past sentinel. */
            ptr++;

        i++;
    }

    return ip_addr_list;
}

/* procified to string routines. */

static char *uint8_to_string_proc(void *data, size_t num, const char *separator)
{
    stringbuffer_t *sb;
    char *str;
    uint8_t *uint8_ptr;
    size_t i;

    uint8_ptr = data;
    sb = stringbuffer_create();

    uint8_ptr = data;
    if(num == 1) {

        stringbuffer_aprintf(sb, "%"PRIu8, *uint8_ptr);

    } else {

        for(i = 0;i < num;i++) {
            stringbuffer_aprintf(sb, "%"PRIu8"%s", uint8_ptr[i], separator);
        }
    }

    str = xstrdup(stringbuffer_getstring(sb));
    stringbuffer_destroy(sb);

    return str;
}

static char *uint16_to_string_proc(void *data, size_t num, char *separator)
{
    stringbuffer_t *sb;
    char *str;
    uint16_t *uint16_ptr;
    size_t i;

    uint16_ptr = data;
    sb = stringbuffer_create();

    if(num == 1) {

        stringbuffer_aprintf(sb, "%"PRIu16, *uint16_ptr);

    } else {

        for(i = 0;i < num;i++) {
            stringbuffer_aprintf(sb, "%"PRIu16"%s", uint16_ptr[i], separator);
        }
    }

    str = xstrdup(stringbuffer_getstring(sb));
    stringbuffer_destroy(sb);

    return str;
}

static char *uint32_to_string_proc(void *data, size_t num, const char *separator)
{
    stringbuffer_t *sb;
    char *str;
    uint32_t *uint32_ptr;
    size_t i;

    uint32_ptr = data;
    sb = stringbuffer_create();

    if(num == 1) {

        stringbuffer_aprintf(sb, "%"PRIu32, *uint32_ptr);

    } else {

        for(i = 0;i < num;i++) {
            stringbuffer_aprintf(sb, "%"PRIu32"%s", uint32_ptr[i], separator);
        }
    }

    str = xstrdup(stringbuffer_getstring(sb));
    stringbuffer_destroy(sb);

    return str;
}

static char *int8_to_string_proc(void *data, size_t num, const char *separator) 
{
    stringbuffer_t *sb;
    char *str;
    int8_t *int8_ptr;
    size_t i;

    int8_ptr = data;
    sb = stringbuffer_create();

    if(num == 1) {

        stringbuffer_aprintf(sb, "%"PRIi8, *int8_ptr);

    } else {

        for(i = 0;i < num;i++) {
            stringbuffer_aprintf(sb, "%"PRIi8"%s", int8_ptr[i], separator);
        }
    }

    str = xstrdup(stringbuffer_getstring(sb));
    stringbuffer_destroy(sb);

    return str;
}

static char *int16_to_string_proc(void *data, size_t num, const char *separator)
{
    stringbuffer_t *sb;
    char *str;
    int16_t *int16_ptr;
    size_t i;

    int16_ptr = data;
    sb = stringbuffer_create();

    if(num == 1) {

        stringbuffer_aprintf(sb, "%"PRIi16, *int16_ptr);

    } else {

        for(i = 0;i < num;i++) {
            stringbuffer_aprintf(sb, "%"PRIi16"%s", int16_ptr[i], separator);
        }
    }

    str = xstrdup(stringbuffer_getstring(sb));
    stringbuffer_destroy(sb);

    return str;
}

static char *int32_to_string_proc(void *data, size_t num, const char *separator)
{
    stringbuffer_t *sb;
    char *str;
    int32_t *int32_ptr;
    size_t i;

    int32_ptr = data;
    sb = stringbuffer_create();

    if(num == 1) {

        stringbuffer_aprintf(sb, "%"PRIi32, *int32_ptr);

    } else {

        for(i = 0;i < num;i++) {
            stringbuffer_aprintf(sb, "%"PRIi32"%s", int32_ptr[i], separator);
        }
    }

    str = xstrdup(stringbuffer_getstring(sb));
    stringbuffer_destroy(sb);

    return str;
}

static char *int_list_to_string_proc(void *list_data, size_t size, uint8_t sign, const char *separator)
{
    int32_t  *int32_ptr;
    int16_t  *int16_ptr;
    int8_t   *int8_ptr;
    uint32_t *uint32_ptr;
    uint16_t *uint16_ptr;
    uint8_t  *uint8_ptr;
    void *data;
    size_t i;

    stringbuffer_t *sb;
    char *str;
    list_t *list;

    sb = stringbuffer_create();
    list = list_data;
    list_rewind(list);

    i = 0;
    while((data = list_next(list)) != NULL) {

        if(sign) {

            switch(size) {

            case sizeof(int8_t):

                i++;
                int8_ptr = data;

                if(i < list_get_len(list)) {
                    stringbuffer_aprintf(sb, "%"PRIi8"%s", *int8_ptr, separator);
                } else {
                    stringbuffer_aprintf(sb, "%"PRIi8, *int8_ptr);
                }
                break;

            case sizeof(int16_t):

                i++;
                int16_ptr = data;

                if(i < list_get_len(list)) {
                    stringbuffer_aprintf(sb, "%"PRIi16"%s", *int16_ptr, separator);
                } else {
                    stringbuffer_aprintf(sb, "%"PRIi16, *int16_ptr);
                }
                break;

            case sizeof(int32_t):

                i++;
                int32_ptr = data;

                if(i < list_get_len(list)) {
                    stringbuffer_aprintf(sb, "%"PRIi32"%s", *int32_ptr, separator);
                } else {
                    stringbuffer_aprintf(sb, "%"PRIi32, *int32_ptr);
                }
                break;
            }

        } else {

            switch (size) {

            case sizeof(uint8_t):

                i++;
                uint8_ptr = data;

                if(i < list_get_len(list)) {
                    stringbuffer_aprintf(sb, "%"PRIu8"%s", *uint8_ptr, separator);
                } else {
                    stringbuffer_aprintf(sb, "%"PRIu8, *uint8_ptr);
                }
                break;

            case sizeof(int16_t):

                i++;
                uint16_ptr = data;

                if(i < list_get_len(list)) {
                    stringbuffer_aprintf(sb, "%"PRIu16"%s", *uint16_ptr, separator);
                } else {
                    stringbuffer_aprintf(sb, "%"PRIu16, *uint16_ptr);
                }
                break;

            case sizeof(int32_t):

                i++;
                uint32_ptr = data;

                if(i < list_get_len(list)) {
                    stringbuffer_aprintf(sb, "%"PRIu32"%s", *uint32_ptr, separator);
                } else {
                    stringbuffer_aprintf(sb, "%"PRIu32, *uint32_ptr);
                }
                break;
            }
        }
    }

    str = xstrdup(stringbuffer_getstring(sb));
    stringbuffer_destroy(sb);

    return str;
}

static char *ip_addr_to_string_proc(void *data, uint8_t quoted)
{
    stringbuffer_t *sb;
    ip_addr_t *ip_addr;
    char *ip_addr_str;

    ip_addr = data;
    ip_addr_str = ip_addr_to_string(*ip_addr);

    if(quoted) {
        sb = stringbuffer_create();
        stringbuffer_aprintf(sb, "\"%s\"", ip_addr_str);

        xfree(ip_addr_str);
        ip_addr_str = xstrdup(stringbuffer_getstring(sb));
    }

    return ip_addr_str;
}

static char *ip_addr_list_to_string_proc(void *data, const char *separator, uint8_t quoted)
{
    ip_addr_t *ip_addr;
    list_t *list;
    stringbuffer_t *sb;
    size_t num;
    char *str, *ip_addr_str;

    sb = stringbuffer_create();

    list = data;
    list_rewind(list);
    num = 0;

    while((ip_addr = list_next(list)) != NULL) {

        ip_addr_str = ip_addr_to_string(*ip_addr);
        num++;
        if(num < list_get_len(list)) {
            stringbuffer_aprintf(sb, "%s%s", ip_addr_str, separator);
        } else {
            stringbuffer_aprintf(sb, "%s", ip_addr_str);
        }

        xfree(ip_addr_str);
    }

    str = xstrdup(stringbuffer_getstring(sb));
    stringbuffer_destroy(sb);

    return str;
}

/* from internal data to user string. */

static char *uint8_to_user_string(void *data, size_t num)
{
    return uint8_to_string_proc(data, num, ", ");
}

static char *uint16_to_user_string(void *data, size_t num)
{
    return uint16_to_string_proc(data, num, ", ");
}

static char *uint32_to_user_string(void *data, size_t num)
{
    return uint32_to_string_proc(data, num, ", ");
}

static char *int8_to_user_string(void *data, size_t num)
{
    return int8_to_string_proc(data, num, ", ");
}

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

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

static char *int_list_to_user_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_user_string(void *data)
{
    return ip_addr_list_to_string_proc(data, ", ", 1);
}

static char *ip_addr_to_user_string(void *data)
{
    return ip_addr_to_string_proc(data, 1);
}

/* from internal data to internal string */

static char *uint8_to_internal_string(void *data, size_t num)
{
    return uint8_to_string_proc(data, num, ";");
}

static char *uint16_to_internal_string(void *data, size_t num)
{
    return uint16_to_string_proc(data, num, ";");
}

static char *uint32_to_internal_string(void *data, size_t num)
{
    return uint32_to_string_proc(data, num, ";");
}

static char *int8_to_internal_string(void *data, size_t num)
{