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