X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fwifi-config.c;h=97b9c6d4a55a66567be08ec8008148da0cda6cbe;hb=4d049dc6877bf31694283630ce72a2736108c5a1;hp=54dae24425ef306b9672ceee51be989b7bf0d7cf;hpb=697f0ce9d4c7c6258cb121b435984bb5faada013;p=platform%2Fcore%2Fconnectivity%2Fnet-config.git diff --git a/src/wifi-config.c b/src/wifi-config.c old mode 100644 new mode 100755 index 54dae24..97b9c6d --- a/src/wifi-config.c +++ b/src/wifi-config.c @@ -18,12 +18,16 @@ */ #include +#include #include #include #include #include #include #include +#include +#include +#include #include @@ -31,28 +35,50 @@ #include "util.h" #include "neterror.h" #include "wifi-config.h" +#include "netsupplicant.h" +#include "wifi-key-encryption.h" #define CONNMAN_STORAGE "/var/lib/connman" -#define WIFI_CONFIG_PREFIX "wifi_" - -#define WIFI_CONFIG_NAME "Name" -#define WIFI_CONFIG_SSID "SSID" -#define WIFI_CONFIG_PASSPHRASE "Passphrase" -#define WIFI_CONFIG_SECURITY_TYPE "Security" -#define WIFI_CONFIG_FAVORITE "Favorite" -#define WIFI_CONFIG_AUTOCONNECT "AutoConnect" -#define WIFI_CONFIG_HIDDEN "Hidden" -#define WIFI_CONFIG_FAILURE "Failure" -#define WIFI_CONFIG_PROXYADDRESS "ProxyAddress" -#define WIFI_CONFIG_PROXY_METHOD "Proxy.Method" -#define WIFI_CONFIG_PROXY_SERVER "Proxy.Servers" #define WIFI_SECURITY_NONE "none" #define WIFI_SECURITY_WEP "wep" #define WIFI_SECURITY_WPA_PSK "psk" #define WIFI_SECURITY_EAP "ieee8021x" -#define WIFI_PREFIX_LENGTH 18 // wifi_485a3f2f506a_ +#define WIFI_CONFIG_PREFIX "wifi_" +#define MAC_ADDRESS_LENGTH 12 +#define WIFI_PREFIX_LENGTH MAC_ADDRESS_LENGTH + 6 /* wifi_485a3f2f506a_ */ +#define PROFILE_PREFIX_LENGTH WIFI_PREFIX_LENGTH + 21 /* /net/connman/service/wifi_485a3f2f506a_ */ + +#define WIFI_MAC_ADD_LENGTH 17 +#define WIFI_MAC_ADD_PATH "/sys/class/net/wlan0/address" + +#define NET_DNS_ADDR_MAX 2 + +#define MAX_WIFI_PROFILES 200 + +struct wifi_eap_config { + gchar *anonymous_identity; + gchar *ca_cert; + gchar *client_cert; + gchar *private_key; + gchar *private_key_password; + gchar *identity; + gchar *eap_type; + gchar *eap_auth_type; + gchar *subject_match; +}; + +typedef struct { + gchar *ip_address; + gchar *subnet_mask; + gchar *gateway_address; + gchar *dns_address[NET_DNS_ADDR_MAX]; + int prefix_length; + int dns_count; + gchar *ip_type; + gchar *dns_type; +} wifi_ip_info_s; struct wifi_config { gchar *name; @@ -62,39 +88,187 @@ struct wifi_config { gboolean favorite; gboolean autoconnect; gchar *is_hidden; + gboolean is_created; gchar *proxy_address; + struct wifi_eap_config *eap_config; + wifi_ip_info_s *ip_info; gchar *last_error; }; -static gint __netconfig_get_mac_address(gchar **mac_address) +static void __free_wifi_configuration(struct wifi_config *conf) +{ + if (conf == NULL) + return; + + g_free(conf->name); + g_free(conf->ssid); + g_free(conf->passphrase); + g_free(conf->security_type); + g_free(conf->is_hidden); + g_free(conf->proxy_address); + g_free(conf->last_error); + if (conf->eap_config) { + g_free(conf->eap_config->anonymous_identity); + g_free(conf->eap_config->ca_cert); + g_free(conf->eap_config->client_cert); + g_free(conf->eap_config->private_key); + g_free(conf->eap_config->private_key_password); + g_free(conf->eap_config->identity); + g_free(conf->eap_config->eap_type); + g_free(conf->eap_config->eap_auth_type); + g_free(conf->eap_config->subject_match); + g_free(conf->eap_config); + } + + if (conf->ip_info) { + g_free(conf->ip_info->ip_type); + g_free(conf->ip_info->ip_address); + g_free(conf->ip_info->subnet_mask); + g_free(conf->ip_info->gateway_address); + g_free(conf->ip_info->dns_type); + conf->ip_info->prefix_length = 0; + + int i = 0, count = conf->ip_info->dns_count; + while (i < count) { + g_free(conf->ip_info->dns_address[i]); + i++; + } + g_free(conf->ip_info); + } + g_free(conf); +} + +static gboolean __get_mac_address(gchar **mac_address) { gchar *tmp_mac = NULL; gchar *tmp = NULL; gchar mac[13] = { 0, }; gint i = 0, j = 0; - tmp_mac = vconf_get_str(VCONFKEY_WIFI_BSSID_ADDRESS); - if (tmp_mac == NULL) { - ERR("vconf_get_str(WIFI_BSSID_ADDRESS) Failed"); - *mac_address = NULL; - return -1; + if (TIZEN_TV) { + FILE *fp = NULL; + char buf[WIFI_MAC_ADD_LENGTH + 1]; + if (0 == access(WIFI_MAC_ADD_PATH, F_OK)) + fp = fopen(WIFI_MAC_ADD_PATH, "r"); + + if (fp == NULL) { + ERR("Failed to open file %s\n", WIFI_MAC_ADD_PATH); + *mac_address = NULL; + return FALSE; + } + + if (fgets(buf, sizeof(buf), fp) == NULL) { + ERR("Failed to get MAC info from %s\n", WIFI_MAC_ADD_PATH); + *mac_address = NULL; + fclose(fp); + return FALSE; + } + tmp_mac = (gchar *)malloc(WIFI_MAC_ADD_LENGTH + 1); + if (tmp_mac == NULL) { + ERR("malloc() failed"); + *mac_address = NULL; + fclose(fp); + return FALSE; + } + memset(tmp_mac, 0, WIFI_MAC_ADD_LENGTH + 1); + g_strlcpy(tmp_mac, buf, WIFI_MAC_ADD_LENGTH + 1); + fclose(fp); + } else { + tmp_mac = vconf_get_str(VCONFKEY_WIFI_BSSID_ADDRESS); + if (tmp_mac == NULL) { + ERR("vconf_get_str(WIFI_BSSID_ADDRESS) Failed"); + *mac_address = NULL; + return FALSE; + } } tmp = g_ascii_strdown(tmp_mac, (gssize)strlen(tmp_mac)); - g_free(tmp_mac); - - while (tmp[i]) { - if (tmp[i] != ':') { + free(tmp_mac); + while (tmp && tmp[i]) { + if (tmp[i] != ':') mac[j++] = tmp[i]; - } i++; } mac[12] = '\0'; *mac_address = g_strdup(mac); + g_free(tmp); - return 0; + return TRUE; +} + +gboolean wifi_config_get_group_name(const gchar *prefix, const gchar *config_id, gchar **group_name) +{ + gchar *mac_address = NULL; + gchar *g_name = NULL; + gboolean ret = FALSE; + + ret = __get_mac_address(&mac_address); + if ((ret != TRUE) || (strlen(mac_address) == 0)) { + ERR("Cannot get WIFI MAC address"); + g_free(mac_address); + return FALSE; + } + + g_name = g_strdup_printf("%s%s_%s", prefix, mac_address, config_id); + if (g_name == NULL) { + g_free(mac_address); + return FALSE; + } + + *group_name = g_strdup(g_name); + + g_free(mac_address); + g_free(g_name); + + return TRUE; +} + +static gboolean __get_security_type(const gchar *config_id, gchar **type) +{ + if (g_str_has_suffix(config_id, WIFI_SECURITY_NONE) == TRUE) { + *type = g_strdup(WIFI_SECURITY_NONE); + } else if (g_str_has_suffix(config_id, WIFI_SECURITY_WEP) == TRUE) { + *type = g_strdup(WIFI_SECURITY_WEP); + } else if (g_str_has_suffix(config_id, WIFI_SECURITY_WPA_PSK) == TRUE) { + *type = g_strdup(WIFI_SECURITY_WPA_PSK); + } else if (g_str_has_suffix(config_id, WIFI_SECURITY_EAP) == TRUE) { + *type = g_strdup(WIFI_SECURITY_EAP); + } else { + *type = NULL; + return FALSE; + } + + return TRUE; +} + +static gboolean __get_config_id(const gchar *profile, gchar **config_id) +{ + *config_id = g_strdup(profile + PROFILE_PREFIX_LENGTH); + if (*config_id == NULL) { + ERR("OOM"); + return FALSE; + } + + return TRUE; +} + + +static GKeyFile *__get_configuration_keyfile(const gchar *group_name) +{ + GKeyFile *keyfile = NULL; + gchar *path; + + path = g_strdup_printf(CONNMAN_STORAGE "/%s/settings", group_name); + + keyfile = netconfig_keyfile_load(path); + if (keyfile == NULL) + ERR("keyfile[%s] is NULL", path); + + g_free(path); + + return keyfile; } -static gboolean ___netconfig_remove_file(const gchar *pathname, const gchar *filename) +static gboolean __remove_file(const gchar *pathname, const gchar *filename) { gboolean ret = FALSE; gchar *path; @@ -111,15 +285,15 @@ static gboolean ___netconfig_remove_file(const gchar *pathname, const gchar *fil return ret; } -static gboolean __netconfig_remove_configuration(const gchar *pathname) +static gboolean __remove_configuration(const gchar *pathname) { int ret = 0; - if (___netconfig_remove_file(pathname, "settings") != TRUE) { + if (__remove_file(pathname, "settings") != TRUE) { ERR("Cannot remove [%s/settings]", pathname); return FALSE; } - if (___netconfig_remove_file(pathname, "data") != TRUE) { + if (__remove_file(pathname, "data") != TRUE) { ERR("Cannot remove [%s/data]", pathname); return FALSE; } @@ -129,96 +303,173 @@ static gboolean __netconfig_remove_configuration(const gchar *pathname) ERR("Cannot remove [%s]", pathname); return FALSE; } - return TRUE; } -static gint _netconfig_get_security_type(const gchar *config_id, gchar **type) -{ - int ret = 0; - - if (g_str_has_suffix(config_id, WIFI_SECURITY_NONE) == TRUE) { - *type = g_strdup(WIFI_SECURITY_NONE); - } else if (g_str_has_suffix(config_id, WIFI_SECURITY_WEP) == TRUE) { - *type = g_strdup(WIFI_SECURITY_WEP); - } else if (g_str_has_suffix(config_id, WIFI_SECURITY_WPA_PSK) == TRUE) { - *type = g_strdup(WIFI_SECURITY_WPA_PSK); - } else if (g_str_has_suffix(config_id, WIFI_SECURITY_EAP) == TRUE) { - *type = g_strdup(WIFI_SECURITY_EAP); - } else { - *type = NULL; - ret = -1; - } - - return ret; -} - -static gboolean _netconfig_load_wifi_configuration(const gchar *config_id, - struct wifi_config *config) +static gboolean _load_configuration(const gchar *config_id, struct wifi_config *config) { GKeyFile *keyfile; - gchar *path; gchar *group_name; - gchar *mac_address = NULL; gboolean hidden = FALSE; + gboolean ret = FALSE; - __netconfig_get_mac_address(&mac_address); - if (strlen(mac_address) == 0) { - ERR("mac_address is NULL"); + ret = wifi_config_get_group_name(WIFI_CONFIG_PREFIX, config_id, &group_name); + if (ret != TRUE) { + ERR("Fail to get_wifi_config_group_name"); return FALSE; } - group_name = g_strdup_printf(WIFI_CONFIG_PREFIX "%s_%s", mac_address, config_id); - g_free(mac_address); - path = g_strdup_printf("/var/lib/connman/%s/settings", group_name); - - DBG("group_name %s", group_name); - DBG("path %s", path); - - keyfile = netconfig_keyfile_load(path); + keyfile = __get_configuration_keyfile(group_name); if (keyfile == NULL) { - ERR("keyfile[%s] is NULL", path); + ERR("Fail to __get_configuration_keyfile[%s]", group_name); + g_free(group_name); return FALSE; } + config->name = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_NAME, NULL); + DBG("name [%s]", config->name); + + __get_security_type(config_id, &config->security_type); + if (config->security_type == NULL) { + ERR("Fail to _get_security_type"); + g_key_file_free(keyfile); + g_free(group_name); + return FALSE; + } + DBG("security_type [%s]", config->security_type); + config->passphrase = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_PASSPHRASE, NULL); - _netconfig_get_security_type(config_id, &config->security_type); + DBG("passphrase []"); + config->proxy_address = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_PROXY_SERVER, NULL); + if (config->proxy_address) + DBG("proxy_address [%s]", config->proxy_address); + hidden = g_key_file_get_boolean(keyfile, group_name, WIFI_CONFIG_HIDDEN, NULL); - if (hidden) { + if (hidden) config->is_hidden = g_strdup("TRUE"); - } else { + else config->is_hidden = g_strdup("FALSE"); + DBG("is_hidden [%s]", config->is_hidden); + + if (config->ip_info) { + GError *error = NULL; + config->ip_info->ip_type = g_key_file_get_string(keyfile, group_name, + WIFI_CONFIG_IPV4_METHOD, NULL); + if (config->ip_info->ip_type) + DBG("IPv4.Method:%s", config->ip_info->ip_type); + + config->ip_info->ip_address = g_key_file_get_string(keyfile, group_name, + WIFI_CONFIG_IPV4_ADDRESS, NULL); + if (config->ip_info->ip_address) + DBG("IPv4.Address:%s", config->ip_info->ip_address); + + int prefix_len; + in_addr_t addr; + struct in_addr netmask; + char *mask; + prefix_len = g_key_file_get_integer(keyfile, group_name, + WIFI_CONFIG_IPV4_SUBNET_MASK, &error); + if (error != NULL) { + DBG("g_key_file_get_integer failed error[%d: %s]", error->code, error->message); + g_error_free(error); + } else { + if (prefix_len > 0 && prefix_len < 32) { + addr = 0xffffffff << (32 - prefix_len); + netmask.s_addr = htonl(addr); + mask = inet_ntoa(netmask); + config->ip_info->subnet_mask = g_strdup(mask); + } + if (config->ip_info->subnet_mask) + DBG("IPv4.SubnetMask:%s", config->ip_info->subnet_mask); + } + + config->ip_info->gateway_address = g_key_file_get_string(keyfile, + group_name, WIFI_CONFIG_IPV4_GATEWAY_ADDRESS, NULL); + if (config->ip_info->gateway_address) + DBG("IPv4.gateway:%s", config->ip_info->gateway_address); + + config->ip_info->dns_type = g_key_file_get_string(keyfile, group_name, + WIFI_CONFIG_IPV4_DNS_METHOD, NULL); + if (config->ip_info->dns_type) + DBG("DNS.IPv4Method:%s", config->ip_info->dns_type); + + char **nameservers; + gsize length; + nameservers = g_key_file_get_string_list(keyfile, group_name, + WIFI_CONFIG_DNS_ADDRESS, &length, NULL); + if (nameservers) { + if (length > 0) { + config->ip_info->dns_count = length; + int i = 0; + while (i < NET_DNS_ADDR_MAX && nameservers[i]) { + config->ip_info->dns_address[i] = g_strdup(nameservers[i]); + DBG("DNSAddress[%d]:%s", i+1, config->ip_info->dns_address[i]); + i += 1; + } + } + g_strfreev(nameservers); + } + } + + + if (g_strcmp0(config->security_type, WIFI_SECURITY_EAP) == 0) { + config->eap_config->anonymous_identity = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_EAP_ANONYMOUS_IDENTITY, NULL); + config->eap_config->ca_cert = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_EAP_CACERT, NULL); + config->eap_config->client_cert = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_EAP_CLIENTCERT, NULL); + config->eap_config->private_key = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_EAP_PRIVATEKEY, NULL); + config->eap_config->private_key_password = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_EAP_PRIVATEKEY_PASSWORD, NULL); + config->eap_config->identity = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_EAP_IDENTITY, NULL); + config->eap_config->eap_type = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_EAP_TYPE, NULL); + config->eap_config->eap_auth_type = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_EAP_AUTH_TYPE, NULL); + config->eap_config->subject_match = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_EAP_SUBJECT_MATCH, NULL); + + if (config->eap_config->anonymous_identity) + DBG("anonymous_identity [%s]", config->eap_config->anonymous_identity); + if (config->eap_config->ca_cert) + DBG("ca_cert [%s]", config->eap_config->ca_cert); + if (config->eap_config->client_cert) + DBG("client_cert [%s]", config->eap_config->client_cert); + if (config->eap_config->private_key) + DBG("private_key [%s]", config->eap_config->private_key); + if (config->eap_config->private_key_password) + DBG("private_key_password [%s]", config->eap_config->private_key_password); + if (config->eap_config->identity) + DBG("identity [%s]", config->eap_config->identity); + if (config->eap_config->eap_type) + DBG("eap_type [%s]", config->eap_config->eap_type); + if (config->eap_config->eap_auth_type) + DBG("eap_auth_type [%s]", config->eap_config->eap_auth_type); + if (config->eap_config->subject_match) + DBG("subject_match [%s]", config->eap_config->subject_match); } + config->last_error = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_FAILURE, NULL); + if (config->last_error) + DBG("last_error [%s]", config->last_error); + g_key_file_free(keyfile); g_free(group_name); - g_free(path); return TRUE; } -static gboolean _netconfig_save_wifi_configuration(const gchar *config_id, - const struct wifi_config *config) +gboolean wifi_config_save_configuration(const gchar *config_id, GKeyFile *keyfile) { - GKeyFile *keyfile; gchar *dir; gchar *path; gchar *group_name; - gchar *mac_address = NULL; + gboolean ret = FALSE; - __netconfig_get_mac_address(&mac_address); - if (mac_address == NULL) { - ERR("mac_address is NULL"); + ret = wifi_config_get_group_name(WIFI_CONFIG_PREFIX, config_id, &group_name); + if (ret != TRUE) { + ERR("Fail to get_wifi_config_group_name"); return FALSE; } - group_name = g_strdup_printf("wifi_%s_%s", mac_address, config_id); - g_free(mac_address); - dir = g_strdup_printf(CONNMAN_STORAGE "/%s", group_name); if (g_file_test(dir, G_FILE_TEST_IS_DIR) == TRUE) { - if (__netconfig_remove_configuration(dir) != TRUE) { + if (__remove_configuration(dir) != TRUE) { ERR("[%s] is existed, but cannot remove", dir); g_free(group_name); g_free(dir); @@ -233,30 +484,6 @@ static gboolean _netconfig_save_wifi_configuration(const gchar *config_id, return FALSE; } - keyfile = g_key_file_new(); - g_key_file_set_string(keyfile, group_name, WIFI_CONFIG_NAME, config->name); - g_key_file_set_string(keyfile, group_name, WIFI_CONFIG_SSID, config->ssid); - - if (config->passphrase != NULL) - g_key_file_set_string(keyfile, group_name, WIFI_CONFIG_PASSPHRASE, config->passphrase); - - g_key_file_set_boolean(keyfile, group_name, WIFI_CONFIG_FAVORITE, config->favorite); - g_key_file_set_boolean(keyfile, group_name, WIFI_CONFIG_AUTOCONNECT, config->autoconnect); - - // Optional field - if (config->proxy_address != NULL) { - g_key_file_set_string(keyfile, group_name, WIFI_CONFIG_PROXY_METHOD, "manual"); - g_key_file_set_string(keyfile, group_name, WIFI_CONFIG_PROXY_SERVER, config->proxy_address); - } - - if (config->is_hidden != NULL) { - gboolean hidden = FALSE; - if (g_strcmp0(config->is_hidden, "TRUE") == 0) { - hidden = TRUE; - } - g_key_file_set_boolean(keyfile, group_name, WIFI_CONFIG_HIDDEN, hidden); - } - path = g_strdup_printf(CONNMAN_STORAGE "/%s/settings", group_name); netconfig_keyfile_save(keyfile, path); g_free(group_name); @@ -266,25 +493,21 @@ static gboolean _netconfig_save_wifi_configuration(const gchar *config_id, return TRUE; } -static gboolean _netconfig_remove_wifi_configuration(const gchar *config_id) +static gboolean _remove_configuration(const gchar *config_id) { gboolean ret = FALSE; gchar *dir; gchar *group_name; - gchar *mac_address = NULL; - __netconfig_get_mac_address(&mac_address); - if (mac_address == NULL) { - ERR("mac_address is NULL"); + ret = wifi_config_get_group_name(WIFI_CONFIG_PREFIX, config_id, &group_name); + if (ret != TRUE) { + ERR("Fail to get_wifi_config_group_name"); return FALSE; } - group_name = g_strdup_printf("wifi_%s_%s", mac_address, config_id); - g_free(mac_address); - dir = g_strdup_printf(CONNMAN_STORAGE "/%s", group_name); if (g_file_test(dir, G_FILE_TEST_IS_DIR) == TRUE) { - if (__netconfig_remove_configuration(dir) != TRUE) { + if (__remove_configuration(dir) != TRUE) { ERR("[%s] is existed, but cannot remove", dir); ret = FALSE; } @@ -301,60 +524,135 @@ static gboolean _netconfig_remove_wifi_configuration(const gchar *config_id) return ret; } -static gboolean _netconfig_set_wifi_config_field(const gchar *config_id, - const gchar *key, const gchar *value) + +static gboolean _set_field(const gchar *config_id, const gchar *key, const gchar *value) { gboolean ret = TRUE; GKeyFile *keyfile; - gchar *path; gchar *group_name; - gchar *mac_address = NULL; - __netconfig_get_mac_address(&mac_address); - if (strlen(mac_address) == 0) { - ERR("mac_address is NULL"); + ret = wifi_config_get_group_name(WIFI_CONFIG_PREFIX, config_id, &group_name); + if (ret != TRUE) { + ERR("Fail to get_wifi_config_group_name"); return FALSE; } - - group_name = g_strdup_printf(WIFI_CONFIG_PREFIX "%s_%s", mac_address, config_id); - g_free(mac_address); - path = g_strdup_printf("/var/lib/connman/%s/settings", group_name); - DBG("group_name %s", group_name); - DBG("path %s", path); - keyfile = netconfig_keyfile_load(path); + keyfile = __get_configuration_keyfile(group_name); if (keyfile == NULL) { - ERR("keyfile[%s] is NULL", path); + ERR("Fail to __get_configuration_keyfile"); + g_free(group_name); return FALSE; } if (g_strcmp0(key, WIFI_CONFIG_PROXY_METHOD) == 0) { g_key_file_set_string(keyfile, group_name, key, value); - }else if (g_strcmp0(key, WIFI_CONFIG_PROXY_SERVER) == 0) { + } else if (g_strcmp0(key, WIFI_CONFIG_PROXY_SERVER) == 0) { g_key_file_set_string(keyfile, group_name, key, value); } else if (g_strcmp0(key, WIFI_CONFIG_HIDDEN) == 0) { gboolean hidden = FALSE; - if (g_strcmp0(value, "TRUE") == 0) { + if (g_strcmp0(value, "TRUE") == 0) hidden = TRUE; - } g_key_file_set_boolean(keyfile, group_name, key, hidden); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_ANONYMOUS_IDENTITY) == 0) { + g_key_file_set_string(keyfile, group_name, key, value); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_CACERT) == 0) { + g_key_file_set_string(keyfile, group_name, key, value); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_CLIENTCERT) == 0) { + g_key_file_set_string(keyfile, group_name, key, value); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_PRIVATEKEY) == 0) { + g_key_file_set_string(keyfile, group_name, key, value); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_IDENTITY) == 0) { + g_key_file_set_string(keyfile, group_name, key, value); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_TYPE) == 0) { + g_key_file_set_string(keyfile, group_name, key, value); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_AUTH_TYPE) == 0) { + g_key_file_set_string(keyfile, group_name, key, value); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_SUBJECT_MATCH) == 0) { + g_key_file_set_string(keyfile, group_name, key, value); } else { ERR("key[%s] is not supported", key); ret = FALSE; } - netconfig_keyfile_save(keyfile, path); + wifi_config_save_configuration(config_id, keyfile); + + g_key_file_free(keyfile); g_free(group_name); - g_free(path); return ret; } -static GSList *_netconfig_get_wifi_config_list(void) +static gboolean _get_field(const gchar *config_id, const gchar *key, gchar **value) +{ + GKeyFile *keyfile; + gchar *group_name; + gchar *val = NULL; + gboolean hidden = FALSE; + gboolean ret = FALSE; + + ret = wifi_config_get_group_name(WIFI_CONFIG_PREFIX, config_id, &group_name); + if (ret != TRUE) { + ERR("Fail to get_wifi_config_group_name"); + return FALSE; + } + DBG("group_name %s", group_name); + + keyfile = __get_configuration_keyfile(group_name); + if (keyfile == NULL) { + ERR("Fail to __get_configuration_keyfile"); + g_free(group_name); + return FALSE; + } + + if (g_strcmp0(key, WIFI_CONFIG_NAME) == 0) { + val = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_NAME, NULL); + } else if (g_strcmp0(key, WIFI_CONFIG_PASSPHRASE) == 0) { + val = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_PASSPHRASE, NULL); + } else if (g_strcmp0(key, WIFI_CONFIG_PROXY_SERVER) == 0) { + val = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_PROXY_SERVER, NULL); + } else if (g_strcmp0(key, WIFI_CONFIG_HIDDEN) == 0) { + hidden = g_key_file_get_boolean(keyfile, group_name, WIFI_CONFIG_HIDDEN, NULL); + if (hidden) + val = g_strdup("TRUE"); + else + val = g_strdup("FALSE"); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_ANONYMOUS_IDENTITY) == 0) { + val = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_EAP_ANONYMOUS_IDENTITY, NULL); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_CACERT) == 0) { + val = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_EAP_CACERT, NULL); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_CLIENTCERT) == 0) { + val = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_EAP_CLIENTCERT, NULL); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_PRIVATEKEY) == 0) { + val = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_EAP_PRIVATEKEY, NULL); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_IDENTITY) == 0) { + val = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_EAP_IDENTITY, NULL); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_TYPE) == 0) { + val = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_EAP_TYPE, NULL); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_AUTH_TYPE) == 0) { + val = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_EAP_AUTH_TYPE, NULL); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_SUBJECT_MATCH) == 0) { + val = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_EAP_SUBJECT_MATCH, NULL); + } else if (g_strcmp0(key, WIFI_CONFIG_FAILURE) == 0) { + val = g_key_file_get_string(keyfile, group_name, WIFI_CONFIG_FAILURE, NULL); + } else { + ERR("Invalid key[%s]", key); + val = g_strdup("NOTSUPPORTED"); + } + + *value = g_strdup(val); + g_free(val); + + g_key_file_free(keyfile); + g_free(group_name); + + return TRUE; +} + +static GSList *_get_list(void) { GSList *list = NULL; - struct dirent *d; + struct dirent *dp = NULL; DIR *dir; dir = opendir(CONNMAN_STORAGE); @@ -363,13 +661,12 @@ static GSList *_netconfig_get_wifi_config_list(void) return NULL; } - while ((d = readdir(dir))) { - if (g_strcmp0(d->d_name, ".") == 0 || - g_strcmp0(d->d_name, "..") == 0 || - strncmp(d->d_name, WIFI_CONFIG_PREFIX, strlen(WIFI_CONFIG_PREFIX)) != 0) { + while ((dp = readdir(dir)) != NULL) { + if (g_strcmp0(dp->d_name, ".") == 0 || g_strcmp0(dp->d_name, "..") == 0 || + strncmp(dp->d_name, WIFI_CONFIG_PREFIX, strlen(WIFI_CONFIG_PREFIX)) != 0) { continue; } - gchar *config_id = g_strdup(d->d_name + WIFI_PREFIX_LENGTH); + gchar *config_id = g_strdup(dp->d_name + WIFI_PREFIX_LENGTH); list = g_slist_append(list, g_strdup(config_id)); g_free(config_id); } @@ -378,84 +675,476 @@ static GSList *_netconfig_get_wifi_config_list(void) return list; } -gboolean handle_get_config_ids(Wifi *wifi, GDBusMethodInvocation *context) +gboolean wifi_config_get_config_id(const gchar *service_profile, gchar **config_id) { - guint i = 0; - GSList *config_ids = NULL; - guint length; - gchar **result = NULL; - - g_return_val_if_fail(wifi != NULL, FALSE); + gboolean ret = FALSE; + gchar *val = NULL; - config_ids = _netconfig_get_wifi_config_list(); - if (config_ids == NULL) { - netconfig_error_no_profile(context); - ERR("Fail to get config list"); + if ((service_profile == NULL) || (config_id == NULL)) { + ERR("Invalid parameter"); return FALSE; } - length = g_slist_length(config_ids); - result = g_new0(gchar *, length + 1); - for (i = 0; i < length; i++) { - gchar *config_id = g_slist_nth_data(config_ids, i); - result[i] = g_strdup(config_id); - } - - config_ids = g_slist_nth(config_ids, 0); - g_slist_free_full(config_ids, g_free); + ret = __get_config_id(service_profile, &val); + *config_id = g_strdup(val); + g_free(val); - wifi_complete_get_config_ids(wifi, context, (const gchar * const*)result); - return TRUE; + return ret; } -gboolean handle_load_configuration(Wifi *wifi, GDBusMethodInvocation *context, - const gchar *config_id) +gboolean wifi_config_remove_configuration(const gchar *config_id) { gboolean ret = FALSE; - gchar *name = NULL, *passphrase = NULL, *security_type = NULL; - gchar *proxy_address = NULL, *is_hidden = NULL, *last_error = NULL; - struct wifi_config *conf = NULL; - - g_return_val_if_fail(wifi != NULL, FALSE); - - conf = g_new0(struct wifi_config, 1); - ret = _netconfig_load_wifi_configuration(config_id, conf); - if (ret != TRUE) { - g_free(conf); - ERR("No wifi configuration"); - netconfig_error_no_profile(context); - return FALSE; - } + ret = _remove_configuration(config_id); - name = g_strdup(conf->name); - passphrase = g_strdup(conf->passphrase); - security_type = g_strdup(conf->security_type); - is_hidden = g_strdup(conf->is_hidden); + return ret; +} - if (conf->proxy_address != NULL) { - proxy_address = g_strdup(conf->proxy_address); - g_free(conf->proxy_address); - } else { - proxy_address = g_strdup("NONE"); - } - if (conf->last_error != NULL) { - last_error = g_strdup(conf->last_error); - g_free(conf->last_error); - } else { - last_error = g_strdup("ERROR_NONE"); - } +int __netconfig_hex_char_to_num(char c) +{ + if (c >= '0' && c <= '9') + return c - '0'; - g_free(conf->name); - g_free(conf->passphrase); - g_free(conf->security_type); - g_free(conf->is_hidden); - g_free(conf); + if (c >= 'a' && c <= 'f') + return c - 'a' + 10; - wifi_complete_load_configuration (wifi, context, name, - passphrase, security_type, proxy_address, is_hidden, last_error); + if (c >= 'A' && c <= 'F') + return c - 'A' + 10; - return TRUE; + return -1; +} + +int __netconfig_hex_to_byte(const char *hex) +{ + int a, b; + + a = __netconfig_hex_char_to_num(*hex++); + if (a < 0) + return -1; + + b = __netconfig_hex_char_to_num(*hex++); + if (b < 0) + return -1; + + return (a << 4) | b; +} + +int __netconfig_hex_str_to_bin(const char *hex, unsigned char *buf, size_t len) +{ + size_t i; + int a; + const char *ipos = hex; + unsigned char *opos = buf; + + for (i = 0; i < len; i++) { + a = __netconfig_hex_to_byte(ipos); + if (a < 0) + return -1; + + *opos++ = a; + ipos += 2; + } + + return 0; +} + +static int __netconfig_byte_to_txt(const unsigned char *src, char **dst, int src_len) +{ + int dst_length = 0; + int i = 0; + char *buf = NULL; + + if (src_len <= 0) { + ERR("Invalid parameter."); + return -1; + } + + *dst = (char *) g_try_malloc0((2*src_len)+1); + if (!(*dst)) { + ERR("failed to allocate memory to buffer."); + return -1; + } + + buf = (*dst); + + for (i = 0; i < src_len; i++) { + snprintf(buf, 3, "%02x", src[i]); + buf += 2; + dst_length += 2; + } + + return dst_length; +} + +static int __netconfig_unpack_ay_malloc(unsigned char **dst, GVariantIter *iter) +{ + GVariantIter *iter_copy = NULL; + int length = 0; + char tmp = 0; + unsigned char *tmp_dst = NULL; + + if (!dst || *dst || !iter) { + ERR("Invalid parameter"); + return 0; + } + + iter_copy = g_variant_iter_copy(iter); + + while (g_variant_iter_loop(iter, "y", &tmp)) + length++; + g_variant_iter_free(iter); + + tmp_dst = (unsigned char *)g_try_malloc0(length + 1); + if (!tmp_dst) { + ERR("failed to allocate memory"); + g_variant_iter_free(iter_copy); + return 0; + } + + length = 0; + while (g_variant_iter_loop(iter_copy, "y", &tmp_dst[length])) + length++; + g_variant_iter_free(iter_copy); + + if (length == 0) { + g_free(tmp_dst); + tmp_dst = NULL; + } else { + tmp_dst[length] = '\0'; + } + + *dst = tmp_dst; + DBG("Length [%d]", length); + return length; +} + +gboolean _add_vsie(int frame_id, const char* vsie) +{ + GVariant *params = NULL; + GVariant *message = NULL; + GVariantBuilder *bytearray_builder = NULL; + char *if_path; + int i = 0; + size_t vsie_len = 0; + + unsigned char *bytearray = NULL; + size_t bytearray_len = 0; + + if (frame_id >= NETCONFIG_VSIE_FRAME_MAX) { + DBG("Invalid parameter, frame-id: %d", frame_id); + return FALSE; + } + + vsie_len = strlen(vsie); + if (vsie_len == 0) { + DBG("vsie length is zero"); + return FALSE; + } + + bytearray_len = (vsie_len % 2) ? ((vsie_len / 2) + 1) : (vsie_len / 2); + + bytearray = (unsigned char *) g_try_malloc0(bytearray_len); + if (bytearray == NULL) { + DBG("Failed to allocate memory to bytearray"); + return FALSE; + } + + if (__netconfig_hex_str_to_bin(vsie, bytearray, bytearray_len) < 0) { + DBG("invalid vsie string"); + g_free(bytearray); + return FALSE; + } + + bytearray_builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); + for (i = 0; i < bytearray_len; i++) + g_variant_builder_add(bytearray_builder, "y", bytearray[i]); + + params = g_variant_new("(iay)", frame_id, bytearray_builder); + g_variant_builder_unref(bytearray_builder); + + if_path = netconfig_wifi_get_supplicant_interface(); + + if (if_path == NULL) { + ERR("Fail to get wpa_supplicant DBus path"); + g_free(bytearray); + return FALSE; + } + + message = netconfig_supplicant_invoke_dbus_method(SUPPLICANT_SERVICE, + if_path, SUPPLICANT_INTERFACE ".Interface", "VendorElemAdd", params); + + g_free(if_path); + if (message == NULL) { + ERR("Failed to send command to wpa_supplicant"); + g_free(bytearray); + return FALSE; + } + + DBG("Succeeded to add vsie: Frame ID[%d], VSIE[%s]", frame_id, vsie); + + g_free(bytearray); + return TRUE; +} + +gboolean _get_vsie(int frame_id, char **vsie) +{ + GVariant *params = NULL; + GVariant *message = NULL; + char *if_path; + + if (frame_id >= NETCONFIG_VSIE_FRAME_MAX) { + DBG("Invalid parameter, frame-id: %d", frame_id); + return FALSE; + } + + if_path = netconfig_wifi_get_supplicant_interface(); + if (if_path == NULL) { + ERR("Fail to get wpa_supplicant DBus path"); + return FALSE; + } + + params = g_variant_new("(i)", frame_id); + + message = netconfig_supplicant_invoke_dbus_method(SUPPLICANT_SERVICE, + if_path, SUPPLICANT_INTERFACE ".Interface", "VendorElemGet", params); + + g_free(if_path); + if (message == NULL) { + ERR("Failed to send command to wpa_supplicant"); + return FALSE; + } else { + GVariantIter *iter = NULL; + unsigned char *vsie_bytes = NULL; + int vsie_len = 0; + int ret = 0; + + g_variant_get(message, "(ay)", &iter); + if (iter == NULL) { + ERR("vsie is not present"); + return FALSE; + } + + vsie_len = __netconfig_unpack_ay_malloc(&vsie_bytes, iter); + if (vsie_bytes == NULL) { + ERR("vsie_bytes not allocated"); + return FALSE; + } + + ret = __netconfig_byte_to_txt(vsie_bytes, vsie, vsie_len); + if (ret < 0) { + g_free(vsie_bytes); + ERR("vsie not allocated."); + return FALSE; + } + + g_free(vsie_bytes); + } + + ERR("Succeeded to get vsie: Frame ID[%d], VSIE[%s]", frame_id, *vsie); + + return TRUE; + +} + +gboolean _remove_vsie(int frame_id, const char *vsie) +{ + GVariant *params = NULL; + GVariant *message = NULL; + GVariantBuilder *bytearray_builder = NULL; + char *if_path; + int i = 0; + size_t vsie_len = 0; + + unsigned char *bytearray = NULL; + size_t bytearray_len = 0; + + if (frame_id >= NETCONFIG_VSIE_FRAME_MAX) { + DBG("Invalid parameter, frame-id: %d", frame_id); + return FALSE; + } + + vsie_len = strlen(vsie); + if (vsie_len == 0) { + DBG("vsie length is zero"); + return FALSE; + } + + bytearray_len = (vsie_len % 2) ? ((vsie_len / 2) + 1) : (vsie_len / 2); + + bytearray = (unsigned char *) g_try_malloc0(bytearray_len); + if (bytearray == NULL) { + DBG("Failed to allocate memory to bytearray"); + return FALSE; + } + + if (__netconfig_hex_str_to_bin(vsie, bytearray, bytearray_len) < 0) { + DBG("invalid vsie string"); + g_free(bytearray); + return FALSE; + } + + bytearray_builder = g_variant_builder_new(G_VARIANT_TYPE("ay")); + for (i = 0; i < bytearray_len; i++) + g_variant_builder_add(bytearray_builder, "y", bytearray[i]); + + params = g_variant_new("(iay)", frame_id, bytearray_builder); + g_variant_builder_unref(bytearray_builder); + + if_path = netconfig_wifi_get_supplicant_interface(); + if (if_path == NULL) { + ERR("Fail to get wpa_supplicant DBus path"); + g_free(bytearray); + return FALSE; + } + + message = netconfig_supplicant_invoke_dbus_method(SUPPLICANT_SERVICE, + if_path, SUPPLICANT_INTERFACE ".Interface", "VendorElemRem", params); + + g_free(if_path); + if (message == NULL) { + ERR("Failed to send command to wpa_supplicant"); + g_free(bytearray); + return FALSE; + } + + DBG("Succeeded to remove vsie: Frame ID[%d], VSIE[%s]", frame_id, vsie); + + g_free(bytearray); + return TRUE; +} + +/* dbus method */ +gboolean handle_get_config_ids(Wifi *wifi, GDBusMethodInvocation *context) +{ + guint i = 0; + GSList *config_ids = NULL; + guint length; + gchar **result = NULL; + + g_return_val_if_fail(wifi != NULL, TRUE); + + config_ids = _get_list(); + if (config_ids == NULL) { + ERR("Fail to get config list"); + netconfig_error_no_profile(context); + return TRUE; + } + + length = g_slist_length(config_ids); + result = g_new0(gchar *, length + 1); + for (i = 0; i < length; i++) { + gchar *config_id = g_slist_nth_data(config_ids, i); + result[i] = g_strdup(config_id); + } + + config_ids = g_slist_nth(config_ids, 0); + g_slist_free_full(config_ids, g_free); + + wifi_complete_get_config_ids(wifi, context, (const gchar * const *)result); + + for (i = 0; i < length; i++) + if (result[i]) + g_free(result[i]); + + if (result) + g_free(result); + + return TRUE; +} + +gboolean handle_load_configuration(Wifi *wifi, GDBusMethodInvocation *context, + const gchar *config_id) +{ + gboolean ret = FALSE; + GVariantBuilder *b = NULL; + struct wifi_config *conf = NULL; + + g_return_val_if_fail(wifi != NULL, TRUE); + + conf = g_new0(struct wifi_config, 1); + conf->ip_info = g_new0(wifi_ip_info_s, 1); + + ret = _load_configuration(config_id, conf); + if (ret != TRUE) { + g_free(conf->ip_info); + g_free(conf); + ERR("Fail to _load_configuration"); + netconfig_error_no_profile(context); + return TRUE; + } + + b = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_NAME, g_variant_new_string(conf->name)); + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_SECURITY_TYPE, g_variant_new_string(conf->security_type)); + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_PASSPHRASE, g_variant_new_string(conf->passphrase)); + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_HIDDEN, g_variant_new_string(conf->is_hidden)); + + if (conf->proxy_address != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_PROXYADDRESS, g_variant_new_string(conf->proxy_address)); + else + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_PROXYADDRESS, g_variant_new_string("NONE")); + + if (conf->ip_info->ip_type != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_IPV4_METHOD, g_variant_new_string(conf->ip_info->ip_type)); + + if (conf->ip_info->ip_address != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_IPV4_ADDRESS, g_variant_new_string(conf->ip_info->ip_address)); + + if (conf->ip_info->subnet_mask != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_IPV4_SUBNET_MASK, g_variant_new_string(conf->ip_info->subnet_mask)); + + if (conf->ip_info->prefix_length > 0) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_IPV6_PREFIX_LEN, g_variant_new_int32(conf->ip_info->prefix_length)); + + if (conf->ip_info->gateway_address != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_IPV4_GATEWAY_ADDRESS, g_variant_new_string(conf->ip_info->gateway_address)); + + if (conf->ip_info->dns_type != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_IPV4_DNS_METHOD, g_variant_new_string(conf->ip_info->dns_type)); + + int i = 0, count = conf->ip_info->dns_count; + while (i < count) { + if (conf->ip_info->dns_address[i] != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_DNS_ADDRESS, g_variant_new_string(conf->ip_info->dns_address[i])); + + i += 1; + } + + if (conf->last_error != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_FAILURE, g_variant_new_string(conf->last_error)); + else + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_FAILURE, g_variant_new_string("ERROR_NONE")); + + __free_wifi_configuration(conf); + + wifi_complete_load_configuration(wifi, context, g_variant_builder_end(b)); + g_variant_builder_unref(b); + return TRUE; +} + +static unsigned char __netconfig_convert_netmask_to_prefixlen( + const char *netmask) +{ + unsigned char bits; + in_addr_t mask; + in_addr_t host; + + if (!netmask) + return 32; + + mask = inet_network(netmask); + host = ~mask; + + /* a valid netmask must be 2^n - 1 */ + if ((host & (host + 1)) != 0) + return -1; + + bits = 0; + for (; mask; mask <<= 1) + ++bits; + + return bits; } gboolean handle_save_configuration(Wifi *wifi, GDBusMethodInvocation *context, @@ -463,75 +1152,584 @@ gboolean handle_save_configuration(Wifi *wifi, GDBusMethodInvocation *context, { gboolean ret = FALSE; struct wifi_config *conf = NULL; + GKeyFile *keyfile = NULL; GVariantIter *iter; GVariant *value; gchar *field; + gchar *group_name = NULL; + int order = 0; if ((wifi == NULL) || (config_id == NULL) || (configuration == NULL)) { - ERR("Invaliad parameter"); + ERR("Invalid parameter"); netconfig_error_invalid_parameter(context); - return FALSE; + return TRUE; } conf = g_new0(struct wifi_config, 1); + conf->ip_info = g_new0(wifi_ip_info_s, 1); g_variant_get(configuration, "a{sv}", &iter); while (g_variant_iter_loop(iter, "{sv}", &field, &value)) { if (g_strcmp0(field, WIFI_CONFIG_NAME) == 0) { if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { conf->name = g_strdup(g_variant_get_string(value, NULL)); - ERR("name [%s]", conf->name); + DBG("name [%s]", conf->name); } else { conf->name = NULL; } } else if (g_strcmp0(field, WIFI_CONFIG_SSID) == 0) { if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { conf->ssid = g_strdup(g_variant_get_string(value, NULL)); - ERR("ssid [%s]", conf->ssid); + DBG("ssid [%s]", conf->ssid); } else { conf->ssid = NULL; } } else if (g_strcmp0(field, WIFI_CONFIG_PASSPHRASE) == 0) { if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { conf->passphrase = g_strdup(g_variant_get_string(value, NULL)); - ERR("passphrase [%s]", conf->passphrase); + DBG("passphrase []"); } else { conf->passphrase = NULL; } } else if (g_strcmp0(field, WIFI_CONFIG_HIDDEN) == 0) { if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { conf->is_hidden = g_strdup(g_variant_get_string(value, NULL)); - ERR("is_hidden [%s]", conf->is_hidden); + DBG("is_hidden [%s]", conf->is_hidden); } else { conf->is_hidden = NULL; } + } else if (g_strcmp0(field, WIFI_CONFIG_CREATED) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_BOOLEAN)) { + conf->is_created = g_variant_get_boolean(value); + DBG("is_created [%d]", conf->is_created); + } else { + conf->is_created = FALSE; + } + } else if (g_strcmp0(field, WIFI_CONFIG_IPV4_METHOD) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->ip_info->ip_type = g_strdup(g_variant_get_string(value, NULL)); + DBG("IP config type [%s]", conf->ip_info->ip_type); + } else { + conf->ip_info->ip_type = NULL; + } + } else if (g_strcmp0(field, WIFI_CONFIG_IPV4_ADDRESS) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->ip_info->ip_address = g_strdup(g_variant_get_string(value, NULL)); + DBG("IP address [%s]", conf->ip_info->ip_address); + } else { + conf->ip_info->ip_address = NULL; + } + } else if (g_strcmp0(field, WIFI_CONFIG_IPV4_SUBNET_MASK) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->ip_info->subnet_mask = g_strdup(g_variant_get_string(value, NULL)); + DBG("Subnet Mask [%s]", conf->ip_info->subnet_mask); + } else { + conf->ip_info->subnet_mask = NULL; + } + } else if (g_strcmp0(field, WIFI_CONFIG_IPV6_PREFIX_LEN) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_INT32)) { + conf->ip_info->prefix_length = g_variant_get_int32(value); + DBG("IPv6 Prefix Length [%d]", conf->ip_info->prefix_length); + } else { + conf->ip_info->prefix_length = 0; + } + } else if (g_strcmp0(field, WIFI_CONFIG_IPV4_GATEWAY_ADDRESS) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->ip_info->gateway_address = g_strdup(g_variant_get_string(value, NULL)); + DBG("Gateway address [%s]", conf->ip_info->gateway_address); + } else { + conf->ip_info->gateway_address = NULL; + } + } else if (g_strcmp0(field, WIFI_CONFIG_IPV4_DNS_METHOD) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->ip_info->dns_type = g_strdup(g_variant_get_string(value, NULL)); + DBG("DNS config type [%s]", conf->ip_info->dns_type); + } else { + conf->ip_info->dns_type = NULL; + } + } else if (g_strcmp0(field, WIFI_CONFIG_DNS_ADDRESS) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->ip_info->dns_address[order] = g_strdup(g_variant_get_string(value, NULL)); + DBG("DNS address [%s]", conf->ip_info->dns_address[order]); + conf->ip_info->dns_count = order + 1; + order++; + } else { + conf->ip_info->dns_address[order++] = NULL; + } } else if (g_strcmp0(field, WIFI_CONFIG_PROXYADDRESS) == 0) { - conf->proxy_address = g_strdup(g_variant_get_string(value, NULL)); - ERR("proxy_address [%s]", conf->proxy_address); - } else { - conf->proxy_address = NULL; + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->proxy_address = g_strdup(g_variant_get_string(value, NULL)); + DBG("proxy_address [%s]", conf->proxy_address); + } else { + conf->proxy_address = NULL; + } } } conf->favorite = TRUE; conf->autoconnect = TRUE; - ret = _netconfig_save_wifi_configuration(config_id, conf); - g_free(conf->name); - g_free(conf->ssid); - g_free(conf->passphrase); - g_free(conf->is_hidden); - g_free(conf->proxy_address); - g_free(conf); + ret = wifi_config_get_group_name(WIFI_CONFIG_PREFIX, config_id, &group_name); + if (ret != TRUE) { + __free_wifi_configuration(conf); + ERR("Fail to get_wifi_config_group_name"); + netconfig_error_fail_save_congifuration(context); + return TRUE; + } - g_variant_iter_free(iter); + keyfile = g_key_file_new(); + g_key_file_set_string(keyfile, group_name, WIFI_CONFIG_NAME, conf->name); + g_key_file_set_string(keyfile, group_name, WIFI_CONFIG_SSID, conf->ssid); + + if (conf->passphrase != NULL) { + gchar *enc_data = NULL; + if (conf->is_created == true) + enc_data = _netconfig_encrypt_passphrase(conf->passphrase); + else + enc_data = g_strdup(conf->passphrase); + + if (!enc_data) { + ERR("Failed to encrypt the passphrase"); + } else { + g_free(conf->passphrase); + conf->passphrase = enc_data; + } + + g_key_file_set_string(keyfile, group_name, WIFI_CONFIG_PASSPHRASE, conf->passphrase); + } + + g_key_file_set_boolean(keyfile, group_name, WIFI_CONFIG_FAVORITE, conf->favorite); + g_key_file_set_boolean(keyfile, group_name, WIFI_CONFIG_AUTOCONNECT, conf->autoconnect); + +#if GLIB_CHECK_VERSION(2,62,0) + gint64 real_time = 0; + GDateTime *dt_real_time = NULL; + + real_time = g_get_real_time(); + dt_real_time = g_date_time_new_from_unix_utc(real_time); + if (dt_real_time) { + gchar *str = g_date_time_format_iso8601(dt_real_time); + g_date_time_unref(dt_real_time); + if (str) { + g_key_file_set_string(keyfile, group_name, + WIFI_CONFIG_MODIFIED, str); + g_free(str); + } + } +#else /* GLIB_CHECK_VERSION(2,62,0) */ + GTimeVal modified; + g_get_current_time(&modified); + gchar *str = g_time_val_to_iso8601(&modified); + if (str) { + g_key_file_set_string(keyfile, group_name, + WIFI_CONFIG_MODIFIED, str); + g_free(str); + } +#endif /* GLIB_CHECK_VERSION(2,62,0) */ + + /* Optional field */ + if (conf->proxy_address != NULL) { + g_key_file_set_string(keyfile, group_name, WIFI_CONFIG_PROXY_METHOD, "manual"); + g_key_file_set_string(keyfile, group_name, WIFI_CONFIG_PROXY_SERVER, conf->proxy_address); + } + + if (conf->is_hidden != NULL) { + gboolean hidden = FALSE; + if (g_strcmp0(conf->is_hidden, "TRUE") == 0) + hidden = TRUE; + g_key_file_set_boolean(keyfile, group_name, WIFI_CONFIG_HIDDEN, hidden); + } + + if (conf->ip_info->ip_type != NULL) + g_key_file_set_string(keyfile, group_name, + WIFI_CONFIG_IPV4_METHOD, conf->ip_info->ip_type); + + if (conf->ip_info->ip_address != NULL) + g_key_file_set_string(keyfile, group_name, + WIFI_CONFIG_IPV4_ADDRESS, conf->ip_info->ip_address); + + if (conf->ip_info->subnet_mask != NULL) { + unsigned char prefix_len; + prefix_len = __netconfig_convert_netmask_to_prefixlen( + conf->ip_info->subnet_mask); + if (prefix_len > 0 && prefix_len < 32) + g_key_file_set_integer(keyfile, group_name, + WIFI_CONFIG_IPV4_SUBNET_MASK, prefix_len); + } + + if (conf->ip_info->prefix_length > 0) + g_key_file_set_integer(keyfile, group_name, + WIFI_CONFIG_IPV6_PREFIX_LEN, conf->ip_info->prefix_length); + + if (conf->ip_info->gateway_address != NULL) + g_key_file_set_string(keyfile, group_name, + WIFI_CONFIG_IPV4_GATEWAY_ADDRESS, conf->ip_info->gateway_address); + + if (conf->ip_info->dns_type != NULL) + g_key_file_set_string(keyfile, group_name, + WIFI_CONFIG_IPV4_DNS_METHOD, conf->ip_info->dns_type); + + int i = 0, count = conf->ip_info->dns_count; + while (i < count) { + if (conf->ip_info->dns_address[i] != NULL) + g_key_file_set_string(keyfile, group_name, WIFI_CONFIG_DNS_ADDRESS, + conf->ip_info->dns_address[i]); + + i += 1; + } + + ret = wifi_config_save_configuration(config_id, keyfile); if (ret == TRUE) { + INFO("Success to save configuration [%s]", config_id); wifi_complete_save_configuration(wifi, context); + char *file; + if (get_files_count(CONNMAN_STORAGE) > MAX_WIFI_PROFILES) { + file = get_least_recently_profile(CONNMAN_STORAGE); + if (file) { + gchar *profileName = g_strdup_printf(CONNMAN_STORAGE "/%s", file); + INFO("least modified file: %s", profileName); + if (profileName) { + if (__remove_configuration(profileName) != TRUE) + DBG("Failed to remove profile: [%s]", profileName); + } else + ERR("Profile: [%s] does not exist", file); + + g_free(profileName); + } + } } else { + INFO("Fail to save configuration [%s]", config_id); netconfig_error_dbus_method_return(context, NETCONFIG_ERROR_INTERNAL, "FailSaveConfiguration"); } - return ret; + g_key_file_free(keyfile); + g_free(group_name); + __free_wifi_configuration(conf); + + g_variant_iter_free(iter); + + return TRUE; +} + +gboolean handle_load_eap_configuration(Wifi *wifi, GDBusMethodInvocation *context, + const gchar *config_id) +{ + gboolean ret = FALSE; + GVariantBuilder *b = NULL; + struct wifi_config *conf = NULL; + + g_return_val_if_fail(wifi != NULL, TRUE); + + conf = g_new0(struct wifi_config, 1); + conf->eap_config = g_new0(struct wifi_eap_config, 1); + conf->ip_info = g_new0(wifi_ip_info_s, 1); + + ret = _load_configuration(config_id, conf); + if (ret != TRUE) { + g_free(conf->eap_config); + g_free(conf->ip_info); + g_free(conf); + ERR("Fail to _load_configuration"); + netconfig_error_no_profile(context); + return TRUE; + } + + b = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_NAME, g_variant_new_string(conf->name)); + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_SECURITY_TYPE, g_variant_new_string(conf->security_type)); + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_HIDDEN, g_variant_new_string(conf->is_hidden)); + if (conf->proxy_address != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_PROXYADDRESS, g_variant_new_string(conf->proxy_address)); + else + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_PROXYADDRESS, g_variant_new_string("NONE")); + + if (conf->last_error != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_FAILURE, g_variant_new_string(conf->last_error)); + else + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_FAILURE, g_variant_new_string("ERROR_NONE")); + + if (conf->eap_config != NULL) { + if (conf->eap_config->anonymous_identity != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_ANONYMOUS_IDENTITY, g_variant_new_string(conf->eap_config->anonymous_identity)); + else + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_ANONYMOUS_IDENTITY, g_variant_new_string("NONE")); + + if (conf->eap_config->ca_cert != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_CACERT, g_variant_new_string(conf->eap_config->ca_cert)); + else + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_CACERT, g_variant_new_string("NONE")); + + if (conf->eap_config->client_cert != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_CLIENTCERT, g_variant_new_string(conf->eap_config->client_cert)); + else + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_CLIENTCERT, g_variant_new_string("NONE")); + + if (conf->eap_config->private_key != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_PRIVATEKEY, g_variant_new_string(conf->eap_config->private_key)); + else + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_PRIVATEKEY, g_variant_new_string("NONE")); + + if (conf->eap_config->private_key_password != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_PRIVATEKEY_PASSWORD, g_variant_new_string(conf->eap_config->private_key_password)); + else + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_PRIVATEKEY_PASSWORD, g_variant_new_string("NONE")); + + if (conf->eap_config->identity != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_IDENTITY, g_variant_new_string(conf->eap_config->identity)); + else + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_IDENTITY, g_variant_new_string("NONE")); + + if (conf->eap_config->eap_type != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_TYPE, g_variant_new_string(conf->eap_config->eap_type)); + else + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_TYPE, g_variant_new_string("NONE")); + + if (conf->eap_config->eap_auth_type != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_AUTH_TYPE, g_variant_new_string(conf->eap_config->eap_auth_type)); + else + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_AUTH_TYPE, g_variant_new_string("NONE")); + + if (conf->eap_config->subject_match != NULL) + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_SUBJECT_MATCH, g_variant_new_string(conf->eap_config->subject_match)); + else + g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_SUBJECT_MATCH, g_variant_new_string("NONE")); + } + + __free_wifi_configuration(conf); + + wifi_complete_load_eap_configuration(wifi, context, g_variant_builder_end(b)); + g_variant_builder_unref(b); + return TRUE; +} + +gboolean handle_save_eap_configuration(Wifi *wifi, GDBusMethodInvocation *context, + const gchar *config_id, GVariant *configuration) +{ + gboolean ret = FALSE; + struct wifi_config *conf = NULL; + GKeyFile *keyfile = NULL; + GVariantIter *iter; + GVariant *value; + gchar *field; + gchar *group_name = NULL; + + if ((wifi == NULL) || (config_id == NULL) || (configuration == NULL)) { + ERR("Invalid parameter"); + netconfig_error_invalid_parameter(context); + return TRUE; + } + + conf = g_new0(struct wifi_config, 1); + conf->eap_config = g_new0(struct wifi_eap_config, 1); + + g_variant_get(configuration, "a{sv}", &iter); + while (g_variant_iter_loop(iter, "{sv}", &field, &value)) { + if (g_strcmp0(field, WIFI_CONFIG_NAME) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->name = g_strdup(g_variant_get_string(value, NULL)); + DBG("name [%s]", conf->name); + } else { + conf->name = NULL; + } + } else if (g_strcmp0(field, WIFI_CONFIG_SSID) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->ssid = g_strdup(g_variant_get_string(value, NULL)); + DBG("ssid [%s]", conf->ssid); + } else { + conf->ssid = NULL; + } + } else if (g_strcmp0(field, WIFI_CONFIG_PASSPHRASE) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->passphrase = g_strdup(g_variant_get_string(value, NULL)); + DBG("passphrase [%s]", conf->passphrase); + } else { + conf->passphrase = NULL; + } + } else if (g_strcmp0(field, WIFI_CONFIG_HIDDEN) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->is_hidden = g_strdup(g_variant_get_string(value, NULL)); + DBG("is_hidden [%s]", conf->is_hidden); + } else { + conf->is_hidden = NULL; + } + } else if (g_strcmp0(field, WIFI_CONFIG_CREATED) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_BOOLEAN)) { + conf->is_created = g_variant_get_boolean(value); + DBG("is_created [%d]", conf->is_created); + } else { + conf->is_created = FALSE; + } + } else if (g_strcmp0(field, WIFI_CONFIG_PROXYADDRESS) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->proxy_address = g_strdup(g_variant_get_string(value, NULL)); + DBG("proxy_address [%s]", conf->proxy_address); + } else { + conf->proxy_address = NULL; + } + } else if (g_strcmp0(field, WIFI_CONFIG_EAP_ANONYMOUS_IDENTITY) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->eap_config->anonymous_identity = g_strdup(g_variant_get_string(value, NULL)); + DBG("anonymous_identity [%s]", conf->eap_config->anonymous_identity); + } else { + conf->eap_config->anonymous_identity = NULL; + } + } else if (g_strcmp0(field, WIFI_CONFIG_EAP_CACERT) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->eap_config->ca_cert = g_strdup(g_variant_get_string(value, NULL)); + DBG("ca_cert [%s]", conf->eap_config->ca_cert); + } else { + conf->eap_config->ca_cert = NULL; + } + } else if (g_strcmp0(field, WIFI_CONFIG_EAP_CLIENTCERT) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->eap_config->client_cert = g_strdup(g_variant_get_string(value, NULL)); + DBG("client_cert [%s]", conf->eap_config->client_cert); + } else { + conf->eap_config->client_cert = NULL; + } + } else if (g_strcmp0(field, WIFI_CONFIG_EAP_PRIVATEKEY) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->eap_config->private_key = g_strdup(g_variant_get_string(value, NULL)); + DBG("private_key [%s]", conf->eap_config->private_key); + } else { + conf->eap_config->private_key = NULL; + } + } else if (g_strcmp0(field, WIFI_CONFIG_EAP_PRIVATEKEY_PASSWORD) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->eap_config->private_key_password = g_strdup(g_variant_get_string(value, NULL)); + DBG("private_key_password[%s]", conf->eap_config->private_key_password); + } else { + conf->eap_config->private_key_password = NULL; + } + } else if (g_strcmp0(field, WIFI_CONFIG_EAP_IDENTITY) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->eap_config->identity = g_strdup(g_variant_get_string(value, NULL)); + DBG("identity [%s]", conf->eap_config->identity); + } else { + conf->eap_config->identity = NULL; + } + } else if (g_strcmp0(field, WIFI_CONFIG_EAP_TYPE) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->eap_config->eap_type = g_strdup(g_variant_get_string(value, NULL)); + DBG("eap_type [%s]", conf->eap_config->eap_type); + } else { + conf->eap_config->eap_type = NULL; + } + } else if (g_strcmp0(field, WIFI_CONFIG_EAP_AUTH_TYPE) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->eap_config->eap_auth_type = g_strdup(g_variant_get_string(value, NULL)); + DBG("eap_auth_type [%s]", conf->eap_config->eap_auth_type); + } else { + conf->eap_config->eap_auth_type = NULL; + } + } else if (g_strcmp0(field, WIFI_CONFIG_EAP_SUBJECT_MATCH) == 0) { + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) { + conf->eap_config->subject_match = g_strdup(g_variant_get_string(value, NULL)); + DBG("subject_match [%s]", conf->eap_config->subject_match); + } else { + conf->eap_config->subject_match = NULL; + } + } + } + conf->favorite = TRUE; + conf->autoconnect = TRUE; + + ret = wifi_config_get_group_name(WIFI_CONFIG_PREFIX, config_id, &group_name); + if (ret != TRUE) { + __free_wifi_configuration(conf); + ERR("Fail to get_wifi_config_group_name"); + return TRUE; + } + + keyfile = g_key_file_new(); + g_key_file_set_string(keyfile, group_name, WIFI_CONFIG_NAME, conf->name); + g_key_file_set_string(keyfile, group_name, WIFI_CONFIG_SSID, conf->ssid); + + if (conf->passphrase != NULL) { + gchar *enc_data = NULL; + + if (conf->is_created == true) + enc_data = _netconfig_encrypt_passphrase(conf->passphrase); + else + enc_data = g_strdup(conf->passphrase); + + if (!enc_data) { + ERR("Failed to encrypt the passphrase"); + } else { + g_free(conf->passphrase); + conf->passphrase = enc_data; + } + g_key_file_set_string(keyfile, group_name, WIFI_CONFIG_PASSPHRASE, conf->passphrase); + } + + g_key_file_set_boolean(keyfile, group_name, WIFI_CONFIG_FAVORITE, conf->favorite); + g_key_file_set_boolean(keyfile, group_name, WIFI_CONFIG_AUTOCONNECT, conf->autoconnect); + + /* Optional field */ + if (conf->proxy_address != NULL) { + g_key_file_set_string(keyfile, group_name, WIFI_CONFIG_PROXY_METHOD, "manual"); + g_key_file_set_string(keyfile, group_name, WIFI_CONFIG_PROXY_SERVER, conf->proxy_address); + } + + if (conf->is_hidden != NULL) { + gboolean hidden = FALSE; + if (g_strcmp0(conf->is_hidden, "TRUE") == 0) + hidden = TRUE; + g_key_file_set_boolean(keyfile, group_name, WIFI_CONFIG_HIDDEN, hidden); + } + + if (conf->eap_config->anonymous_identity != NULL) + g_key_file_set_string(keyfile, group_name, + WIFI_CONFIG_EAP_ANONYMOUS_IDENTITY, conf->eap_config->anonymous_identity); + + if (conf->eap_config->ca_cert != NULL) + g_key_file_set_string(keyfile, group_name, + WIFI_CONFIG_EAP_CACERT, conf->eap_config->ca_cert); + + if (conf->eap_config->client_cert != NULL) + g_key_file_set_string(keyfile, group_name, + WIFI_CONFIG_EAP_CLIENTCERT, conf->eap_config->client_cert); + + if (conf->eap_config->private_key != NULL) + g_key_file_set_string(keyfile, group_name, + WIFI_CONFIG_EAP_PRIVATEKEY, conf->eap_config->private_key); + + if (conf->eap_config->private_key_password != NULL) + g_key_file_set_string(keyfile, group_name, + WIFI_CONFIG_EAP_PRIVATEKEY_PASSWORD, conf->eap_config->private_key_password); + + if (conf->eap_config->identity != NULL) + g_key_file_set_string(keyfile, group_name, + WIFI_CONFIG_EAP_IDENTITY, conf->eap_config->identity); + + if (conf->eap_config->eap_type != NULL) + g_key_file_set_string(keyfile, group_name, + WIFI_CONFIG_EAP_TYPE, conf->eap_config->eap_type); + + if (conf->eap_config->eap_auth_type != NULL) + g_key_file_set_string(keyfile, group_name, + WIFI_CONFIG_EAP_AUTH_TYPE, conf->eap_config->eap_auth_type); + + if (conf->eap_config->subject_match != NULL) + g_key_file_set_string(keyfile, group_name, + WIFI_CONFIG_EAP_SUBJECT_MATCH, conf->eap_config->subject_match); + + ret = wifi_config_save_configuration(config_id, keyfile); + if (ret == TRUE) { + INFO("Success to save eap configuration [%s]", config_id); + wifi_complete_save_eap_configuration(wifi, context); + } else { + INFO("Fail to save eap configuration [%s]", config_id); + netconfig_error_dbus_method_return(context, NETCONFIG_ERROR_INTERNAL, "FailSaveEapConfiguration"); + } + + g_key_file_free(keyfile); + g_free(group_name); + __free_wifi_configuration(conf); + + g_variant_iter_free(iter); + + return TRUE; } gboolean handle_remove_configuration(Wifi *wifi, GDBusMethodInvocation *context, const gchar *config_id) @@ -539,24 +1737,24 @@ gboolean handle_remove_configuration(Wifi *wifi, GDBusMethodInvocation *context, gboolean ret = FALSE; if ((wifi == NULL) || (config_id == NULL)) { - ERR("Invaliad parameter"); + ERR("Invalid parameter"); netconfig_error_invalid_parameter(context); - return FALSE; + return TRUE; } - ret = _netconfig_remove_wifi_configuration(config_id); + ret = _remove_configuration(config_id); if (ret != TRUE) { - // no configuration or error + /* no configuration or error */ ERR("No [%s] configuration", config_id); netconfig_error_no_profile(context); - return FALSE; + return TRUE; } wifi_complete_remove_configuration(wifi, context); - return ret; + return TRUE; } -// config field key / value +/* config field key / value */ /* * [wifi_macaddress_config_id] * Name=name (mandatory) @@ -582,37 +1780,141 @@ gboolean handle_set_config_field(Wifi *wifi, GDBusMethodInvocation *context, gboolean ret = FALSE; gchar *keyfile_key = NULL; - g_return_val_if_fail(wifi != NULL, FALSE); - g_return_val_if_fail(config_id != NULL, FALSE); - g_return_val_if_fail(key != NULL, FALSE); + g_return_val_if_fail(wifi != NULL, TRUE); + g_return_val_if_fail(config_id != NULL, TRUE); + g_return_val_if_fail(key != NULL, TRUE); - DBG("Key[%s] Value[%d]", key, value); + DBG("Key[%s] Value[%s]", key, value); if (g_strcmp0(key, WIFI_CONFIG_PROXYADDRESS) == 0) { - ret = _netconfig_set_wifi_config_field(config_id, WIFI_CONFIG_PROXY_METHOD, "manual"); + ret = _set_field(config_id, WIFI_CONFIG_PROXY_METHOD, "manual"); if (!ret) { ERR("Fail to [%s]set_wifi_config_field(%s/manual)", config_id, WIFI_CONFIG_PROXY_METHOD); netconfig_error_invalid_parameter(context); - return FALSE; + return TRUE; } keyfile_key = g_strdup_printf("%s", WIFI_CONFIG_PROXY_SERVER); } else if (g_strcmp0(key, WIFI_CONFIG_HIDDEN) == 0) { keyfile_key = g_strdup_printf("%s", WIFI_CONFIG_HIDDEN); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_ANONYMOUS_IDENTITY) == 0) { + keyfile_key = g_strdup_printf("%s", WIFI_CONFIG_EAP_ANONYMOUS_IDENTITY); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_CACERT) == 0) { + keyfile_key = g_strdup_printf("%s", WIFI_CONFIG_EAP_CACERT); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_CLIENTCERT) == 0) { + keyfile_key = g_strdup_printf("%s", WIFI_CONFIG_EAP_CLIENTCERT); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_PRIVATEKEY) == 0) { + keyfile_key = g_strdup_printf("%s", WIFI_CONFIG_EAP_PRIVATEKEY); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_IDENTITY) == 0) { + keyfile_key = g_strdup_printf("%s", WIFI_CONFIG_EAP_IDENTITY); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_TYPE) == 0) { + keyfile_key = g_strdup_printf("%s", WIFI_CONFIG_EAP_TYPE); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_AUTH_TYPE) == 0) { + keyfile_key = g_strdup_printf("%s", WIFI_CONFIG_EAP_AUTH_TYPE); + } else if (g_strcmp0(key, WIFI_CONFIG_EAP_SUBJECT_MATCH) == 0) { + keyfile_key = g_strdup_printf("%s", WIFI_CONFIG_EAP_SUBJECT_MATCH); } else { ERR("Not supported key[%s]", key); netconfig_error_invalid_parameter(context); - return FALSE; + return TRUE; } - ret = _netconfig_set_wifi_config_field(config_id, keyfile_key, (const gchar *)value); + ret = _set_field(config_id, keyfile_key, (const gchar *)value); if (!ret) { ERR("Fail to [%s]set_wifi_config_field(%s/%s)", config_id, key, value); - ret = FALSE; } if (keyfile_key != NULL) g_free(keyfile_key); - wifi_complete_set_config_field(wifi,context); - return ret; + wifi_complete_set_config_field(wifi, context); + return TRUE; +} + +gboolean handle_get_config_passphrase(Wifi *wifi, GDBusMethodInvocation *context, const gchar *config_id) +{ + gboolean ret = FALSE; + gchar *passphrase = NULL; + + if ((wifi == NULL) || (config_id == NULL)) { + ERR("Invalid parameter"); + netconfig_error_invalid_parameter(context); + return TRUE; + } + + ret = _get_field(config_id, WIFI_CONFIG_PASSPHRASE, &passphrase); + if (!ret) { + ERR("Fail to [%s] _get_field(%s)", config_id, WIFI_CONFIG_PASSPHRASE); + netconfig_error_dbus_method_return(context, NETCONFIG_ERROR_INTERNAL, "OperationFailed"); + return TRUE; + } + + wifi_complete_get_config_passphrase(wifi, context, passphrase); + g_free(passphrase); + + return TRUE; +} + +gboolean handle_add_vsie(Wifi *wifi, GDBusMethodInvocation *context, + int frame_id, const gchar *vsie) +{ + DBG("Frame ID: [%d] VSIE: [%s]", frame_id, vsie); + + g_return_val_if_fail(wifi != NULL, TRUE); + g_return_val_if_fail(vsie != NULL, TRUE); + + gboolean ret = FALSE; + + ret = _add_vsie(frame_id, vsie); + if (!ret) { + DBG("Failed to add vsie: %s", vsie); + netconfig_error_dbus_method_return(context, NETCONFIG_ERROR_INTERNAL, "OperationFailed"); + return TRUE; + } + + wifi_complete_add_vsie(wifi, context); + return TRUE; +} + +gboolean handle_get_vsie(Wifi *wifi, GDBusMethodInvocation *context, + int frame_id) +{ + DBG("Frame ID: [%d]", frame_id); + + g_return_val_if_fail(wifi != NULL, TRUE); + + gboolean ret = FALSE; + gchar *vsie = NULL; + + ret = _get_vsie(frame_id, &vsie); + if (!ret) { + DBG("Failed to get vsie for frame:[%d]", frame_id); + netconfig_error_dbus_method_return(context, NETCONFIG_ERROR_INTERNAL, "OperationFailed"); + return TRUE; + } + + DBG("Received vsie: %s", vsie); + wifi_complete_get_vsie(wifi, context, vsie); + + return TRUE; +} + +gboolean handle_remove_vsie(Wifi *wifi, GDBusMethodInvocation *context, + int frame_id, const gchar *vsie) +{ + DBG("Frame ID: [%d] VSIE: [%s]", frame_id, vsie); + + g_return_val_if_fail(wifi != NULL, TRUE); + g_return_val_if_fail(vsie != NULL, TRUE); + + gboolean ret = FALSE; + + ret = _remove_vsie(frame_id, vsie); + if (!ret) { + DBG("Failed to remove vsie: %s", vsie); + netconfig_error_dbus_method_return(context, NETCONFIG_ERROR_INTERNAL, "OperationFailed"); + return TRUE; + } + + wifi_complete_remove_vsie(wifi, context); + return TRUE; }