src/network-signal-handler.c

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