Update parsing code in sa_systemdata.c

Signed-off-by: nshero.lee <nshero.lee@samsung.com>

diff --git a/src/sa_systemdata.c b/src/sa_systemdata.c
index fdf4a0a9ec833a93702cda11c234c9cc57ba4817..b18b66b83738dc35e9a4da7e513b1a6222b904c8 100644 (file)
--- a/src/sa_systemdata.c
+++ b/src/sa_systemdata.c
@@ -197,10 +197,8 @@ static int json_get_boolean_from_obj(json_object *inputObj, char *key)
                        ret = json_object_get_boolean(bodyObj);
                } else {
                        _E("ERROR : no data");
-
                }
        }
-       json_object_put(inputObj);
        return ret;
 }
 
@@ -228,29 +226,197 @@ static char *json_get_string_from_obj(json_object *inputObj, char *key)
                return NULL;
        }
 
-       _D("ret_buf [%s]", ret_buf);
+       _D("string object [%s]", ret_buf);
        return ret_buf;
 }
 
+static int __parse_network_static_info(json_object *inputObj, sa_network_static_s *staticInfo)
+{
+       char *ipAddress = NULL;
+       char *netmask = NULL;
+       char *defaultGateway = NULL;
+       char *primaryDnsServer = NULL;
+       char *secondaryDnsServer = NULL;
+
+       if (inputObj == NULL || staticInfo == NULL) {
+               _E("__parse_network_static_info input error");
+               return -1;
+       }
+
+       //ipAddress
+       ipAddress = json_get_string_from_obj(inputObj, SA_CONFIG_NETWORKDATA_IPADDRESS);
+       if (ipAddress != NULL) {
+               memcpy(staticInfo->ipAddress, ipAddress, MIN(strlen(ipAddress), sizeof(staticInfo->ipAddress)-1));
+               free(ipAddress);
+               ipAddress = NULL;
+       }
+
+       //netmask
+       netmask = json_get_string_from_obj(inputObj, SA_CONFIG_NETWORKDATA_NETMASK);
+       if (netmask != NULL) {
+               memcpy(staticInfo->netmask, netmask, MIN(strlen(netmask), sizeof(staticInfo->netmask)-1));
+               free(netmask);
+               netmask = NULL;
+       }
+
+       //defaultGateway
+       defaultGateway = json_get_string_from_obj(inputObj, SA_CONFIG_NETWORKDATA_DEFAULTGATEWAY);
+       if (defaultGateway != NULL) {
+               memcpy(staticInfo->defaultGateway, defaultGateway, MIN(strlen(defaultGateway), sizeof(staticInfo->defaultGateway)-1));
+               free(defaultGateway);
+               defaultGateway = NULL;
+       }
+       
+       //primaryDnsServer
+       primaryDnsServer = json_get_string_from_obj(inputObj, SA_CONFIG_NETWORKDATA_PRIMARYDNSSERVER);
+       if (primaryDnsServer != NULL) {
+               memcpy(staticInfo->primaryDnsServer, primaryDnsServer, MIN(strlen(primaryDnsServer), sizeof(staticInfo->primaryDnsServer)-1));
+               free(primaryDnsServer);
+               primaryDnsServer = NULL;
+       }
+       
+       //secondaryDnsServer
+       secondaryDnsServer = json_get_string_from_obj(inputObj, SA_CONFIG_NETWORKDATA_SECONDARYDNSSERVER);
+       if (secondaryDnsServer != NULL) {
+               memcpy(staticInfo->secondaryDnsServer, secondaryDnsServer, MIN(strlen(secondaryDnsServer), sizeof(staticInfo->secondaryDnsServer)-1));
+               free(secondaryDnsServer);
+               secondaryDnsServer = NULL;
+       }
+
+       return 0;
+}
+
 static int __parse_network_eth(json_object *inputObj, sa_eth_s *eth)
 {
+       int ret = 0;
+
+       if (inputObj == NULL || eth == NULL) {
+               _E("__parse_network_eth input error");
+               return -1;
+       }
+
+       // enabled
+       eth->enabled = json_get_boolean_from_obj(inputObj, SA_CONFIG_NETWORKDATA_ENABLED);
+
+       // dhcpEnabled
+       eth->dhcpEnabled = json_get_boolean_from_obj(inputObj, SA_CONFIG_NETWORKDATA_DHCPENABLED);
+       if (eth->dhcpEnabled == 0) {
+               eth->staticInfo = (sa_network_static_s *)malloc(sizeof(sa_network_static_s));
+               if (eth->staticInfo != NULL) {
+                       ret = __parse_network_static_info(inputObj, eth->staticInfo);
+               } else {
+                       ret = -1;
+               }
+       } else {
+               _D("dhcp is true");
+       }
 
+       return ret;
 }
 
 static int __parse_network_wifi(json_object *inputObj, sa_wifi_s *wifi)
 {
+       char *ssid = NULL;
+       char *password = NULL;
+       int ret = 0;
+
+       if (inputObj == NULL || wifi == NULL) {
+               _E("__parse_network_wifi input error");
+               return -1;
+       }
+       // enabled
+       wifi->enabled = json_get_boolean_from_obj(inputObj, SA_CONFIG_NETWORKDATA_ENABLED);
+
+       // ssid
+       ssid = json_get_string_from_obj(inputObj, SA_CONFIG_NETWORKDATA_WIFI_SSID);
+       if (ssid != NULL) {
+               memcpy(wifi->ssid, ssid, MIN(strlen(ssid), sizeof(wifi->ssid)-1));
+               free(ssid);
+               ssid = NULL;
+       } else {
+               ret = -1;
+       }
 
+       // password
+       password = json_get_string_from_obj(inputObj, SA_CONFIG_NETWORKDATA_WIFI_PASSWORD);
+       if (password != NULL) {
+               memcpy(wifi->password, password, MIN(strlen(password), sizeof(wifi->password)-1));
+               free(password);
+               password = NULL;
+       } else {
+               ret = -1;
+       }
+
+       // dhcpEnabled
+       wifi->dhcpEnabled = json_get_boolean_from_obj(inputObj, SA_CONFIG_NETWORKDATA_DHCPENABLED);
+       if (wifi->dhcpEnabled == 0) {
+               wifi->staticInfo = (sa_network_static_s *)malloc(sizeof(sa_network_static_s));
+               if (wifi->staticInfo != NULL) {
+                       ret = __parse_network_static_info(inputObj, wifi->staticInfo);
+               } else {
+                       ret = -1;
+               }
+       } else {
+               _D("dhcp is true");
+       }
+
+       return ret;
 }
 
-static int __parse_network_data(char *data, sa_network_s *network)
+static int __parse_network_data(json_object *inputObj, sa_network_s *network)
 {
+       struct json_object *wifiObj = NULL;
+       struct json_object *ethernetObj = NULL;
+       int wifiRet = 0, ethRet = 0;
+
+       if (inputObj == NULL || network == NULL) {
+               _E("__parse_network_data input error");
+               return -1;
+       }
+
+       //parse wifi
+       if (json_object_object_get_ex(inputObj, SA_CONFIG_NETWORKDATA_WIFI, &wifiObj)) {
+               if (json_object_get_type(wifiObj) == json_type_object) {
+                       // malloc
+                       network->wifi = (sa_wifi_s *)malloc(sizeof(sa_wifi_s));
+                       if (network->wifi != NULL) {
+                               wifiRet = __parse_network_wifi(wifiObj, network->wifi);
+                       } else {
+                               _E("network->wifi malloc fail");
+                       }
+               }
+       }
+
+       //parse eth
+       if (json_object_object_get_ex(inputObj, SA_CONFIG_NETWORKDATA_ETHERNET, &ethernetObj)) {
+               if (json_object_get_type(ethernetObj) == json_type_object) {
+                       // malloc
+                       network->eth = (sa_eth_s *)malloc(sizeof(sa_eth_s));
+                       if (network->eth != NULL) {
+                               ethRet = __parse_network_eth(ethernetObj, network->eth);
+                       } else {
+                               _E("network->eth malloc fail"); 
+                       }
+               }
+       }
+
+       // if both of network interfaces are failed, it would return -1
+       if (wifiRet != 0 && ethRet != 0) {
+               _E("__parse_network_data fail");        
+               return -1;
+       }
        
        return 0;
 }
 
 
-static int __parse_system_data(char *data, sa_systemdata_s *system)
+static int __parse_system_data(json_object *inputObj, sa_systemdata_s *system)
 {
+       if (inputObj == NULL || system == NULL) {
+               _E("__parse_system_data input error");
+               return -1;
+       }
+
        return 0;
 }
 
@@ -260,6 +426,7 @@ static int __parse_version(json_object *inputObj, sa_config_s *setupConfig)
        char *version = NULL;
 
        if (inputObj == NULL || setupConfig == NULL) {
+               _E("__parse_version input error");
                return -1;
        }
 
@@ -277,6 +444,8 @@ static int __parse_version(json_object *inputObj, sa_config_s *setupConfig)
 static int __parse_config(char *file, sa_config_s *setupConfig)
 {
        struct json_object *configObj = NULL;
+       struct json_object *networkObj = NULL;
+       struct json_object *systemObj = NULL;
        char *jsonData = NULL;
        int readLen = 0;
        int fd = 0;
@@ -303,18 +472,31 @@ static int __parse_config(char *file, sa_config_s *setupConfig)
 
                                        // parse system data
                                        if (ret == 0) {
-                                               ret = __parse_system_data(configObj, setupConfig->systemData);
+                                               if (json_object_object_get_ex(configObj, SA_CONFIG_SYSTEMDATA, &systemObj)) {
+                                                       if (json_object_get_type(systemObj) == json_type_object) {
+                                                               // malloc
+                                                               setupConfig->systemData = (sa_systemdata_s *)malloc(sizeof(sa_systemdata_s));
+                                                               ret = __parse_system_data(systemObj, setupConfig->systemData);
+                                                       }
+                                               }
                                        }
 
                                        // parse network data
                                        if (ret == 0) {
-                                               ret = __parse_network_data(configObj, setupConfig->networkData);
+                                               if (json_object_object_get_ex(configObj, SA_CONFIG_NETWORKDATA, &networkObj)) {
+                                                       if (json_object_get_type(networkObj) == json_type_object) {
+                                                               // malloc
+                                                               setupConfig->networkData = (sa_network_s *)malloc(sizeof(sa_network_s));
+                                                               ret = __parse_network_data(networkObj, setupConfig->networkData);
+                                                       }
+                                               }                                               
                                        }
                                } else {
                                        ret = -1;
                                        _E("ConfigObj is not existed");
                                }
                                
+                               json_object_put(configObj);
                                free(jsonData);
                        } else {
                                ret = -1;