#include "configm.h"
#include "rpc.h"
#include "parsefile.h"
#include "netconfig.h"

uchar ip_masklen(struct in_addr netmask)
{
	uint tmp = ~ntohl(netmask.s_addr);
	if (tmp)
		/* clz: count leading zeroes. sadly, the behaviour of this
		 * builtin
		 * is undefined for a 0 argument, even though most CPUs give 32
		 */
		return __builtin_clz(tmp);
	else
		return 32;
}


/* Convert masklen into IP address's netmask (network byte order). */
void masklen2ip(const int masklen, struct in_addr *netmask)
{
    if(masklen < 0 || masklen > IPV4_MAX_BITLEN)
    {
        return;
    }

	/* left shift is only defined for less than the size of the type.
	 * we unconditionally use long long in case the target platform
	 * has defined behaviour for << 32 (or has a 64-bit left shift) */

	if (sizeof(unsigned long long) > 4)
		netmask->s_addr = htonl(0xffffffffULL << (32 - masklen));
	else
		netmask->s_addr =
			htonl(masklen ? 0xffffffffU << (32 - masklen) : 0);
}

static ret_code ip_inet6_pton(char *bufp, struct in6_addr *dst)
{
    struct sockaddr_in6 sin6 = {0};

    sin6.sin6_family = AF_INET6;
    sin6.sin6_port = 0;

    if (inet_pton(AF_INET6, bufp, sin6.sin6_addr.s6_addr) <= 0)
    {
        return RET_ERR;
    }

    memcpy((char *) dst, (char *) &sin6.sin6_addr, sizeof(struct in6_addr));

    return RET_OK;
}

static char *ip_inet6_print(struct in6_addr *ptr)
{
    static char name[80] = {0};

    inet_ntop(AF_INET6,  ptr, name, 80);
    return name;
}


void ip_save_file(ip_config_t *ip_conf, uint config_type)
{
    char *addr_name = "address";
    char *mask_name = "netmask";
    struct in_addr netmask;
    char addr_buff[IF_BUFF_LEN] = {0};
    char mask_buff[IF_BUFF_LEN] = {0};

    if(config_type == CM_CONFIG_SET)
    {   
        sprintf(addr_buff, "address %s\n", inet_ntoa(ip_conf->prefix));
        masklen2ip(ip_conf->prefixlen, &netmask);
        sprintf(mask_buff, "netmask %s\n", inet_ntoa(netmask));
        rpc_log_info("%s %s",addr_buff, mask_buff);
        
        ip_conf_file_set(ip_conf->ifname, addr_name, addr_buff);
        ip_conf_file_set(ip_conf->ifname, mask_name, mask_buff);
    }
    else if(config_type == CM_CONFIG_DEL)
    {
        ip_conf_file_del(ip_conf->ifname, addr_name);
        ip_conf_file_del(ip_conf->ifname, mask_name);
    }
}

void ip6_save_file(ip_config_t *ip_conf, uint config_type)
{
    char *addr_name = "address";
    char *mask_name = "netmask";
    char addr_buff[IF_BUFF_LEN] = {0};
    char mask_buff[IF_BUFF_LEN] = {0};

    if(config_type == CM_CONFIG_SET)
    {   
        sprintf(addr_buff, "address %s\n", ip_inet6_print(&ip_conf->prefix6));
        sprintf(mask_buff, "netmask %d\n", ip_conf->prefixlen);
        rpc_log_info("%s %s",addr_buff, mask_buff);
        
        ipv6_conf_file_set(ip_conf->ifname, addr_name, addr_buff);
        ipv6_conf_file_set(ip_conf->ifname, mask_name, mask_buff);
    }
    else if(config_type == CM_CONFIG_DEL)
    {
        ipv6_conf_file_del(ip_conf->ifname, addr_name);
        ipv6_conf_file_del(ip_conf->ifname, mask_name);
    }
}

ret_code ip_config_json_parse(pointer input, uint *conf_type, ip_config_t *config_buff)
{
    cJSON *json_obj;
    
    json_obj = cJSON_Parse(input);
    if(!json_obj)
    {
        return RET_JSONERR;
    }

    rpc_json_print(json_obj);
    
    s2j_create_struct_obj(ip_config, ip_config_string_t);

    if(ip_config == NULL)
    {
        cJSON_Delete(json_obj);  
        return RET_NOMEM;
    }
    
    s2j_struct_get_basic_element(ip_config, json_obj, int, config_type);
    s2j_struct_get_string_element(ip_config, json_obj, ifname, INTERFACE_NAMSIZ);
    s2j_struct_get_basic_element(ip_config, json_obj, int, family);
    s2j_struct_get_string_element(ip_config, json_obj, ipaddr, DOT_IP_STR);
    s2j_struct_get_basic_element(ip_config, json_obj, int, prefixlen);
    
    strncpy(config_buff->ifname, ip_config->ifname, INTERFACE_NAMSIZ - 1);
    
    config_buff->family        = (uchar)ip_config->family;
    config_buff->prefixlen     = (uchar)ip_config->prefixlen;

    if(config_buff->family == AF_INET)
    {
        config_buff->prefix.s_addr = inet_addr(ip_config->ipaddr);
    }
    else if(config_buff->family == AF_INET6)
    {
        ip_inet6_pton(ip_config->ipaddr, &(config_buff->prefix6));
    }

    if(ip_config->config_type)
    {
        *conf_type = ip_config->config_type;
    }

    s2j_delete_struct_obj(ip_config);
    cJSON_Delete(json_obj);

    return RET_OK;
}

cJSON * ip_config_format_json(if_info_t *config_buff)
{
    if_v4addr_t *ipv4 = &config_buff->ipv4;
    if_v6addr_t *ipv6 = &config_buff->ipv6;
    if_cnt_t *stats = &config_buff->stats;

    s2j_create_json_obj(json_ipv4);
    s2j_create_json_obj(json_ipv6);
    s2j_create_json_obj(json_stats);
    s2j_create_json_obj(json_obj);

    s2j_json_set_basic_element(json_ipv4, ipv4, string, addr);
    s2j_json_set_basic_element(json_ipv4, ipv4, int, prefixlen);

    s2j_json_set_basic_element(json_ipv6, ipv6, string, addr);
    s2j_json_set_basic_element(json_ipv6, ipv6, int, prefixlen);

    s2j_json_set_basic_element(json_stats, stats, string, rcv_packets);
    s2j_json_set_basic_element(json_stats, stats, string, rcv_bytes);
    s2j_json_set_basic_element(json_stats, stats, string, snd_packets);
    s2j_json_set_basic_element(json_stats, stats, string, snd_bytes);

    s2j_json_set_basic_element(json_obj, config_buff, string, ifname);
    s2j_json_set_basic_element(json_obj, config_buff, string, maxspeed);
    s2j_json_set_basic_element(json_obj, config_buff, string, state);
    s2j_json_set_basic_element(json_obj, config_buff, string, hwaddr);

    cJSON_AddItemToObject(json_obj, "ipv4", json_ipv4);
    cJSON_AddItemToObject(json_obj, "ipv6", json_ipv6);
    cJSON_AddItemToObject(json_obj, "statistics", json_stats);

    return json_obj;
}

ret_code if_get_info(if_info_t *if_info, int *code)
{
    ret_code ret = RET_OK;

    ret = if_get_hwaddr(if_info, code);
    ASSERT_RET(ret);
    
    ret = if_get_maxspeed(if_info, code);
    //ASSERT_RET(ret);

    ret = if_get_linkstat(if_info, code);
    ASSERT_RET(ret);
    
    ret = if_get_prefix(if_info, code);
    ASSERT_RET(ret);

    ret = if_read_stats_file(if_info);
    ASSERT_RET(ret);

    return ret;
}


ret_code ip_config_v4chk(uint config_type, ip_config_t *ip_conf)
{
    ret_code ret = RET_OK;
    
    if (config_type != CM_CONFIG_DEL && ipv4_martian(&ip_conf->prefix)) 
    {
        ret =  RET_IPINVALID;
    }

    ASSERT_RET(ret);

    if(ip_conf->prefixlen == 0 || ip_conf->prefixlen > IPV4_MAX_PREFIXLEN)
    {
        ip_conf->prefixlen = IPV4_DEFAULT_PREFIXLEN;
    }

    return ret;
}

ret_code ip_config_v6chk(uint config_type, ip_config_t *ip_conf)
{
    ret_code ret = RET_OK;
    
    if (config_type != CM_CONFIG_DEL && ipv6_martian(&(ip_conf->prefix6))) 
    {
        ret =  RET_IPINVALID;
    }

    ASSERT_RET(ret);

    if(ip_conf->prefixlen == 0 || ip_conf->prefixlen > IPV6_MAX_PREFIXLEN)
    {
        ip_conf->prefixlen = IPV6_DEFAULT_PREFIXLEN;
    }

    return ret;
}


ret_code ip_config_set_chk(uint source,uint config_type,
                       pointer input, int input_len,
                       pointer output, int *output_len)
{
    ret_code ret = RET_OK;
    ip_config_t *ip_conf;
    
    ip_conf = (ip_config_t *)input;
    
    if(input_len < sizeof(ip_config_t)
       || strlen(ip_conf->ifname) == 0)
    {
        ret = RET_INPUTERR;
    }

    if(ip_conf->family == AF_INET)
    {
        ret = ip_config_v4chk(config_type, ip_conf);
    }
    else if(ip_conf->family == AF_INET6)
    {
        ret = ip_config_v6chk(config_type, ip_conf);
    }

    ASSERT_RET(ret);
    
    return RET_OK;
}

ret_code ip_config_get_chk(uint source,uint config_type,
                       pointer input, int input_len,
                       pointer output, int *output_len)
{
    ret_code ret = RET_OK;
    ip_config_t *ip_config;

    ip_config = (ip_config_t *)input;
    
    if(input_len < sizeof(ip_config_t)
       || strlen(ip_config->ifname) == 0 )
    {
        ret = RET_INPUTERR;
    }
    ASSERT_RET(ret);
    
    return ret;
}

ret_code ip_config_getall_chk(uint source,uint config_type,
                       pointer input, int input_len,
                       pointer output, int *output_len)
{
    ret_code ret = RET_OK;

    if(*output_len < MAX_IF_NUM * sizeof(ip_config_t))
    {
       ret = RET_INPUTERR;
    }
    ASSERT_RET(ret);

    return ret;
}


ret_code ip_config_chk(uint source,uint *config_type,
                       pointer input, int *input_len,
                       pointer output, int *output_len)

{
    int config_len = sizeof(ip_config_t);
    uint conf_type = CM_CONFIG_GET;
    ip_config_t ip_config = {0};
    ret_code ret = RET_OK;
    int code = 0;

    ret = ip_config_json_parse(input, &conf_type, &ip_config);
    ASSERT_RET(ret);

    switch (conf_type)
    {
        case CM_CONFIG_SET:            
        case CM_CONFIG_DEL:
            ret = ip_config_set_chk(source, conf_type, 
                                    &ip_config, config_len,
                                    output, output_len);
            break;
         case CM_CONFIG_GET:
            ret = ip_config_get_chk(source, conf_type, 
                                    &ip_config, config_len,
                                    output, output_len);
            break;
         case CM_CONFIG_GET_ALL:
            ret = ip_config_getall_chk(source, conf_type, 
                                       &ip_config, config_len,
                                       output, output_len);
            break;
         default:
            ret = RET_NOTSUPPORT;
    }

    /* 将传入的json数据转换成结构体，便于后续处理 */
    if(config_len <= CM_BUFF_SIZE)
    {
        memset(input, 0, *input_len);
        memcpy(input, &ip_config, config_len);
        *config_type = conf_type;
        *input_len = config_len;
    }
    else
    {        
        ret = RET_NOMEM;
    }
    
    RET_ERR_FORMART(ret, code, output, *output_len);
    
    return ret;
}

/*
设置ipv4地址
{"config_type":3,"ifname":"br0","family":2,"ipaddr":"192.168.3.1","prefixlen":16}
设置ipv6地址
{"config_type":3,"ifname":"br0","family":10,"ipaddr":"2001::1","prefixlen":64}
删除ipv4地址
{"config_type":2,"ifname":"br0","family":2,"ipaddr":"192.168.3.1","prefixlen":16}
删除ipv6地址
{"config_type":2,"ifname":"br0","family":10,"ipaddr":"2001::1","prefixlen":64} 
*/
ret_code ip_config_proc(uint source, uint config_type,
                       pointer input, int input_len,
                       pointer output, int *output_len)
{    
    uint conf_type = config_type;
    ip_config_t *ip_conf;
    ret_code ret = RET_OK;
    int code;

    ip_conf = (ip_config_t *)input;

    if(conf_type == CM_CONFIG_DEL)
    {
        ip_conf->prefix.s_addr = 0;
    }

    if(ip_conf->family == AF_INET)
    {
        rpc_log_info("config type is %d, if %s ip %s prefixlen %d\n", 
                     conf_type, ip_conf->ifname, 
                     inet_ntoa(ip_conf->prefix), 
                     ip_conf->prefixlen);
        
        ip_conf->prefixlen = IPV4_DEFAULT_PREFIXLEN;
        ret = if_set_prefix(ip_conf, &code);
        RET_ERR_FORMART(ret, code, output, *output_len);
        ASSERT_RET(ret);

        ip_save_file(ip_conf, conf_type);
    }
    else if(ip_conf->family == AF_INET6)
    {
        rpc_log_info("config type is %d, if %s ip %s prefixlen %d\n", 
                     conf_type, ip_conf->ifname, 
                     ip_inet6_print(&(ip_conf->prefix6)),
                     ip_conf->prefixlen);
        
        ip_conf->prefixlen = IPV6_DEFAULT_PREFIXLEN;
        ret = if_set_prefix6(conf_type, ip_conf, &code);
        RET_ERR_FORMART(ret, code, output, *output_len);
        ASSERT_RET(ret);

        ip6_save_file(ip_conf, conf_type);
    }

    return RET_OK;
}

/*{"config_type":4,"ifname":"br0"}*/
ret_code ip_config_get(uint source, 
                       pointer input, int input_len,
                       pointer output, int *output_len)
{
    if_info_t if_info = {0};
    ret_code ret = RET_OK;    
    ip_config_t *if_config;
    cJSON *item_obj;
    int code;
    
    if_config = (ip_config_t *)input;
    strncpy(if_info.ifname, if_config->ifname, INTERFACE_NAMSIZ - 1);

    ret = if_get_info(&if_info, &code);
    ASSERT_RET(ret);
    
    item_obj = ip_config_format_json(&if_info);
    *output_len = cm_format_data(RET_OK, item_obj, output);

    return ret;
}

/* {"config_type":5} */
ret_code ip_config_get_all(uint source, pointer output, int *output_len)
{
    struct ifreq *ifreq;
    ret_code ret = RET_OK;
    int if_count = 0;
    if_info_t *if_info;
    cJSON *json_array;
    cJSON *item_obj;
    int code = 0;
    int i;

    ifreq = rpc_new0(struct ifreq, MAX_IF_NUM);
    ASSERT_PTR(ifreq, RET_NOMEM);
    
    if_count = if_get_allport(ifreq, MAX_IF_NUM);
    
    rpc_log_info("if num is %d\n", if_count);

    if((if_count * sizeof(if_info_t) > CM_BUFF_SIZE)
     || (if_count == 0))
    {
        rpc_free(ifreq);
        ret = RET_NOMEM;
    }
    ASSERT_RET(ret);

    if_info = rpc_new0(if_info_t, if_count);
    if(if_info == NULL)
    {
        rpc_free(ifreq);
        return RET_NOMEM;
    }

    json_array = cJSON_CreateArray();
    if(json_array == NULL)
    {
        rpc_free(ifreq);
        rpc_free(if_info);
        return RET_NOMEM;
    }

    for(i = 0; i < if_count; i++)
    {
        rpc_log_info("get interface %s info\n", ifreq[i].ifr_name);
        strncpy(if_info[i].ifname, ifreq[i].ifr_name, INTERFACE_NAMSIZ - 1);

        ret = if_get_info(&if_info[i], &code);
        ASSERT_CONTINUE(ret);
         
        item_obj = ip_config_format_json(&if_info[i]);
        if(item_obj == NULL)
        {
            continue;
        }

        cJSON_AddItemToArray(json_array, item_obj);
    }
     
     rpc_free(ifreq);
     rpc_free(if_info);

    *output_len = cm_format_data(RET_OK, json_array, output);

    rpc_log_info("ip_config_get_all: %s\n", (char *)output);

    RET_ERR_FORMART(ret, code, output, *output_len);

    ASSERT_RET(ret);

    return RET_OK;

}