src/signal-handler.c

   1 /*
   2  * Network Configuration Module
   3  *
   4  * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <vconf.h>
  24 #include <vconf-keys.h>
  25 #include <sys/wait.h>
  26
  27 #include "log.h"
  28 #include "util.h"
  29 #include "netdbus.h"
  30 #include "neterror.h"
  31 #include "wifi-wps.h"
  32 #include "wifi-agent.h"
  33 #include "wifi-power.h"
  34 #include "wifi-state.h"
  35 #include "wifi-scan.h"
  36 #include "wifi-bssid-scan.h"
  37 #include "wifi-background-scan.h"
  38 #include "netsupplicant.h"
  39 #include "network-state.h"
  40 #include "cellular-state.h"
  41 #include "signal-handler.h"
  42 #include "wifi-tdls.h"
  43 #include "wifi-dpp.h"
  44 #include "ip-conflict-detect.h"
  45 #include "wifi-key-encryption.h"
  46 #include "clatd-handler.h"
  47 #if defined TIZEN_DEBUG_ENABLE
  48 #include "network-dump.h"
  49 #define NETWORK_LOG_DUMP_SCRIPT  "/opt/var/lib/net-config/network_log_dump.sh"
  50 #define MAX_SIZE_ERROR_BUFFER 256
  51 #endif
  52
  53 #define DBUS_SERVICE_DBUS                       "org.freedesktop.DBus"
  54 #define DBUS_INTERFACE_DBUS                     "org.freedesktop.DBus"
  55 #define SIGNAL_INTERFACE_REMOVED                "InterfaceRemoved"
  56 #define SIGNAL_SCAN_DONE                        "ScanDone"
  57 #define SIGNAL_SCAN_CHANGED                     "ScanChanged"
  58 #define SIGNAL_BSS_ADDED                        "BSSAdded"
  59 #define SIGNAL_PROPERTIES_CHANGED               "PropertiesChanged"
  60 #define SIGNAL_PROPERTIES_DRIVER_HANGED         "DriverHanged"
  61 #define SIGNAL_PROPERTIES_SESSION_OVERLAPPED    "SessionOverlapped"
  62 #define SIGNAL_TDLS_CONNECTED                           "TDLSConnected"
  63 #define SIGNAL_TDLS_DISCONNECTED                        "TDLSDisconnected"
  64 #define SIGNAL_TDLS_PEER_FOUND                          "TDLSPeerFound"
  65
  66 #define SIGNAL_DPP_AUTH_SUCCESS "DPPAuthSuccess"
  67 #define SIGNAL_DPP_AUTH_FAILED "DPPAuthFailed"
  68 #define SIGNAL_DPP_NOT_COMPATIBLE "DPPNotCompatible"
  69 #define SIGNAL_DPP_CONF_FAILED "DPPConfFailed"
  70 #define SIGNAL_DPP_SCAN_PEER_QR "DPPScanPeerQrCode"
  71 #define SIGNAL_DPP_NETWORK_ID "DPPNetworkID"
  72 #define SIGNAL_DPP_CONF_SENT "DPPConfSent"
  73 #define SIGNAL_DPP_CONF_RECEIVED "DPPConfReceived"
  74 #define SIGNAL_DPP_CONF_OBJ "DPPConfObj"
  75
  76 #define SIGNAL_WPS_CONNECTED                            "WPSConnected"
  77 #define SIGNAL_WPS_EVENT                                        "Event"
  78 #define SIGNAL_WPS_CREDENTIALS                          "Credentials"
  79
  80 #define CONNMAN_SIGNAL_SERVICES_CHANGED         "ServicesChanged"
  81 #define CONNMAN_SIGNAL_PROPERTY_CHANGED         "PropertyChanged"
  82 #define CONNMAN_SIGNAL_DEVICE_CHANGED           "DeviceChanged"
  83 #define CONNMAN_SIGNAL_DEVICE_DETECTED          "DeviceDetected"
  84 #define SIGNAL_NAME_OWNER_CHANGED               "NameOwnerChanged"
  85
  86 #define MAX_SIG_LEN 64
  87 #define TOTAL_CONN_SIGNALS 6
  88 #define MAX_SOCKET_OPEN_RETRY 5
  89
  90 typedef enum {
  91         SIG_INTERFACE_REMOVED = 0,
  92         SIG_PROPERTIES_CHANGED,
  93         SIG_BSS_ADDED,
  94         SIG_SCAN_DONE,
  95         SIG_DRIVER_HANGED,
  96         SIG_SESSION_OVERLAPPED,
  97         SIG_TDLS_CONNECTED,
  98         SIG_TDLS_DISCONNECTED,
  99         SIG_TDLS_PEER_FOUND,
 100         SIG_DPP_AUTH_SUCCESS,
 101         SIG_DPP_AUTH_FAILED,
 102         SIG_DPP_NOT_COMPATIBLE,
 103         SIG_DPP_CONF_FAILED,
 104         SIG_DPP_SCAN_PEER_QR,
 105         SIG_DPP_NETWORK_ID,
 106         SIG_DPP_CONF_SENT,
 107         SIG_DPP_CONF_RECEIVED,
 108         SIG_DPP_CONF_OBJ,
 109         SIG_MAX
 110 } SuppSigArrayIndex;
 111
 112 static int conn_subscription_ids[TOTAL_CONN_SIGNALS] = {0};
 113 static const char supplicant_signals[SIG_MAX][MAX_SIG_LEN] = {
 114                 SIGNAL_INTERFACE_REMOVED,
 115                 SIGNAL_PROPERTIES_CHANGED,
 116                 SIGNAL_BSS_ADDED,
 117                 SIGNAL_SCAN_DONE,
 118                 SIGNAL_PROPERTIES_DRIVER_HANGED,
 119                 SIGNAL_PROPERTIES_SESSION_OVERLAPPED,
 120                 SIGNAL_TDLS_CONNECTED,
 121                 SIGNAL_TDLS_DISCONNECTED,
 122                 SIGNAL_TDLS_PEER_FOUND,
 123                 SIGNAL_DPP_AUTH_SUCCESS,
 124                 SIGNAL_DPP_AUTH_FAILED,
 125                 SIGNAL_DPP_NOT_COMPATIBLE,
 126                 SIGNAL_DPP_CONF_FAILED,
 127                 SIGNAL_DPP_SCAN_PEER_QR,
 128                 SIGNAL_DPP_NETWORK_ID,
 129                 SIGNAL_DPP_CONF_SENT,
 130                 SIGNAL_DPP_CONF_RECEIVED,
 131                 SIGNAL_DPP_CONF_OBJ,
 132 };
 133 static const char *supplicant_iface_for_sig[SIG_MAX] = {
 134                 SUPPLICANT_INTERFACE,
 135                 SUPPLICANT_IFACE_INTERFACE,
 136                 SUPPLICANT_IFACE_INTERFACE,
 137                 SUPPLICANT_IFACE_INTERFACE,
 138                 SUPPLICANT_IFACE_INTERFACE,
 139                 SUPPLICANT_IFACE_INTERFACE,
 140                 SUPPLICANT_IFACE_INTERFACE,
 141                 SUPPLICANT_IFACE_INTERFACE,
 142                 SUPPLICANT_IFACE_INTERFACE,
 143                 SUPPLICANT_IFACE_DPP,
 144                 SUPPLICANT_IFACE_DPP,
 145                 SUPPLICANT_IFACE_DPP,
 146                 SUPPLICANT_IFACE_DPP,
 147                 SUPPLICANT_IFACE_DPP,
 148                 SUPPLICANT_IFACE_DPP,
 149                 SUPPLICANT_IFACE_DPP,
 150                 SUPPLICANT_IFACE_DPP,
 151                 SUPPLICANT_IFACE_DPP,
 152 };
 153
 154 static int supp_subscription_ids[SIG_MAX] = {0};
 155 #if defined TIZEN_DEBUG_ENABLE
 156 static int dumpservice_subscription_id = 0;
 157 #endif
 158
 159 typedef void (*supplicant_signal_cb)(GDBusConnection *conn,
 160                 const gchar *name, const gchar *path, const gchar *interface,
 161                 const gchar *sig, GVariant *param, gpointer user_data);
 162 typedef void (*connman_signal_cb)(GDBusConnection *conn,
 163                 const gchar *name, const gchar *path, const gchar *interface,
 164                 const gchar *sig, GVariant *param, gpointer user_data);
 165
 166 static void __netconfig_extract_ipv4_signal_data(GVariant *dictionary,
 167                 const gchar *profile)
 168 {
 169         gchar *key = NULL;
 170         const gchar *value = NULL;
 171         GVariant *var = NULL;
 172         GVariantIter iter;
 173         GVariantBuilder *builder;
 174         GVariant *params;
 175
 176         g_variant_iter_init(&iter, dictionary);
 177         while (g_variant_iter_loop(&iter, "{sv}", &key, &var)) {
 178                 if (g_strcmp0(key, "Address") == 0)  {
 179                         g_variant_get(var, "&s", &value);
 180                         char *old_ip = vconf_get_str(VCONFKEY_NETWORK_IP);
 181
 182                         DBG("Old IPv4.Address [%s] Received new IPv4.Address [%s]", old_ip,
 183                                                   value);
 184                         if (g_strcmp0(old_ip, value) != 0) {
 185                                 builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 186
 187                                 if (value != NULL) {
 188                                         netconfig_set_default_ipaddress(value);
 189                                         vconf_set_str(VCONFKEY_NETWORK_IP, value);
 190                                         g_variant_builder_add(builder, "{sv}", "IPv4Address",
 191                                                                   g_variant_new_string(value));
 192                                 } else if (old_ip != NULL && strlen(old_ip) > 0) {
 193                                         vconf_set_str(VCONFKEY_NETWORK_IP, "");
 194                                         g_variant_builder_add(builder, "{sv}", "IPv4Address",
 195                                                                   g_variant_new_string(""));
 196                                 }
 197
 198                                 params = g_variant_new("(@a{sv})",
 199                                                                            g_variant_builder_end(builder));
 200
 201                                 g_variant_builder_unref(builder);
 202
 203                                 netconfig_dbus_emit_signal(NULL, NETCONFIG_NETWORK_PATH,
 204                                                    NETCONFIG_NETWORK_INTERFACE, "NetworkConfigChanged",
 205                                                    params);
 206                         }
 207                         free(old_ip);
 208                 }
 209         }
 210 }
 211
 212 static void __netconfig_extract_ipv6_signal_data(GVariant *dictionary,
 213                                                                                                  const gchar *profile)
 214 {
 215         gchar *key = NULL;
 216         const gchar *value = NULL;
 217         GVariant *var = NULL;
 218         GVariantIter iter;
 219         GVariantBuilder *builder;
 220         GVariant *params;
 221
 222         g_variant_iter_init(&iter, dictionary);
 223         while (g_variant_iter_loop(&iter, "{sv}", &key, &var)) {
 224                 if (g_strcmp0(key, "Address") == 0)  {
 225                         g_variant_get(var, "&s", &value);
 226                         char *old_ip6 = vconf_get_str(VCONFKEY_NETWORK_IP6);
 227
 228                         DBG("Old IPv6.Address [%s] Received new IPv6.Address [%s]", old_ip6,
 229                                                         value);
 230                         if (g_strcmp0(old_ip6, value) != 0) {
 231                                 builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 232
 233                                 if (value != NULL) {
 234                                         netconfig_set_default_ipaddress6(value);
 235                                         vconf_set_str(VCONFKEY_NETWORK_IP6, value);
 236                                         g_variant_builder_add(builder, "{sv}", "IPv6Address",
 237                                                                   g_variant_new_string(value));
 238                                 } else if (old_ip6 != NULL && strlen(old_ip6) > 0) {
 239                                         vconf_set_str(VCONFKEY_NETWORK_IP6, "");
 240                                         g_variant_builder_add(builder, "{sv}", "IPv6Address",
 241                                                                   g_variant_new_string(""));
 242                                 }
 243
 244                                 params = g_variant_new("(@a{sv})",
 245                                                                            g_variant_builder_end(builder));
 246                                 g_variant_builder_unref(builder);
 247
 248                                 netconfig_dbus_emit_signal(NULL, NETCONFIG_NETWORK_PATH,
 249                                                    NETCONFIG_NETWORK_INTERFACE, "NetworkConfigChanged",
 250                                                    params);
 251                         }
 252                         free(old_ip6);
 253                 }
 254         }
 255 }
 256
 257 #if defined TIZEN_DEBUG_ENABLE
 258 static int __netconfig_handle_execute_file(const char *file_path,
 259                 char *const args[], char *const envs[])
 260 {
 261         pid_t pid = 0;
 262         int status = 0;
 263         int rv = 0;
 264         errno = 0;
 265         register unsigned int index = 0;
 266         char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
 267
 268         while (args[index] != NULL) {
 269                 DBG("%s", args[index]);
 270                 index++;
 271         }
 272
 273         if (!(pid = fork())) {
 274                 DBG("pid(%d), ppid (%d)", getpid(), getppid());
 275                 DBG("Inside child, exec (%s) command", file_path);
 276
 277                 errno = 0;
 278                 if (execve(file_path, args, envs) == -1) {
 279                         DBG("Fail to execute command (%s)",
 280                                         strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER));
 281                         exit(1);
 282                 }
 283         } else if (pid > 0) {
 284                 if (waitpid(pid, &status, 0) == -1)
 285                         DBG("wait pid (%u) status (%d)", pid, status);
 286
 287                 if (WIFEXITED(status)) {
 288                         rv = WEXITSTATUS(status);
 289                         DBG("exited, status=%d", rv);
 290                 } else if (WIFSIGNALED(status)) {
 291                         DBG("killed by signal %d", WTERMSIG(status));
 292                 } else if (WIFSTOPPED(status)) {
 293                         DBG("stopped by signal %d", WSTOPSIG(status));
 294                 } else if (WIFCONTINUED(status)) {
 295                         DBG("continued");
 296                 }
 297
 298                 return rv;
 299         }
 300
 301         DBG("failed to fork(%s)",
 302                 strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER));
 303         return -EIO;
 304 }
 305
 306 static int _start_dump()
 307 {
 308         int rv = 0;
 309         gchar *path = NETWORK_LOG_DUMP_SCRIPT;
 310         char *const args[] = { NETWORK_LOG_DUMP_SCRIPT, NULL };
 311         char *const envs[] = { NULL };
 312
 313         rv = __netconfig_handle_execute_file(path, args, envs);
 314         if (rv < 0) {
 315                 ERR("Fail to execute network log dump shell");
 316                 return -EIO;
 317         }
 318         return 0;
 319 }
 320 #endif
 321
 322 static char *__supplicant_get_interface_name(const gchar *path, const gchar *interface)
 323 {
 324         GVariant *params = NULL;
 325         GVariant *reply = NULL, *var = NULL;;
 326         char *interface_name = NULL;
 327
 328         params = g_variant_new("(ss)", interface, "Ifname");
 329
 330         reply = netconfig_supplicant_invoke_dbus_method(SUPPLICANT_SERVICE,
 331                                 path, DBUS_INTERFACE_PROPERTIES, "Get", params);
 332         if (reply == NULL) {
 333                 ERR("Failed to get interface name");
 334                 return NULL;
 335         }
 336
 337         g_variant_get(reply, "(v)", &var);
 338
 339         if (g_variant_is_of_type(var, G_VARIANT_TYPE_STRING)) {
 340                 interface_name = g_variant_dup_string(var, NULL);
 341                 DBG("%s [%s]", path, interface_name);
 342         }
 343
 344         g_variant_unref(var);
 345         g_variant_unref(reply);
 346
 347         return interface_name;
 348 }
 349
 350 static void _technology_signal_cb(GDBusConnection *conn,
 351                 const gchar *name, const gchar *path, const gchar *interface,
 352                 const gchar *sig, GVariant *param, gpointer user_data)
 353 {
 354         gchar *key = NULL;
 355         GVariant *var = NULL;
 356         GVariantIter *iter = NULL;
 357         const gchar *svalue = NULL;
 358         gboolean bvalue = FALSE;
 359
 360         DBG("%s %s", path, sig);
 361
 362         if (param == NULL)
 363                 return;
 364
 365         if (g_str_has_prefix(path, CONNMAN_WIFI_TECHNOLOGY_PREFIX) != TRUE)
 366                 return;
 367
 368         if (g_strcmp0(sig, CONNMAN_SIGNAL_DEVICE_CHANGED) == 0) {
 369                 g_variant_get(param, "(a{sv})", &iter);
 370                 while (g_variant_iter_loop(iter, "{sv}", &key, &var)) {
 371                         if (g_strcmp0(key, "Ifname") == 0) {
 372                                 svalue = g_variant_get_string(var, NULL);
 373                                 DBG("Ifname [%s]", svalue);
 374                         } else if (g_strcmp0(key, "Powered") == 0) {
 375                                 bvalue = g_variant_get_boolean(var);
 376                                 DBG("Powered [%d]", bvalue);
 377                                 wifi_state_update_power_state(svalue, bvalue);
 378                         } else if (g_strcmp0(key, "Connected") == 0) {
 379                                 bvalue = g_variant_get_boolean(var);
 380                                 DBG("Connected [%d]", bvalue);
 381                                 wifi_state_set_connected(svalue, bvalue);
 382                                 if (bvalue == TRUE)
 383                                         wifi_state_set_technology_state(svalue, NETCONFIG_WIFI_TECH_CONNECTED);
 384                                 else
 385                                         wifi_state_set_technology_state(svalue, NETCONFIG_WIFI_TECH_POWERED);
 386                         }
 387                 }
 388                 g_variant_iter_free(iter);
 389         } else if (g_strcmp0(sig, CONNMAN_SIGNAL_DEVICE_DETECTED) == 0) {
 390                 wifi_state_update_device_list();
 391         }
 392 }
 393
 394 static void _service_signal_cb(GDBusConnection *conn,
 395                 const gchar *name, const gchar *path,
 396                 const gchar *interface, const gchar *sig,
 397                 GVariant *param, gpointer user_data)
 398 {
 399         gchar *sigvalue = NULL;
 400         gchar *property;
 401         GVariant *variant = NULL, *var;
 402         GVariantIter *iter;
 403         const gchar *value = NULL;
 404         struct sock_data *sd = NULL;
 405         gchar *pf = NULL;
 406         int idx = 0;
 407         const char *interface_name = NULL;
 408
 409         if (path == NULL || param == NULL)
 410                 goto done;
 411
 412         g_variant_get(param, "(sv)", &sigvalue, &variant);
 413         if (sigvalue == NULL)
 414                 goto done;
 415
 416         if (g_strcmp0(sig, CONNMAN_SIGNAL_PROPERTY_CHANGED) != 0)
 417                 goto done;
 418
 419         interface_name = netconfig_get_ifname(path);
 420
 421         if (g_strcmp0(sigvalue, "State") == 0) {
 422                 g_variant_get(variant, "s", &property);
 423
 424                 DBG("[%s] %s", property, path);
 425
 426                 if (netconfig_is_wifi_profile(path) == TRUE) {
 427                         int wifi_state = 0;
 428
 429                         netconfig_vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_state);
 430                         if (wifi_state == VCONFKEY_WIFI_OFF) {
 431                                 g_free(property);
 432                                 goto done;
 433                         }
 434
 435                         if (g_strcmp0(property, "ready") == 0 || g_strcmp0(property, "online") == 0) {
 436                                 netconfig_update_default_profile();
 437
 438                                 wifi_state_set_service_state(interface_name, NETCONFIG_WIFI_CONNECTED);
 439
 440                         } else if (g_strcmp0(property, "failure") == 0 ||
 441                                 g_strcmp0(property, "disconnect") == 0 || g_strcmp0(property, "idle") == 0) {
 442                                 if (g_strcmp0(property, "failure") == 0)
 443                                         wifi_state_set_service_state(interface_name, NETCONFIG_WIFI_FAILURE);
 444                                 else
 445                                         wifi_state_set_service_state(interface_name, NETCONFIG_WIFI_IDLE);
 446
 447                                 if (g_strcmp0(path, netconfig_get_default_profile()) != 0) {
 448                                         g_free(property);
 449                                         goto done;
 450                                 }
 451
 452                                 netconfig_update_default_profile();
 453
 454                         } else if (g_strcmp0(property, "association") == 0 || g_strcmp0(property, "configuration") == 0) {
 455                                 if (g_strcmp0(property, "association") == 0)
 456                                         wifi_state_set_service_state(interface_name, NETCONFIG_WIFI_ASSOCIATION);
 457                                 else
 458                                         wifi_state_set_service_state(interface_name, NETCONFIG_WIFI_CONFIGURATION);
 459
 460                                 if (g_strcmp0(path, netconfig_get_default_profile()) != 0) {
 461                                         g_free(property);
 462                                         goto done;
 463                                 }
 464
 465                                 netconfig_update_default_profile();
 466
 467                         }
 468                 } else {
 469                         if (g_strcmp0(property, "ready") == 0 || g_strcmp0(property, "online") == 0) {
 470                                 netconfig_update_default_profile();
 471
 472                                 if (netconfig_is_cellular_profile(netconfig_get_default_profile())) {
 473                                         pf = netconfig_get_connected_cellular_internet_ipv6only_profile(NULL);
 474                                         if (pf) {
 475                                                 g_free(pf);
 476
 477                                                 /* Enable clatd if it is not in running state */
 478                                                 DBG("Connected to ipv6 only cellular, enable clatd");
 479                                                 netconfig_clatd_enable();
 480                                         }
 481                                 }
 482
 483                                 if (netconfig_is_cellular_profile(path) && netconfig_is_cellular_internet_profile(path))
 484                                         cellular_state_set_service_state(NETCONFIG_CELLULAR_ONLINE);
 485
 486                         } else if (g_strcmp0(property, "failure") == 0 ||
 487                                 g_strcmp0(property, "disconnect") == 0 || g_strcmp0(property, "idle") == 0) {
 488                                 if (netconfig_get_default_profile() == NULL) {
 489                                         g_free(property);
 490                                         goto done;
 491                                 }
 492
 493                                 if (netconfig_is_cellular_profile(path) && netconfig_is_cellular_internet_profile(path)) {
 494                                         cellular_state_set_service_state(NETCONFIG_CELLULAR_IDLE);
 495
 496                                         /* Disable clatd if it is in running state */
 497                                         DBG("disable clatd");
 498                                         netconfig_clatd_disable();
 499                                 }
 500
 501                                 if (g_strcmp0(path, netconfig_get_default_profile()) != 0) {
 502                                         g_free(property);
 503                                         goto done;
 504                                 }
 505
 506                                 netconfig_update_default_profile();
 507                         } else if (g_strcmp0(property, "association") == 0 || g_strcmp0(property, "configuration") == 0) {
 508                                 if (netconfig_get_default_profile() == NULL) {
 509                                         g_free(property);
 510                                         goto done;
 511                                 }
 512
 513                                 if (netconfig_is_cellular_profile(path) && netconfig_is_cellular_internet_profile(path))
 514                                         cellular_state_set_service_state(NETCONFIG_CELLULAR_CONNECTING);
 515
 516                                 if (g_strcmp0(path, netconfig_get_default_profile()) != 0) {
 517                                         g_free(property);
 518                                         goto done;
 519                                 }
 520
 521                                 netconfig_update_default_profile();
 522                         }
 523                 }
 524
 525                 if (netconfig_is_wifi_profile(path) || netconfig_is_ethernet_profile(path)) {
 526                         if (g_strcmp0(property, "ready") == 0) {
 527                                 for (idx = 0; idx < MAX_SOCKET_OPEN_RETRY; idx++) {
 528                                         sd = start_ip_conflict_mon();
 529                                         if (sd != NULL)
 530                                                 break;
 531                                 }
 532                         } else if (g_strcmp0(property, "online") == 0) {
 533                                 // do nothing
 534                         } else {
 535                                 stop_ip_conflict_mon();
 536                         }
 537                 }
 538
 539                 g_free(property);
 540         } else if (g_strcmp0(sigvalue, "Proxy") == 0) {
 541                 if (g_strcmp0(path, netconfig_get_default_profile()) != 0)
 542                         goto done;
 543
 544                 if (!g_variant_is_of_type(variant, G_VARIANT_TYPE_ARRAY))
 545                         goto done;
 546
 547                 g_variant_get(variant, "a{sv}", &iter);
 548                 while (g_variant_iter_loop(iter, "{sv}", &property, &var)) {
 549                         GVariantBuilder *builder;
 550                         GVariant *sig_params;
 551                         if (g_strcmp0(property, "Servers") == 0) {
 552                                 GVariantIter *iter_sub = NULL;
 553
 554                                 g_variant_get(var, "as", &iter_sub);
 555                                 g_variant_iter_loop(iter_sub, "s", &value);
 556                                 g_variant_iter_free(iter_sub);
 557
 558                                 DBG("Proxy - [%s]", value);
 559                                 if (g_strcmp0(value, netconfig_get_default_proxy()) != 0) {
 560                                         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 561
 562                                         netconfig_set_default_proxy(value);
 563                                         vconf_set_str(VCONFKEY_NETWORK_PROXY, value);
 564
 565                                         g_variant_builder_add(builder, "{sv}", "ProxyAddress",
 566                                                                         g_variant_new_string(value));
 567
 568                                         sig_params = g_variant_new("(@a{sv})",
 569                                                                         g_variant_builder_end(builder));
 570                                         g_variant_builder_unref(builder);
 571
 572                                         netconfig_dbus_emit_signal(NULL, NETCONFIG_NETWORK_PATH,
 573                                                            NETCONFIG_NETWORK_INTERFACE, "NetworkConfigChanged",
 574                                                            sig_params);
 575                                 }
 576
 577                                 g_free(property);
 578                                 g_variant_unref(var);
 579                                 break;
 580                         } else if (g_strcmp0(property, "Method") == 0) {
 581                                 value = g_variant_get_string(var, NULL);
 582                                 DBG("Method - [%s]", value);
 583
 584                                 if (g_strcmp0(value, "direct") == 0) {
 585                                         if (g_strcmp0("", netconfig_get_default_proxy()) != 0) {
 586                                                 builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 587
 588                                                 netconfig_set_default_proxy("");
 589                                                 vconf_set_str(VCONFKEY_NETWORK_PROXY, "");
 590
 591                                                 g_variant_builder_add(builder, "{sv}", "ProxyAddress",
 592                                                                         g_variant_new_string(""));
 593
 594                                                 sig_params = g_variant_new("(@a{sv})",
 595                                                                         g_variant_builder_end(builder));
 596                                                 g_variant_builder_unref(builder);
 597
 598                                                 netconfig_dbus_emit_signal(NULL, NETCONFIG_NETWORK_PATH,
 599                                                                    NETCONFIG_NETWORK_INTERFACE,
 600                                                                    "NetworkConfigChanged", sig_params);
 601                                         }
 602                                 }
 603
 604                                 g_free(property);
 605                                 g_variant_unref(var);
 606                                 break;
 607                         }
 608                 }
 609
 610                 g_variant_iter_free(iter);
 611         } else if (g_strcmp0(sigvalue, "IPv4") == 0) {
 612                 if (g_strcmp0(path, netconfig_get_default_profile()) != 0)
 613                         goto done;
 614
 615                 __netconfig_extract_ipv4_signal_data(variant, path);
 616         } else if (g_strcmp0(sigvalue, "IPv6") == 0) {
 617                 if (g_strcmp0(path, netconfig_get_default_profile()) != 0)
 618                         goto done;
 619
 620                 __netconfig_extract_ipv6_signal_data(variant, path);
 621         } else if (g_strcmp0(sigvalue, "Error") == 0) {
 622                 g_variant_get(variant, "s", &property);
 623                 INFO("[%s] Property : %s", sigvalue, property);
 624 #if defined TIZEN_DEBUG_ENABLE
 625                 if (g_strcmp0(property, "dhcp-failed") == 0
 626                         || g_strcmp0(property, "connect-failed") == 0
 627                         || g_strcmp0(property, "login-failed") == 0
 628                         || g_strcmp0(property, "auth-failed") == 0
 629                         || g_strcmp0(property, "invalid-key") == 0) {
 630
 631                         INFO("start dump");
 632                         _start_dump();
 633                 }
 634 #endif
 635                 g_free(property);
 636         }
 637 done:
 638         g_free(sigvalue);
 639
 640         if (variant)
 641                 g_variant_unref(variant);
 642
 643         return;
 644 }
 645
 646 static void _dbus_name_changed_cb(GDBusConnection *conn,
 647                 const gchar *Name, const gchar *path, const gchar *interface,
 648                 const gchar *sig, GVariant *param, gpointer user_data)
 649 {
 650         gchar *name = NULL;
 651         gchar *old = NULL;
 652         gchar *new = NULL;
 653
 654         if (param == NULL)
 655                 return;
 656
 657         g_variant_get(param, "(sss)", &name, &old, &new);
 658
 659         if (g_strcmp0(name, CONNMAN_SERVICE) == 0 && *new == '\0') {
 660                 DBG("ConnMan destroyed: name %s, old %s, new %s", name, old, new);
 661
 662                 connman_register_agent();
 663         } else if (g_strcmp0(name, CLATD_SERVICE) == 0 && *new == '\0') {
 664                 DBG("Clat destroyed: name %s, old %s, new %s", name, old, new);
 665
 666                 /* If clatd is terminated unexpectedly, reset and enable clat service. */
 667                 if (NETCONFIG_CELLULAR_ONLINE == cellular_state_get_service_state())
 668                         netconfig_clatd_reset();
 669         }
 670         g_free(name);
 671         g_free(old);
 672         g_free(new);
 673
 674         return;
 675 }
 676
 677 static void _scan_changed_cb(GDBusConnection *conn,
 678                 const gchar *name, const gchar *path, const gchar *interface,
 679                 const gchar *sig, GVariant *param, gpointer user_data)
 680 {
 681         const char *key = NULL;
 682         GVariant *var;
 683         gboolean value = false;
 684
 685         if (g_strcmp0(sig, SIGNAL_SCAN_CHANGED) == 0) {
 686                 g_variant_get(param, "(sv)", &key, &var);
 687
 688                 if (g_strcmp0(key, "scan_started") == 0)
 689                         value = true;
 690                 else if (g_strcmp0(key, "scan_done") == 0)
 691                         value = false;
 692
 693                 DBG("Scan changed [%s]", (value == true) ? "Started" : "Done");
 694                 netconfig_battery_update_wifi_scan(value);
 695
 696                 if (var != NULL)
 697                         g_variant_unref(var);
 698         }
 699 }
 700
 701 static void _supplicant_interface_removed(GDBusConnection *conn,
 702                 const gchar *name, const gchar *path, const gchar *interface,
 703                 const gchar *sig, GVariant *param, gpointer user_data)
 704 {
 705         char *interface_name = NULL;
 706
 707         DBG("Interface removed handling!");
 708
 709         interface_name = __supplicant_get_interface_name(path, interface);
 710         if (interface_name == NULL)
 711                 return;
 712
 713         if (netconfig_wifi_bssidscan_get_mode(interface_name) == TRUE)
 714                 netconfig_wifi_bssid_signal_scanaborted(interface_name);
 715
 716         g_free(interface_name);
 717         return;
 718 }
 719
 720 static void _supplicant_properties_changed(GDBusConnection *conn,
 721                 const gchar *name, const gchar *path, const gchar *interface,
 722                 const gchar *sig, GVariant *param, gpointer user_data)
 723 {
 724         DBG("Properties changed handling!");
 725         gchar *key = NULL;
 726         const gchar *state = NULL;
 727         GVariantIter *iter = NULL;
 728         GVariant *variant = NULL;
 729         gboolean scanning = FALSE;
 730         char *interface_name = NULL;
 731
 732         if (param == NULL)
 733                 return;
 734
 735         interface_name = __supplicant_get_interface_name(path, interface);
 736         if (interface_name == NULL)
 737                 return;
 738
 739         g_variant_get(param, "(a{sv})", &iter);
 740         while (g_variant_iter_loop(iter, "{sv}", &key, &variant)) {
 741                 if (g_strcmp0(key, "Scanning") == 0) {
 742                         scanning = g_variant_get_boolean(variant);
 743                         DBG("setting scanning %s", scanning ? "TRUE" : "FALSE");
 744                         if (scanning == TRUE)
 745                                 netconfig_wifi_scan_set_scanning(interface_name, TRUE);
 746                         else
 747                                 netconfig_wifi_scan_set_scanning(interface_name, FALSE);
 748
 749                         g_variant_unref(variant);
 750                         g_free(key);
 751                         variant = NULL;
 752                         key = NULL;
 753                         break;
 754                 } else if (g_strcmp0(key, "State") == 0) {
 755                         state = g_variant_get_string(variant, NULL);
 756                         if (state != NULL)
 757                                 DBG("Supplicant state : %s", state);
 758
 759                         g_variant_unref(variant);
 760                         g_free(key);
 761                         variant = NULL;
 762                         key = NULL;
 763                         break;
 764                 } else if (g_strcmp0(key, "DisconnectReason") == 0) {
 765                         int reason = g_variant_get_int32(variant);
 766                         DBG("Supplicant DisconnReason : %d", reason);
 767
 768                         g_variant_unref(variant);
 769                         g_free(key);
 770                         variant = NULL;
 771                         key = NULL;
 772                         break;
 773                 } else {
 774                         gchar *value;
 775                         value = g_variant_print(variant, TRUE);
 776                         DBG("Supplicant %s : %s", key, value);
 777
 778                         g_free(value);
 779                 }
 780         }
 781
 782         g_variant_iter_free(iter);
 783         g_free(interface_name);
 784         return;
 785 }
 786
 787 static void _supplicant_bss_added(GDBusConnection *conn,
 788                 const gchar *name, const gchar *path, const gchar *interface,
 789                 const gchar *sig, GVariant *param, gpointer user_data)
 790 {
 791         DBG("BSS added handling!");
 792         wifi_state_set_bss_found(TRUE);
 793
 794         return;
 795 }
 796
 797 static void _supplicant_scan_done(GDBusConnection *conn,
 798                 const gchar *name, const gchar *path, const gchar *interface,
 799                 const gchar *sig, GVariant *param, gpointer user_data)
 800 {
 801         char *interface_name = NULL;
 802
 803         DBG("Scan Done handling!");
 804
 805         interface_name = __supplicant_get_interface_name(path, interface);
 806         if (interface_name == NULL)
 807                 return;
 808
 809         netconfig_wifi_scan_set_scanning(interface_name, FALSE);
 810
 811         if (netconfig_wifi_bssidscan_get_mode(interface_name) == TRUE) {
 812                 DBG("%s bssid scan done!", interface_name);
 813                 netconfig_wifi_bssid_signal_scandone(interface_name);
 814                 if (wifi_state_get_technology_state(interface_name)
 815                                 < NETCONFIG_WIFI_TECH_POWERED) {
 816                         g_free(interface_name);
 817                         return;
 818                 }
 819         }
 820
 821         if (netconfig_wifi_bgscan_get_mode(interface_name) == TRUE) {
 822                 DBG("%s bgscan done!", interface_name);
 823                 if (wifi_state_get_technology_state(interface_name)
 824                                 >= NETCONFIG_WIFI_TECH_POWERED) {
 825                         netconfig_wifi_bgscan_start(interface_name, FALSE);
 826                 }
 827
 828                 wifi_start_timer_network_notification(interface_name);
 829         }
 830
 831         g_free(interface_name);
 832         return;
 833 }
 834
 835 static void _supplicant_driver_hanged(GDBusConnection *conn,
 836                 const gchar *name, const gchar *path, const gchar *interface,
 837                 const gchar *sig, GVariant *param, gpointer user_data)
 838 {
 839         char *interface_name = NULL;
 840
 841         DBG("Driver Hanged handling!");
 842         ERR("Critical. Wi-Fi firmware crashed");
 843
 844 #if !defined TIZEN_WEARABLE
 845         netconfig_send_message_to_net_popup("Wi-Fi Error",
 846                 "Wi-Fi Driver Hanged. Please get log dump and report", "popup", NULL);
 847 #endif
 848
 849         interface_name = __supplicant_get_interface_name(path, interface);
 850         if (interface_name == NULL)
 851                 return;
 852
 853         wifi_power_recover_firmware(interface_name);
 854
 855         g_free(interface_name);
 856         return;
 857
 858 }
 859
 860 static void _supplicant_session_overlapped(GDBusConnection *conn,
 861                 const gchar *name, const gchar *path, const gchar *interface,
 862                 const gchar *sig, GVariant *param, gpointer user_data)
 863 {
 864         DBG("Driver session overlapped handling!");
 865         ERR("WPS PBC SESSION OVERLAPPED");
 866 #if defined TIZEN_WEARABLE
 867         return;
 868 #else
 869         netconfig_send_message_to_net_popup("WPS Error",
 870                                         "wps session overlapped", "popup", NULL);
 871 #endif
 872 }
 873
 874 #if defined TIZEN_DEBUG_ENABLE
 875 static void __netconfig_dumpservice_handler(GDBusConnection *conn,
 876                 const gchar *name, const gchar *path, const gchar *interface,
 877                 const gchar *sig, GVariant *param, gpointer user_data)
 878 {
 879         int mode;
 880         gchar *signal_path = NULL;
 881
 882         if (param == NULL)
 883                 return;
 884
 885         g_variant_get(param, "(is)", &mode, &signal_path);
 886         DBG("Path: %s and mode: %d", signal_path, mode);
 887
 888         netconfig_dump_log(signal_path);
 889         if (signal_path)
 890                 g_free(signal_path);
 891
 892         return;
 893 }
 894 #endif
 895
 896 static void _supplicant_tdls_connected(GDBusConnection *conn,
 897                 const gchar *name, const gchar *path, const gchar *interface,
 898                 const gchar *sig, GVariant *param, gpointer user_data)
 899 {
 900         char *interface_name = NULL;
 901
 902         DBG("Received TDLS Connected Signal");
 903
 904         interface_name = __supplicant_get_interface_name(path, interface);
 905         if (interface_name == NULL)
 906                 return;
 907
 908         netconfig_wifi_tdls_connected_event(interface_name, param);
 909
 910         g_free(interface_name);
 911         return;
 912 }
 913
 914 static void _supplicant_tdls_disconnected(GDBusConnection *conn,
 915                 const gchar *name, const gchar *path, const gchar *interface,
 916                 const gchar *sig, GVariant *param, gpointer user_data)
 917 {
 918         char *interface_name = NULL;
 919
 920         DBG("Received TDLS Disconnected Signal");
 921
 922         interface_name = __supplicant_get_interface_name(path, interface);
 923         if (interface_name == NULL)
 924                 return;
 925
 926         netconfig_wifi_tdls_disconnected_event(interface_name, param);
 927
 928         g_free(interface_name);
 929         return;
 930 }
 931
 932 static void _supplicant_tdls_peer_found(GDBusConnection *conn,
 933                 const gchar *name, const gchar *path, const gchar *interface,
 934                 const gchar *sig, GVariant *param, gpointer user_data)
 935 {
 936         char *interface_name = NULL;
 937
 938         DBG("Received TDLS Peer Found Signal");
 939
 940         interface_name = __supplicant_get_interface_name(path, interface);
 941         if (interface_name == NULL)
 942                 return;
 943
 944         netconfig_wifi_tdls_peer_found_event(interface_name, param);
 945
 946         g_free(interface_name);
 947         return;
 948 }
 949
 950 static void _supplicant_dpp_auth_success(GDBusConnection *conn,
 951                 const gchar *name, const gchar *path, const gchar *interface,
 952                 const gchar *sig, GVariant *param, gpointer user_data)
 953 {
 954         DBG("Received DPP Auth Success Signal");
 955         netconfig_wifi_dpp_auth_success_event(param);
 956         return;
 957 }
 958
 959 static void _supplicant_dpp_auth_failed(GDBusConnection *conn,
 960                 const gchar *name, const gchar *path, const gchar *interface,
 961                 const gchar *sig, GVariant *param, gpointer user_data)
 962 {
 963         DBG("Received DPP Auth Failed Signal");
 964         netconfig_wifi_dpp_auth_failed_event(param);
 965         return;
 966 }
 967
 968 static void _supplicant_dpp_not_compatible(GDBusConnection *conn,
 969                 const gchar *name, const gchar *path, const gchar *interface,
 970                 const gchar *sig, GVariant *param, gpointer user_data)
 971 {
 972         DBG("Received DPP Not Compatible Signal");
 973         netconfig_wifi_dpp_not_compatible_event(param);
 974         return;
 975 }
 976
 977 static void _supplicant_dpp_conf_failed(GDBusConnection *conn,
 978                 const gchar *name, const gchar *path, const gchar *interface,
 979                 const gchar *sig, GVariant *param, gpointer user_data)
 980 {
 981         DBG("Received DPP Conf Failed Signal");
 982         netconfig_wifi_dpp_conf_failed_event(param);
 983         return;
 984 }
 985
 986 static void _supplicant_dpp_scan_peer_qr(GDBusConnection *conn,
 987                 const gchar *name, const gchar *path, const gchar *interface,
 988                 const gchar *sig, GVariant *param, gpointer user_data)
 989 {
 990         DBG("Received DPP Scan Peer QR Signal");
 991         netconfig_wifi_dpp_scan_peer_qr_event(param);
 992         return;
 993 }
 994
 995 static void _supplicant_dpp_network_id(GDBusConnection *conn,
 996                 const gchar *name, const gchar *path, const gchar *interface,
 997                 const gchar *sig, GVariant *param, gpointer user_data)
 998 {
 999         DBG("Received DPP Network Id Signal");
1000         netconfig_wifi_dpp_network_id_event(param);
1001         return;
1002 }
1003
1004 static void _supplicant_dpp_conf_sent(GDBusConnection *conn,
1005                 const gchar *name, const gchar *path, const gchar *interface,
1006                 const gchar *sig, GVariant *param, gpointer user_data)
1007 {
1008         DBG("Received DPP Conf Sent Signal");
1009         netconfig_wifi_dpp_conf_sent_event(param);
1010         return;
1011 }
1012
1013 static void _supplicant_dpp_conf_received(GDBusConnection *conn,
1014                 const gchar *name, const gchar *path, const gchar *interface,
1015                 const gchar *sig, GVariant *param, gpointer user_data)
1016 {
1017         DBG("Received DPP Conf Received Signal");
1018         netconfig_wifi_dpp_conf_received_event(param);
1019         return;
1020 }
1021
1022 static void _supplicant_dpp_conf_obj(GDBusConnection *conn,
1023                 const gchar *name, const gchar *path, const gchar *interface,
1024                 const gchar *sig, GVariant *param, gpointer user_data)
1025 {
1026         char *interface_name = NULL;
1027
1028         DBG("Received DPP Conf Obj Signal");
1029
1030         interface_name = __supplicant_get_interface_name(path, interface);
1031         if (interface_name == NULL)
1032                 return;
1033
1034         netconfig_wifi_dpp_conf_obj_event(interface_name, param);
1035
1036         g_free(interface_name);
1037         return;
1038 }
1039
1040 static void _supplicant_wifi_wps_connected(const char *interface_name, GVariant *param)
1041 {
1042         gchar *key;
1043         char ssid[32] = {0, };
1044         gchar *name;
1045         GVariantIter *iter;
1046         GVariant *variant;
1047         int config_error = 0;
1048         int error_indication = 0;
1049         gsize ssid_len = 0;
1050
1051         if (param == NULL) {
1052                 ERR("Param is NULL");
1053                 return;
1054         }
1055
1056         g_variant_get(param, "(sa{sv})", &name, &iter);
1057         INFO("wps Result: %s", name);
1058         while (g_variant_iter_loop(iter, "{sv}", &key, &variant)) {
1059                 INFO("wps Key is %s", key);
1060                 if (g_strcmp0(key, "SSID") == 0) {
1061                         const char *t_key = NULL;
1062                         t_key = g_variant_get_fixed_array(variant, &ssid_len, sizeof(guchar));
1063                         INFO("wps ssid_len is %zd ", ssid_len);
1064                         if (t_key == NULL) {
1065                                 g_free(key);
1066                                 g_variant_unref(variant);
1067                                 ERR("WPS PBC Connection Failed");
1068                                 goto error;
1069                         }
1070                         if (ssid_len > 0 && ssid_len <= 32) {
1071                                 memcpy(ssid, t_key, ssid_len);
1072                         } else {
1073                                 memset(ssid, 0, sizeof(ssid));
1074                                 ssid_len = 0;
1075                         }
1076                         INFO("WPS PBC Connection completed with AP %s", ssid);
1077                         netconfig_wifi_notify_wps_completed(interface_name,
1078                                 ssid, ssid_len);
1079                 }
1080         }
1081
1082         g_variant_iter_free(iter);
1083         g_free(name);
1084         return;
1085
1086 error:
1087         g_variant_iter_free(iter);
1088         g_free(name);
1089         error_indication = WPS_EI_OPERATION_FAILED;
1090         config_error = WPS_CFG_NO_ERROR;
1091         ERR("Error Occured! Notifying Fail Event");
1092         netconfig_wifi_notify_wps_fail_event(interface_name,
1093                 config_error, error_indication);
1094
1095 }
1096
1097 static void _supplicant_wifi_wps_event(const char *interface_name, GVariant *param)
1098 {
1099         gchar *key;
1100         gchar *name;
1101         GVariantIter *iter;
1102         GVariant *variant;
1103         gint32 config_error = 0;
1104         gint32 error_indication = 0;
1105
1106         if (param == NULL) {
1107                 ERR("Param is NULL");
1108                 return;
1109         }
1110
1111         g_variant_get(param, "(sa{sv})", &name, &iter);
1112         INFO("Event Result: %s", name);
1113         if (g_strcmp0(name, "fail") == 0) {
1114                 while (g_variant_iter_loop(iter, "{sv}", &key, &variant)) {
1115                         if (key == NULL)
1116                                 goto error;
1117                         INFO("Key is %s", key);
1118                         if (g_strcmp0(key, "config_error") == 0) {
1119                                 config_error = g_variant_get_int32(variant);
1120                                 ERR("Config Error %d", config_error);
1121                         } else if (g_strcmp0(key, "error_indication") == 0) {
1122                                 error_indication = g_variant_get_int32(variant);
1123                                 ERR("Error Indication %d", error_indication);
1124                         }
1125                 }
1126                 netconfig_wifi_notify_wps_fail_event(interface_name,
1127                         config_error, error_indication);
1128         }
1129
1130         g_variant_iter_free(iter);
1131         g_free(name);
1132         return;
1133
1134 error:
1135         g_variant_iter_free(iter);
1136         g_free(name);
1137         error_indication = WPS_EI_OPERATION_FAILED;
1138         config_error = WPS_CFG_NO_ERROR;
1139         ERR("Error Occured! Notifying Fail Event");
1140         netconfig_wifi_notify_wps_fail_event(interface_name,
1141                 config_error, error_indication);
1142 }
1143
1144 static void _find_service_and_set_passphrase(char *ssid, char *key)
1145 {
1146         GString *str;
1147         GVariant *reply = NULL;
1148         int i, j, ssid_len;
1149         char *service_path;
1150         char *dev_mac_addr;
1151         char ident[13];
1152         gchar *enc_passphrase;
1153
1154         ssid_len = strlen(ssid);
1155
1156         str = g_string_sized_new((ssid_len * 2) + 55);
1157         if (!str)
1158                 return;
1159
1160         dev_mac_addr = vconf_get_str(VCONFKEY_WIFI_BSSID_ADDRESS);
1161         if (!dev_mac_addr) {
1162                 ERR("Failed to get mac address from vconf key");
1163                 g_string_free(str, TRUE);
1164                 return;
1165         }
1166
1167         j = 0;
1168         for (i = 0; dev_mac_addr[i]; i++) {
1169                 if (dev_mac_addr[i] != ':')
1170                         ident[j++] = dev_mac_addr[i];
1171         }
1172         ident[j] = '\0';
1173
1174         g_string_append_printf(str, "%s%s_", CONNMAN_WIFI_SERVICE_PROFILE_PREFIX,
1175                                                    ident);
1176         free(dev_mac_addr);
1177
1178         for (i = 0; i < ssid_len; i++) {
1179                 if (ssid[i] != '"')
1180                         g_string_append_printf(str, "%02x", ssid[i]);
1181         }
1182
1183         g_string_append_printf(str, "_managed_psk");
1184
1185         service_path = g_string_free(str, FALSE);
1186
1187         enc_passphrase = _netconfig_encrypt_passphrase(key);
1188         if (!enc_passphrase) {
1189                 ERR("Failed to encrypt passphrase");
1190                 g_free(service_path);
1191                 return;
1192         }
1193
1194         INFO("wps service_path %s Passphrase %s", service_path, enc_passphrase);
1195
1196         reply = netconfig_invoke_dbus_method(CONNMAN_SERVICE, service_path,
1197                                          CONNMAN_SERVICE_INTERFACE, "SetProperty",
1198                                          g_variant_new("(sv)", "Passphrase",
1199                                                                    g_variant_new_string(enc_passphrase)));
1200         if (reply != NULL)
1201                 g_variant_unref(reply);
1202         else
1203                 ERR("Failed to set passphrase");
1204
1205         g_free(service_path);
1206
1207         return;
1208 }
1209
1210 static void _supplicant_wifi_wps_credentials(const char *interface_name, GVariant *param)
1211 {
1212         gchar *key;
1213         char ssid[32] = {0, };
1214         char wps_key[100] = {0, };
1215         GVariantIter *iter;
1216         GVariant *variant;
1217         int config_error = 0;
1218         int error_indication = 0;
1219         gsize ssid_len = 0;
1220         char *key_mgmt = NULL;
1221
1222         if (param == NULL) {
1223                 ERR("Param is NULL");
1224                 return;
1225         }
1226
1227         g_variant_get(param, "(a{sv})", &iter);
1228         while (g_variant_iter_loop(iter, "{sv}", &key, &variant)) {
1229                 if (key == NULL)
1230                         goto error;
1231                 INFO("wps Key is %s", key);
1232                 if (g_strcmp0(key, "Key") == 0) {
1233                         gsize key_len = 0;
1234                         const char *t_key = NULL;
1235                         key_len = g_variant_get_size(variant);
1236
1237                         INFO("wps password len %zd ", key_len);
1238                         if (key_len > 0) {
1239                                 t_key = g_variant_get_fixed_array(variant, &key_len,
1240                                                   sizeof(guchar));
1241                                 if (!t_key) {
1242                                         g_free(key);
1243                                         g_variant_unref(variant);
1244                                         goto error;
1245                                 }
1246                                 strncpy(wps_key, t_key, key_len);
1247                                 wps_key[key_len] = '\0';
1248                                 INFO("WPS Key in process credentials %s", wps_key);
1249                         } else
1250                                 SLOGI("WPS AP Security ->Open");
1251                 } else if (g_strcmp0(key, "SSID") == 0) {
1252                         const char *t_key = NULL;
1253                         t_key = g_variant_get_fixed_array(variant, &ssid_len,
1254                                                   sizeof(guchar));
1255                         INFO("wps ssid_len is %zd ", ssid_len);
1256                         if (!t_key) {
1257                                 g_free(key);
1258                                 g_variant_unref(variant);
1259                                 goto error;
1260                         }
1261                         if (ssid_len > 0 && ssid_len <= 32) {
1262                                 memcpy(ssid, t_key, ssid_len);
1263                         } else {
1264                                 memset(ssid, 0, sizeof(ssid));
1265                                 ssid_len = 0;
1266                         }
1267                         INFO("SSID in process credentials %s", ssid);
1268                 } else if (g_strcmp0(key, "AuthType") == 0) {
1269                         gchar *auth_type;
1270                         GVariantIter *var_iter;
1271                         g_variant_get(variant, "as", &var_iter);
1272                         while (g_variant_iter_loop(var_iter, "s", &auth_type)) {
1273                                 INFO("wps auth_type %s", auth_type);
1274                                 if (g_strcmp0(auth_type, "wpa-psk") == 0 ||
1275                                         g_strcmp0(auth_type, "wpa2-psk") == 0)
1276                                         key_mgmt = "psk";
1277                                 else if (g_strcmp0(auth_type, "open") == 0)
1278                                         key_mgmt = "none";
1279                         }
1280                         g_variant_iter_free(var_iter);
1281                 } else if (g_strcmp0(key, "EncrType") == 0) {
1282                         gchar *encr_type;
1283                         GVariantIter *var_iter;
1284                         g_variant_get(variant, "as", &var_iter);
1285                         while (g_variant_iter_loop(var_iter, "s", &encr_type))
1286                                 INFO("wps encr_type %s", encr_type);
1287                         g_variant_iter_free(var_iter);
1288                 } else if (g_strcmp0(key, "BSSID") == 0) {
1289                         const guchar *bssid;
1290                         gsize bssid_len;
1291                         bssid = g_variant_get_fixed_array(variant, &bssid_len,
1292                                                                 sizeof(guchar));
1293                         if (bssid && bssid_len == 6)
1294                                 INFO("wps BSSID %2x:%2x:%2x:%2x:%2x:%2x", bssid[0], bssid[1],
1295                                          bssid[2], bssid[3], bssid[4], bssid[5]);
1296                 }
1297         }
1298
1299         g_variant_iter_free(iter);
1300
1301         if (g_strcmp0(key_mgmt, "psk") == 0)
1302                 _find_service_and_set_passphrase(ssid, wps_key);
1303
1304         netconfig_wifi_notify_wps_credentials(interface_name, ssid, ssid_len, wps_key);
1305         return;
1306
1307 error:
1308         g_variant_iter_free(iter);
1309         error_indication = WPS_EI_OPERATION_FAILED;
1310         config_error = WPS_CFG_NO_ERROR;
1311         ERR("Error Occured! Notifying Fail Event");
1312         netconfig_wifi_notify_wps_fail_event(interface_name, config_error, error_indication);
1313 }
1314
1315 static void __netconfig_wps_signal_filter_handler(GDBusConnection *conn,
1316                 const gchar *name, const gchar *path, const gchar *interface,
1317                 const gchar *sig, GVariant *param, gpointer user_data)
1318 {
1319         char *interface_name = NULL;
1320
1321         interface_name = __supplicant_get_interface_name(path, interface);
1322         if (interface_name == NULL)
1323                 return;
1324
1325         if (g_strcmp0(sig, SIGNAL_WPS_CREDENTIALS) == 0) {
1326                 INFO("Received wps CREDENTIALS Signal from Supplicant");
1327                 _supplicant_wifi_wps_credentials(interface_name, param);
1328         } else if (g_strcmp0(sig, SIGNAL_WPS_EVENT) == 0) {
1329                 INFO("Received wps EVENT Signal from Supplicant");
1330                 _supplicant_wifi_wps_event(interface_name, param);
1331         } else if (g_strcmp0(sig, SIGNAL_WPS_CONNECTED) == 0) {
1332                 INFO("Received WPSConnected Signal from Supplicant");
1333                 _supplicant_wifi_wps_connected(interface_name, param);
1334         }
1335
1336         g_free(interface_name);
1337         return;
1338 }
1339
1340 static void __telephony_svc_cs_changed_cb(keynode_t * node, void *data)
1341 {
1342         int telephony_svc_cs = 0;
1343
1344         if (node != NULL)
1345                 telephony_svc_cs = vconf_keynode_get_int(node);
1346         else
1347                 netconfig_vconf_get_int(VCONFKEY_TELEPHONY_SVC_CS, &telephony_svc_cs);
1348
1349         DBG("Telephony svc cs [%d]", telephony_svc_cs);
1350
1351         switch (telephony_svc_cs) {
1352         case 1:
1353                 netconfig_battery_end_dn();
1354                 break;
1355         case 2:
1356                 netconfig_battery_start_dn();
1357                 break;
1358         default:
1359                 break;
1360         }
1361 }
1362
1363 static void __telephony_rssi_changed_cb(keynode_t * node, void *data)
1364 {
1365         int rssi = 0;
1366
1367         if (node != NULL)
1368                 rssi = vconf_keynode_get_int(node);
1369         else
1370                 netconfig_vconf_get_int(VCONFKEY_TELEPHONY_RSSI, &rssi);
1371
1372         DBG("Telephony rssi [%d]", rssi);
1373
1374         netconfig_battery_update_dn_rssi(rssi);
1375 }
1376
1377 static void _notify_telephony_svc_cs(void)
1378 {
1379         int telephony_svc_cs = 0;
1380
1381         netconfig_vconf_get_int(VCONFKEY_TELEPHONY_SVC_CS, &telephony_svc_cs);
1382         DBG("Telephony svc cs [%d]", telephony_svc_cs);
1383
1384         switch (telephony_svc_cs) {
1385         case 1:
1386                 netconfig_battery_end_dn();
1387                 break;
1388         case 2:
1389                 netconfig_battery_start_dn();
1390                 break;
1391         default:
1392                 break;
1393         }
1394
1395         vconf_notify_key_changed(VCONFKEY_TELEPHONY_SVC_CS, __telephony_svc_cs_changed_cb, NULL);
1396 }
1397
1398 static void _notify_telephony_rssi(void)
1399 {
1400         int rssi = 0;
1401
1402         netconfig_vconf_get_int(VCONFKEY_TELEPHONY_RSSI, &rssi);
1403         DBG("Telephony rssi [%d]", rssi);
1404
1405         netconfig_battery_update_dn_rssi(rssi);
1406
1407         vconf_notify_key_changed(VCONFKEY_TELEPHONY_RSSI, __telephony_rssi_changed_cb, NULL);
1408 }
1409
1410 static void _ignore_telephony_svc_cs(void)
1411 {
1412         vconf_ignore_key_changed(VCONFKEY_TELEPHONY_SVC_CS, __telephony_svc_cs_changed_cb);
1413 }
1414
1415 static void _ignore_telephony_rssi(void)
1416 {
1417         vconf_ignore_key_changed(VCONFKEY_TELEPHONY_RSSI, __telephony_rssi_changed_cb);
1418 }
1419
1420 static supplicant_signal_cb supplicant_cbs[SIG_MAX] = {
1421                 _supplicant_interface_removed,
1422                 _supplicant_properties_changed,
1423                 _supplicant_bss_added,
1424                 _supplicant_scan_done,
1425                 _supplicant_driver_hanged,
1426                 _supplicant_session_overlapped,
1427                 _supplicant_tdls_connected,
1428                 _supplicant_tdls_disconnected,
1429                 _supplicant_tdls_peer_found,
1430                 _supplicant_dpp_auth_success,
1431                 _supplicant_dpp_auth_failed,
1432                 _supplicant_dpp_not_compatible,
1433                 _supplicant_dpp_conf_failed,
1434                 _supplicant_dpp_scan_peer_qr,
1435                 _supplicant_dpp_network_id,
1436                 _supplicant_dpp_conf_sent,
1437                 _supplicant_dpp_conf_received,
1438                 _supplicant_dpp_conf_obj,
1439 };
1440
1441 void register_gdbus_signal(void)
1442 {
1443         GDBusConnection *connection = NULL;
1444         SuppSigArrayIndex sig;
1445         connection = netdbus_get_connection();
1446
1447         if (connection == NULL) {
1448                 ERR("Failed to get GDbus Connection");
1449                 return;
1450         }
1451
1452         /* listening to messages from all objects as no path is specified */
1453         /* see signals from the given interface */
1454         conn_subscription_ids[0] = g_dbus_connection_signal_subscribe(
1455                         connection,
1456                         CONNMAN_SERVICE,
1457                         CONNMAN_TECHNOLOGY_INTERFACE,
1458                         NULL,
1459                         NULL,
1460                         NULL,
1461                         G_DBUS_SIGNAL_FLAGS_NONE,
1462                         _technology_signal_cb,
1463                         NULL,
1464                         NULL);
1465
1466         conn_subscription_ids[1] = g_dbus_connection_signal_subscribe(
1467                         connection,
1468                         CONNMAN_SERVICE,
1469                         CONNMAN_SERVICE_INTERFACE,
1470                         CONNMAN_SIGNAL_PROPERTY_CHANGED,
1471                         NULL,
1472                         NULL,
1473                         G_DBUS_SIGNAL_FLAGS_NONE,
1474                         _service_signal_cb,
1475                         NULL,
1476                         NULL);
1477
1478         conn_subscription_ids[2] = g_dbus_connection_signal_subscribe(
1479                         connection,
1480                         DBUS_SERVICE_DBUS,
1481                         DBUS_INTERFACE_DBUS,
1482                         SIGNAL_NAME_OWNER_CHANGED,
1483                         NULL,
1484                         CONNMAN_SERVICE,
1485                         G_DBUS_SIGNAL_FLAGS_NONE,
1486                         _dbus_name_changed_cb,
1487                         NULL,
1488                         NULL);
1489
1490         conn_subscription_ids[3] = g_dbus_connection_signal_subscribe(
1491                         connection,
1492                         CONNMAN_SERVICE,
1493                         CONNMAN_MANAGER_INTERFACE,
1494                         SIGNAL_SCAN_CHANGED,
1495                         CONNMAN_MANAGER_PATH,
1496                         NULL,
1497                         G_DBUS_SIGNAL_FLAGS_NONE,
1498                         _scan_changed_cb,
1499                         NULL,
1500                         NULL);
1501
1502         INFO("Successfully register connman DBus signal filters");
1503
1504         conn_subscription_ids[4] = g_dbus_connection_signal_subscribe(
1505                         connection,
1506                         SUPPLICANT_SERVICE,
1507                         SUPPLICANT_INTERFACE ".Interface.WPS",
1508                         NULL,
1509                         NULL,
1510                         NULL,
1511                         G_DBUS_SIGNAL_FLAGS_NONE,
1512                         __netconfig_wps_signal_filter_handler,
1513                         NULL,
1514                         NULL);
1515
1516         INFO("Successfully register Supplicant WPS DBus signal filters");
1517
1518         conn_subscription_ids[5] = g_dbus_connection_signal_subscribe(
1519                         connection,
1520                         DBUS_SERVICE_DBUS,
1521                         DBUS_INTERFACE_DBUS,
1522                         SIGNAL_NAME_OWNER_CHANGED,
1523                         NULL,
1524                         CLATD_SERVICE,
1525                         G_DBUS_SIGNAL_FLAGS_NONE,
1526                         _dbus_name_changed_cb,
1527                         NULL,
1528                         NULL);
1529
1530         INFO("Successfully register clat DBus signal filters");
1531
1532         for (sig = SIG_INTERFACE_REMOVED; sig < SIG_MAX; sig++) {
1533                 supp_subscription_ids[sig] = g_dbus_connection_signal_subscribe(
1534                                 connection,
1535                                 SUPPLICANT_SERVICE,
1536                                 supplicant_iface_for_sig[sig],
1537                                 supplicant_signals[sig],
1538                                 NULL,
1539                                 NULL,
1540                                 G_DBUS_SIGNAL_FLAGS_NONE,
1541                                 supplicant_cbs[sig],
1542                                 NULL,
1543                                 NULL);
1544         }
1545
1546         INFO("Successfully register Supplicant DBus signal filters");
1547
1548 #if defined TIZEN_DEBUG_ENABLE
1549         dumpservice_subscription_id = g_dbus_connection_signal_subscribe(
1550                         connection,
1551                         NULL,
1552                         DUMP_SERVICE_INTERFACE,
1553                         DUMP_SIGNAL,
1554                         NULL,
1555                         NULL,
1556                         G_DBUS_SIGNAL_FLAGS_NONE,
1557                         __netconfig_dumpservice_handler,
1558                         NULL,
1559                         NULL);
1560
1561         INFO("Successfully registered Dumpservice DBus signal filter");
1562 #endif
1563
1564         _notify_telephony_svc_cs();
1565         _notify_telephony_rssi();
1566
1567         INFO("Successfully register Telephony vconf keys");
1568
1569         /* In case ConnMan precedes this signal register,
1570          * net-config should update the default connected profile.
1571          */
1572         netconfig_update_default();
1573 }
1574
1575 void deregister_gdbus_signal(void)
1576 {
1577         GDBusConnection *connection = NULL;
1578         int signal;
1579         SuppSigArrayIndex sig;
1580         connection = netdbus_get_connection();
1581         if (!connection) {
1582                 ERR("Already de-registered. Nothing to be done");
1583                 return;
1584         }
1585
1586         for (signal = 0; signal < TOTAL_CONN_SIGNALS; signal++) {
1587                 if (conn_subscription_ids[signal]) {
1588                         g_dbus_connection_signal_unsubscribe(connection,
1589                                                 conn_subscription_ids[signal]);
1590                 }
1591         }
1592
1593         for (sig = SIG_INTERFACE_REMOVED; sig < SIG_MAX; sig++) {
1594                 if (supp_subscription_ids[sig]) {
1595                         g_dbus_connection_signal_unsubscribe(connection,
1596                                                 supp_subscription_ids[sig]);
1597                 }
1598         }
1599
1600 #if defined TIZEN_DEBUG_ENABLE
1601         g_dbus_connection_signal_unsubscribe(connection,
1602                         dumpservice_subscription_id);
1603 #endif
1604
1605         _ignore_telephony_svc_cs();
1606         _ignore_telephony_rssi();
1607 }