src/network-signal-handler.c

   1 /*
   2  *  Network Client Library
   3  *
   4 * Copyright 2012  Samsung Electronics Co., Ltd
   5
   6 * Licensed under the Flora License, Version 1.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.tizenopensource.org/license
  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
  21 #ifdef __cplusplus
  22 extern "C"
  23 {
  24 #endif /* __cplusplus */
  25
  26
  27 /*****************************************************************************
  28  *      Standard headers
  29  *****************************************************************************/
  30 #include <stdio.h>
  31 #include <errno.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <glib.h>
  35
  36 #include <vconf.h>
  37 #include <dbus/dbus.h>
  38 #include <dbus/dbus-glib-lowlevel.h>
  39
  40 /*****************************************************************************
  41  *      Platform headers
  42  *****************************************************************************/
  43
  44 #include "network-internal.h"
  45 #include "network-signal-handler.h"
  46 #include "network-dbus-request.h"
  47
  48 /*****************************************************************************
  49  *      Macros and Typedefs
  50  *****************************************************************************/
  51
  52
  53 /*****************************************************************************
  54  *      Local Functions Declaration
  55  *****************************************************************************/
  56 static DBusHandlerResult __net_signal_filter
  57       (DBusConnection *conn, DBusMessage *msg, void *user_data);
  58
  59 static int __net_get_state(DBusMessage *msg, char *state, char *error);
  60 static char* __net_get_property(DBusMessage* msg, char** property);
  61 static int __net_handle_scan_rsp(DBusMessage* msg);
  62 static int __net_handle_wifi_power_rsp(const char *state);
  63 static int __net_svc_error_string_to_enum(const char *error);
  64 static void __net_handle_svc_failure_ind(const char *profile_name, const char *svc_error);
  65 static void __net_handle_state_ind(const char* profile_name, net_state_type_t profile_state);
  66 static void __net_init_dbus_thread();
  67
  68 /*****************************************************************************
  69  *      Global Functions
  70  *****************************************************************************/
  71
  72
  73 /*****************************************************************************
  74  *      Extern Global Variables
  75  *****************************************************************************/
  76 extern network_info_t NetworkInfo;
  77 extern network_request_table_t request_table[NETWORK_REQUEST_TYPE_MAX];
  78
  79 /*****************************************************************************
  80  *      Extern Functions Declarations
  81  *****************************************************************************/
  82
  83 /*****************************************************************************
  84  *      Global Variables
  85  *****************************************************************************/
  86 DBusConnection* signal_conn = NULL;
  87 static net_state_type_t service_state_table[NET_DEVICE_MAX] = {NET_STATE_TYPE_UNKNOWN,};
  88
  89 /*****************************************************************************
  90  *      Local Functions Definition
  91  *****************************************************************************/
  92
  93 static int __net_get_state(DBusMessage *msg, char *state, char *error)
  94 {
  95         __NETWORK_FUNC_ENTER__;
  96
  97         char *key_name = NULL;
  98         char *svc_state = NULL;
  99         char *svc_error = NULL;
 100         DBusMessageIter iter, sub_iter;
 101         int Error = NET_ERR_UNKNOWN;
 102
 103         /* Get state */
 104         dbus_message_iter_init(msg, &iter);
 105         int ArgType = dbus_message_iter_get_arg_type(&iter);
 106
 107         if (ArgType != DBUS_TYPE_STRING)
 108                 goto done;
 109
 110         dbus_message_iter_get_basic(&iter, &key_name);
 111         if (strcmp(key_name, "State") != 0)
 112                 goto done;
 113
 114         dbus_message_iter_next(&iter);
 115         ArgType = dbus_message_iter_get_arg_type(&iter);
 116         if (ArgType != DBUS_TYPE_VARIANT)
 117                 goto done;
 118
 119         dbus_message_iter_recurse(&iter, &sub_iter);
 120         ArgType = dbus_message_iter_get_arg_type(&sub_iter);
 121         if (ArgType != DBUS_TYPE_STRING)
 122                 goto done;
 123
 124         dbus_message_iter_get_basic(&sub_iter, &svc_state);
 125         snprintf(state, strlen(svc_state) + 1, "%s", svc_state);
 126         Error = NET_ERR_NONE;
 127
 128         /* Get error */
 129         dbus_message_iter_next(&iter);
 130         ArgType = dbus_message_iter_get_arg_type(&iter);
 131         if (ArgType != DBUS_TYPE_STRING)
 132                 goto done;
 133
 134         dbus_message_iter_get_basic(&iter, &key_name);
 135         if (strcmp(key_name, "Error") != 0)
 136                 goto done;
 137
 138         dbus_message_iter_next(&iter);
 139         ArgType = dbus_message_iter_get_arg_type(&iter);
 140         if (ArgType != DBUS_TYPE_VARIANT)
 141                 goto done;
 142
 143         dbus_message_iter_recurse(&iter, &sub_iter);
 144         ArgType = dbus_message_iter_get_arg_type(&sub_iter);
 145         if (ArgType != DBUS_TYPE_STRING)
 146                 goto done;
 147
 148         dbus_message_iter_get_basic(&sub_iter, &svc_error);
 149         snprintf(error, strlen(svc_error) + 1, "%s", svc_error);
 150
 151 done:
 152         __NETWORK_FUNC_EXIT__;
 153         return Error;
 154 }
 155
 156 static char* __net_get_property(DBusMessage* msg, char** property)
 157 {
 158         DBusMessageIter args, variant;
 159         char* sigvalue = NULL;
 160
 161         __NETWORK_FUNC_ENTER__;
 162
 163         if (!dbus_message_iter_init(msg, &args))
 164         {
 165                 NETWORK_LOG( NETWORK_LOW, "Message does not have parameters\n");
 166         }
 167         else if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_STRING)
 168         {
 169                 NETWORK_LOG( NETWORK_LOW, "Argument is not string\n");
 170         }
 171         else
 172         {
 173                 dbus_message_iter_get_basic(&args, &sigvalue);
 174                 dbus_message_iter_next(&args);
 175                 dbus_message_iter_recurse(&args, &variant);
 176                 if (dbus_message_iter_get_arg_type(&variant) == DBUS_TYPE_STRING)
 177                         dbus_message_iter_get_basic(&variant, property);
 178                 else
 179                         *property = NULL;
 180         }
 181
 182         __NETWORK_FUNC_EXIT__;
 183         return sigvalue;
 184
 185 }
 186
 187 static int __net_handle_scan_rsp(DBusMessage* msg)
 188 {
 189         __NETWORK_FUNC_ENTER__;
 190
 191         int boolvalue = FALSE;
 192         net_event_info_t event_data = {0,};
 193
 194         boolvalue = _net_get_boolean(msg);
 195         if(boolvalue == TRUE)
 196                 event_data.Error = NET_ERR_NONE;
 197         else
 198                 event_data.Error = NET_ERR_UNKNOWN;
 199
 200         NETWORK_LOG( NETWORK_LOW, "[Manager : ScanCompleted] Got Signal with value [%d]\n", boolvalue);
 201
 202         if(request_table[NETWORK_REQUEST_TYPE_SCAN].flag == TRUE)
 203         {
 204                 memset(&request_table[NETWORK_REQUEST_TYPE_SCAN], 0, sizeof(network_request_table_t));
 205
 206                 event_data.Event = NET_EVENT_WIFI_SCAN_RSP;
 207                 event_data.Datalength = 0;
 208                 event_data.Data = NULL;
 209                 NETWORK_LOG(NETWORK_LOW, "Sending NET_EVENT_WIFI_SCAN_RSP\n");
 210                 _net_client_callback(&event_data);
 211         }
 212         else
 213         {
 214                 event_data.Event = NET_EVENT_WIFI_SCAN_IND;
 215                 event_data.Datalength = 0;
 216                 event_data.Data = NULL;
 217                 NETWORK_LOG(NETWORK_LOW, "Sending NET_EVENT_WIFI_SCAN_IND\n");
 218                 _net_client_callback(&event_data);
 219         }
 220
 221         __NETWORK_FUNC_EXIT__;
 222         return NET_ERR_NONE;
 223 }
 224
 225 static int __net_handle_wifi_power_rsp(const char *state)
 226 {
 227         __NETWORK_FUNC_ENTER__;
 228
 229         int wifi_state_flag = 0;
 230         net_event_info_t event_data = {0,};
 231         int hotspot_state = 0;
 232
 233         vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &hotspot_state);
 234         if (hotspot_state & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI) {
 235                 __NETWORK_FUNC_EXIT__;
 236                 return NET_ERR_NONE;
 237         }
 238
 239         if (strcmp(state, "offline") == 0 && NetworkInfo.wifi_state != WIFI_OFF) {
 240                 NetworkInfo.wifi_state = WIFI_OFF;
 241                 wifi_state_flag = 1;
 242                 event_data.Error = NET_ERR_NONE;
 243
 244                 if(request_table[NETWORK_REQUEST_TYPE_SCAN].flag == TRUE)
 245                         memset(&request_table[NETWORK_REQUEST_TYPE_SCAN], 0, sizeof(network_request_table_t));
 246
 247         } else if (strcmp(state, "enabled") == 0 && NetworkInfo.wifi_state != WIFI_ON) {
 248                 NetworkInfo.wifi_state = WIFI_ON;
 249                 wifi_state_flag = 1;
 250                 event_data.Error = NET_ERR_NONE;
 251         }
 252
 253         if (wifi_state_flag != 0) {
 254                 if (request_table[NETWORK_REQUEST_TYPE_WIFI_POWER].flag == TRUE) {
 255                         memset(&request_table[NETWORK_REQUEST_TYPE_WIFI_POWER],
 256                                         0, sizeof(network_request_table_t));
 257
 258                         event_data.Event = NET_EVENT_WIFI_POWER_RSP;
 259                         NETWORK_LOG(NETWORK_LOW,
 260                                         "Sending NET_EVENT_WIFI_POWER_RSP  wifi state : %d\n",
 261                                         NetworkInfo.wifi_state);
 262                         _net_dbus_clear_pending_call();
 263                 } else {
 264                         event_data.Event = NET_EVENT_WIFI_POWER_IND;
 265                         NETWORK_LOG(NETWORK_LOW,
 266                                         "Sending NET_EVENT_WIFI_POWER_IND  wifi state : %d\n",
 267                                         NetworkInfo.wifi_state);
 268                 }
 269
 270                 event_data.Datalength = sizeof(net_wifi_state_t);
 271                 event_data.Data = &(NetworkInfo.wifi_state);
 272                 _net_client_callback(&event_data);
 273         }
 274
 275         __NETWORK_FUNC_EXIT__;
 276         return NET_ERR_NONE;
 277 }
 278
 279 static int __net_handle_specific_scan_resp(GSList *bss_info_list)
 280 {
 281         __NETWORK_FUNC_ENTER__;
 282
 283         net_event_info_t event_data = {0,};
 284
 285         if (request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN].flag == TRUE) {
 286                 memset(&request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN],
 287                                 0, sizeof(network_request_table_t));
 288
 289                 _net_dbus_clear_pending_call();
 290
 291                 event_data.Event = NET_EVENT_SPECIFIC_SCAN_IND;
 292                 NETWORK_LOG(NETWORK_LOW,
 293                                 "Sending NET_EVENT_SPECIFIC_SCAN_IND  wifi state : %d\n",
 294                                 NetworkInfo.wifi_state);
 295
 296                 NETWORK_LOG(NETWORK_LOW, "bss_info_list : 0x%x\n", bss_info_list);
 297                 event_data.Data = bss_info_list;
 298                 _net_client_callback(&event_data);
 299         }
 300
 301         __NETWORK_FUNC_EXIT__;
 302         return NET_ERR_NONE;
 303 }
 304
 305 static int __net_svc_error_string_to_enum(const char *error)
 306 {
 307         if (strcmp(error, "out-of-range") == 0)
 308                 return NET_ERR_CONNECTION_OUT_OF_RANGE;
 309         else if (strcmp(error, "pin-missing") == 0)
 310                 return NET_ERR_CONNECTION_PIN_MISSING;
 311         else if (strcmp(error, "dhcp-failed") == 0)
 312                 return NET_ERR_CONNECTION_DHCP_FAILED;
 313         else if (strcmp(error, "connect-failed") == 0)
 314                 return NET_ERR_CONNECTION_CONNECT_FAILED;
 315         else if (strcmp(error, "login-failed") == 0)
 316                 return NET_ERR_CONNECTION_LOGIN_FAILED;
 317         else if (strcmp(error, "auth-failed") == 0)
 318                 return NET_ERR_CONNECTION_AUTH_FAILED;
 319         else if (strcmp(error, "invalid-key") == 0)
 320                 return NET_ERR_CONNECTION_INVALID_KEY;
 321
 322         return NET_ERR_UNKNOWN;
 323 }
 324
 325 static void __net_handle_svc_failure_ind(const char *profile_name, const char *svc_error)
 326 {
 327         __NETWORK_FUNC_ENTER__;
 328
 329         net_event_info_t event_data = {0,};
 330         char event_string[64] = {0,};
 331
 332         char *svc_name1 = request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].ProfileName;
 333         char *svc_name2 = request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].ProfileName;
 334
 335         if (request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag == TRUE &&
 336             strstr(profile_name, svc_name1) != NULL) {
 337
 338                 memset(&request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION], 0,
 339                                 sizeof(network_request_table_t));
 340
 341                 event_data.Event = NET_EVENT_OPEN_RSP;
 342                 g_strlcpy(event_string, "Sending NET_EVENT_OPEN_RSP", 64);
 343                 _net_dbus_clear_pending_call();
 344         } else if (request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag == TRUE &&
 345                    strcmp(profile_name, svc_name2) == 0) {
 346
 347                 memset(&request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS], 0,
 348                                 sizeof(network_request_table_t));
 349
 350                 event_data.Event = NET_EVENT_WIFI_WPS_RSP;
 351                 g_strlcpy(event_string, "Sending NET_EVENT_WIFI_WPS_RSP", 64);
 352                 _net_dbus_clear_pending_call();
 353         } else {
 354                 __net_handle_state_ind(profile_name, NET_STATE_TYPE_FAILURE);
 355                 __NETWORK_FUNC_EXIT__;
 356                 return;
 357         }
 358
 359         snprintf(event_data.ProfileName,
 360                         NET_PROFILE_NAME_LEN_MAX+1, "%s", profile_name);
 361
 362         event_data.Error = __net_svc_error_string_to_enum(svc_error);
 363         event_data.Datalength = 0;
 364         event_data.Data = NULL;
 365
 366         NETWORK_LOG(NETWORK_LOW, "%s, Error : %d\n", event_string, event_data.Error);
 367         _net_client_callback(&event_data);
 368
 369         __NETWORK_FUNC_EXIT__;
 370 }
 371
 372 static void __net_handle_state_ind(const char* profile_name, net_state_type_t profile_state)
 373 {
 374         __NETWORK_FUNC_ENTER__;
 375
 376         net_event_info_t event_data = {0,};
 377
 378         event_data.Error = NET_ERR_NONE;
 379         event_data.Event = NET_EVENT_NET_STATE_IND;
 380
 381         g_strlcpy(event_data.ProfileName, profile_name,
 382                         sizeof(event_data.ProfileName));
 383
 384         event_data.Datalength = sizeof(net_state_type_t);
 385         event_data.Data = &profile_state;
 386
 387         NETWORK_LOG(NETWORK_LOW, "Sending NET_EVENT_NET_STATE_IND, state : %d, profile name : %s\n",
 388                         profile_state, event_data.ProfileName);
 389
 390         _net_client_callback(&event_data);
 391
 392         __NETWORK_FUNC_EXIT__;
 393 }
 394
 395 static wlan_security_mode_type_t __net_get_wlan_sec_mode(int security)
 396 {
 397         switch (security) {
 398         default:
 399                 return WLAN_SEC_MODE_NONE;
 400         case 2:
 401                 return WLAN_SEC_MODE_WEP;
 402         case 3:
 403                 return WLAN_SEC_MODE_WPA_PSK;
 404         case 4:
 405                 return WLAN_SEC_MODE_IEEE8021X;
 406         }
 407 }
 408
 409 static DBusHandlerResult
 410 __net_signal_filter (DBusConnection* conn, DBusMessage* msg, void* user_data)
 411 {
 412         __NETWORK_FUNC_ENTER__;
 413
 414         static char svc_state[CONNMAN_MAX_BUFLEN] = "";
 415         static char svc_error[CONNMAN_MAX_BUFLEN] = "";
 416         static char ProfileName[NET_PROFILE_NAME_LEN_MAX + 1] = "";
 417
 418         static int open_connection_rsp_sent = FALSE;
 419
 420         const char* sig_path = NULL;
 421         const char* svc_name1 = NULL;
 422         const char* svc_name2 = NULL;
 423         const char* svc_name3 = NULL;
 424
 425         char* sigvalue = NULL;
 426         net_event_info_t event_data = {0,};
 427         net_err_t Error = NET_ERR_NONE;
 428         net_device_t device_type = NET_DEVICE_UNKNOWN;
 429
 430         if (msg == NULL) {
 431                 NETWORK_LOG(NETWORK_LOW, "Invalid Message. Ignore\n");
 432                 /* We have handled this message, don't pass it on */
 433                 __NETWORK_FUNC_EXIT__;
 434                 return DBUS_HANDLER_RESULT_HANDLED;
 435         }
 436
 437         if (dbus_message_is_signal(msg, CONNMAN_MANAGER_INTERFACE, CONNMAN_SIGNAL_PROPERTY_CHANGED)) {
 438                 sigvalue = _net_get_string(msg);
 439                 if (sigvalue == NULL) {
 440                         /* We have handled this message, don't pass it on */
 441                         __NETWORK_FUNC_EXIT__;
 442                         return DBUS_HANDLER_RESULT_HANDLED;
 443                 }
 444
 445                 NETWORK_LOG(NETWORK_LOW, "[Manager : PropertyChanged] Got Signal with value [%s]\n", sigvalue);
 446
 447                 if (strcmp(sigvalue, "Services") == 0) {
 448                         /** Ignore - compared for future use */
 449                 } else if (strcmp(sigvalue, "ConnectedTechnologies") == 0) {
 450                         /** Ignore - compared for future use */
 451                 } else if (strcmp(sigvalue, "State") == 0) {
 452                         /** Ignore - compared for future use */
 453                 } else if (strcmp(sigvalue, "DefaultTechnology") == 0) {
 454                         /** Ignore - compared for future use */
 455                 } else {
 456                         NETWORK_LOG(NETWORK_LOW, "-------[Manager : PropertyChanged]--------\n");
 457                 }
 458
 459                 /* We have handled this message, don't pass it on */
 460                 __NETWORK_FUNC_EXIT__;
 461                 return DBUS_HANDLER_RESULT_HANDLED;
 462         } else if (dbus_message_is_signal(msg, CONNMAN_MANAGER_INTERFACE, CONNMAN_SIGNAL_STATE_CHANGED)) {
 463                 sigvalue = _net_get_string(msg);
 464                 if (sigvalue == NULL) {
 465                         /* We have handled this message, don't pass it on */
 466                         __NETWORK_FUNC_EXIT__;
 467                         return DBUS_HANDLER_RESULT_HANDLED;
 468                 }
 469
 470                 NETWORK_LOG(NETWORK_LOW, "[Manager : StateChanged] Got Signal with value [%s]\n", sigvalue);
 471
 472                 if (strcmp(sigvalue, "online") == 0) {
 473                         /** Ignore - compared for future use */
 474                 }
 475
 476                 /* We have handled this message, don't pass it on */
 477                 __NETWORK_FUNC_EXIT__;
 478                 return DBUS_HANDLER_RESULT_HANDLED;
 479         } else if (dbus_message_is_signal(msg, CONNMAN_MANAGER_INTERFACE, CONNMAN_SIGNAL_SCAN_COMPLETED)) {
 480                 __net_handle_scan_rsp(msg);
 481
 482                 /* We have handled this message, don't pass it on */
 483                 __NETWORK_FUNC_EXIT__;
 484                 return DBUS_HANDLER_RESULT_HANDLED;
 485         } else if (dbus_message_is_signal(msg, NETCONFIG_WIFI_INTERFACE, NETCONFIG_SIGNAL_POWERON_COMPLETED)) {
 486                 __net_handle_wifi_power_rsp("enabled");
 487
 488                 /* We have handled this message, don't pass it on */
 489                 __NETWORK_FUNC_EXIT__;
 490                 return DBUS_HANDLER_RESULT_HANDLED;
 491         } else if (dbus_message_is_signal(msg, NETCONFIG_WIFI_INTERFACE, NETCONFIG_SIGNAL_POWEROFF_COMPLETED)) {
 492                 __net_handle_wifi_power_rsp("offline");
 493
 494                 /* We have handled this message, don't pass it on */
 495                 __NETWORK_FUNC_EXIT__;
 496                 return DBUS_HANDLER_RESULT_HANDLED;
 497         } else if (dbus_message_is_signal(msg, NETCONFIG_WIFI_INTERFACE, NETCONFIG_SIGNAL_SPECIFIC_SCAN_DONE)) {
 498                 DBusMessageIter iter, array;
 499                 dbus_message_iter_init(msg, &iter);
 500                 dbus_message_iter_recurse(&iter, &array);
 501
 502                 GSList *bss_info_list = NULL;
 503
 504                 /* The dbus message will be packed in this format: {{"ssid", <ssid name>}{"security", <security mode>}....}*/
 505                 while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
 506                         DBusMessageIter entry, dict;
 507                         const char *key = NULL;
 508                         const char *ssid = NULL;
 509                         const int security = 0;
 510
 511                         dbus_message_iter_recurse(&array, &entry);
 512                         dbus_message_iter_get_basic(&entry, &key);
 513
 514                         if (g_strcmp0(key, "ssid")) {
 515                                 Error = NET_ERR_UNKNOWN;
 516                                 break;
 517                         }
 518                         dbus_message_iter_next(&entry);
 519                         dbus_message_iter_recurse(&entry, &dict);
 520                         dbus_message_iter_get_basic(&dict, &ssid);
 521                         NETWORK_LOG(NETWORK_LOW, "Got an ssid: %s", ssid);
 522
 523                         dbus_message_iter_next(&array);
 524                         if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_DICT_ENTRY) {
 525                                 Error = NET_ERR_UNKNOWN;
 526                                 break;
 527                         }
 528                         dbus_message_iter_recurse(&array, &entry);
 529                         dbus_message_iter_get_basic(&entry, &key);
 530                         if (g_strcmp0(key, "security")) {
 531                                 Error = NET_ERR_UNKNOWN;
 532                                 break;
 533                         }
 534                         dbus_message_iter_next(&entry);
 535                         dbus_message_iter_recurse(&entry, &dict);
 536                         dbus_message_iter_get_basic(&dict, (void *)&security);
 537                         NETWORK_LOG(NETWORK_LOW, "with security: %d", security);
 538
 539                         net_wifi_connection_info_t *resp_data = g_try_new0(net_wifi_connection_info_t, 1);
 540                         g_strlcpy(resp_data->essid, ssid, NET_WLAN_ESSID_LEN);
 541                         resp_data->security_info.sec_mode = __net_get_wlan_sec_mode(security);
 542                         bss_info_list = g_slist_append(bss_info_list, resp_data);
 543
 544                         dbus_message_iter_next(&array);
 545                 }
 546
 547                 NETWORK_LOG(NETWORK_LOW, "Received the signal: %s with total bss count = %d(Error = %d)", NETCONFIG_SIGNAL_SPECIFIC_SCAN_DONE, g_slist_length(bss_info_list), Error);
 548
 549                 __net_handle_specific_scan_resp(bss_info_list);
 550
 551                 /* Specific Scan response handled. Release/Destroy the list */
 552                 g_slist_free_full(bss_info_list, g_free);
 553
 554                 /* We have handled this message, don't pass it on */
 555                 __NETWORK_FUNC_EXIT__;
 556                 return DBUS_HANDLER_RESULT_HANDLED;
 557         } else if (dbus_message_is_signal(msg, CONNMAN_TECHNOLOGY_INTERFACE, CONNMAN_SIGNAL_PROPERTY_CHANGED)) {
 558                 char* property = NULL;
 559
 560                 sigvalue = __net_get_property(msg, &property);
 561                 if (sigvalue == NULL) {
 562                         /* We have handled this message, don't pass it on */
 563                         __NETWORK_FUNC_EXIT__;
 564                         return DBUS_HANDLER_RESULT_HANDLED;
 565                 }
 566
 567                 memset(ProfileName, 0, sizeof(ProfileName));
 568                 _net_get_path(msg, ProfileName);
 569
 570                 NETWORK_LOG(NETWORK_LOW,
 571                                 "[Technology : PropertyChanged] Got Signal with value [%s] path [%s] state [%s]\n",
 572                                 sigvalue, ProfileName, property);
 573
 574                 /* We have handled this message, don't pass it on */
 575                 __NETWORK_FUNC_EXIT__;
 576                 return DBUS_HANDLER_RESULT_HANDLED;
 577         } else if (dbus_message_is_signal(msg, CONNMAN_SERVICE_INTERFACE, CONNMAN_SIGNAL_PROPERTY_CHANGED)) {
 578                 sigvalue = _net_get_string(msg);
 579                 if (sigvalue == NULL) {
 580                         /* We have handled this message, don't pass it on */
 581                         __NETWORK_FUNC_EXIT__;
 582                         return DBUS_HANDLER_RESULT_HANDLED;
 583                 }
 584
 585                 if(strcmp(sigvalue, "Strength") != 0) /** Ignore Strength signal */
 586                         NETWORK_LOG(NETWORK_LOW, "[Service : PropertyChanged] Got Signal with value [%s]\n", sigvalue);
 587
 588                 if (strcmp(sigvalue, "PassphraseRequired") == 0) {
 589                         /** Ignore - compared for future use */
 590                 } else if (strcmp(sigvalue, "State") == 0) {
 591                         memset(ProfileName, 0, sizeof(ProfileName));
 592                         _net_get_path(msg, ProfileName);
 593
 594                         device_type = _net_get_tech_type_from_path(ProfileName);
 595
 596                         if (device_type == NET_DEVICE_UNKNOWN) {
 597                                 /* We have handled this message, don't pass it on */
 598                                 __NETWORK_FUNC_EXIT__;
 599                                 return DBUS_HANDLER_RESULT_HANDLED;
 600                         }
 601
 602                         sig_path = ProfileName;
 603
 604                         memset(svc_state, 0, sizeof(svc_state));
 605                         memset(svc_error, 0, sizeof(svc_error));
 606                         __net_get_state(msg, svc_state, svc_error);
 607                         NETWORK_LOG(NETWORK_LOW, "Current ConnMan svc_state [%s] and svc_error [%s] for ProfileName [%s]\n",
 608                                         svc_state, svc_error, ProfileName);
 609
 610                         if (device_type == NET_DEVICE_WIFI &&
 611                                         NetworkInfo.wifi_state == WIFI_OFF) {
 612                                 NETWORK_LOG(NETWORK_LOW, "Warning!! Wi-Fi is already off!!\n");
 613                                 /* We have handled this message, don't pass it on */
 614                                 __NETWORK_FUNC_EXIT__;
 615                                 return DBUS_HANDLER_RESULT_HANDLED;;
 616                         }
 617
 618                         if (strcmp(svc_state, "idle") == 0) {
 619                                 service_state_table[device_type] = NET_STATE_TYPE_IDLE;
 620                                 __net_handle_state_ind(ProfileName, NET_STATE_TYPE_IDLE);
 621                         } else if (strcmp(svc_state, "association") == 0) {
 622                                 service_state_table[device_type] = NET_STATE_TYPE_ASSOCIATION;
 623                                 __net_handle_state_ind(ProfileName, NET_STATE_TYPE_ASSOCIATION);
 624                         } else if (strcmp(svc_state, "configuration") == 0) {
 625                                 service_state_table[device_type] = NET_STATE_TYPE_CONFIGURATION;
 626                                 __net_handle_state_ind(ProfileName, NET_STATE_TYPE_CONFIGURATION);
 627                         } else if (strcmp(svc_state, "ready") == 0 ||
 628                                         strcmp(svc_state, "online") == 0) {
 629                                 if (service_state_table[device_type] != NET_STATE_TYPE_READY &&
 630                                                 service_state_table[device_type] != NET_STATE_TYPE_ONLINE) {
 631                                         svc_name1 = request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].ProfileName;
 632                                         svc_name2 = request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].ProfileName;
 633
 634                                         if (request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag == TRUE &&
 635                                             strstr(sig_path, svc_name1) != NULL) {
 636                                                 memset(&request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION], 0,
 637                                                                 sizeof(network_request_table_t));
 638
 639                                                 event_data.Event =  NET_EVENT_OPEN_RSP;
 640                                                 NETWORK_LOG(NETWORK_LOW, "Sending NET_EVENT_OPEN_RSP\n");
 641                                                 _net_dbus_clear_pending_call();
 642                                         } else if (request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag == TRUE &&
 643                                                         strcmp(sig_path, svc_name2) == 0) {
 644                                                 memset(&request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS], 0,
 645                                                                 sizeof(network_request_table_t));
 646
 647                                                 event_data.Event =  NET_EVENT_WIFI_WPS_RSP;
 648                                                 NETWORK_LOG(NETWORK_LOW, "Sending NET_EVENT_WIFI_WPS_RSP\n");
 649                                                 _net_dbus_clear_pending_call();
 650                                         } else {
 651                                                 event_data.Event =  NET_EVENT_OPEN_IND;
 652                                                 NETWORK_LOG(NETWORK_LOW, "Sending NET_EVENT_OPEN_IND\n");
 653                                         }
 654
 655                                         net_profile_info_t prof_info;
 656                                         if ((Error = net_get_profile_info(ProfileName, &prof_info)) != NET_ERR_NONE) {
 657                                                 NETWORK_LOG(NETWORK_ERROR, "Error!!! net_get_profile_info() failed [%s]\n",
 658                                                                 _net_print_error(Error));
 659                                                 event_data.Datalength = 0;
 660                                                 event_data.Data = NULL;
 661                                         } else {
 662                                                 event_data.Datalength = sizeof(net_profile_info_t);
 663                                                 event_data.Data = &prof_info;
 664                                         }
 665
 666                                         event_data.Error = Error;
 667                                         snprintf(event_data.ProfileName, NET_PROFILE_NAME_LEN_MAX + 1, "%s", ProfileName);
 668                                         open_connection_rsp_sent = TRUE;
 669                                         _net_client_callback(&event_data);
 670                                 } else {
 671                                         if (strcmp(svc_state, "ready") == 0)
 672                                                 __net_handle_state_ind(ProfileName, NET_STATE_TYPE_READY);
 673                                         else
 674                                                 __net_handle_state_ind(ProfileName, NET_STATE_TYPE_ONLINE);
 675                                 }
 676
 677                                 if (strcmp(svc_state, "ready") == 0)
 678                                         service_state_table[device_type] = NET_STATE_TYPE_READY;
 679                                 else
 680                                         service_state_table[device_type] = NET_STATE_TYPE_ONLINE;
 681                         } else if (strcmp(svc_state, "disconnect") == 0) {
 682                                 svc_name1 = request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].ProfileName;
 683                                 svc_name2 = request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].ProfileName;
 684                                 svc_name3 = request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].ProfileName;
 685
 686                                 if (request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag == TRUE &&
 687                                     strstr(sig_path, svc_name2) != NULL) {
 688                                         memset(&request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION], 0,
 689                                                         sizeof(network_request_table_t));
 690
 691                                         /** Send Open Resp */
 692                                         event_data.Error = NET_ERR_OPERATION_ABORTED;
 693                                         event_data.Event =  NET_EVENT_OPEN_RSP;
 694                                         snprintf(event_data.ProfileName,
 695                                                         NET_PROFILE_NAME_LEN_MAX+1, "%s", ProfileName);
 696
 697                                         event_data.Datalength = 0;
 698                                         event_data.Data = NULL;
 699                                         NETWORK_LOG(NETWORK_LOW, "Sending NET_EVENT_OPEN_RSP\n");
 700                                         _net_dbus_clear_pending_call();
 701                                         _net_client_callback(&event_data);
 702                                 } else if (request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag == TRUE &&
 703                                                 strcmp(sig_path, svc_name3) == 0) {
 704                                         memset(&request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS], 0,
 705                                                         sizeof(network_request_table_t));
 706
 707                                         /** Send WPS Resp */
 708                                         event_data.Error = NET_ERR_OPERATION_ABORTED;
 709                                         event_data.Event =  NET_EVENT_WIFI_WPS_RSP;
 710                                         snprintf(event_data.ProfileName,
 711                                                         NET_PROFILE_NAME_LEN_MAX+1, "%s", ProfileName);
 712
 713                                         event_data.Datalength = 0;
 714                                         event_data.Data = NULL;
 715                                         NETWORK_LOG(NETWORK_LOW, "Sending NET_EVENT_WIFI_WPS_RSP\n");
 716                                         _net_dbus_clear_pending_call();
 717                                         _net_client_callback(&event_data);
 718                                 } else if (request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].flag == TRUE &&
 719                                                 strcmp(sig_path, svc_name1) == 0) {
 720                                         memset(&request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION], 0,
 721                                                         sizeof(network_request_table_t));
 722
 723                                         /** Send Close Resp */
 724                                         event_data.Error = Error;
 725                                         event_data.Event =  NET_EVENT_CLOSE_RSP;
 726                                         snprintf(event_data.ProfileName,
 727                                                         NET_PROFILE_NAME_LEN_MAX+1, "%s", ProfileName);
 728
 729                                         event_data.Datalength = 0;
 730                                         event_data.Data = NULL;
 731                                         NETWORK_LOG(NETWORK_LOW, "Sending NET_EVENT_CLOSE_RSP\n");
 732                                         _net_dbus_clear_pending_call();
 733                                         _net_client_callback(&event_data);
 734                                 } else {
 735                                         /** Send Close Ind */
 736                                         event_data.Error = Error;
 737                                         event_data.Event =  NET_EVENT_CLOSE_IND;
 738                                         snprintf(event_data.ProfileName,
 739                                                         NET_PROFILE_NAME_LEN_MAX+1, "%s", ProfileName);
 740
 741                                         event_data.Datalength = 0;
 742                                         event_data.Data = NULL;
 743                                         NETWORK_LOG(NETWORK_LOW, "Sending NET_EVENT_CLOSE_IND\n");
 744                                         _net_client_callback(&event_data);
 745                                 }
 746
 747                                 service_state_table[device_type] = NET_STATE_TYPE_DISCONNECT;
 748                         } else if (strcmp(svc_state, "failure") == 0) {
 749                                 __net_handle_svc_failure_ind(sig_path, (char*)svc_error);
 750                                 service_state_table[device_type] = NET_STATE_TYPE_FAILURE;
 751                                 __NETWORK_FUNC_EXIT__;
 752                                 return DBUS_HANDLER_RESULT_HANDLED;
 753                         }
 754                 } else if (strcmp(sigvalue, "Nameservers") == 0) {
 755                         /* We have handled this message, don't pass it on */
 756                         __NETWORK_FUNC_EXIT__;
 757                         return DBUS_HANDLER_RESULT_HANDLED;
 758                 } else if (strcmp(sigvalue, "IPv4") == 0) {
 759                         /** Ignore - compared for future use */
 760                 } else if (strcmp(sigvalue, "Ethernet") == 0) {
 761                         /** Ignore - compared for future use */
 762                 } else if (strcmp(sigvalue, "Domains") == 0) {
 763                         /** Ignore - compared for future use */
 764                 } else if (strcmp(sigvalue, "IPv4.Configuration") == 0) {
 765                         /** Ignore - compared for future use */
 766                 } else {
 767                         /** Ignore - compared for future use */
 768                 }
 769
 770                 /* We have handled this message, don't pass it on */
 771                 __NETWORK_FUNC_EXIT__;
 772                 return DBUS_HANDLER_RESULT_HANDLED;
 773         }
 774
 775         if (dbus_message_is_signal(msg, CONNMAN_COUNTER_INTERFACE, "Usage")) {
 776                 NETWORK_LOG(NETWORK_LOW, "Received [COUNTER_USAGE_SIGNAL] signal\n");
 777         } else if (dbus_message_is_signal(msg, CONNMAN_COUNTER_INTERFACE, "Release")) {
 778                 NETWORK_LOG(NETWORK_LOW, "Received [COUNTER_RELEASE_SIGNAL] signal\n");
 779         }
 780
 781         NETWORK_LOG(NETWORK_LOW, "Useless signal. Ignored !!!\n");
 782         __NETWORK_FUNC_EXIT__;
 783         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 784 }
 785
 786 static void __net_init_dbus_thread()
 787 {
 788         static dbus_bool_t init_required = TRUE;
 789         if (init_required) {
 790                 dbus_g_thread_init();
 791                 init_required = FALSE;
 792         }
 793 }
 794
 795 /*****************************************************************************
 796  *      Global Functions
 797  *****************************************************************************/
 798
 799 int _net_deregister_signal(void)
 800 {
 801         __NETWORK_FUNC_ENTER__;
 802
 803         DBusError err;
 804         dbus_error_init(&err);
 805
 806         if (signal_conn == NULL) {
 807                 NETWORK_LOG(NETWORK_HIGH, "Already de-registered. Nothing to be done\n");
 808                 __NETWORK_FUNC_EXIT__;
 809                 return NET_ERR_NONE;
 810         }
 811
 812         dbus_bus_remove_match(signal_conn, CONNMAN_MANAGER_SIGNAL_FILTER, &err);
 813         dbus_connection_flush(signal_conn);
 814         if (dbus_error_is_set(&err)) {
 815                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Remove Match Error (%s)\n", err.message);
 816                 dbus_error_free(&err);
 817                 __NETWORK_FUNC_EXIT__;
 818                 return NET_ERR_UNKNOWN;
 819         }
 820
 821         dbus_bus_remove_match(signal_conn, CONNMAN_TECHNOLOGY_SIGNAL_FILTER, &err);
 822         dbus_connection_flush(signal_conn);
 823         if (dbus_error_is_set(&err)) {
 824                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Remove Match Error (%s)\n", err.message);
 825                 dbus_error_free(&err);
 826                 __NETWORK_FUNC_EXIT__;
 827                 return NET_ERR_UNKNOWN;
 828         }
 829
 830         dbus_bus_remove_match(signal_conn, CONNMAN_SERVICE_SIGNAL_FILTER, &err);
 831         dbus_connection_flush(signal_conn);
 832         if (dbus_error_is_set(&err)) {
 833                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Remove Match Error (%s)\n", err.message);
 834                 dbus_error_free(&err);
 835                 __NETWORK_FUNC_EXIT__;
 836                 return NET_ERR_UNKNOWN;
 837         }
 838
 839         dbus_bus_remove_match(signal_conn, CONNMAN_NETWORK_COUNTER_FILTER, &err);
 840         dbus_connection_flush(signal_conn);
 841         if (dbus_error_is_set(&err)) {
 842                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Remove Match Error (%s)\n", err.message);
 843                 dbus_error_free(&err);
 844                 __NETWORK_FUNC_EXIT__;
 845                 return NET_ERR_UNKNOWN;
 846         }
 847
 848         dbus_bus_remove_match(signal_conn, NETCONFIG_WIFI_FILTER, &err);
 849         dbus_connection_flush(signal_conn);
 850         if (dbus_error_is_set(&err)) {
 851                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Remove Match Error (%s)\n", err.message);
 852                 dbus_error_free(&err);
 853                 __NETWORK_FUNC_EXIT__;
 854                 return NET_ERR_UNKNOWN;
 855         }
 856
 857         dbus_connection_remove_filter(signal_conn, __net_signal_filter, NULL);
 858         NETWORK_LOG(NETWORK_HIGH, "dbus_connection_remove_filter() successful\n");
 859         NETWORK_LOG(NETWORK_LOW, "Successfully removed signal filter rules\n");
 860
 861         /* If DBusPendingCall remains, it should be released */
 862         if (_net_dbus_is_pending_call_used() == TRUE) {
 863                 _net_dbus_clear_pending_call();
 864                 NETWORK_LOG(NETWORK_HIGH, "DBus pending call successfully removed\n");
 865         }
 866
 867         dbus_connection_unref(signal_conn);
 868         signal_conn = NULL;
 869
 870         __NETWORK_FUNC_EXIT__;
 871         return NET_ERR_NONE;
 872 }
 873
 874 int _net_register_signal(void)
 875 {
 876         __NETWORK_FUNC_ENTER__;
 877
 878         DBusConnection* conn = NULL;
 879         DBusError err;
 880
 881         __net_init_dbus_thread();
 882
 883         dbus_error_init(&err);
 884         conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
 885         if (conn == NULL) {
 886                 NETWORK_LOG(NETWORK_EXCEPTION, "Error!!! Failed to connect to the D-BUS daemon: [%s]\n", err.message);
 887                 dbus_error_free(&err);
 888                 __NETWORK_FUNC_EXIT__;
 889                 return NET_ERR_UNKNOWN;
 890         }
 891
 892         signal_conn = conn;
 893
 894         dbus_connection_setup_with_g_main(conn, NULL);
 895
 896         /** listening to messages from all objects as no path is specified */
 897         /** see signals from the given interface */
 898         dbus_bus_add_match(conn, CONNMAN_MANAGER_SIGNAL_FILTER, &err);
 899         dbus_connection_flush(conn);
 900         if (dbus_error_is_set(&err)) {
 901                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Add Match Error (%s)\n", err.message);
 902                 dbus_error_free(&err);
 903                 __NETWORK_FUNC_EXIT__;
 904                 return NET_ERR_UNKNOWN;
 905         }
 906
 907         dbus_bus_add_match(conn, CONNMAN_TECHNOLOGY_SIGNAL_FILTER, &err);
 908         dbus_connection_flush(conn);
 909         if (dbus_error_is_set(&err)) {
 910                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Add Match Error (%s)\n", err.message);
 911                 dbus_error_free(&err);
 912                 __NETWORK_FUNC_EXIT__;
 913                 return NET_ERR_UNKNOWN;
 914         }
 915
 916         dbus_bus_add_match(conn, CONNMAN_SERVICE_SIGNAL_FILTER, &err);
 917         dbus_connection_flush(conn);
 918         if (dbus_error_is_set(&err)) {
 919                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Add Match Error (%s)\n", err.message);
 920                 dbus_error_free(&err);
 921                 __NETWORK_FUNC_EXIT__;
 922                 return NET_ERR_UNKNOWN;
 923         }
 924
 925         dbus_bus_add_match(conn, CONNMAN_NETWORK_COUNTER_FILTER, &err);
 926         dbus_connection_flush(conn);
 927         if (dbus_error_is_set(&err)) {
 928                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Add Match Error (%s)\n", err.message);
 929                 dbus_error_free(&err);
 930                 __NETWORK_FUNC_EXIT__;
 931                 return NET_ERR_UNKNOWN;
 932         }
 933
 934         dbus_bus_add_match(conn, NETCONFIG_WIFI_FILTER, &err);
 935         dbus_connection_flush(conn);
 936         if (dbus_error_is_set(&err)) {
 937                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Add Match Error (%s)\n", err.message);
 938                 dbus_error_free(&err);
 939                 __NETWORK_FUNC_EXIT__;
 940                 return NET_ERR_UNKNOWN;
 941         }
 942
 943         if (dbus_connection_add_filter(conn, __net_signal_filter, NULL, NULL) == FALSE) {
 944                 NETWORK_LOG(NETWORK_ERROR, "Error!!! dbus_connection_add_filter() failed\n");
 945                 __NETWORK_FUNC_EXIT__;
 946                 return NET_ERR_UNKNOWN;
 947         }
 948
 949         NETWORK_LOG(NETWORK_LOW, "Successfully set signal filter rules\n");
 950
 951         __NETWORK_FUNC_EXIT__;
 952         return NET_ERR_NONE;
 953 }
 954
 955 int _net_init_service_state_table(void)
 956 {
 957         __NETWORK_FUNC_ENTER__;
 958
 959         net_err_t Error = NET_ERR_NONE;
 960         net_cm_network_status_t network_status;
 961
 962         Error = _net_dbus_get_network_status(NET_DEVICE_WIFI, &network_status);
 963         if (Error != NET_ERR_NONE) {
 964                 __NETWORK_FUNC_EXIT__;
 965                 return Error;
 966         }
 967
 968         if (network_status == NET_STATUS_AVAILABLE)
 969                 service_state_table[NET_DEVICE_WIFI] = NET_STATE_TYPE_READY;
 970
 971         Error = _net_dbus_get_network_status(NET_DEVICE_CELLULAR, &network_status);
 972         if (Error != NET_ERR_NONE) {
 973                 __NETWORK_FUNC_EXIT__;
 974                 return Error;
 975         }
 976
 977         if (network_status == NET_STATUS_AVAILABLE)
 978                 service_state_table[NET_DEVICE_CELLULAR] = NET_STATE_TYPE_READY;
 979
 980         NETWORK_LOG(NETWORK_HIGH, "init service state table. wifi:%d, cellular:%d\n",
 981                         service_state_table[NET_DEVICE_WIFI],
 982                         service_state_table[NET_DEVICE_CELLULAR]);
 983
 984         __NETWORK_FUNC_EXIT__;
 985         return NET_ERR_NONE;
 986 }
 987
 988 #ifdef __cplusplus
 989 }
 990 #endif /* __cplusplus */