Start IP conflict monitoring only after default profile has been updated
[platform/core/connectivity/net-config.git] / src / signal-handler.c
index 9190dfc..8d7b66b 100755 (executable)
 #include <string.h>
 #include <vconf.h>
 #include <vconf-keys.h>
+#include <sys/wait.h>
 
 #include "log.h"
 #include "util.h"
 #include "netdbus.h"
 #include "neterror.h"
 #include "wifi-wps.h"
+#include "wifi-bssid-scan.h"
 #include "wifi-agent.h"
 #include "wifi-power.h"
 #include "wifi-state.h"
 #include "network-state.h"
 #include "cellular-state.h"
 #include "signal-handler.h"
-#include "wifi-ssid-scan.h"
 #include "wifi-background-scan.h"
 #include "wifi-tdls.h"
+#include "ip-conflict-detect.h"
+#include "wifi-key-encryption.h"
+#if defined TIZEN_DEBUG_ENABLE
+#include "network-dump.h"
+#define NETWORK_LOG_DUMP_SCRIPT  "/opt/var/lib/net-config/network_log_dump.sh"
+#define MAX_SIZE_ERROR_BUFFER 256
+#endif
 
 #define DBUS_SERVICE_DBUS                      "org.freedesktop.DBus"
 #define DBUS_INTERFACE_DBUS                    "org.freedesktop.DBus"
@@ -61,6 +69,7 @@
 
 #define MAX_SIG_LEN 64
 #define TOTAL_CONN_SIGNALS 5
+#define MAX_SOCKET_OPEN_RETRY 5
 
 typedef enum {
        SIG_INTERFACE_REMOVED = 0,
@@ -89,6 +98,9 @@ static const char supplicant_signals[SIG_MAX][MAX_SIG_LEN] = {
 };
 
 static int supp_subscription_ids[SIG_MAX] = {0};
+#if defined TIZEN_DEBUG_ENABLE
+static int dumpservice_subscription_id = 0;
+#endif
 
 typedef void (*supplicant_signal_cb)(GDBusConnection *conn,
                const gchar *name, const gchar *path, const gchar *interface,
@@ -97,56 +109,160 @@ typedef void (*connman_signal_cb)(GDBusConnection *conn,
                const gchar *name, const gchar *path, const gchar *interface,
                const gchar *sig, GVariant *param, gpointer user_data);
 
-static void __netconfig_extract_ipv4_signal_data(GVariant *dictionary, const gchar *profile)
+static void __netconfig_extract_ipv4_signal_data(GVariant *dictionary,
+               const gchar *profile)
 {
        gchar *key = NULL;
        const gchar *value = NULL;
        GVariant *var = NULL;
        GVariantIter iter;
+       GVariantBuilder *builder;
+       GVariant *params;
 
        g_variant_iter_init(&iter, dictionary);
        while (g_variant_iter_loop(&iter, "{sv}", &key, &var)) {
                if (g_strcmp0(key, "Address") == 0)  {
-                       value = g_variant_get_string(var, NULL);
+                       g_variant_get(var, "&s", &value);
                        char *old_ip = vconf_get_str(VCONFKEY_NETWORK_IP);
 
-                       DBG("Old IPv4.Address [%s] Received new IPv4.Address [%s]", old_ip, value);
+                       DBG("Old IPv4.Address [%s] Received new IPv4.Address [%s]", old_ip,
+                                                 value);
                        if (g_strcmp0(old_ip, value) != 0) {
-                               if (value != NULL)
+                               builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+
+                               if (value != NULL) {
                                        vconf_set_str(VCONFKEY_NETWORK_IP, value);
-                               else if (old_ip != NULL && strlen(old_ip) > 0)
+                                       g_variant_builder_add(builder, "{sv}", "IPv4Address",
+                                                                 g_variant_new_string(value));
+                               } else if (old_ip != NULL && strlen(old_ip) > 0) {
                                        vconf_set_str(VCONFKEY_NETWORK_IP, "");
+                                       g_variant_builder_add(builder, "{sv}", "IPv4Address",
+                                                                 g_variant_new_string(""));
+                               }
+
+                               params = g_variant_new("(@a{sv})",
+                                                                          g_variant_builder_end(builder));
+
+                               g_variant_builder_unref(builder);
+
+                               netconfig_dbus_emit_signal(NULL, NETCONFIG_NETWORK_PATH,
+                                                  NETCONFIG_NETWORK_INTERFACE, "NetworkConfigChanged",
+                                                  params);
                        }
                        free(old_ip);
                }
        }
 }
 
-static void __netconfig_extract_ipv6_signal_data(GVariant *dictionary, const gchar *profile)
+static void __netconfig_extract_ipv6_signal_data(GVariant *dictionary,
+                                                                                                const gchar *profile)
 {
        gchar *key = NULL;
        const gchar *value = NULL;
        GVariant *var = NULL;
        GVariantIter iter;
+       GVariantBuilder *builder;
+       GVariant *params;
 
        g_variant_iter_init(&iter, dictionary);
        while (g_variant_iter_loop(&iter, "{sv}", &key, &var)) {
                if (g_strcmp0(key, "Address") == 0)  {
-                       value = g_variant_get_string(var, NULL);
+                       g_variant_get(var, "&s", &value);
                        char *old_ip6 = vconf_get_str(VCONFKEY_NETWORK_IP6);
 
-                       DBG("Old IPv6.Address [%s] Received new IPv6.Address [%s]", old_ip6, value);
+                       DBG("Old IPv6.Address [%s] Received new IPv6.Address [%s]", old_ip6,
+                                                       value);
                        if (g_strcmp0(old_ip6, value) != 0) {
-                               if (value != NULL)
+                               builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+
+                               if (value != NULL) {
                                        vconf_set_str(VCONFKEY_NETWORK_IP6, value);
-                               else if (old_ip6 != NULL && strlen(old_ip6) > 0)
+                                       g_variant_builder_add(builder, "{sv}", "IPv6Address",
+                                                                 g_variant_new_string(value));
+                               } else if (old_ip6 != NULL && strlen(old_ip6) > 0) {
                                        vconf_set_str(VCONFKEY_NETWORK_IP6, "");
+                                       g_variant_builder_add(builder, "{sv}", "IPv6Address",
+                                                                 g_variant_new_string(""));
+                               }
+
+                               params = g_variant_new("(@a{sv})",
+                                                                          g_variant_builder_end(builder));
+                               g_variant_builder_unref(builder);
+
+                               netconfig_dbus_emit_signal(NULL, NETCONFIG_NETWORK_PATH,
+                                                  NETCONFIG_NETWORK_INTERFACE, "NetworkConfigChanged",
+                                                  params);
                        }
                        free(old_ip6);
                }
        }
 }
 
+#if defined TIZEN_DEBUG_ENABLE
+static int __netconfig_handle_execute_file(const char *file_path,
+               char *const args[], char *const envs[])
+{
+       pid_t pid = 0;
+       int status = 0;
+       int rv = 0;
+       errno = 0;
+       register unsigned int index = 0;
+       char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
+
+       while (args[index] != NULL) {
+               DBG("%s", args[index]);
+               index++;
+       }
+
+       if (!(pid = fork())) {
+               DBG("pid(%d), ppid (%d)", getpid(), getppid());
+               DBG("Inside child, exec (%s) command", file_path);
+
+               errno = 0;
+               if (execve(file_path, args, envs) == -1) {
+                       strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
+                       DBG("Fail to execute command (%s)", error_buf);
+                       exit(1);
+               }
+       } else if (pid > 0) {
+               if (waitpid(pid, &status, 0) == -1)
+                       DBG("wait pid (%u) status (%d)", pid, status);
+
+               if (WIFEXITED(status)) {
+                       rv = WEXITSTATUS(status);
+                       DBG("exited, status=%d", rv);
+               } else if (WIFSIGNALED(status)) {
+                       DBG("killed by signal %d", WTERMSIG(status));
+               } else if (WIFSTOPPED(status)) {
+                       DBG("stopped by signal %d", WSTOPSIG(status));
+               } else if (WIFCONTINUED(status)) {
+                       DBG("continued");
+               }
+
+               return rv;
+       }
+
+       strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
+       DBG("failed to fork(%s)", error_buf);
+       return -EIO;
+}
+
+static int _start_dump()
+{
+       int rv = 0;
+       gchar *path = NETWORK_LOG_DUMP_SCRIPT;
+       char *const args[] = { NETWORK_LOG_DUMP_SCRIPT, NULL };
+       char *const envs[] = { NULL };
+
+       rv = __netconfig_handle_execute_file(path, args, envs);
+       if (rv < 0) {
+               ERR("Fail to execute network log dump shell");
+               return -EIO;
+       }
+       return 0;
+}
+#endif
+
 static void _technology_signal_cb(GDBusConnection *conn,
                const gchar *name, const gchar *path, const gchar *interface,
                const gchar *sig, GVariant *param, gpointer user_data)
@@ -178,22 +294,23 @@ static void _technology_signal_cb(GDBusConnection *conn,
                        /* Tethering state */
                        wifi_state_set_tech_state(NETCONFIG_WIFI_TECH_TETHERED);
                }
-               if (key)
-                       g_free(key);
-               if (var)
-                       g_variant_unref(var);
+               g_free(key);
+               g_variant_unref(var);
        }
 }
 
 static void _service_signal_cb(GDBusConnection *conn,
                const gchar *name, const gchar *path,
-               const gchar *interface, const gchar *sig, GVariant *param, gpointer user_data)
+               const gchar *interface, const gchar *sig,
+               GVariant *param, gpointer user_data)
 {
        gchar *sigvalue = NULL;
        gchar *property;
        GVariant *variant = NULL, *var;
        GVariantIter *iter;
        const gchar *value = NULL;
+       struct sock_data *sd = NULL;
+       int idx = 0;
 
        if (path == NULL || param == NULL)
                goto done;
@@ -209,6 +326,7 @@ static void _service_signal_cb(GDBusConnection *conn,
                g_variant_get(variant, "s", &property);
 
                DBG("[%s] %s", property, path);
+
                if (netconfig_is_wifi_profile(path) == TRUE) {
                        int wifi_state = 0;
 
@@ -322,19 +440,38 @@ static void _service_signal_cb(GDBusConnection *conn,
                                netconfig_update_default_profile(NULL);
                        }
                }
+
+               if (netconfig_is_wifi_profile(path) || netconfig_is_ethernet_profile(path)) {
+                       if (g_strcmp0(property, "ready") == 0) {
+                               for (idx = 0; idx < MAX_SOCKET_OPEN_RETRY; idx++) {
+                                       sd = start_ip_conflict_mon();
+                                       if (sd != NULL)
+                                               break;
+                               }
+                       } else if (g_strcmp0(property, "online") == 0) {
+                               // do nothing
+                       } else {
+                               stop_ip_conflict_mon();
+                       }
+               }
+
                g_free(property);
        } else if (g_strcmp0(sigvalue, "Proxy") == 0) {
                if (netconfig_is_wifi_profile(path) != TRUE || g_strcmp0(path, netconfig_get_default_profile()) != 0)
                        goto done;
 
-               if (!g_variant_type_equal(variant, G_VARIANT_TYPE_ARRAY))
+               if (!g_variant_is_of_type(variant, G_VARIANT_TYPE_ARRAY))
                        goto done;
 
                g_variant_get(variant, "a{sv}", &iter);
                while (g_variant_iter_loop(iter, "{sv}", &property, &var)) {
+                       GVariantBuilder *builder;
+                       GVariant *sig_params;
                        if (g_strcmp0(property, "Servers") == 0) {
                                GVariantIter *iter_sub = NULL;
 
+                               builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+
                                g_variant_get(var, "as", &iter_sub);
                                g_variant_iter_loop(iter_sub, "s", &value);
                                g_variant_iter_free(iter_sub);
@@ -342,6 +479,17 @@ static void _service_signal_cb(GDBusConnection *conn,
                                DBG("Proxy - [%s]", value);
                                vconf_set_str(VCONFKEY_NETWORK_PROXY, value);
 
+                               g_variant_builder_add(builder, "{sv}", "ProxyAddress",
+                                                               g_variant_new_string(value));
+
+                               sig_params = g_variant_new("(@a{sv})",
+                                                               g_variant_builder_end(builder));
+                               g_variant_builder_unref(builder);
+
+                               netconfig_dbus_emit_signal(NULL, NETCONFIG_NETWORK_PATH,
+                                                  NETCONFIG_NETWORK_INTERFACE, "NetworkConfigChanged",
+                                                  sig_params);
+
                                g_free(property);
                                g_variant_unref(var);
                                break;
@@ -349,8 +497,21 @@ static void _service_signal_cb(GDBusConnection *conn,
                                value = g_variant_get_string(var, NULL);
                                DBG("Method - [%s]", value);
 
-                               if (g_strcmp0(value, "direct") == 0)
+                               if (g_strcmp0(value, "direct") == 0) {
+                                       builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+
                                        vconf_set_str(VCONFKEY_NETWORK_PROXY, "");
+                                       g_variant_builder_add(builder, "{sv}", "ProxyAddress",
+                                                               g_variant_new_string(""));
+
+                                       sig_params = g_variant_new("(@a{sv})",
+                                                               g_variant_builder_end(builder));
+                                       g_variant_builder_unref(builder);
+
+                                       netconfig_dbus_emit_signal(NULL, NETCONFIG_NETWORK_PATH,
+                                                          NETCONFIG_NETWORK_INTERFACE,
+                                                          "NetworkConfigChanged", sig_params);
+                               }
 
                                g_free(property);
                                g_variant_unref(var);
@@ -366,11 +527,21 @@ static void _service_signal_cb(GDBusConnection *conn,
        } else if (g_strcmp0(sigvalue, "Error") == 0) {
                g_variant_get(variant, "s", &property);
                INFO("[%s] Property : %s", sigvalue, property);
+#if defined TIZEN_DEBUG_ENABLE
+               if (g_strcmp0(property, "dhcp-failed") == 0
+                       || g_strcmp0(property, "connect-failed") == 0
+                       || g_strcmp0(property, "login-failed") == 0
+                       || g_strcmp0(property, "auth-failed") == 0
+                       || g_strcmp0(property, "invalid-key") == 0) {
+
+                       INFO("start dump");
+                       _start_dump();
+               }
+#endif
                g_free(property);
        }
 done:
-       if (sigvalue)
-               g_free(sigvalue);
+       g_free(sigvalue);
 
        if (variant)
                g_variant_unref(variant);
@@ -396,12 +567,9 @@ static void _dbus_name_changed_cb(GDBusConnection *conn,
 
                connman_register_agent();
        }
-       if (name)
-               g_free(name);
-       if (old)
-               g_free(old);
-       if (new)
-               g_free(new);
+       g_free(name);
+       g_free(old);
+       g_free(new);
 
        return;
 }
@@ -433,7 +601,7 @@ static void _services_changed_cb(GDBusConnection *conn, const gchar *name,
                is_cell_internet_prof = netconfig_is_cellular_internet_profile(
                                service_path);
                if (service_path != NULL) {
-                       while (g_variant_iter_loop(next, "{sv}", &property,
+                       while (next && g_variant_iter_loop(next, "{sv}", &property,
                                                &variant)) {
                                if (g_strcmp0(property, "State") == 0) {
                                        g_variant_get(variant, "s", &value);
@@ -487,8 +655,8 @@ static void _supplicant_interface_removed(GDBusConnection *conn,
                const gchar *sig, GVariant *param, gpointer user_data)
 {
        DBG("Interface removed handling!");
-       if (netconfig_wifi_is_wps_enabled() == TRUE)
-               netconfig_wifi_wps_signal_scanaborted();
+       if (netconfig_wifi_is_bssid_scan_started() == TRUE)
+               netconfig_wifi_bssid_signal_scanaborted();
 
        return;
 }
@@ -498,9 +666,10 @@ static void _supplicant_properties_changed(GDBusConnection *conn,
                const gchar *sig, GVariant *param, gpointer user_data)
 {
        DBG("Properties changed handling!");
-       gchar *key;
-       GVariantIter *iter;
-       GVariant *variant;
+       gchar *key = NULL;
+       const gchar *state = NULL;
+       GVariantIter *iter = NULL;
+       GVariant *variant = NULL;
        gboolean scanning = FALSE;
 
        if (param == NULL)
@@ -510,12 +679,42 @@ static void _supplicant_properties_changed(GDBusConnection *conn,
        while (g_variant_iter_loop(iter, "{sv}", &key, &variant)) {
                if (g_strcmp0(key, "Scanning") == 0) {
                        scanning = g_variant_get_boolean(variant);
+                       DBG("setting scanning %s", scanning ? "TRUE" : "FALSE");
                        if (scanning == TRUE)
                                netconfig_wifi_set_scanning(TRUE);
+                       else
+                               netconfig_wifi_set_scanning(FALSE);
 
                        g_variant_unref(variant);
                        g_free(key);
+                       variant = NULL;
+                       key = NULL;
                        break;
+               } else if (g_strcmp0(key, "State") == 0) {
+                       state = g_variant_get_string(variant, NULL);
+                       if (state != NULL)
+                               ERR("Supplicant state : %s", state);
+
+                       g_variant_unref(variant);
+                       g_free(key);
+                       variant = NULL;
+                       key = NULL;
+                       break;
+               } else if (g_strcmp0(key, "DisconnectReason") == 0) {
+                       int reason = g_variant_get_int32(variant);
+                       ERR("Supplicant DisconnReason : %d", reason);
+
+                       g_variant_unref(variant);
+                       g_free(key);
+                       variant = NULL;
+                       key = NULL;
+                       break;
+               } else {
+                       gchar *value;
+                       value = g_variant_print(variant, TRUE);
+                       DBG("Supplicant %s : %s", key, value);
+
+                       g_free(value);
                }
        }
 
@@ -529,10 +728,7 @@ static void _supplicant_bss_added(GDBusConnection *conn,
                const gchar *sig, GVariant *param, gpointer user_data)
 {
        DBG("BSS added handling!");
-       if (wifi_ssid_scan_get_state() == TRUE)
-               wifi_ssid_scan_add_bss(param);
-       else
-               wifi_state_set_bss_found(TRUE);
+       wifi_state_set_bss_found(TRUE);
 
        return;
 }
@@ -544,18 +740,13 @@ static void _supplicant_scan_done(GDBusConnection *conn,
        DBG("Scan Done handling!");
        netconfig_wifi_set_scanning(FALSE);
 
-       if (netconfig_wifi_is_wps_enabled() == TRUE) {
-               netconfig_wifi_wps_signal_scandone();
+       if (netconfig_wifi_is_bssid_scan_started() == TRUE) {
+               netconfig_wifi_bssid_signal_scandone();
                if (wifi_state_get_technology_state() < NETCONFIG_WIFI_TECH_POWERED)
                        return;
        }
 
-       if (netconfig_wifi_get_bgscan_state() != TRUE) {
-               if (wifi_ssid_scan_get_state() == TRUE)
-                       wifi_ssid_scan_emit_scan_completed();
-               else
-                       wifi_ssid_scan(NULL);
-       } else {
+       if (netconfig_wifi_get_bgscan_state() == TRUE) {
                if (wifi_state_get_technology_state() >=
                                NETCONFIG_WIFI_TECH_POWERED)
                        netconfig_wifi_bgscan_start(FALSE);
@@ -573,9 +764,14 @@ static void _supplicant_driver_hanged(GDBusConnection *conn,
        DBG("Driver Hanged handling!");
        ERR("Critical. Wi-Fi firmware crashed");
 
+#if !defined TIZEN_WEARABLE
+       netconfig_send_message_to_net_popup("Wi-Fi Error",
+               "Wi-Fi Driver Hanged. Please get log dump and report", "popup", NULL);
+#endif
        wifi_power_recover_firmware();
 
        return;
+
 }
 
 static void _supplicant_session_overlapped(GDBusConnection *conn,
@@ -592,6 +788,28 @@ static void _supplicant_session_overlapped(GDBusConnection *conn,
 #endif
 }
 
+#if defined TIZEN_DEBUG_ENABLE
+static void __netconfig_dumpservice_handler(GDBusConnection *conn,
+               const gchar *name, const gchar *path, const gchar *interface,
+               const gchar *sig, GVariant *param, gpointer user_data)
+{
+       int mode;
+       gchar *signal_path = NULL;
+
+       if (param == NULL)
+               return;
+
+       g_variant_get(param, "(is)", &mode, &signal_path);
+       DBG("Path: %s and mode: %d", signal_path, mode);
+
+       netconfig_dump_log(signal_path);
+       if (signal_path)
+               g_free(signal_path);
+
+       return;
+}
+#endif
+
 static void _supplicant_tdls_connected(GDBusConnection *conn,
                const gchar *name, const gchar *path, const gchar *interface,
                const gchar *sig, GVariant *param, gpointer user_data)
@@ -721,16 +939,83 @@ error:
        netconfig_wifi_notify_wps_fail_event(config_error, error_indication);
 }
 
+static void _find_service_and_set_passphrase(char *ssid, char *key)
+{
+       GString *str;
+       GVariant *reply = NULL;
+       int i, j, ssid_len;
+       char *service_path;
+       char *dev_mac_addr;
+       char ident[13];
+       gchar *enc_passphrase;
+
+       ssid_len = strlen(ssid);
+
+       str = g_string_sized_new((ssid_len * 2) + 55);
+       if (!str)
+               return;
+
+       dev_mac_addr = vconf_get_str(VCONFKEY_WIFI_BSSID_ADDRESS);
+       if (!dev_mac_addr) {
+               ERR("Failed to get mac address from vconf key");
+               g_string_free(str, TRUE);
+               return;
+       }
+
+       j = 0;
+       for (i = 0; dev_mac_addr[i]; i++) {
+               if (dev_mac_addr[i] != ':')
+                       ident[j++] = dev_mac_addr[i];
+       }
+       ident[j] = '\0';
+
+       g_string_append_printf(str, "%s%s_", CONNMAN_WIFI_SERVICE_PROFILE_PREFIX,
+                                                  ident);
+       free(dev_mac_addr);
+
+       for (i = 0; i < ssid_len; i++) {
+               if (ssid[i] != '"')
+                       g_string_append_printf(str, "%02x", ssid[i]);
+       }
+
+       g_string_append_printf(str, "_managed_psk");
+
+       service_path = g_string_free(str, FALSE);
+
+       enc_passphrase = _netconfig_encrypt_passphrase(key);
+       if (!enc_passphrase) {
+               ERR("Failed to encrypt passphrase");
+               g_free(service_path);
+               return;
+       }
+
+       INFO("wps service_path %s Passphrase %s", service_path, enc_passphrase);
+
+       reply = netconfig_invoke_dbus_method(CONNMAN_SERVICE, service_path,
+                                        CONNMAN_SERVICE_INTERFACE, "SetProperty",
+                                        g_variant_new("(sv)", "Passphrase",
+                                                                  g_variant_new_string(enc_passphrase)));
+       if (reply != NULL)
+               g_variant_unref(reply);
+       else
+               ERR("Failed to set passphrase");
+
+       g_free(service_path);
+
+       return;
+}
+
 static void _supplicant_wifi_wps_credentials(GVariant *param)
 {
        gchar *key;
-       char ssid[32];
-       char wps_key[100];
+       char ssid[32] = {0, };
+       char wps_key[100] = {0, };
        GVariantIter *iter;
        GVariant *variant;
        int config_error = 0;
        int error_indication = 0;
        gsize ssid_len = 0;
+       char *key_mgmt = NULL;
 
        if (param == NULL) {
                ERR("Param is NULL");
@@ -749,7 +1034,8 @@ static void _supplicant_wifi_wps_credentials(GVariant *param)
 
                        INFO("wps password len %d ", key_len);
                        if (key_len > 0) {
-                               t_key = g_variant_get_fixed_array(variant, &key_len, sizeof(guchar));
+                               t_key = g_variant_get_fixed_array(variant, &key_len,
+                                                 sizeof(guchar));
                                if (!t_key) {
                                        g_free(key);
                                        g_variant_unref(variant);
@@ -762,7 +1048,8 @@ static void _supplicant_wifi_wps_credentials(GVariant *param)
                                SLOGI("WPS AP Security ->Open");
                } else if (g_strcmp0(key, "SSID") == 0) {
                        const char *t_key = NULL;
-                       t_key = g_variant_get_fixed_array(variant, &ssid_len, sizeof(guchar));
+                       t_key = g_variant_get_fixed_array(variant, &ssid_len,
+                                                 sizeof(guchar));
                        INFO("wps ssid_len is %d ", ssid_len);
                        if (!t_key) {
                                g_free(key);
@@ -776,11 +1063,42 @@ static void _supplicant_wifi_wps_credentials(GVariant *param)
                                ssid_len = 0;
                        }
                        INFO("SSID in process credentials %s", ssid);
+               } else if (g_strcmp0(key, "AuthType") == 0) {
+                       gchar *auth_type;
+                       GVariantIter *var_iter;
+                       g_variant_get(variant, "as", &var_iter);
+                       while (g_variant_iter_loop(var_iter, "s", &auth_type)) {
+                               INFO("wps auth_type %s", auth_type);
+                               if (g_strcmp0(auth_type, "wpa-psk") == 0 ||
+                                       g_strcmp0(auth_type, "wpa2-psk") == 0)
+                                       key_mgmt = "psk";
+                               else if (g_strcmp0(auth_type, "open") == 0)
+                                       key_mgmt = "none";
+                       }
+                       g_variant_iter_free(var_iter);
+               } else if (g_strcmp0(key, "EncrType") == 0) {
+                       gchar *encr_type;
+                       GVariantIter *var_iter;
+                       g_variant_get(variant, "as", &var_iter);
+                       while (g_variant_iter_loop(var_iter, "s", &encr_type))
+                               INFO("wps encr_type %s", encr_type);
+                       g_variant_iter_free(var_iter);
+               } else if (g_strcmp0(key, "BSSID") == 0) {
+                       const guchar *bssid;
+                       gsize bssid_len;
+                       bssid = g_variant_get_fixed_array(variant, &bssid_len,
+                                                               sizeof(guchar));
+                       if (bssid && bssid_len == 6)
+                               INFO("wps BSSID %2x:%2x:%2x:%2x:%2x:%2x", bssid[0], bssid[1],
+                                        bssid[2], bssid[3], bssid[4], bssid[5]);
                }
        }
 
        g_variant_iter_free(iter);
 
+       if (g_strcmp0(key_mgmt, "psk") == 0)
+               _find_service_and_set_passphrase(ssid, wps_key);
+
 #if 0
        /*
         * Notify WPS Credentials only when requested through WPS PBC
@@ -929,6 +1247,22 @@ void register_gdbus_signal(void)
 
        INFO("Successfully register Supplicant DBus signal filters");
 
+#if defined TIZEN_DEBUG_ENABLE
+       dumpservice_subscription_id = g_dbus_connection_signal_subscribe(
+                       connection,
+                       NULL,
+                       DUMP_SERVICE_INTERFACE,
+                       DUMP_SIGNAL,
+                       NULL,
+                       NULL,
+                       G_DBUS_SIGNAL_FLAGS_NONE,
+                       __netconfig_dumpservice_handler,
+                       NULL,
+                       NULL);
+
+       INFO("Successfully registered Dumpservice DBus signal filter");
+#endif
+
        /* In case ConnMan precedes this signal register,
         * net-config should update the default connected profile.
         */
@@ -960,4 +1294,8 @@ void deregister_gdbus_signal(void)
                }
        }
 
+#if defined TIZEN_DEBUG_ENABLE
+       g_dbus_connection_signal_unsubscribe(connection,
+                       dumpservice_subscription_id);
+#endif
 }