src/network_dbus.c

   1 /*
   2  * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
   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 #include <arpa/inet.h>
  18 #include <netinet/in.h>
  19
  20 #include "wifi_internal.h"
  21 #include "network_internal.h"
  22 #include "network_dbus.h"
  23
  24 #define DBUS_REPLY_TIMEOUT_SYNC (10 * 1000)
  25
  26 #define WIFI_SECURITY_NONE                      "none"
  27 #define WIFI_SECURITY_WEP                       "wep"
  28 #define WIFI_SECURITY_WPA_PSK                   "psk"
  29 #define WIFI_SECURITY_WPA_FT_PSK                "ft_psk"
  30 #define WIFI_SECURITY_EAP                       "ieee8021x"
  31 #define WIFI_SECURITY_SAE                       "sae"
  32 #define WIFI_SECURITY_OWE                       "owe"
  33 #define WIFI_SECURITY_DPP                       "dpp"
  34
  35 //LCOV_EXCL_START
  36 static int __net_error_string_to_enum(const char *error)
  37 {
  38         WIFI_LOG(WIFI_INFO, "Passed error string [%s]", error);
  39
  40         if (NULL != strstr(error, "NoReply"))
  41                 return NET_ERR_TIME_OUT;
  42         else if (NULL != strstr(error, "Device or resource busy"))
  43                 return NET_ERR_FAIL_DEVICE_BUSY;
  44         else if (NULL != strstr(error, "UnknownMethod"))
  45                 return NET_ERR_UNKNOWN_METHOD;
  46         else if (NULL != strstr(error, "InvalidArguments"))
  47                 return NET_ERR_INVALID_PARAM;
  48         else if (NULL != strstr(error, "AccessDenied"))
  49                 return NET_ERR_ACCESS_DENIED;
  50         else if (NULL != strstr(error, "PermissionDenied"))
  51                 return NET_ERR_ACCESS_DENIED;
  52         else if (NULL != strstr(error, "PassphraseRequired"))
  53                 return NET_ERR_INVALID_OPERATION;
  54         else if (NULL != strstr(error, "NotRegistered"))
  55                 return NET_ERR_INVALID_OPERATION;
  56         else if (NULL != strstr(error, "NotUnique"))
  57                 return NET_ERR_INVALID_OPERATION;
  58         else if (NULL != strstr(error, "NotSupported"))
  59                 return NET_ERR_NOT_SUPPORTED;
  60         else if (NULL != strstr(error, "NotImplemented"))
  61                 return NET_ERR_NOT_SUPPORTED;
  62         else if (NULL != strstr(error, "NotFound"))
  63                 return NET_ERR_NOT_SUPPORTED;
  64         else if (NULL != strstr(error, "NoCarrier"))
  65                 return NET_ERR_NOT_SUPPORTED;
  66         else if (NULL != strstr(error, "InProgress"))
  67                 return NET_ERR_IN_PROGRESS;
  68         else if (NULL != strstr(error, "AlreadyExists"))
  69                 return NET_ERR_INVALID_OPERATION;
  70         else if (NULL != strstr(error, "AlreadyEnabled"))
  71                 return NET_ERR_INVALID_OPERATION;
  72         else if (NULL != strstr(error, "AlreadyDisabled"))
  73                 return NET_ERR_INVALID_OPERATION;
  74         else if (NULL != strstr(error, "AlreadyConnected"))
  75                 return NET_ERR_ACTIVE_CONNECTION_EXISTS;
  76         else if (NULL != strstr(error, "NotConnected"))
  77                 return NET_ERR_NO_ACTIVE_CONNECTIONS;
  78         else if (NULL != strstr(error, "OperationAborted"))
  79                 return NET_ERR_OPERATION_ABORTED;
  80         else if (NULL != strstr(error, "OperationTimeout"))
  81                 return NET_ERR_TIME_OUT;
  82         else if (NULL != strstr(error, "InvalidService"))
  83                 return NET_ERR_NO_SERVICE;
  84         else if (NULL != strstr(error, "InvalidProperty"))
  85                 return NET_ERR_INVALID_OPERATION;
  86         else if (NULL != strstr(error, "NoProfile"))
  87                 return NET_ERR_NO_PROFILE;
  88         else if (NULL != strstr(error, "FailTdlsDiscover"))
  89                 return NET_ERR_FAIL_TDLS_DISCOVER;
  90
  91         return NET_ERR_UNKNOWN;
  92 }
  93
  94 static int __net_netconfig_error_string_to_enum(const char* error)
  95 {
  96         WIFI_LOG(WIFI_ERROR, "Passed error value [%s]", error);
  97
  98         if (error == NULL)
  99                 return NET_ERR_UNKNOWN;
 100
 101         if (NULL != strstr(error, "WifiDriverFailed"))
 102                 return NET_ERR_WIFI_DRIVER_FAILURE;
 103         else if (NULL != strstr(error, "PermissionDenied"))
 104                 return NET_ERR_SECURITY_RESTRICTED;
 105         else if (NULL != strstr(error, "InProgress"))
 106                 return NET_ERR_WIFI_DRIVER_LOAD_INPROGRESS;
 107         else if (NULL != strstr(error, "AccessDenied"))
 108                 return NET_ERR_ACCESS_DENIED;
 109         else if (NULL != strstr(error, "NoProfile"))
 110                 return NET_ERR_NO_PROFILE;
 111         return NET_ERR_UNKNOWN;
 112 }
 113
 114 static net_wifi_security_type_e __net_wifi_security_type_to_int(const gchar *type)
 115 {
 116         net_wifi_security_type_e ret = WIFI_SEC_NONE;
 117
 118         if (type == NULL)
 119                 return ret;
 120
 121         if (g_strcmp0(type, WIFI_SECURITY_NONE) == 0)
 122                 ret = WIFI_SEC_NONE;
 123         else if (g_strcmp0(type, WIFI_SECURITY_WEP) == 0)
 124                 ret = WIFI_SEC_WEP;
 125         else if (g_strcmp0(type, WIFI_SECURITY_WPA_PSK) == 0)
 126                 ret = WIFI_SEC_WPA_PSK;
 127         else if (g_strcmp0(type, WIFI_SECURITY_EAP) == 0)
 128                 ret = WIFI_SEC_EAP;
 129         else if (g_strcmp0(type, WIFI_SECURITY_WPA_FT_PSK) == 0)
 130                 ret = WIFI_SEC_FT_PSK;
 131         else if (g_strcmp0(type, WIFI_SECURITY_SAE) == 0)
 132                 ret = WIFI_SEC_SAE;
 133         else if (g_strcmp0(type, WIFI_SECURITY_OWE) == 0)
 134                 ret = WIFI_SEC_OWE;
 135         else if (g_strcmp0(type, WIFI_SECURITY_DPP) == 0)
 136                 ret = WIFI_SEC_DPP;
 137         else
 138                 WIFI_LOG(WIFI_ERROR, "Not supported type (%s)", type);
 139
 140         return ret;
 141 }
 142
 143 static int __net_wifi_last_error_to_enum(const gchar *last_error)
 144 {
 145         wifi_manager_error_e ret = WIFI_MANAGER_ERROR_OPERATION_FAILED;
 146
 147         if (g_strcmp0(last_error, "ERROR_NONE") == 0) {
 148                 ret = WIFI_MANAGER_ERROR_NONE;
 149         } else if (g_strcmp0(last_error, "invalid-key") == 0) {
 150                 ret = WIFI_MANAGER_ERROR_INVALID_KEY;
 151         } else if (g_strcmp0(last_error, "dhcp-failed") == 0) {
 152                 ret = WIFI_MANAGER_ERROR_DHCP_FAILED;
 153         } else {
 154                 WIFI_LOG(WIFI_ERROR, "Not supported error type (%s)", last_error);
 155                 ret = WIFI_MANAGER_ERROR_NONE;
 156         }
 157
 158         return ret;
 159 }
 160
 161 gchar *__net_wifi_eap_type_to_string(net_wifi_eap_type_e eap_type)
 162 {
 163         gchar *type = NULL;
 164
 165         switch (eap_type) {
 166         case WIFI_MANAGER_EAP_PEAP:
 167                 type = g_strdup("PEAP");
 168                 break;
 169         case WIFI_MANAGER_EAP_TLS:
 170                 type = g_strdup("TLS");
 171                 break;
 172         case WIFI_MANAGER_EAP_TTLS:
 173                 type = g_strdup("TTLS");
 174                 break;
 175         case WIFI_MANAGER_EAP_SIM:
 176                 type = g_strdup("SIM");
 177                 break;
 178         case WIFI_MANAGER_EAP_AKA:
 179                 type = g_strdup("AKA");
 180                 break;
 181         }
 182         return type;
 183 }
 184
 185 gchar *__net_wifi_eap_auth_type_to_string(net_wifi_eap_auth_type_e eap_auth_type)
 186 {
 187         gchar *type = NULL;
 188
 189         switch (eap_auth_type) {
 190         case WIFI_MANAGER_EAP_AUTH_PAP:
 191                 type = g_strdup("PAP");
 192                 break;
 193         case WIFI_MANAGER_EAP_AUTH_MSCHAP:
 194                 type = g_strdup("MSCHAP");
 195                 break;
 196         case WIFI_MANAGER_EAP_AUTH_MSCHAPV2:
 197                 type = g_strdup("MSCHAPV2");
 198                 break;
 199         case WIFI_MANAGER_EAP_AUTH_GTC:
 200                 type = g_strdup("GTC");
 201                 break;
 202         case WIFI_MANAGER_EAP_AUTH_MD5:
 203                 type = g_strdup("MD5");
 204                 break;
 205         default:
 206         case WIFI_MANAGER_EAP_AUTH_NONE:
 207                 type = NULL;
 208                 break;
 209         }
 210         return type;
 211 }
 212
 213 net_wifi_eap_type_e __net_wifi_eap_type_to_int(const gchar *type)
 214 {
 215         net_wifi_eap_type_e ret = -1;
 216
 217         if (type == NULL)
 218                 return ret;
 219
 220         if (g_strcmp0(type, "PEAP") == 0)
 221                 ret = WIFI_MANAGER_EAP_PEAP;
 222         else if (g_strcmp0(type, "TLS") == 0)
 223                 ret = WIFI_MANAGER_EAP_TLS;
 224         else if (g_strcmp0(type, "TTLS") == 0)
 225                 ret = WIFI_MANAGER_EAP_TTLS;
 226         else if (g_strcmp0(type, "SIM") == 0)
 227                 ret = WIFI_MANAGER_EAP_SIM;
 228         else if (g_strcmp0(type, "AKA") == 0)
 229                 ret = WIFI_MANAGER_EAP_AKA;
 230         else
 231                 WIFI_LOG(WIFI_ERROR, "Not supported type (%s)", type);
 232
 233         return ret;
 234 }
 235
 236 static net_wifi_eap_auth_type_e __net_wifi_eap_auth_type_to_int(const gchar *type)
 237 {
 238         net_wifi_eap_auth_type_e ret = WIFI_MANAGER_EAP_AUTH_TYPE_NONE;
 239
 240         if (type == NULL)
 241                 return ret;
 242
 243         if (g_strcmp0(type, "PAP") == 0)
 244                 ret = WIFI_MANAGER_EAP_AUTH_PAP;
 245         else if (g_strcmp0(type, "MSCHAP") == 0)
 246                 ret = WIFI_MANAGER_EAP_AUTH_MSCHAP;
 247         else if (g_strcmp0(type, "MSCHAPV2") == 0)
 248                 ret = WIFI_MANAGER_EAP_AUTH_MSCHAPV2;
 249         else if (g_strcmp0(type, "GTC") == 0)
 250                 ret = WIFI_MANAGER_EAP_AUTH_GTC;
 251         else if (g_strcmp0(type, "MD5") == 0)
 252                 ret = WIFI_MANAGER_EAP_AUTH_MD5;
 253         else
 254                 WIFI_LOG(WIFI_ERROR, "Not supported type (%s)", type);
 255
 256         return ret;
 257 }
 258
 259 static void __net_open_connection_reply(GObject *source_object, GAsyncResult *res, gpointer user_data)
 260 {
 261         __NETWORK_FUNC_ENTER__;
 262
 263         GDBusConnection *conn = NULL;
 264         GError *error = NULL;
 265         net_err_e Error = NET_ERR_NONE;
 266         GVariant *reply;
 267         net_event_info_s *event_data = NULL;
 268         net_profile_info_s prof_info;
 269         network_info_s *network_info = (network_info_s *)user_data;
 270         network_request_table_s *request_table;
 271         network_request_table_s *open_info;
 272         network_request_table_s *wps_info;
 273
 274         WIFI_LOG(WIFI_INFO, "__net_open_connection_reply() called");
 275
 276         conn = G_DBUS_CONNECTION(source_object);
 277         reply = g_dbus_connection_call_finish(conn, res, &error);
 278
 279         if (error != NULL) {
 280                 Error = __net_error_string_to_enum(error->message);
 281                 if (error->code == G_IO_ERROR_CANCELLED) {
 282                         WIFI_LOG(WIFI_INFO, "Ignore open connection reply, as operation is cancelled");
 283                         g_error_free(error);
 284                         __NETWORK_FUNC_EXIT__;
 285                         return;
 286                 }
 287
 288                 g_error_free(error);
 289         }
 290
 291         if (reply)
 292                 g_variant_unref(reply);
 293
 294         if (Error == NET_ERR_NONE) {
 295                 __NETWORK_FUNC_EXIT__;
 296                 return;
 297         }
 298
 299         if (false == _wifi_find_network_info_from_handle_list(network_info)) {
 300                 __NETWORK_FUNC_EXIT__;
 301                 return;
 302         }
 303
 304         WIFI_LOG(WIFI_ERROR, "Connection open failed[%d]", Error);
 305
 306         event_data = g_try_malloc0(sizeof(net_event_info_s));
 307         if (event_data == NULL) {
 308                 __NETWORK_FUNC_EXIT__;
 309                 return;
 310         }
 311
 312         request_table = network_info->request_table;
 313         open_info = &request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION];
 314         wps_info = &request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS];
 315
 316         memset(&prof_info, 0, sizeof(net_profile_info_s));
 317
 318         if (open_info->flag == TRUE) {
 319                 g_strlcpy(event_data->ProfileName, open_info->ProfileName,
 320                                 NET_PROFILE_NAME_LEN_MAX + 1);
 321                 memset(open_info, 0, sizeof(network_request_table_s));
 322
 323                 event_data->Error = Error;
 324
 325                 if (Error == NET_ERR_ACTIVE_CONNECTION_EXISTS) {
 326                         Error = net_get_profile_info(network_info, event_data->ProfileName, &prof_info);
 327                         if (Error != NET_ERR_NONE) {
 328                                 WIFI_LOG(WIFI_ERROR, "Fail to get profile info[%s]",
 329                                                 _net_print_error(Error));
 330
 331                                 event_data->Datalength = 0;
 332                                 event_data->Data = NULL;
 333                         } else {
 334                                 event_data->Datalength = sizeof(net_profile_info_s);
 335                                 event_data->Data = &prof_info;
 336                         }
 337                 }
 338
 339                 event_data->Event = NET_EVENT_OPEN_RSP;
 340                 WIFI_LOG(WIFI_INFO, "Sending NET_EVENT_OPEN_RSP Error[%s]",
 341                                 _net_print_error(event_data->Error));
 342
 343         } else if (wps_info->flag == TRUE) {
 344                 g_strlcpy(event_data->ProfileName, wps_info->ProfileName,
 345                                 NET_PROFILE_NAME_LEN_MAX + 1);
 346                 memset(wps_info, 0, sizeof(network_request_table_s));
 347
 348                 event_data->Error = Error;
 349
 350                 if (Error == NET_ERR_ACTIVE_CONNECTION_EXISTS) {
 351                         Error = net_get_profile_info(network_info, event_data->ProfileName, &prof_info);
 352                         if (Error != NET_ERR_NONE) {
 353                                 WIFI_LOG(WIFI_ERROR, "Fail to get profile info[%s]",
 354                                                 _net_print_error(Error));
 355
 356                                 event_data->Datalength = 0;
 357                                 event_data->Data = NULL;
 358                         } else {
 359                                 event_data->Datalength = sizeof(net_profile_info_s);
 360                                 event_data->Data = &prof_info;
 361                         }
 362                 }
 363
 364                 event_data->Event = NET_EVENT_WIFI_WPS_RSP;
 365
 366                 WIFI_LOG(WIFI_INFO, "Sending NET_EVENT_WIFI_WPS_RSP Error[%s]",
 367                                 _net_print_error(event_data->Error));
 368
 369         } else {
 370                 g_free(event_data);
 371                 __NETWORK_FUNC_EXIT__;
 372                 return;
 373         }
 374
 375         if (network_info->event_callback)
 376                 network_info->event_callback(event_data, network_info->user_data);
 377
 378         if (prof_info.vsie_list)
 379                 g_slist_free_full(prof_info.vsie_list, g_free);
 380
 381         if (prof_info.bssid_list)
 382                 g_slist_free_full(prof_info.bssid_list, g_free);
 383
 384         g_free(event_data);
 385
 386         __NETWORK_FUNC_EXIT__;
 387 }
 388
 389 static void __net_scan_reply(GObject *source_object, GAsyncResult *res, gpointer user_data)
 390 {
 391         __NETWORK_FUNC_ENTER__;
 392
 393         GVariant *reply;
 394         GDBusConnection *conn = NULL;
 395         GError *error = NULL;
 396         net_err_e Error = NET_ERR_NONE;
 397         net_event_info_s *event_data;
 398
 399         network_info_s *network_info = (network_info_s *)user_data;
 400         network_request_table_s *request_table;
 401         network_request_table_s *bssid_scan_info;
 402
 403         event_data = g_try_malloc0(sizeof(net_event_info_s));
 404         if (event_data == NULL) {
 405                 __NETWORK_FUNC_EXIT__;
 406                 return;
 407         }
 408
 409         conn = G_DBUS_CONNECTION(source_object);
 410         reply = g_dbus_connection_call_finish(conn, res, &error);
 411
 412         if (error != NULL) {
 413                 WIFI_LOG(WIFI_ERROR, "Scan failed. Error [%s]",
 414                                 error->message);
 415                 Error = __net_error_string_to_enum(error->message);
 416                 if (error->code == G_IO_ERROR_CANCELLED) {
 417                         WIFI_LOG(WIFI_INFO, "Ignore scan reply, as operation is cancelled");
 418                         g_error_free(error);
 419                         __NETWORK_FUNC_EXIT__;
 420                         return;
 421                 }
 422
 423                 g_error_free(error);
 424         }
 425
 426         if (reply)
 427                 g_variant_unref(reply);
 428
 429         request_table = network_info->request_table;
 430         bssid_scan_info = &request_table[NETWORK_REQUEST_TYPE_BSSID_SCAN];
 431
 432         /* Show scan list even if device is in association state */
 433         if (bssid_scan_info->flag == TRUE && Error == NET_ERR_FAIL_DEVICE_BUSY) {
 434                 memset(&request_table[NETWORK_REQUEST_TYPE_BSSID_SCAN],
 435                                 0, sizeof(network_request_table_s));
 436
 437
 438                 event_data->Event = NET_EVENT_WIFI_BSSID_SCAN_IND;
 439                 WIFI_LOG(WIFI_INFO, "Sending NET_EVENT_WIFI_BSSID_SCAN_IND[%s]",
 440                                 _net_print_error(event_data->Error));
 441                 event_data->Error = NET_ERR_NONE;
 442                 event_data->Datalength = 0;
 443                 event_data->Data = NULL;
 444
 445                 if (network_info->event_callback)
 446                         network_info->event_callback(event_data, network_info->user_data);
 447
 448                 g_free(event_data);
 449
 450                 __NETWORK_FUNC_EXIT__;
 451                 return;
 452         } else if (Error == NET_ERR_IN_PROGRESS) {
 453                 /* should retry scan after receiving scan result */
 454                 if (request_table[NETWORK_REQUEST_TYPE_SCAN].flag == TRUE) {
 455                         WIFI_LOG(WIFI_INFO, "Full channel Scan pending");
 456                         network_info->scan_pending = TRUE;
 457                 } else if (bssid_scan_info->flag == TRUE) {
 458                         WIFI_LOG(WIFI_INFO, "BSSID Scan pending");
 459                         network_info->scan_pending = TRUE;
 460                 }
 461         } else if (Error != NET_ERR_NONE) {
 462                 WIFI_LOG(WIFI_ERROR, "Scan failed. Error [%d]", Error);
 463
 464                 if (request_table[NETWORK_REQUEST_TYPE_SCAN].flag == TRUE) {
 465                         memset(&request_table[NETWORK_REQUEST_TYPE_SCAN],
 466                                         0, sizeof(network_request_table_s));
 467
 468                         event_data->Event = NET_EVENT_WIFI_SCAN_RSP;
 469                 } else if (bssid_scan_info->flag == TRUE) {
 470                         memset(&request_table[NETWORK_REQUEST_TYPE_BSSID_SCAN],
 471                                         0, sizeof(network_request_table_s));
 472
 473                         event_data->Event = NET_EVENT_WIFI_BSSID_SCAN_IND;
 474                 }
 475
 476                 if (event_data->Event) {
 477                         event_data->Datalength = 0;
 478                         event_data->Data = NULL;
 479                         event_data->Error = Error;
 480
 481                         if (network_info->event_callback)
 482                                 network_info->event_callback(event_data, network_info->user_data);
 483
 484                         g_free(event_data);
 485
 486                         __NETWORK_FUNC_EXIT__;
 487                         return;
 488                 }
 489         } else
 490                 WIFI_LOG(WIFI_INFO, "Scan Request success");
 491
 492         g_free(event_data);
 493         __NETWORK_FUNC_EXIT__;
 494 }
 495
 496 static void __net_close_connection_reply(GObject *source_object, GAsyncResult *res, gpointer user_data)
 497 {
 498         __NETWORK_FUNC_ENTER__;
 499
 500         GDBusConnection *conn = NULL;
 501         GError *error = NULL;
 502         net_err_e Error = NET_ERR_NONE;
 503         GVariant *reply;
 504         net_event_info_s *event_data = NULL;
 505         network_info_s *network_info = (network_info_s *)user_data;
 506         network_request_table_s *request_table;
 507         network_request_table_s *close_info;
 508
 509         WIFI_LOG(WIFI_INFO, "__net_close_connection_reply() called");
 510
 511         event_data = g_try_malloc0(sizeof(net_event_info_s));
 512         if (event_data == NULL) {
 513                 __NETWORK_FUNC_EXIT__;
 514                 return;
 515         }
 516
 517         conn = G_DBUS_CONNECTION(source_object);
 518         reply = g_dbus_connection_call_finish(conn, res, &error);
 519
 520         if (error != NULL) {
 521                 Error = __net_error_string_to_enum(error->message);
 522                 if (error->code == G_IO_ERROR_CANCELLED) {
 523                         WIFI_LOG(WIFI_INFO, "Ignore close connection reply, as operation is cancelled");
 524                         g_error_free(error);
 525                         __NETWORK_FUNC_EXIT__;
 526                         return;
 527                 }
 528
 529                 g_error_free(error);
 530         }
 531
 532         if (reply)
 533                 g_variant_unref(reply);
 534
 535         if (Error == NET_ERR_NONE)
 536                 goto done;
 537
 538         WIFI_LOG(WIFI_ERROR, "Connection close failed[%d]", Error);
 539
 540         request_table = network_info->request_table;
 541         close_info = &request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION];
 542
 543         if (close_info->flag == TRUE) {
 544                 g_strlcpy(event_data->ProfileName, close_info->ProfileName,
 545                                 NET_PROFILE_NAME_LEN_MAX + 1);
 546                 memset(close_info, 0, sizeof(network_request_table_s));
 547
 548                 event_data->Error = Error;
 549                 event_data->Datalength = 0;
 550                 event_data->Data = NULL;
 551                 event_data->Event = NET_EVENT_CLOSE_RSP;
 552
 553                 WIFI_LOG(WIFI_INFO, "Sending NET_EVENT_CLOSE_RSP Error[%s]",
 554                                 _net_print_error(event_data->Error));
 555         } else {
 556                 g_free(event_data);
 557                 __NETWORK_FUNC_EXIT__;
 558                 return;
 559         }
 560
 561 done:
 562         if (network_info->event_callback)
 563                 network_info->event_callback(event_data, network_info->user_data);
 564
 565         g_free(event_data);
 566
 567         __NETWORK_FUNC_EXIT__;
 568 }
 569
 570 static void __net_wifi_power_reply(GObject *source_object, GAsyncResult *res, gpointer user_data)
 571 {
 572         __NETWORK_FUNC_ENTER__;
 573
 574         GDBusConnection *conn = NULL;
 575         GError *error = NULL;
 576         net_err_e Error = NET_ERR_NONE;
 577         net_event_info_s *event_data = NULL;
 578         GVariant *reply;
 579         network_info_s *network_info = (network_info_s *)user_data;
 580         network_request_table_s *request_table;
 581
 582         WIFI_LOG(WIFI_INFO, "__net_wifi_power_reply() called");
 583
 584         event_data = g_try_malloc0(sizeof(net_event_info_s));
 585         if (event_data == NULL) {
 586                 __NETWORK_FUNC_EXIT__;
 587                 return;
 588         }
 589
 590         conn = G_DBUS_CONNECTION(source_object);
 591         reply = g_dbus_connection_call_finish(conn, res, &error);
 592
 593         if (error != NULL) {
 594                 Error = __net_netconfig_error_string_to_enum(error->message);
 595                 if (error->code == G_IO_ERROR_CANCELLED) {
 596                         WIFI_LOG(WIFI_INFO, "Ignore wifi power reply, as operation is cancelled");
 597                         g_error_free(error);
 598                         __NETWORK_FUNC_EXIT__;
 599                         return;
 600                 }
 601
 602                 g_error_free(error);
 603         }
 604
 605         if (reply)
 606                 g_variant_unref(reply);
 607
 608         request_table = network_info->request_table;
 609
 610         if (Error != NET_ERR_NONE) {
 611                 WIFI_LOG(WIFI_ERROR, "Wi-Fi power operation failed. Error [%d]", Error);
 612
 613                 if (Error != NET_ERR_WIFI_DRIVER_LOAD_INPROGRESS) {
 614                         if (request_table[NETWORK_REQUEST_TYPE_WIFI_POWER].flag == TRUE) {
 615                                 memset(&request_table[NETWORK_REQUEST_TYPE_WIFI_POWER],
 616                                                 0, sizeof(network_request_table_s));
 617
 618                                 event_data->Event = NET_EVENT_WIFI_POWER_RSP;
 619
 620                                 WIFI_LOG(WIFI_INFO,
 621                                                 "Sending NET_EVENT_WIFI_POWER_RSP Wi-Fi: %d Error = %d",
 622                                                 network_info->wifi_state, Error);
 623
 624                                 event_data->Datalength = sizeof(net_wifi_state_e);
 625                                 event_data->Data = &(network_info->wifi_state);
 626                                 event_data->Error = Error;
 627                         }
 628                 }
 629         } else {
 630                 g_free(event_data);
 631                 __NETWORK_FUNC_EXIT__;
 632                 return;
 633         }
 634
 635         if (network_info->event_callback)
 636                 network_info->event_callback(event_data, network_info->user_data);
 637
 638         g_free(event_data);
 639         __NETWORK_FUNC_EXIT__;
 640 }
 641
 642 static void __net_bssid_scan_wifi_reply(GObject *source_object, GAsyncResult *res, gpointer user_data)
 643 {
 644         __NETWORK_FUNC_ENTER__;
 645
 646         GDBusConnection *conn = NULL;
 647         GError *error = NULL;
 648         GVariant *reply;
 649         net_err_e Error = NET_ERR_NONE;
 650         net_event_info_s *event_data = NULL;
 651         network_info_s *network_info = (network_info_s *)user_data;
 652         network_request_table_s *request_table;
 653
 654         event_data = g_try_malloc0(sizeof(net_event_info_s));
 655         if (event_data == NULL) {
 656                 __NETWORK_FUNC_EXIT__;
 657                 return;
 658         }
 659
 660         conn = G_DBUS_CONNECTION(source_object);
 661         reply = g_dbus_connection_call_finish(conn, res, &error);
 662
 663         if (error != NULL) {
 664                 Error = __net_netconfig_error_string_to_enum(error->message);
 665                 if (error->code == G_IO_ERROR_CANCELLED) {
 666                         WIFI_LOG(WIFI_INFO, "Ignore bssid scan reply, as operation is cancelled");
 667                         g_error_free(error);
 668                         __NETWORK_FUNC_EXIT__;
 669                         return;
 670                 }
 671
 672                 g_error_free(error);
 673         }
 674
 675         if (reply)
 676                 g_variant_unref(reply);
 677
 678         request_table = network_info->request_table;
 679
 680         if (Error != NET_ERR_NONE) {
 681                 WIFI_LOG(WIFI_ERROR, "bssid scan failed[%d]", Error);
 682
 683                 if (request_table[NETWORK_REQUEST_TYPE_BSSID_SCAN].flag == TRUE) {
 684                         memset(&request_table[NETWORK_REQUEST_TYPE_BSSID_SCAN],
 685                                         0, sizeof(network_request_table_s));
 686
 687                         event_data->Event = NET_EVENT_WIFI_BSSID_SCAN_IND;
 688                         event_data->Datalength = 0;
 689                         event_data->Data = NULL;
 690                         event_data->Error = Error;
 691
 692                         if (network_info->event_callback)
 693                                 network_info->event_callback(event_data, network_info->user_data);
 694
 695                         g_free(event_data);
 696                         __NETWORK_FUNC_EXIT__;
 697                         return;
 698                 }
 699         } else
 700                 WIFI_LOG(WIFI_INFO, "bssid scan succeed");
 701
 702         g_free(event_data);
 703         __NETWORK_FUNC_EXIT__;
 704 }
 705
 706 static void __net_netlink_scan_wifi_reply(GObject *source_object, GAsyncResult *res, gpointer user_data)
 707 {
 708         __NETWORK_FUNC_ENTER__;
 709
 710         GDBusConnection *conn = NULL;
 711         GError *error = NULL;
 712         GVariant *reply;
 713         net_err_e Error = NET_ERR_NONE;
 714         net_event_info_s *event_data = NULL;
 715         network_info_s *network_info = (network_info_s *)user_data;
 716         network_request_table_s *request_table;
 717
 718         event_data = g_try_malloc0(sizeof(net_event_info_s));
 719         if (event_data == NULL) {
 720                 __NETWORK_FUNC_EXIT__;
 721                 return;
 722         }
 723
 724         conn = G_DBUS_CONNECTION(source_object);
 725         reply = g_dbus_connection_call_finish(conn, res, &error);
 726
 727         if (error != NULL) {
 728                 Error = __net_netconfig_error_string_to_enum(error->message);
 729                 if (error->code == G_IO_ERROR_CANCELLED) {
 730                         WIFI_LOG(WIFI_INFO, "Ignore netlink scan reply, as operation is cancelled");
 731                         g_error_free(error);
 732                         __NETWORK_FUNC_EXIT__;
 733                         return;
 734                 }
 735
 736                 g_error_free(error);
 737         }
 738
 739         if (reply)
 740                 g_variant_unref(reply);
 741
 742         request_table = network_info->request_table;
 743
 744         if (Error != NET_ERR_NONE) {
 745                 WIFI_LOG(WIFI_ERROR, "netlink scan failed[%d]", Error);
 746
 747                 if (request_table[NETWORK_REQUEST_TYPE_NETLINK_SCAN].flag == TRUE) {
 748                         memset(&request_table[NETWORK_REQUEST_TYPE_NETLINK_SCAN],
 749                                         0, sizeof(network_request_table_s));
 750                         event_data->Event = NET_EVENT_WIFI_NETLINK_SCAN_IND;
 751
 752                         event_data->Datalength = 0;
 753                         event_data->Data = NULL;
 754                         event_data->Error = Error;
 755
 756                         if (network_info->event_callback)
 757                                 network_info->event_callback(event_data, network_info->user_data);
 758
 759                         g_free(event_data);
 760
 761                         __NETWORK_FUNC_EXIT__;
 762                         return;
 763                 }
 764         } else
 765                 WIFI_LOG(WIFI_INFO, "netlink scan succeed");
 766
 767         g_free(event_data);
 768         __NETWORK_FUNC_EXIT__;
 769 }
 770
 771 static void __net_set_passpoint_reply(GObject *source_object, GAsyncResult *res, gpointer user_data)
 772 {
 773         __NETWORK_FUNC_ENTER__;
 774
 775         GDBusConnection *conn = NULL;
 776         GError *error = NULL;
 777         net_err_e Error = NET_ERR_NONE;
 778         GVariant *reply;
 779
 780         conn = G_DBUS_CONNECTION(source_object);
 781         reply = g_dbus_connection_call_finish(conn, res, &error);
 782
 783         if (error != NULL) {
 784                 Error = __net_netconfig_error_string_to_enum(error->message);
 785                 if (error->code == G_IO_ERROR_CANCELLED) {
 786                         WIFI_LOG(WIFI_INFO, "Ignore set passpoint reply, as operation is cancelled");
 787                         g_error_free(error);
 788                         __NETWORK_FUNC_EXIT__;
 789                         return;
 790                 }
 791
 792                 g_error_free(error);
 793         }
 794
 795         if (reply)
 796                 g_variant_unref(reply);
 797
 798         if (Error != NET_ERR_NONE)
 799                 WIFI_LOG(WIFI_ERROR, "set passpoint failed[%d]", Error);
 800         else
 801                 WIFI_LOG(WIFI_INFO, "set passpoint succeeded");
 802
 803         __NETWORK_FUNC_EXIT__;
 804 }
 805
 806 static char *__net_make_group_name(unsigned char *raw_ssid,
 807                 int raw_ssid_len, const char *net_mode, const char *sec)
 808 {
 809         char *buf = NULL;
 810         const char *hidden_str = "hidden";
 811         const char *g_sec;
 812         char ssid_hex[NET_WLAN_ESSID_LEN * 2 + 1] = { 0, };
 813         int i;
 814         int ssid_len = 0;
 815         int actual_len = 0;
 816         int buf_len = 0;
 817
 818         if (net_mode == NULL || sec == NULL)
 819                 return NULL;
 820
 821         if (NULL != raw_ssid) {
 822                 actual_len = raw_ssid_len * 2;
 823         } else {
 824                 ssid_len = strlen(hidden_str);
 825                 actual_len = ssid_len;
 826         }
 827
 828         if (g_strcmp0(net_mode, "managed") != 0)
 829                 return NULL;
 830
 831         if (!g_strcmp0(sec, "wpa") || !g_strcmp0(sec, "rsn"))
 832                 g_sec = "psk";
 833         else
 834                 g_sec = sec;
 835
 836         buf_len = actual_len + strlen(net_mode) + strlen(g_sec) + 4;
 837
 838         buf = g_try_malloc0(buf_len);
 839         if (buf == NULL)
 840                 return NULL;
 841
 842         if (NULL != raw_ssid) {
 843                 for (i = 0; i < raw_ssid_len; i++)
 844                         g_snprintf(ssid_hex + i * 2, 3, "%02x", raw_ssid[i]);
 845         } else {
 846                 g_snprintf(ssid_hex, strlen(hidden_str) + 1, "%s", hidden_str);
 847         }
 848
 849         g_snprintf(buf, buf_len, "_%s_%s_%s", ssid_hex, net_mode, g_sec);
 850
 851         WIFI_LOG(WIFI_INFO, "Group name: %s", buf);
 852
 853         return buf;
 854 }
 855
 856 static int __net_dbus_set_agent_field_and_connect(network_info_s *network_info,
 857                 const char *key, const char *value, const char *profilename)
 858 {
 859         __NETWORK_FUNC_ENTER__;
 860
 861         net_err_e Error = NET_ERR_NONE;
 862         GVariant *params = NULL;
 863         GVariantBuilder *builder;
 864
 865         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 866         g_variant_builder_add(builder, "{sv}", key, g_variant_new_string(value));
 867
 868         params = g_variant_new("(o@a{sv})", profilename, g_variant_builder_end(builder));
 869         g_variant_builder_unref(builder);
 870
 871         Error = _net_invoke_dbus_method_nonblock(network_info,
 872                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
 873                         CONNMAN_AGENT_INTERFACE, "SetField", params,
 874                         DBUS_REPLY_TIMEOUT, __net_open_connection_reply);
 875
 876         __NETWORK_FUNC_EXIT__;
 877         return Error;
 878 }
 879 //LCOV_EXCL_STOP
 880
 881 GVariant *_net_invoke_dbus_method(network_info_s *network_info,
 882                 const char *dest, const char *path, const char *interface_name,
 883                 const char *method, GVariant *params, int *dbus_error)
 884 {
 885         __NETWORK_FUNC_ENTER__;
 886
 887         GError *error = NULL;
 888         GVariant *reply = NULL;
 889         *dbus_error = NET_ERR_NONE;
 890         GDBusConnection *connection = NULL;
 891         gboolean created = FALSE;
 892
 893         if ((network_info == NULL || network_info->connection == NULL) &&
 894                         access(CONTAINER_FILE, F_OK) == 0) {
 895
 896                 connection = g_dbus_connection_new_for_address_sync(
 897                                 DBUS_HOST_SYSTEM_BUS_ADDRESS,
 898                                 G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT | G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION,
 899                                 NULL, NULL, &error);
 900                 created = TRUE;
 901         } else if (network_info == NULL || network_info->connection == NULL) {
 902                 connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
 903                 created = TRUE;
 904         } else {
 905                 connection = network_info->connection;
 906                 created = FALSE;
 907         }
 908
 909         /* LCOV_EXCL_START */
 910         if (connection == NULL) {
 911                 if (error != NULL) {
 912                         WIFI_LOG(WIFI_ERROR,
 913                                         "Failed to connect to the D-BUS daemon [%s]", error->message);
 914                         g_error_free(error);
 915                 }
 916                 return NULL;
 917         }
 918         /* LCOV_EXCL_STOP */
 919
 920         reply = g_dbus_connection_call_sync(connection,
 921                         dest,
 922                         path,
 923                         interface_name,
 924                         method,
 925                         params,
 926                         NULL,
 927                         G_DBUS_CALL_FLAGS_NONE,
 928                         DBUS_REPLY_TIMEOUT_SYNC,
 929                         NULL,
 930                         &error);
 931         if (reply == NULL) {
 932                 if (error != NULL) {
 933                         WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE
 934                                                 "g_dbus_connection_call_sync() failed "
 935                                                 "error [%d: %s]", error->code, error->message);
 936                         *dbus_error = __net_error_string_to_enum(error->message); //LCOV_EXCL_LINE
 937                         g_error_free(error); //LCOV_EXCL_LINE
 938                 } else {
 939                         WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE
 940                                         "g_dbus_connection_call_sync() failed");
 941                         *dbus_error = NET_ERR_UNKNOWN; //LCOV_EXCL_LINE
 942                 }
 943
 944                 if (created)
 945                         g_object_unref(connection);
 946                 __NETWORK_FUNC_EXIT__;
 947                 return NULL;
 948         }
 949
 950         if (created)
 951                 g_object_unref(connection);
 952
 953         __NETWORK_FUNC_EXIT__;
 954         return reply;
 955 }
 956
 957 int _net_invoke_dbus_method_nonblock(network_info_s *network_info,
 958                 const char *dest, const char *path,
 959                 const char *interface_name, const char *method,
 960                 GVariant *params, int timeout,
 961                 GAsyncReadyCallback notify_func)
 962 {
 963         __NETWORK_FUNC_ENTER__;
 964
 965         g_dbus_connection_call(network_info->connection,
 966                                dest,
 967                                path,
 968                                interface_name,
 969                                method,
 970                                params,
 971                                NULL,
 972                                G_DBUS_CALL_FLAGS_NONE,
 973                                timeout,
 974                                network_info->cancellable,
 975                                (GAsyncReadyCallback) notify_func,
 976                                network_info);
 977
 978         __NETWORK_FUNC_EXIT__;
 979         return NET_ERR_NONE;
 980 }
 981
 982 int _net_dbus_open_connection(network_info_s *network_info,
 983                 const char* profile_name)
 984 {
 985         __NETWORK_FUNC_ENTER__;
 986
 987         net_err_e Error = NET_ERR_NONE;
 988
 989         /* use DBus signal than reply pending because of performance reason */
 990         Error = _net_invoke_dbus_method_nonblock(network_info,
 991                         CONNMAN_SERVICE, profile_name,
 992                         CONNMAN_SERVICE_INTERFACE, "Connect", NULL,
 993                         DBUS_REPLY_TIMEOUT, __net_open_connection_reply);
 994
 995         __NETWORK_FUNC_EXIT__;
 996         return Error;
 997 }
 998
 999 int _net_dbus_close_connection(network_info_s *network_info,
1000                 const char* profile_name)
1001 {
1002         __NETWORK_FUNC_ENTER__;
1003
1004         net_err_e Error = NET_ERR_NONE;
1005
1006         /* use DBus signal than reply pending because of performance reason */
1007         Error = _net_invoke_dbus_method_nonblock(network_info,
1008                         CONNMAN_SERVICE, profile_name,
1009                         CONNMAN_SERVICE_INTERFACE, "Disconnect", NULL,
1010                         DBUS_REPLY_TIMEOUT, __net_close_connection_reply);
1011
1012         __NETWORK_FUNC_EXIT__;
1013         return Error;
1014 }
1015
1016 int _net_dbus_scan_request(network_info_s *network_info)
1017 {
1018         __NETWORK_FUNC_ENTER__;
1019
1020         net_err_e Error = NET_ERR_NONE;
1021         GVariant *params = NULL;
1022
1023         params = g_variant_new("(s)", network_info->interface_name);
1024
1025         /* use DBus signal than reply pending because of performance reason */
1026         Error = _net_invoke_dbus_method_nonblock(network_info,
1027                         CONNMAN_SERVICE, CONNMAN_WIFI_TECHNOLOGY_PREFIX,
1028                         CONNMAN_TECHNOLOGY_INTERFACE, "ScanDevice", params,
1029                         DBUS_REPLY_TIMEOUT, __net_scan_reply);
1030
1031         if (Error == NET_ERR_IN_PROGRESS)
1032                 Error = NET_ERR_NONE; //LCOV_EXCL_LINE
1033
1034         __NETWORK_FUNC_EXIT__;
1035         return Error;
1036 }
1037
1038 int _net_dbus_get_scan_state(network_info_s *network_info, int *scanstate)
1039 {
1040         __NETWORK_FUNC_ENTER__;
1041
1042         net_err_e Error = NET_ERR_NONE;
1043         GVariant *message = NULL;
1044         GVariant *value = NULL;
1045         GVariantIter *iter;
1046         gchar *key;
1047         GVariant *params = NULL;
1048         const char *method = "GetScanState";
1049
1050         message = _net_invoke_dbus_method(network_info,
1051                         CONNMAN_SERVICE, CONNMAN_WIFI_TECHNOLOGY_PREFIX,
1052                         CONNMAN_TECHNOLOGY_INTERFACE, method, params, &Error);
1053
1054         if (message == NULL) {
1055                 WIFI_LOG(WIFI_ERROR, "Failed to get scan state"); //LCOV_EXCL_LINE
1056                 __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE
1057                 return Error; //LCOV_EXCL_LINE
1058         }
1059
1060         g_variant_get(message, "(a{sv})", &iter);
1061         while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
1062                 if (g_variant_is_of_type(value, G_VARIANT_TYPE_BOOLEAN)) {
1063                         if (g_strcmp0(key, network_info->interface_name) == 0)
1064                                 *scanstate = g_variant_get_boolean(value);
1065                 }
1066         }
1067
1068         g_variant_iter_free(iter);
1069         g_variant_unref(message);
1070
1071         WIFI_LOG(WIFI_INFO, "scan state: %d", *scanstate);
1072
1073         __NETWORK_FUNC_EXIT__;
1074         return Error;
1075 }
1076
1077 //LCOV_EXCL_START
1078 int _net_dbus_set_bgscan_mode(network_info_s *network_info,
1079                 net_wifi_background_scan_mode_e mode)
1080 {
1081         __NETWORK_FUNC_ENTER__;
1082
1083         net_err_e Error = NET_ERR_NONE;
1084         GVariant *message = NULL;
1085         GVariant *params;
1086
1087         params = g_variant_new("(su)", network_info->interface_name, mode);
1088
1089         message = _net_invoke_dbus_method(network_info,
1090                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
1091                         NETCONFIG_WIFI_INTERFACE, "SetBgscan",
1092                         params, &Error);
1093
1094         if (Error != NET_ERR_NONE)
1095                 WIFI_LOG(WIFI_ERROR, "_net_invoke_dbus_method failed"); //LCOV_EXCL_LINE
1096
1097         if (message != NULL)
1098                 g_variant_unref(message); //LCOV_EXCL_LINE
1099
1100         __NETWORK_FUNC_EXIT__;
1101         return Error;
1102 }
1103
1104 int _net_dbus_set_ip_conflict_period(network_info_s *network_info, unsigned int initial_time)
1105 {
1106         __NETWORK_FUNC_ENTER__;
1107
1108         net_err_e Error = NET_ERR_NONE;
1109         GVariant *message = NULL;
1110         GVariant *params;
1111
1112         params = g_variant_new("(su)", network_info->interface_name, initial_time);
1113
1114         message = _net_invoke_dbus_method(network_info,
1115                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
1116                         NETCONFIG_WIFI_INTERFACE, "SetIpConflictPeriod",
1117                         params, &Error);
1118
1119         if (Error != NET_ERR_NONE)
1120                 WIFI_LOG(WIFI_ERROR, "_net_invoke_dbus_method failed"); //LCOV_EXCL_LINE
1121
1122         if (message != NULL)
1123                 g_variant_unref(message); //LCOV_EXCL_LINE
1124
1125         __NETWORK_FUNC_EXIT__;
1126         return Error;
1127 }
1128 //LCOV_EXCL_STOP
1129
1130 int _net_dbus_get_technology_state(network_info_s *network_info,
1131                 network_tech_state_info_s *tech_state)
1132 {
1133         __NETWORK_FUNC_ENTER__;
1134
1135         net_err_e Error = NET_ERR_NONE;
1136         GVariant *message = NULL;
1137
1138         if ((tech_state == NULL) || (strlen(tech_state->technology) == 0)) {
1139                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1140                 __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE
1141                 return NET_ERR_INVALID_PARAM; //LCOV_EXCL_LINE
1142         }
1143
1144         message = _net_invoke_dbus_method(network_info,
1145                         CONNMAN_SERVICE, CONNMAN_MANAGER_PATH,
1146                         CONNMAN_MANAGER_INTERFACE, "GetTechnologies",
1147                         NULL, &Error);
1148         if (message == NULL) {
1149                 WIFI_LOG(WIFI_ERROR, "Failed to get technology info"); //LCOV_EXCL_LINE
1150                 goto done; //LCOV_EXCL_LINE
1151         }
1152
1153         Error = _net_get_tech_state(network_info, message, tech_state);
1154
1155         g_variant_unref(message);
1156
1157 done:
1158         __NETWORK_FUNC_EXIT__;
1159         return Error;
1160 }
1161
1162 int _net_dbus_get_tech_status(network_info_s *network_info,
1163                 net_tech_info_s *tech_status)
1164 {
1165         __NETWORK_FUNC_ENTER__;
1166
1167         net_err_e Error = NET_ERR_NONE;
1168         network_tech_state_info_s tech_state = {{0,}, 0, 0, 0, 0, 0, 0};
1169
1170         g_strlcpy(tech_state.technology, "wifi", NET_TECH_LENGTH_MAX);
1171
1172         Error = _net_dbus_get_technology_state(network_info, &tech_state);
1173         if (Error != NET_ERR_NONE) {
1174                 WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE
1175                         "_net_dbus_get_technology_state() failed. Error [%s]",
1176                         _net_print_error(Error));
1177                 goto done; //LCOV_EXCL_LINE
1178         }
1179
1180         if (tech_state.Powered == TRUE)
1181                 tech_status->powered = TRUE;
1182         else
1183                 tech_status->powered = FALSE;
1184
1185         if (tech_state.Connected == TRUE)
1186                 tech_status->connected = TRUE;
1187         else
1188                 tech_status->connected = FALSE;
1189
1190 done:
1191         __NETWORK_FUNC_EXIT__;
1192         return Error;
1193 }
1194
1195 //LCOV_EXCL_START
1196 static int _net_dbus_set_eap_config_fields_and_connect(network_info_s *network_info,
1197                 const net_wifi_connect_service_info_t *wifi_info,
1198                 const char *profilename)
1199 {
1200         __NETWORK_FUNC_ENTER__;
1201
1202         net_err_e Error = NET_ERR_NONE;
1203         GVariant *params = NULL;
1204         GVariantBuilder *builder;
1205
1206         builder = g_variant_builder_new(G_VARIANT_TYPE("a{ss}"));
1207         g_variant_builder_add(builder, "{ss}", CONNMAN_CONFIG_FIELD_TYPE, "wifi");
1208
1209         if (wifi_info->ssid)
1210                 g_variant_builder_add(builder, "{ss}",
1211                                 CONNMAN_CONFIG_FIELD_NAME, wifi_info->ssid);
1212
1213         if (wifi_info->eap_type)
1214                 g_variant_builder_add(builder, "{ss}",
1215                                 CONNMAN_CONFIG_FIELD_EAP_METHOD, wifi_info->eap_type);
1216
1217         if (wifi_info->eap_keymgmt_type)
1218                 g_variant_builder_add(builder, "{ss}",
1219                                 CONNMAN_CONFIG_FIELD_EAP_KEYMGMT_TYPE, wifi_info->eap_keymgmt_type);
1220
1221         if (wifi_info->identity)
1222                 g_variant_builder_add(builder, "{ss}",
1223                                 CONNMAN_CONFIG_FIELD_IDENTITY, wifi_info->identity);
1224
1225         if (wifi_info->anonymous_identity)
1226                 g_variant_builder_add(builder, "{ss}",
1227                                 CONNMAN_CONFIG_FIELD_ANONYMOUS_IDENTITY, wifi_info->anonymous_identity);
1228
1229         if (wifi_info->password)
1230                 g_variant_builder_add(builder, "{ss}",
1231                                 CONNMAN_CONFIG_FIELD_PASSPHRASE, wifi_info->password);
1232
1233         if (wifi_info->eap_auth &&
1234                         g_strcmp0(wifi_info->eap_auth, "NONE") != 0)
1235                 g_variant_builder_add(builder, "{ss}",
1236                                 CONNMAN_CONFIG_FIELD_PHASE2, wifi_info->eap_auth);
1237
1238         if (wifi_info->ca_cert_file)
1239                 g_variant_builder_add(builder, "{ss}",
1240                                 CONNMAN_CONFIG_FIELD_CA_CERT_FILE, wifi_info->ca_cert_file);
1241
1242         if (wifi_info->client_cert_file)
1243                 g_variant_builder_add(builder, "{ss}",
1244                                 CONNMAN_CONFIG_FIELD_CLIENT_CERT_FILE,
1245                                 wifi_info->client_cert_file);
1246
1247         if (wifi_info->private_key_file)
1248                 g_variant_builder_add(builder, "{ss}",
1249                                 CONNMAN_CONFIG_FIELD_PVT_KEY_FILE,
1250                                 wifi_info->private_key_file);
1251
1252         if (wifi_info->private_key_password)
1253                 g_variant_builder_add(builder, "{ss}",
1254                                 CONNMAN_CONFIG_FIELD_PVT_KEY_PASSPHRASE,
1255                                 wifi_info->private_key_password);
1256
1257         params = g_variant_new("(o@a{ss})", profilename, g_variant_builder_end(builder));
1258         g_variant_builder_unref(builder);
1259
1260         Error = _net_invoke_dbus_method_nonblock(network_info,
1261                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
1262                         NETCONFIG_WIFI_INTERFACE, "CreateEapConfig", params,
1263                         DBUS_REPLY_TIMEOUT, __net_open_connection_reply);
1264
1265         __NETWORK_FUNC_EXIT__;
1266         return Error;
1267 }
1268 //LCOV_EXCL_STOP
1269
1270 int _net_dbus_set_agent_passphrase_and_connect(network_info_s *network_info,
1271                 const char *passphrase, const char *profilename)
1272 {
1273         __NETWORK_FUNC_ENTER__;
1274
1275         net_err_e Error = NET_ERR_NONE;
1276
1277         if (NULL == passphrase || strlen(passphrase) == 0 || NULL == profilename) {
1278                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1279                 return NET_ERR_INVALID_PARAM; //LCOV_EXCL_LINE
1280         }
1281
1282         Error = __net_dbus_set_agent_field_and_connect(network_info,
1283                         NETCONFIG_AGENT_FIELD_PASSPHRASE, passphrase, profilename);
1284         if (NET_ERR_NONE != Error) {
1285                 WIFI_LOG(WIFI_ERROR, "Configuration failed(%d)", Error); //LCOV_EXCL_LINE
1286                 return Error; //LCOV_EXCL_LINE
1287         }
1288
1289         __NETWORK_FUNC_EXIT__;
1290         return Error;
1291 }
1292
1293 //LCOV_EXCL_START
1294 static int _net_dbus_set_agent_fields_and_connect(network_info_s *network_info,
1295                 const char *ssid, const char *passphrase, const char *profilename)
1296 {
1297         __NETWORK_FUNC_ENTER__;
1298
1299         net_err_e Error = NET_ERR_NONE;
1300         GVariant *params = NULL;
1301         GVariantBuilder *builder;
1302
1303         /* If OPEN network, passphrase can be NULL */
1304         if (NULL == ssid || strlen(ssid) == 0 || NULL == profilename) {
1305                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1306                 return NET_ERR_INVALID_PARAM; //LCOV_EXCL_LINE
1307         }
1308
1309         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1310         g_variant_builder_add(builder, "{sv}", NETCONFIG_AGENT_FIELD_SSID,
1311                         g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, ssid,
1312                                         strlen(ssid), sizeof(guchar)));
1313
1314         if (passphrase)
1315                 g_variant_builder_add(builder, "{sv}", NETCONFIG_AGENT_FIELD_PASSPHRASE,
1316                                 g_variant_new_string(passphrase));
1317
1318         params = g_variant_new("(o@a{sv})", profilename, g_variant_builder_end(builder));
1319         g_variant_builder_unref(builder);
1320
1321         Error = _net_invoke_dbus_method_nonblock(network_info,
1322                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
1323                         CONNMAN_AGENT_INTERFACE, "SetField", params,
1324                         DBUS_REPLY_TIMEOUT, __net_open_connection_reply);
1325         if (NET_ERR_NONE != Error) {
1326                 WIFI_LOG(WIFI_ERROR, "Configuration failed(%d)", Error); //LCOV_EXCL_LINE
1327                 return Error; //LCOV_EXCL_LINE
1328         }
1329
1330         __NETWORK_FUNC_EXIT__;
1331         return Error;
1332 }
1333
1334 int _net_dbus_get_wps_generated_pin(network_info_s *network_info, char **wps_pin)
1335 {
1336         __NETWORK_FUNC_ENTER__;
1337         net_err_e error = NET_ERR_NONE;
1338         GVariant *params = NULL;
1339         GVariant *reply = NULL;
1340         const gchar *value = NULL;
1341         const gchar *path = NULL;
1342
1343         params = g_variant_new("(s)", network_info->interface_name);
1344
1345         reply = _net_invoke_dbus_method(network_info,
1346                         SUPPLICANT_SERVICE, SUPPLICANT_PATH,
1347                         SUPPLICANT_INTERFACE, "GetInterface",
1348                         params, &error);
1349         if (reply == NULL) {
1350                 WIFI_LOG(WIFI_ERROR, "Failed to get Wi-Fi interface");
1351                 return error;
1352         }
1353         g_variant_get(reply, "(&o)", &path);
1354
1355         reply = _net_invoke_dbus_method(network_info,
1356                         SUPPLICANT_SERVICE, path,
1357                         SUPPLICANT_INTERFACE ".Interface.WPS",
1358                         "GeneratePin", NULL, &error);
1359         if (reply == NULL) {
1360                 WIFI_LOG(WIFI_ERROR, "Failed to get wps pin");
1361                 return error;
1362         }
1363         g_variant_get(reply, "(&s)", &value);
1364         *wps_pin = g_strdup_printf("%s", value);
1365         g_variant_unref(reply);
1366
1367         __NETWORK_FUNC_EXIT__;
1368         return error;
1369 }
1370
1371 int _net_dbus_set_agent_wps_pbc_and_connect(network_info_s *network_info,
1372                 const char *profilename)
1373 {
1374         __NETWORK_FUNC_ENTER__;
1375
1376         net_err_e Error = NET_ERR_NONE;
1377
1378         Error = __net_dbus_set_agent_field_and_connect(network_info,
1379                         NETCONFIG_AGENT_FIELD_WPS_PBC, "enable", profilename);
1380         if (NET_ERR_NONE != Error) {
1381                 WIFI_LOG(WIFI_ERROR, "PBC configuration failed(%d)", Error);
1382                 return Error;
1383         }
1384
1385         __NETWORK_FUNC_EXIT__;
1386         return Error;
1387 }
1388
1389 int _net_dbus_set_agent_wps_pin_and_connect(network_info_s *network_info,
1390                 const char *wps_pin, const char *profilename)
1391 {
1392         __NETWORK_FUNC_ENTER__;
1393
1394         net_err_e Error = NET_ERR_NONE;
1395
1396         if (NULL == wps_pin || strlen(wps_pin) == 0) {
1397                 WIFI_LOG(WIFI_ERROR, "Invalid param ");
1398                 return NET_ERR_INVALID_PARAM;
1399         }
1400
1401         Error = __net_dbus_set_agent_field_and_connect(network_info,
1402                         NETCONFIG_AGENT_FIELD_WPS_PIN, wps_pin, profilename);
1403         if (NET_ERR_NONE != Error) {
1404                 WIFI_LOG(WIFI_ERROR, "PIN configuration failed(%d)", Error);
1405                 return Error;
1406         }
1407
1408         __NETWORK_FUNC_EXIT__;
1409         return Error;
1410 }
1411 //LCOV_EXCL_STOP
1412
1413 int _net_dbus_connect_service(network_info_s *network_info,
1414                 const net_wifi_connect_service_info_t *wifi_connection_info)
1415 {
1416         __NETWORK_FUNC_ENTER__;
1417
1418         net_err_e Error = NET_ERR_NONE;
1419         char *grp_name = NULL;
1420         GSList *list = NULL;
1421         GSList *profile_list = NULL;
1422         net_profile_info_s *prof_info = NULL;
1423
1424         /* Get group name with prefix 'ssid' in hex */
1425         grp_name = __net_make_group_name(wifi_connection_info->is_hidden == TRUE ?
1426                                 NULL : wifi_connection_info->raw_ssid,
1427                                 wifi_connection_info->raw_ssid_len,
1428                                 wifi_connection_info->mode,
1429                                 wifi_connection_info->security);
1430         if (NULL == grp_name) {
1431                 WIFI_LOG(WIFI_ERROR, "Failed to make a group name"); //LCOV_EXCL_LINE
1432                 __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE
1433                 return NET_ERR_UNKNOWN; //LCOV_EXCL_LINE
1434         }
1435
1436         Error = _net_get_profile_list(network_info, &profile_list);
1437         if (NET_ERR_NONE != Error) {
1438                 WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE
1439                                 "_net_get_profile_list fail. Error [%s]",
1440                                 _net_print_error(Error));
1441
1442                 goto error; //LCOV_EXCL_LINE
1443         }
1444
1445         for (list = profile_list; list; list = list->next) {
1446                 prof_info = (net_profile_info_s *)list->data;
1447                 if (g_strstr_len(prof_info->ProfileName,
1448                                 NET_PROFILE_NAME_LEN_MAX + 1, grp_name) != NULL) {
1449                         WIFI_LOG(WIFI_INFO, "Found profile %s", prof_info->ProfileName);
1450
1451                         if (prof_info->ProfileState == NET_STATE_TYPE_READY ||
1452                                         prof_info->ProfileState == NET_STATE_TYPE_ONLINE) {
1453                                 WIFI_LOG(WIFI_ERROR, "Already profile is connected"); //LCOV_EXCL_LINE
1454                                 Error = NET_ERR_ACTIVE_CONNECTION_EXISTS; //LCOV_EXCL_LINE
1455
1456                                 goto error; //LCOV_EXCL_LINE
1457                         }
1458
1459                         break;
1460                 }
1461         }
1462
1463         if (!list) {
1464                 WIFI_LOG(WIFI_ERROR, "No matching profile found"); //LCOV_EXCL_LINE
1465                 Error = NET_ERR_NO_SERVICE; //LCOV_EXCL_LINE
1466
1467                 goto error; //LCOV_EXCL_LINE
1468         }
1469         if (wifi_connection_info->is_hidden == TRUE) {
1470                 //LCOV_EXCL_START
1471                 char *target_name = __net_make_group_name((unsigned char*)wifi_connection_info->ssid,
1472                                 strlen(wifi_connection_info->ssid),
1473                                 wifi_connection_info->mode,
1474                                 wifi_connection_info->security);
1475
1476                 WIFI_LOG(WIFI_INFO, "Hidden target name %s", target_name);
1477                 g_strlcpy(network_info->request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].ProfileName,
1478                                   target_name, NET_PROFILE_NAME_LEN_MAX + 1);
1479
1480                 g_free(target_name);
1481                 //LCOV_EXCL_STOP
1482         } else {
1483                 g_strlcpy(network_info->request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].ProfileName,
1484                                 prof_info->ProfileName, NET_PROFILE_NAME_LEN_MAX + 1);
1485         }
1486
1487         //LCOV_EXCL_START
1488         if (g_strcmp0(wifi_connection_info->security, "ieee8021x") == 0) {
1489                 /* Create the EAP config file */
1490                 Error = _net_dbus_set_eap_config_fields_and_connect(network_info,
1491                                 wifi_connection_info, prof_info->ProfileName);
1492                 if (NET_ERR_NONE != Error) {
1493                         WIFI_LOG(WIFI_ERROR, "Fail to create eap_config");
1494
1495                         goto error;
1496                 }
1497         } else if (wifi_connection_info->is_hidden == TRUE) {
1498                 Error = _net_dbus_set_agent_fields_and_connect(network_info,
1499                                 wifi_connection_info->ssid,
1500                                 wifi_connection_info->passphrase,
1501                                 prof_info->ProfileName);
1502         } else if (g_strcmp0(wifi_connection_info->security, "none") != 0 &&
1503                         g_strcmp0(wifi_connection_info->security, "owe") != 0) {
1504                 Error = _net_dbus_set_agent_passphrase_and_connect(network_info,
1505                                 wifi_connection_info->passphrase, prof_info->ProfileName);
1506                 if (NET_ERR_NONE != Error) {
1507                         WIFI_LOG(WIFI_ERROR, "Fail to set agent_passphrase");
1508
1509                         goto error;
1510                 }
1511         } else {
1512                 Error = _net_dbus_open_connection(network_info, prof_info->ProfileName);
1513         //LCOV_EXCL_STOP
1514         }
1515
1516 error:
1517         if (NET_ERR_NONE != Error) {
1518                 WIFI_LOG(WIFI_ERROR, //LCOV_EXCL_LINE
1519                                 "Failed to request open connection, Error [%s]",
1520                                 _net_print_error(Error));
1521
1522                 memset(&(network_info->request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION]), //LCOV_EXCL_LINE
1523                                 0, sizeof(network_request_table_s));
1524         }
1525
1526         __clear_profile_list(&profile_list);
1527
1528         g_free(grp_name);
1529
1530         __NETWORK_FUNC_EXIT__;
1531         return Error;
1532 }
1533
1534 //LCOV_EXCL_START
1535 int _net_dbus_get_preferred_ipv6_address(network_info_s *network_info,
1536                 const char *profilename, char **address)
1537 {
1538         __NETWORK_FUNC_ENTER__;
1539
1540         net_err_e Error = NET_ERR_NONE;
1541         GVariant *message = NULL;
1542         GVariant *params = NULL;
1543
1544         if (address == NULL) {
1545                 WIFI_LOG(WIFI_ERROR, "Invalid Parameter");
1546                 __NETWORK_FUNC_EXIT__;
1547                 return NET_ERR_INVALID_PARAM;
1548         }
1549
1550         params = g_variant_new("(s)", profilename);
1551         message = _net_invoke_dbus_method(network_info,
1552                         NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH,
1553                         NETCONFIG_NETWORK_INTERFACE, "PreferredIpv6Address",
1554                         params, &Error);
1555         if (message == NULL) {
1556                 WIFI_LOG(WIFI_ERROR, "Failed to get preferred IPv6 address");
1557                 __NETWORK_FUNC_EXIT__;
1558                 return Error;
1559         }
1560
1561         g_variant_get(message, "(s)", address);
1562
1563         WIFI_LOG(WIFI_INFO, "Preferred IPv6 Address [%s]", *address);
1564
1565         g_variant_unref(message);
1566
1567         __NETWORK_FUNC_EXIT__;
1568         return Error;
1569 }
1570
1571 int _net_dbus_set_profile_ipv4(network_info_s *network_info,
1572                 net_profile_info_s *prof_info, char *profile_name)
1573 {
1574         __NETWORK_FUNC_ENTER__;
1575
1576         net_err_e Error = NET_ERR_NONE;
1577
1578         const char *manual_method = "manual";
1579         const char *dhcp_method = "dhcp";
1580         const char *off_method = "off";
1581
1582         const char *prop_ipv4_configuration = "IPv4.Configuration";
1583         const char *prop_method = "Method";
1584         const char *prop_address = "Address";
1585         const char *prop_gateway = "Gateway";
1586         const char *prop_netmask = "Netmask";
1587
1588         char ip_buffer[NET_IPV4_STR_LEN_MAX+1] = "";
1589         char netmask_buffer[NET_IPV4_STR_LEN_MAX+1] = "";
1590         char gateway_buffer[NET_IPV4_STR_LEN_MAX+1] = "";
1591
1592         char *ipaddress = ip_buffer;
1593         char *netmask = netmask_buffer;
1594         char *gateway = gateway_buffer;
1595
1596         GVariant *params = NULL;
1597         GVariantBuilder *builder;
1598         net_dev_info_s *profile_net_info  = NULL;
1599
1600         GVariant *message = NULL;
1601
1602         WIFI_LOG(WIFI_INFO, "profile_name: [%s]", profile_name);
1603
1604         if ((prof_info == NULL) || (profile_name == NULL) || (strlen(profile_name) == 0)) {
1605                 WIFI_LOG(WIFI_ERROR, "Invalid argument"); //LCOV_EXCL_LINE
1606                 __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE
1607                 return NET_ERR_INVALID_PARAM; //LCOV_EXCL_LINE
1608         }
1609
1610         profile_net_info = &(prof_info->net_info);
1611
1612         g_strlcpy(ip_buffer,
1613                         inet_ntoa(profile_net_info->IpAddr.Data.Ipv4),
1614                         NET_IPV4_STR_LEN_MAX + 1);
1615
1616         g_strlcpy(netmask_buffer,
1617                         inet_ntoa(profile_net_info->SubnetMask.Data.Ipv4),
1618                         NET_IPV4_STR_LEN_MAX + 1);
1619
1620         g_strlcpy(gateway_buffer,
1621                         inet_ntoa(profile_net_info->GatewayAddr.Data.Ipv4),
1622                         NET_IPV4_STR_LEN_MAX + 1);
1623
1624         WIFI_LOG(WIFI_INFO, "ip: %s, netmask: %s, gateway: %s",
1625                         ipaddress, netmask, gateway);
1626
1627         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1628
1629         if (profile_net_info->IpConfigType == NET_IP_CONFIG_TYPE_DYNAMIC ||
1630             profile_net_info->IpConfigType == NET_IP_CONFIG_TYPE_AUTO_IP) {
1631
1632                 g_variant_builder_add(builder, "{sv}", prop_method, g_variant_new_string(dhcp_method));
1633
1634         } else if (profile_net_info->IpConfigType == NET_IP_CONFIG_TYPE_OFF) {
1635
1636                 g_variant_builder_add(builder, "{sv}", prop_method, g_variant_new_string(off_method));
1637
1638         } else if (profile_net_info->IpConfigType == NET_IP_CONFIG_TYPE_STATIC) {
1639
1640                 g_variant_builder_add(builder, "{sv}", prop_method, g_variant_new_string(manual_method));
1641
1642                 if (strlen(ipaddress) >= NET_IPV4_STR_LEN_MIN)
1643                         g_variant_builder_add(builder, "{sv}", prop_address, g_variant_new_string(ipaddress));
1644
1645                 if (strlen(netmask) >= NET_IPV4_STR_LEN_MIN)
1646                         g_variant_builder_add(builder, "{sv}", prop_netmask, g_variant_new_string(netmask));
1647
1648                 if (strlen(gateway) >= NET_IPV4_STR_LEN_MIN)
1649                         g_variant_builder_add(builder, "{sv}", prop_gateway, g_variant_new_string(gateway));
1650
1651         } else {
1652                 WIFI_LOG(WIFI_ERROR, "Invalid argument");
1653                 g_variant_builder_unref(builder);
1654                 __NETWORK_FUNC_EXIT__;
1655                 return NET_ERR_INVALID_PARAM;
1656         }
1657
1658         params = g_variant_new("(sv)",
1659                         prop_ipv4_configuration, g_variant_builder_end(builder));
1660         g_variant_builder_unref(builder);
1661
1662         message = _net_invoke_dbus_method(network_info,
1663                         CONNMAN_SERVICE, profile_name,
1664                         CONNMAN_SERVICE_INTERFACE, "SetProperty",
1665                         params, &Error);
1666         if (message == NULL) {
1667                 WIFI_LOG(WIFI_ERROR, "Failed to set IPv4 Property"); //LCOV_EXCL_LINE
1668                 __NETWORK_FUNC_EXIT__; //LCOV_EXCL_LINE
1669                 return Error; //LCOV_EXCL_LINE
1670         }
1671
1672         g_variant_unref(message);
1673         WIFI_LOG(WIFI_INFO, "Successfully configured IPv4.Configuration");
1674
1675         __NETWORK_FUNC_EXIT__;
1676         return Error;
1677 }
1678
1679 int _net_dbus_set_profile_ipv6(network_info_s *network_info,
1680                 net_profile_info_s* prof_info, char* profile_name)
1681 {
1682         __NETWORK_FUNC_ENTER__;
1683
1684         const char *manual_method = "manual";
1685         const char *auto_method = "auto";
1686         const char *off_method = "off";
1687
1688         const char *prop_ipv6_configuration = "IPv6.Configuration";
1689         const char *prop_method = "Method";
1690         const char *prop_address = "Address";
1691         const char *prop_gateway = "Gateway";
1692         const char *prop_prefixlen = "PrefixLength";
1693
1694         char ipaddr6[INET6_ADDRSTRLEN];
1695         char gwaddr6[INET6_ADDRSTRLEN];
1696
1697         char *ip6_ptr = ipaddr6;
1698         char *gw6_ptr = gwaddr6;
1699         int prefix_length = 0;
1700
1701         net_err_e Error = NET_ERR_NONE;
1702         GVariant *params = NULL;
1703         GVariantBuilder *builder;
1704         GVariant *message = NULL;
1705         net_dev_info_s *profile_net_info  = NULL;
1706
1707         if ((prof_info == NULL) || (profile_name == NULL) || (strlen(profile_name) == 0)) {
1708                 WIFI_LOG(WIFI_ERROR,  "Error!!! Invalid argument");
1709                 __NETWORK_FUNC_EXIT__;
1710                 return NET_ERR_INVALID_PARAM;
1711         }
1712
1713         profile_net_info = &(prof_info->net_info);
1714
1715         inet_ntop(AF_INET6, &profile_net_info->IpAddr6.Data.Ipv6, ipaddr6,
1716                         INET6_ADDRSTRLEN);
1717         inet_ntop(AF_INET6, &profile_net_info->GatewayAddr6.Data.Ipv6, gwaddr6,
1718                         INET6_ADDRSTRLEN);
1719         prefix_length = profile_net_info->PrefixLen6;
1720
1721         WIFI_LOG(WIFI_INFO, "ipaddress : %s, prefix_len : %d, gateway : %s",
1722                                 ip6_ptr, prefix_length, gw6_ptr);
1723
1724         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1725
1726         if (profile_net_info->IpConfigType6 == NET_IP_CONFIG_TYPE_DYNAMIC ||
1727                 profile_net_info->IpConfigType6 == NET_IP_CONFIG_TYPE_AUTO_IP) {
1728
1729                 g_variant_builder_add(builder, "{sv}", prop_method,
1730                                 g_variant_new_string(auto_method));
1731
1732         } else if (profile_net_info->IpConfigType6 == NET_IP_CONFIG_TYPE_OFF) {
1733
1734                 g_variant_builder_add(builder, "{sv}", prop_method,
1735                                 g_variant_new_string(off_method));
1736
1737                 WIFI_LOG(WIFI_INFO, "DBus Message 2/2: %s %s",
1738                                 prop_method, off_method);
1739         } else if (profile_net_info->IpConfigType6 == NET_IP_CONFIG_TYPE_STATIC) {
1740
1741                 g_variant_builder_add(builder, "{sv}", prop_method,
1742                                 g_variant_new_string(manual_method));
1743
1744                 if (strlen(ipaddr6) >= NET_IPV6_STR_LEN_MIN) {
1745                         g_variant_builder_add(builder, "{sv}", prop_address,
1746                                         g_variant_new_string(ip6_ptr));
1747                 }
1748                 if (profile_net_info->PrefixLen6 <= NET_IPV6_MAX_PREFIX_LEN) {
1749                         g_variant_builder_add(builder, "{sv}", prop_prefixlen,
1750                                         g_variant_new_byte(prefix_length));
1751                 }
1752
1753                 if (strlen(gwaddr6) >= NET_IPV6_STR_LEN_MIN) {
1754                         g_variant_builder_add(builder, "{sv}", prop_gateway,
1755                                         g_variant_new_string(gw6_ptr));
1756                 }
1757                 WIFI_LOG(WIFI_INFO, "DBus Message 2/2: %s %s %s %s %s %d %s %s",
1758                                 prop_method, manual_method,
1759                                 prop_address, ipaddr6, prop_prefixlen,
1760                                 prefix_length, prop_gateway, gwaddr6);
1761         } else {
1762                 WIFI_LOG(WIFI_ERROR, "Invalid argument");
1763                 g_variant_builder_unref(builder);
1764                 __NETWORK_FUNC_EXIT__;
1765                 return NET_ERR_INVALID_PARAM;
1766         }
1767
1768         params = g_variant_new("(sv)", prop_ipv6_configuration,
1769                         g_variant_builder_end(builder));
1770         g_variant_builder_unref(builder);
1771
1772         message = _net_invoke_dbus_method(network_info,
1773                         CONNMAN_SERVICE, profile_name,
1774                         CONNMAN_SERVICE_INTERFACE, "SetProperty",
1775                         params, &Error);
1776         if (message == NULL) {
1777                 WIFI_LOG(WIFI_ERROR, "Failed to set IPv6 Property");
1778                 __NETWORK_FUNC_EXIT__;
1779                 return Error;
1780         }
1781
1782         g_variant_unref(message);
1783         WIFI_LOG(WIFI_INFO, "Successfully configured IPv6.Configuration");
1784
1785         __NETWORK_FUNC_EXIT__;
1786         return Error;
1787 }
1788
1789 int _net_dbus_set_profile_dns(network_info_s *network_info,
1790                 net_profile_info_s* prof_info, char* profile_name)
1791 {
1792         __NETWORK_FUNC_ENTER__;
1793
1794         const char *prop_nameserver_configuration = "Nameservers.Configuration";
1795
1796         const char *manual_method = "ipv4.manual";
1797         const char *dhcp_method = "ipv4.dhcp";
1798         const char *ipv6_manual_method = "ipv6.manual";
1799         const char *ipv6_dhcp_method = "ipv6.dhcp";
1800
1801         char dns_buffer[NET_DNS_ADDR_MAX][NET_IPV4_STR_LEN_MAX+1];
1802         char *dns_address[NET_DNS_ADDR_MAX];
1803         char ipv6_dns_buffer[NET_DNS_ADDR_MAX][NET_IPV6_STR_LEN_MAX + 1];
1804         char *ipv6_dns_address[NET_DNS_ADDR_MAX];
1805
1806         net_err_e Error = NET_ERR_NONE;
1807         GVariant *params = NULL;
1808         GVariantBuilder *builder = NULL;
1809         int i = 0;
1810         net_dev_info_s *profile_net_info  = NULL;
1811         GVariant *message = NULL;
1812
1813         if ((prof_info == NULL) || (profile_name == NULL) || (strlen(profile_name) == 0)) {
1814                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1815                 __NETWORK_FUNC_EXIT__;
1816                 return NET_ERR_INVALID_PARAM;
1817         }
1818
1819         profile_net_info = &(prof_info->net_info);
1820
1821         if (profile_net_info->DnsCount > NET_DNS_ADDR_MAX) {
1822                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1823                 __NETWORK_FUNC_EXIT__;
1824                 return NET_ERR_INVALID_PARAM;
1825         }
1826
1827         for (i = 0; i < profile_net_info->DnsCount; i++) {
1828                 dns_buffer[i][0] = '\0';
1829                 dns_address[i] = NULL;
1830
1831                 if (profile_net_info->DnsAddr[i].Data.Ipv4.s_addr != 0)
1832                         g_strlcpy(dns_buffer[i],
1833                                         inet_ntoa(profile_net_info->DnsAddr[i].Data.Ipv4),
1834                                         NET_IPV4_STR_LEN_MAX + 1);
1835
1836                 if (profile_net_info->DnsConfigType == NET_DNS_CONFIG_TYPE_STATIC)
1837                         dns_address[i] = dns_buffer[i];
1838         }
1839
1840         for (i = 0; i < profile_net_info->DnsCount6; i++) {
1841                 ipv6_dns_buffer[i][0] = '\0';
1842                 ipv6_dns_address[i] = NULL;
1843
1844                 if (profile_net_info->DnsAddr6[i].Type == NET_ADDR_IPV6) {
1845                         inet_ntop(AF_INET6,
1846                                         &profile_net_info->DnsAddr6[i].Data.Ipv6,
1847                                         ipv6_dns_buffer[i], INET6_ADDRSTRLEN);
1848                 }
1849
1850                 if (profile_net_info->DnsConfigType6 == NET_DNS_CONFIG_TYPE_STATIC)
1851                         ipv6_dns_address[i] = ipv6_dns_buffer[i];
1852         }
1853
1854         if (profile_net_info->DnsConfigType == NET_DNS_CONFIG_TYPE_STATIC ||
1855                         profile_net_info->DnsConfigType == NET_DNS_CONFIG_TYPE_DYNAMIC ||
1856                         profile_net_info->DnsConfigType6 == NET_DNS_CONFIG_TYPE_STATIC ||
1857                         profile_net_info->DnsConfigType6 == NET_DNS_CONFIG_TYPE_DYNAMIC) {
1858                 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1859
1860                 WIFI_LOG(WIFI_INFO, "IPv4 DnsConfigType: %d", profile_net_info->DnsConfigType);
1861                 if (profile_net_info->DnsConfigType ==
1862                                 NET_DNS_CONFIG_TYPE_STATIC ||
1863                                 profile_net_info->DnsConfigType6 ==
1864                                 NET_DNS_CONFIG_TYPE_STATIC)
1865                         g_variant_builder_add(builder, "s",
1866                                         manual_method);
1867                 else
1868                         g_variant_builder_add(builder, "s",
1869                                         dhcp_method);
1870
1871                 WIFI_LOG(WIFI_INFO, "IPv6 DnsConfigType: %d", profile_net_info->DnsConfigType6);
1872                 if (profile_net_info->DnsConfigType6 ==
1873                                 NET_DNS_CONFIG_TYPE_STATIC)
1874                         g_variant_builder_add(builder, "s",
1875                                         ipv6_manual_method);
1876                 else if (profile_net_info->DnsConfigType6 ==
1877                                 NET_DNS_CONFIG_TYPE_DYNAMIC)
1878                         g_variant_builder_add(builder, "s",
1879                                         ipv6_dhcp_method);
1880
1881                 for (i = 0; i < profile_net_info->DnsCount; i++) {
1882                         if (profile_net_info->DnsConfigType ==
1883                                         NET_DNS_CONFIG_TYPE_STATIC) {
1884                                 if (dns_address[i] == NULL)
1885                                         g_strlcpy(dns_address[i], "0.0.0.0",
1886                                                         NET_IPV4_STR_LEN_MIN + 1);
1887                                 g_variant_builder_add(builder, "s",
1888                                                 dns_address[i]);
1889                         }
1890                         WIFI_LOG(WIFI_INFO, "IPv4 DNS Address added in g_variant: %s", dns_address[i]);
1891                 }
1892
1893                 for (i = 0; i < profile_net_info->DnsCount6; i++) {
1894                         if (profile_net_info->DnsConfigType6 ==
1895                                         NET_DNS_CONFIG_TYPE_STATIC) {
1896                                 if (ipv6_dns_address[i] == NULL)
1897                                         g_strlcpy(ipv6_dns_address[i], "::",
1898                                                         NET_IPV6_STR_LEN_MIN + 1);
1899                                 g_variant_builder_add(builder, "s",
1900                                                 ipv6_dns_address[i]);
1901                         }
1902                         WIFI_LOG(WIFI_INFO, "IPv6 DNS Address added in g_variant: %s", ipv6_dns_address[i]);
1903                 }
1904
1905                 params = g_variant_new("(sv)", prop_nameserver_configuration, g_variant_builder_end(builder));
1906                 g_variant_builder_unref(builder);
1907         }
1908
1909         message = _net_invoke_dbus_method(network_info,
1910                         CONNMAN_SERVICE, profile_name,
1911                         CONNMAN_SERVICE_INTERFACE, "SetProperty",
1912                         params, &Error);
1913         if (message == NULL) {
1914                 __NETWORK_FUNC_EXIT__;
1915                 return Error;
1916         }
1917         WIFI_LOG(WIFI_INFO, "Successfully configured Nameservers.Configuration");
1918         g_variant_unref(message);
1919
1920         __NETWORK_FUNC_EXIT__;
1921         return Error;
1922 }
1923
1924 int _net_dbus_set_proxy(network_info_s *network_info,
1925                 net_profile_info_s* prof_info, char* profile_name)
1926 {
1927         __NETWORK_FUNC_ENTER__;
1928
1929         net_err_e Error = NET_ERR_NONE;
1930
1931         const char *direct_method = "direct";
1932         const char *auto_method = "auto";
1933         const char *manual_method = "manual";
1934
1935         const char *prop_proxy_configuration = "Proxy.Configuration";
1936         const char *prop_method = "Method";
1937         const char *prop_url = "URL";
1938         const char *prop_servers = "Servers";
1939
1940         char proxy_buffer[NET_PROXY_LEN_MAX+1] = "";
1941         char *proxy_address = proxy_buffer;
1942
1943         GVariant *params = NULL;
1944         GVariantBuilder *builder;
1945         GVariantBuilder *builder_sub;
1946         net_dev_info_s *profile_net_info  = NULL;
1947
1948         GVariant *message = NULL;
1949
1950         if ((prof_info == NULL) || (profile_name == NULL) || (strlen(profile_name) == 0)) {
1951                 WIFI_LOG(WIFI_ERROR, "Invalid argument");
1952                 __NETWORK_FUNC_EXIT__;
1953                 return NET_ERR_INVALID_PARAM;
1954         }
1955
1956         profile_net_info = &(prof_info->net_info);
1957
1958         g_strlcpy(proxy_buffer,
1959                         profile_net_info->ProxyAddr, NET_PROXY_LEN_MAX+1);
1960
1961         WIFI_LOG(WIFI_INFO, "method: %d, proxy address: %s, Profile Name %s",
1962                         profile_net_info->ProxyMethod, proxy_address, profile_net_info->ProfileName);
1963
1964         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1965
1966         switch (profile_net_info->ProxyMethod) {
1967         case NET_PROXY_TYPE_AUTO:
1968                 g_variant_builder_add(builder, "{sv}", prop_method, g_variant_new_string(auto_method));
1969                 break;
1970         case NET_PROXY_TYPE_MANUAL:
1971                 g_variant_builder_add(builder, "{sv}", prop_method, g_variant_new_string(manual_method));
1972                 break;
1973         default:
1974                 g_variant_builder_add(builder, "{sv}", prop_method, g_variant_new_string(direct_method));
1975                 break;
1976         }
1977
1978         if (profile_net_info->ProxyMethod == NET_PROXY_TYPE_AUTO &&
1979                         proxy_address[0] != '\0') {
1980                 g_variant_builder_add(builder, "{sv}", prop_url, g_variant_new_string(proxy_address));
1981         }
1982
1983         if (profile_net_info->ProxyMethod == NET_PROXY_TYPE_MANUAL &&
1984                         proxy_address[0] != '\0') {
1985                 builder_sub = g_variant_builder_new(G_VARIANT_TYPE("as"));
1986                 g_variant_builder_add(builder_sub, "s", proxy_address);
1987                 g_variant_builder_add(builder, "{sv}", prop_servers, g_variant_builder_end(builder_sub));
1988                 g_variant_builder_unref(builder_sub);
1989         }
1990
1991         params = g_variant_new("(sv)", prop_proxy_configuration, g_variant_builder_end(builder));
1992         g_variant_builder_unref(builder);
1993
1994         message = _net_invoke_dbus_method(network_info,
1995                         CONNMAN_SERVICE, profile_name,
1996                         CONNMAN_SERVICE_INTERFACE, "SetProperty",
1997                         params, &Error);
1998         if (message == NULL) {
1999                 WIFI_LOG(WIFI_ERROR, "Failed to set Proxy Configuration");
2000                 __NETWORK_FUNC_EXIT__;
2001                 return Error;
2002         }
2003         WIFI_LOG(WIFI_INFO, "Successfully configured Proxy.Configuration");
2004         g_variant_unref(message);
2005
2006         __NETWORK_FUNC_EXIT__;
2007         return Error;
2008 }
2009
2010 int _net_dbus_load_wifi_driver(network_info_s *network_info, gboolean wifi_picker_test)
2011 {
2012         __NETWORK_FUNC_ENTER__;
2013
2014         net_err_e Error = NET_ERR_NONE;
2015         GVariant *params;
2016
2017         params = g_variant_new("(sb)", network_info->interface_name, wifi_picker_test);
2018
2019         /* use DBus signal than reply pending because of performance reason */
2020         Error = _net_invoke_dbus_method_nonblock(network_info,
2021                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
2022                         NETCONFIG_WIFI_INTERFACE, "LoadDriver",
2023                         params, DBUS_REPLY_TIMEOUT,
2024                         __net_wifi_power_reply);
2025
2026         __NETWORK_FUNC_EXIT__;
2027         return Error;
2028 }
2029
2030 int _net_dbus_remove_wifi_driver(network_info_s *network_info)
2031 {
2032         __NETWORK_FUNC_ENTER__;
2033
2034         net_err_e Error = NET_ERR_NONE;
2035         GVariant *params = NULL;
2036
2037         params = g_variant_new("(s)", network_info->interface_name);
2038
2039         /* use DBus signal than reply pending because of performance reason */
2040         Error = _net_invoke_dbus_method_nonblock(network_info,
2041                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
2042                         NETCONFIG_WIFI_INTERFACE, "RemoveDriver",
2043                         params, DBUS_REPLY_TIMEOUT,
2044                         __net_wifi_power_reply);
2045
2046         __NETWORK_FUNC_EXIT__;
2047         return Error;
2048 }
2049
2050 static void __net_specific_scan_request_reply(GObject *source_object, GAsyncResult *res,
2051                 gpointer user_data)
2052 {
2053         __NETWORK_FUNC_ENTER__;
2054
2055         GDBusConnection *conn = NULL;
2056         GError *error = NULL;
2057         net_err_e Error = NET_ERR_NONE;
2058         net_event_info_s *event_data = NULL;
2059         GVariant *reply;
2060         network_info_s *network_info = (network_info_s *)user_data;
2061         network_request_table_s *request_table;
2062
2063         event_data = g_try_malloc0(sizeof(net_event_info_s));
2064         if (event_data == NULL) {
2065                 __NETWORK_FUNC_EXIT__;
2066                 return;
2067         }
2068
2069         conn = G_DBUS_CONNECTION(source_object);
2070         reply = g_dbus_connection_call_finish(conn, res, &error);
2071
2072         if (error != NULL) {
2073                 WIFI_LOG(WIFI_ERROR, "Scan failed. Error [%s]",
2074                                 error->message);
2075                 Error = __net_error_string_to_enum(error->message);
2076                 if (error->code == G_IO_ERROR_CANCELLED) {
2077                         WIFI_LOG(WIFI_INFO, "Ignore specific scan request reply, as operation is cancelled");
2078                         g_error_free(error);
2079                         __NETWORK_FUNC_EXIT__;
2080                         return;
2081                 }
2082
2083                 g_error_free(error);
2084         }
2085
2086         if (reply)
2087                 g_variant_unref(reply);
2088
2089         request_table = network_info->request_table;
2090
2091         if (Error == NET_ERR_IN_PROGRESS) {
2092                 /* should retry scan after receiving scan result */
2093                 if (request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN].flag == TRUE) {
2094                         WIFI_LOG(WIFI_INFO, "Specific Scan pending");
2095                         network_info->scan_pending = TRUE;
2096                 }
2097         } else if (Error != NET_ERR_NONE) {
2098                 WIFI_LOG(WIFI_ERROR, "Specific Scan failed. Error [%d]", Error);
2099
2100                 if (request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN].flag == TRUE) {
2101                         memset(&request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN],
2102                                         0, sizeof(network_request_table_s));
2103
2104                         event_data->Event = NET_EVENT_WIFI_SPECIFIC_SCAN_RSP;
2105                         event_data->Datalength = 0;
2106                         event_data->Data = NULL;
2107                         event_data->Error = Error;
2108
2109                         if (network_info->event_callback)
2110                                 network_info->event_callback(event_data, network_info->user_data);
2111
2112                         g_free(event_data);
2113                         __NETWORK_FUNC_EXIT__;
2114                         return;
2115                 }
2116
2117         } else
2118                 WIFI_LOG(WIFI_INFO, "Specific Scan Request success");
2119
2120         g_free(event_data);
2121         __NETWORK_FUNC_EXIT__;
2122 }
2123
2124 int _net_dbus_specific_scan_request(network_info_s *network_info, const char *ssid)
2125 {
2126         __NETWORK_FUNC_ENTER__;
2127         GVariant *params = NULL;
2128         GVariantBuilder *builder;
2129         net_err_e Error = NET_ERR_NONE;
2130
2131         WIFI_LOG(WIFI_ERROR, "specific scan ssid : %s", ssid);
2132
2133         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
2134         g_variant_builder_add(builder, "{sv}", "SSID", g_variant_new_string(ssid));
2135
2136         params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
2137         g_variant_builder_unref(builder);
2138
2139         /* use DBus signal than reply pending because of performance reason */
2140         Error = _net_invoke_dbus_method_nonblock(network_info,
2141                         CONNMAN_SERVICE, CONNMAN_WIFI_TECHNOLOGY_PREFIX,
2142                         CONNMAN_TECHNOLOGY_INTERFACE, "SpecificScan", params,
2143                         DBUS_REPLY_TIMEOUT, __net_specific_scan_request_reply);
2144
2145         if (Error == NET_ERR_IN_PROGRESS)
2146                 Error = NET_ERR_NONE; //LCOV_EXCL_LINE
2147
2148         __NETWORK_FUNC_EXIT__;
2149         return Error;
2150 }
2151
2152 int _net_dbus_bssid_scan_request(network_info_s *network_info)
2153 {
2154         __NETWORK_FUNC_ENTER__;
2155         net_err_e Error = NET_ERR_NONE;
2156         GVariant *params = NULL;
2157
2158         params = g_variant_new("(s)", network_info->interface_name);
2159
2160         Error = _net_invoke_dbus_method_nonblock(network_info,
2161                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
2162                         NETCONFIG_WIFI_INTERFACE, "RequestBssidScan",
2163                         params, 6 * DBUS_REPLY_TIMEOUT,
2164                         __net_bssid_scan_wifi_reply);
2165
2166         __NETWORK_FUNC_EXIT__;
2167         return Error;
2168 }
2169
2170 int _net_dbus_netlink_scan_request(network_info_s *network_info,
2171                 GSList *nl_scan_list, const char *vsie)
2172 {
2173         __NETWORK_FUNC_ENTER__;
2174         net_err_e Error = NET_ERR_NONE;
2175         GSList *list = NULL;
2176         GVariant *params = NULL;
2177         GVariantBuilder *builder;
2178         char ssid[NET_WLAN_ESSID_LEN + 1] = {0, };
2179
2180         WIFI_LOG(WIFI_INFO, "Number of elements in a list: %d", g_slist_length(nl_scan_list));
2181
2182         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
2183
2184         if (nl_scan_list != NULL) {
2185                 for (list = nl_scan_list; list; list = list->next) {
2186                         WIFI_LOG(WIFI_INFO, "AP name: %s", (char *)list->data);
2187                         g_strlcpy(ssid, (char *)list->data, NET_WLAN_ESSID_LEN + 1);
2188                         g_variant_builder_add(builder, "{sv}", "SSID", g_variant_new_string(ssid));
2189                 }
2190         }
2191
2192         if (vsie[0] != '\0') {
2193                 WIFI_LOG(WIFI_INFO, "VSIE: %s", vsie);
2194                 g_variant_builder_add(builder, "{sv}", "VSIE", g_variant_new_string(vsie));
2195         }
2196
2197         params = g_variant_new("(s@a{sv})", network_info->interface_name, g_variant_builder_end(builder));
2198         g_variant_builder_unref(builder);
2199
2200         Error = _net_invoke_dbus_method_nonblock(network_info,
2201                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
2202                         NETCONFIG_WIFI_INTERFACE, "NetlinkScan",
2203                         params, 6 * DBUS_REPLY_TIMEOUT,
2204                         __net_netlink_scan_wifi_reply);
2205
2206         __NETWORK_FUNC_EXIT__;
2207         return Error;
2208 }
2209
2210 int _net_dbus_get_passpoint(network_info_s *network_info, int *enabled)
2211 {
2212         __NETWORK_FUNC_ENTER__;
2213
2214         GVariant *params = NULL;
2215         GVariant *message = NULL;
2216         net_err_e Error = NET_ERR_NONE;
2217
2218         params = g_variant_new("(s)", network_info->interface_name);
2219
2220         message = _net_invoke_dbus_method(network_info,
2221                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
2222                         NETCONFIG_WIFI_INTERFACE, "GetPasspoint",
2223                         params, &Error);
2224         if (message == NULL) {
2225                 WIFI_LOG(WIFI_ERROR, "Failed to Get Passpoint");
2226                 __NETWORK_FUNC_EXIT__;
2227                 return Error;
2228         }
2229
2230         /** Check Reply */
2231         int result = 0;
2232         g_variant_get(message, "(i)", &result);
2233         *enabled = result;
2234
2235         WIFI_LOG(WIFI_INFO, "Get passpoint result: %d", result);
2236
2237         g_variant_unref(message);
2238
2239         __NETWORK_FUNC_EXIT__;
2240         return Error;
2241 }
2242
2243 int _net_dbus_set_passpoint(network_info_s *network_info, int enable)
2244 {
2245         __NETWORK_FUNC_ENTER__;
2246
2247         GVariant *params;
2248         net_err_e Error = NET_ERR_NONE;
2249
2250         params = g_variant_new("(si)", network_info->interface_name, enable);
2251
2252         Error = _net_invoke_dbus_method_nonblock(network_info,
2253                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
2254                         NETCONFIG_WIFI_INTERFACE, "SetPasspoint",
2255                         params, 6 * DBUS_REPLY_TIMEOUT,
2256                         __net_set_passpoint_reply);
2257
2258         __NETWORK_FUNC_EXIT__;
2259         return Error;
2260 }
2261
2262 int _net_dbus_add_vsie(network_info_s *network_info,
2263                 unsigned int frame_id, const char *vsie_str)
2264 {
2265         __NETWORK_FUNC_ENTER__;
2266
2267         GVariant *message = NULL;
2268         GVariant *params = NULL;
2269         net_err_e Error = NET_ERR_NONE;
2270
2271         params = g_variant_new("(sis)", network_info->interface_name, frame_id, vsie_str);
2272
2273         message = _net_invoke_dbus_method(network_info,
2274                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
2275                         NETCONFIG_WIFI_INTERFACE, "AddVsie",
2276                         params, &Error);
2277
2278         if (message == NULL) {
2279                 WIFI_LOG(WIFI_ERROR, "Failed to add vsie");
2280                 __NETWORK_FUNC_EXIT__;
2281                 return Error;
2282         }
2283
2284         g_variant_unref(message);
2285         WIFI_LOG(WIFI_INFO, "Successfully Added VSIE");
2286
2287         __NETWORK_FUNC_EXIT__;
2288         return Error;
2289 }
2290
2291 int _net_dbus_get_vsie(network_info_s *network_info,
2292                 unsigned int frame_id, char **vsie_str)
2293 {
2294         __NETWORK_FUNC_ENTER__;
2295
2296         GVariant *message = NULL;
2297         GVariant *params = NULL;
2298         const char *val = NULL;
2299         net_err_e Error = NET_ERR_NONE;
2300
2301         params = g_variant_new("(si)", network_info->interface_name, frame_id);
2302
2303         message = _net_invoke_dbus_method(network_info,
2304                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
2305                         NETCONFIG_WIFI_INTERFACE, "GetVsie",
2306                         params, &Error);
2307
2308         if (message == NULL) {
2309                 WIFI_LOG(WIFI_ERROR, "Failed to get vsie");
2310                 __NETWORK_FUNC_EXIT__;
2311                 return Error;
2312         }
2313
2314         /** Check Reply */
2315         g_variant_get(message, "(&s)", &val);
2316         if (val != NULL)
2317                 *vsie_str = g_strdup(val);
2318
2319         WIFI_LOG(WIFI_INFO, "GetVsie result: %s", *vsie_str);
2320
2321         g_variant_unref(message);
2322
2323         __NETWORK_FUNC_EXIT__;
2324         return Error;
2325 }
2326
2327 int _net_dbus_remove_vsie(network_info_s *network_info,
2328                 unsigned int frame_id, const char *vsie_str)
2329 {
2330         __NETWORK_FUNC_ENTER__;
2331
2332         GVariant *message = NULL;
2333         GVariant *params = NULL;
2334         net_err_e Error = NET_ERR_NONE;
2335
2336         params = g_variant_new("(sis)", network_info->interface_name, frame_id, vsie_str);
2337
2338         message = _net_invoke_dbus_method(network_info,
2339                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
2340                         NETCONFIG_WIFI_INTERFACE, "RemoveVsie",
2341                         params, &Error);
2342
2343         if (message == NULL) {
2344                 WIFI_LOG(WIFI_ERROR, "Failed to remove vsie");
2345                 __NETWORK_FUNC_EXIT__;
2346                 return Error;
2347         }
2348
2349         g_variant_unref(message);
2350         WIFI_LOG(WIFI_INFO, "Successfully Added VSIE");
2351
2352         __NETWORK_FUNC_EXIT__;
2353         return Error;
2354 }
2355
2356 int _net_dbus_flush_bss(network_info_s *network_info)
2357 {
2358         __NETWORK_FUNC_ENTER__;
2359
2360         net_err_e Error = NET_ERR_NONE;
2361         GVariant *params = NULL;
2362         GVariant *message = NULL;
2363
2364         params = g_variant_new("(s)", network_info->interface_name);
2365
2366         message = _net_invoke_dbus_method(network_info,
2367                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
2368                         NETCONFIG_WIFI_INTERFACE, "FlushBss",
2369                         params, &Error);
2370
2371         if (message == NULL) {
2372                 WIFI_LOG(WIFI_ERROR, "Failed to flush bss");
2373                 __NETWORK_FUNC_EXIT__;
2374                 return Error;
2375         }
2376
2377         g_variant_unref(message);
2378         WIFI_LOG(WIFI_INFO, "Successfully flush bss");
2379
2380         __NETWORK_FUNC_EXIT__;
2381         return Error;
2382 }
2383
2384 int _net_dbus_set_bssid(network_info_s *network_info, char *bssid)
2385 {
2386         __NETWORK_FUNC_ENTER__;
2387
2388         net_err_e Error = NET_ERR_NONE;
2389         GVariant *message = NULL;
2390
2391         const char *method = "SetBSSID";
2392         GVariant *params = NULL;
2393
2394         WIFI_LOG(WIFI_INFO, "SetBSSID [%s]", bssid);
2395
2396         params = g_variant_new("(ss)", network_info->interface_name, bssid);
2397
2398         message = _net_invoke_dbus_method(network_info,
2399                         CONNMAN_SERVICE, CONNMAN_WIFI_TECHNOLOGY_PREFIX,
2400                         CONNMAN_TECHNOLOGY_INTERFACE,
2401                         method, params, &Error);
2402
2403         if (message == NULL) {
2404                 WIFI_LOG(WIFI_ERROR, "Failed to set bssid");
2405                 __NETWORK_FUNC_EXIT__;
2406                 return Error;
2407         }
2408
2409         g_variant_unref(message);
2410
2411         __NETWORK_FUNC_EXIT__;
2412         return Error;
2413 }
2414
2415 int _net_dbus_get_5ghz_support(network_info_s *network_info, gboolean *supported)
2416 {
2417         __NETWORK_FUNC_ENTER__;
2418
2419         net_err_e Error = NET_ERR_NONE;
2420         GVariant *message = NULL;
2421         GVariant *value = NULL;
2422         GVariantIter *iter = NULL;
2423         gchar *key = NULL;
2424         gboolean is_5ghz_supported = FALSE;
2425
2426         message = _net_invoke_dbus_method(network_info,
2427                         CONNMAN_SERVICE, CONNMAN_WIFI_TECHNOLOGY_PREFIX,
2428                         CONNMAN_TECHNOLOGY_INTERFACE, "Get5GhzSupported",
2429                         NULL, &Error);
2430         if (message == NULL) {
2431                 WIFI_LOG(WIFI_ERROR, "Failed to get technology properties");
2432
2433                 __NETWORK_FUNC_EXIT__;
2434                 return Error;
2435         }
2436
2437         g_variant_get(message, "(a{sv})", &iter);
2438
2439         while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
2440                 if (g_strcmp0(key, "Is5GhzSupported") == 0) {
2441                         is_5ghz_supported = g_variant_get_boolean(value);
2442                         g_variant_unref(value);
2443                         g_free(key);
2444                         break;
2445                 }
2446         }
2447
2448         *supported = is_5ghz_supported;
2449
2450         WIFI_LOG(WIFI_INFO, "Successfully get 5ghz supported: %d", *supported);
2451
2452         g_variant_iter_free(iter);
2453         g_variant_unref(message);
2454
2455         __NETWORK_FUNC_EXIT__;
2456         return Error;
2457 }
2458
2459 int _net_dbus_get_auto_connect_mode(network_info_s *network_info,
2460                 int *connect_mode)
2461 {
2462         __NETWORK_FUNC_ENTER__;
2463
2464         net_err_e Error = NET_ERR_NONE;
2465         GVariant *message = NULL;
2466         GVariant *value = NULL;
2467         GVariantIter *iter = NULL;
2468         gchar *key = NULL;
2469         gboolean status = TRUE;
2470
2471         message = _net_invoke_dbus_method(network_info,
2472                         CONNMAN_SERVICE, CONNMAN_MANAGER_PATH,
2473                         CONNMAN_MANAGER_INTERFACE, "GetProperties",
2474                         NULL, &Error);
2475         if (message == NULL) {
2476                 WIFI_LOG(WIFI_ERROR, "Failed to get service properties");
2477
2478                 __NETWORK_FUNC_EXIT__;
2479                 return Error;
2480         }
2481
2482         g_variant_get(message, "(a{sv})", &iter);
2483
2484         while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
2485                 if (g_strcmp0(key, "AutoConnectMode") == 0) {
2486                         status = g_variant_get_boolean(value);
2487                         g_variant_unref(value);
2488                         g_free(key);
2489                         break;
2490                 }
2491         }
2492
2493         *connect_mode = (int)status;
2494
2495         WIFI_LOG(WIFI_INFO, "Successfully auto connect mode: %d", *connect_mode);
2496
2497         g_variant_iter_free(iter);
2498         g_variant_unref(message);
2499
2500         __NETWORK_FUNC_EXIT__;
2501         return Error;
2502 }
2503
2504
2505 int _net_dbus_set_auto_connect_mode(network_info_s *network_info, int connect_mode)
2506 {
2507         __NETWORK_FUNC_ENTER__;
2508
2509         GVariant *message = NULL;
2510         GVariant *params = NULL;
2511         net_err_e Error = NET_ERR_NONE;
2512         char key[] = "AutoConnectMode";
2513         gboolean value_enable = TRUE;
2514         gboolean value_disable = FALSE;
2515
2516         WIFI_LOG(WIFI_INFO, "Request auto connect mode [%s]",
2517                         connect_mode == 1 ? "enable" : "disable");
2518
2519         params = g_variant_new("(sv)", key, (connect_mode == 1) ?
2520                 g_variant_new_boolean(value_enable) : g_variant_new_boolean(value_disable));
2521
2522         message = _net_invoke_dbus_method(network_info,
2523                         CONNMAN_SERVICE, CONNMAN_MANAGER_PATH,
2524                         CONNMAN_MANAGER_INTERFACE, "SetProperty",
2525                         params, &Error);
2526         if (message == NULL) {
2527                 WIFI_LOG(WIFI_ERROR, "Failed to Set AutoConnect");
2528                 __NETWORK_FUNC_EXIT__;
2529                 return Error;
2530         }
2531
2532         g_variant_unref(message);
2533
2534         __NETWORK_FUNC_EXIT__;
2535         return Error;
2536 }
2537
2538 int _net_dbus_wifi_set_autoconnect(network_info_s *network_info,
2539                 const char *profile_name, gboolean autoconnect)
2540 {
2541         __NETWORK_FUNC_ENTER__;
2542
2543         net_err_e Error = NET_ERR_NONE;
2544
2545         GVariant *message = NULL;
2546         GVariant *params = NULL;
2547
2548         WIFI_LOG(WIFI_INFO, "[%s] auto connect", autoconnect ? "enable" : "disable");
2549
2550         params = g_variant_new("(sv)", "AutoConnect", g_variant_new_boolean(autoconnect));
2551
2552         message = _net_invoke_dbus_method(network_info,
2553                         CONNMAN_SERVICE, profile_name,
2554                         CONNMAN_SERVICE_INTERFACE, "SetProperty",
2555                         params, &Error);
2556         if (message == NULL) {
2557                 WIFI_LOG(WIFI_ERROR, "Failed to Set AutoConnect");
2558                 __NETWORK_FUNC_EXIT__;
2559                 return Error;
2560         }
2561
2562         g_variant_unref(message);
2563
2564         __NETWORK_FUNC_EXIT__;
2565         return Error;
2566 }
2567
2568 int _net_dbus_wifi_get_autoconnect(network_info_s *network_info,
2569                 const char *profile_name, gboolean *autoconnect)
2570 {
2571         __NETWORK_FUNC_ENTER__;
2572
2573         net_err_e Error = NET_ERR_NONE;
2574         GVariant *message = NULL;
2575         GVariant *value = NULL;
2576         GVariantIter *iter = NULL;
2577         gchar *key = NULL;
2578
2579         message = _net_invoke_dbus_method(network_info,
2580                         CONNMAN_SERVICE, profile_name,
2581                         CONNMAN_SERVICE_INTERFACE, "GetProperties",
2582                         NULL, &Error);
2583         if (message == NULL) {
2584                 WIFI_LOG(WIFI_ERROR, "Failed to get service properties");
2585                 __NETWORK_FUNC_EXIT__;
2586                 return Error;
2587         }
2588
2589         g_variant_get(message, "(a{sv})", &iter);
2590
2591         while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
2592                 if (g_strcmp0(key, "AutoConnect") == 0) {
2593                         *autoconnect = g_variant_get_boolean(value);
2594                         g_variant_unref(value);
2595                         g_free(key);
2596                         break;
2597                 }
2598         }
2599
2600         WIFI_LOG(WIFI_INFO, "Successfully get autoconnect: %d", *autoconnect);
2601
2602         g_variant_iter_free(iter);
2603         g_variant_unref(message);
2604
2605         __NETWORK_FUNC_EXIT__;
2606         return Error;
2607 }
2608
2609 static void __net_wps_cancel_reply(GObject *source_object,
2610                 GAsyncResult *res, gpointer user_data)
2611 {
2612         __NETWORK_FUNC_ENTER__;
2613
2614         WIFI_LOG(WIFI_INFO, "__net_wps_cancel_wifi_reply() called");
2615
2616         GDBusConnection *conn = NULL;
2617         GVariant *dbus_result = NULL;
2618         GError *error = NULL;
2619
2620         conn = G_DBUS_CONNECTION(source_object);
2621         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
2622
2623         if (error != NULL) {
2624                 WIFI_LOG(WIFI_ERROR, "error msg - [%s]", error->message);
2625                 if (error->code == G_IO_ERROR_CANCELLED) {
2626                         WIFI_LOG(WIFI_INFO, "Ignore wps cancel reply, as operation is cancelled");
2627                         g_error_free(error);
2628                         __NETWORK_FUNC_EXIT__;
2629                         return;
2630                 }
2631
2632                 g_error_free(error);
2633         }
2634
2635         if (dbus_result)
2636                 g_variant_unref(dbus_result);
2637
2638         __NETWORK_FUNC_EXIT__;
2639 }
2640
2641
2642 int _net_dbus_cancel_wps(network_info_s *network_info)
2643 {
2644         __NETWORK_FUNC_ENTER__;
2645
2646         GVariant *params = NULL;
2647         net_err_e Error = NET_ERR_NONE;
2648
2649         params = g_variant_new("(s)", network_info->interface_name);
2650
2651         Error = _net_invoke_dbus_method_nonblock(network_info,
2652                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
2653                         NETCONFIG_WIFI_INTERFACE, "RequestWpsCancel",
2654                         params, DBUS_REPLY_TIMEOUT,
2655                         __net_wps_cancel_reply);
2656
2657         __NETWORK_FUNC_EXIT__;
2658         return Error;
2659
2660 }
2661
2662 static void __net_wps_connect_wifi_reply(GObject *source_object,
2663                                                 GAsyncResult *res, gpointer user_data)
2664 {
2665         __NETWORK_FUNC_ENTER__;
2666
2667         GDBusConnection *conn = NULL;
2668         GError *error = NULL;
2669         GVariant *dbus_result = NULL;
2670         net_event_info_s *event_data = NULL;
2671         net_err_e Error = NET_ERR_NONE;
2672         network_info_s *network_info = (network_info_s *)user_data;
2673         network_request_table_s *request_table;
2674         network_request_table_s *wps_info;
2675
2676         event_data = g_try_malloc0(sizeof(net_event_info_s));
2677         if (event_data == NULL) {
2678                 __NETWORK_FUNC_EXIT__;
2679                 return;
2680         }
2681
2682         conn = G_DBUS_CONNECTION(source_object);
2683         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
2684
2685         if (error != NULL) {
2686                 WIFI_LOG(WIFI_INFO, "error msg - [%s]", error->message);
2687                 Error = __net_error_string_to_enum(error->message);
2688                 if (error->code == G_IO_ERROR_CANCELLED) {
2689                         WIFI_LOG(WIFI_INFO, "Ignore wps connect reply, as operation is cancelled");
2690                         g_error_free(error);
2691                         __NETWORK_FUNC_EXIT__;
2692                         return;
2693                 }
2694
2695                 g_error_free(error);
2696         } else
2697                 WIFI_LOG(WIFI_INFO, "error msg is NULL");
2698
2699         if (dbus_result)
2700                 g_variant_unref(dbus_result);
2701
2702         if (Error == NET_ERR_NONE) {
2703                 g_free(event_data);
2704                 __NETWORK_FUNC_EXIT__;
2705                 return;
2706         }
2707
2708         WIFI_LOG(WIFI_ERROR, "Connection open failed. Error [%d]", Error);
2709
2710         request_table = network_info->request_table;
2711         wps_info = &request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS];
2712
2713         memset(wps_info, 0, sizeof(network_request_table_s));
2714
2715         event_data->Error = Error;
2716         event_data->Event = NET_EVENT_WIFI_WPS_RSP;
2717
2718         WIFI_LOG(WIFI_INFO, "Sending NET_EVENT_WIFI_WPS_RSP Error = %s",
2719                         _net_print_error(event_data->Error));
2720
2721         if (network_info->event_callback)
2722                 network_info->event_callback(event_data, network_info->user_data);
2723
2724         g_free(event_data);
2725         __NETWORK_FUNC_EXIT__;
2726 }
2727
2728 int _net_dbus_open_connection_without_ssid(network_info_s *network_info)
2729 {
2730         __NETWORK_FUNC_ENTER__;
2731
2732         net_err_e Error = NET_ERR_NONE;
2733         GVariant *params = NULL;
2734
2735         params = g_variant_new("(ss)", network_info->interface_name, "PBC");
2736         WIFI_LOG(WIFI_INFO, "Invoke wps connection without ssid");
2737
2738         Error = _net_invoke_dbus_method_nonblock(network_info,
2739                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
2740                         NETCONFIG_WIFI_INTERFACE, "RequestWpsConnect",
2741                         params, DBUS_REPLY_TIMEOUT,
2742                         __net_wps_connect_wifi_reply);
2743
2744         __NETWORK_FUNC_EXIT__;
2745         return Error;
2746 }
2747
2748 int _net_dbus_open_pin_connection_without_ssid(network_info_s *network_info,
2749                 const char *pin)
2750 {
2751         __NETWORK_FUNC_ENTER__;
2752
2753         net_err_e Error = NET_ERR_NONE;
2754
2755         GVariant *params = NULL;
2756         params = g_variant_new("(ss)", network_info->interface_name, pin);
2757
2758         Error = _net_invoke_dbus_method_nonblock(network_info,
2759                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
2760                         NETCONFIG_WIFI_INTERFACE, "RequestWpsConnect",
2761                         params, DBUS_REPLY_TIMEOUT,
2762                         __net_wps_connect_wifi_reply);
2763
2764
2765         __NETWORK_FUNC_EXIT__;
2766         return Error;
2767 }
2768
2769 int _net_dbus_dpp_enter_peer_uri(network_info_s *network_info,
2770                 guint32 peer_id, guint32 own_id, const char *uri)
2771 {
2772         __NETWORK_FUNC_ENTER__;
2773
2774         GVariant *params = NULL;
2775         GVariantBuilder *builder;
2776         GVariant *message = NULL;
2777         net_err_e Error = NET_ERR_NONE;
2778
2779         /* TODO: send & handle dbus */
2780         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
2781
2782         g_variant_builder_add(builder, "{sv}", "peer_id", g_variant_new_uint32(peer_id));
2783         g_variant_builder_add(builder, "{sv}", "own_id", g_variant_new_uint32(own_id));
2784         g_variant_builder_add(builder, "{sv}", "uri", g_variant_new_string(uri));
2785
2786         params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
2787         g_variant_builder_unref(builder);
2788
2789         message = _net_invoke_dbus_method(network_info,
2790                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE,
2791                         "DppEnterPeerUri", params, &Error);
2792
2793         if (message == NULL) {
2794                 WIFI_LOG(WIFI_ERROR, "Failed to DppEnterPeerUri");
2795                 __NETWORK_FUNC_EXIT__;
2796                 return Error;
2797         }
2798
2799         g_variant_unref(message);
2800         WIFI_LOG(WIFI_INFO, "Successfully DppEnterPeerUri");
2801
2802         __NETWORK_FUNC_EXIT__;
2803         return Error;
2804 }
2805
2806 int _net_dbus_dpp_generate_uri(network_info_s *network_info,
2807                 guint32 peer_id, guint32 own_id, gboolean is_initiator, const char *key)
2808 {
2809         __NETWORK_FUNC_ENTER__;
2810
2811         GVariant *params = NULL;
2812         GVariantBuilder *builder;
2813         GVariant *message = NULL;
2814         net_err_e Error = NET_ERR_NONE;
2815
2816         /* TODO: send & handle dbus */
2817         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
2818
2819         g_variant_builder_add(builder, "{sv}", "peer_id", g_variant_new_uint32(peer_id));
2820         g_variant_builder_add(builder, "{sv}", "own_id", g_variant_new_uint32(own_id));
2821         g_variant_builder_add(builder, "{sv}", "is_initiator", g_variant_new_boolean(is_initiator));
2822         if (key)
2823                 g_variant_builder_add(builder, "{sv}", "key", g_variant_new_string(key));
2824
2825         params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
2826         g_variant_builder_unref(builder);
2827
2828         message = _net_invoke_dbus_method(network_info,
2829                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE,
2830                         "DppGenerateUri", params, &Error);
2831
2832         if (message == NULL) {
2833                 WIFI_LOG(WIFI_ERROR, "Failed to DppGenerateUri");
2834                 __NETWORK_FUNC_EXIT__;
2835                 return Error;
2836         }
2837
2838         g_variant_unref(message);
2839         WIFI_LOG(WIFI_INFO, "Successfully DppGenerateUri");
2840
2841         __NETWORK_FUNC_EXIT__;
2842         return Error;
2843 }
2844
2845 int _net_dbus_dpp_start_configurator_initiator(network_info_s *network_info,
2846                 const gchar *group_id, const gchar *ssid,
2847                 const gchar *peer_uri, guint32 peer_id, const gchar *net_role,
2848                 const gchar *akm, const gchar *configurator_key, const gchar *pass)
2849 {
2850         __NETWORK_FUNC_ENTER__;
2851         GVariant *params = NULL;
2852         GVariantBuilder *builder;
2853         GVariant *message = NULL;
2854         net_err_e Error = NET_ERR_NONE;
2855
2856         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
2857         if (group_id)
2858                 g_variant_builder_add(builder, "{sv}", "group_id", g_variant_new_string(group_id));
2859         if (ssid)
2860                 g_variant_builder_add(builder, "{sv}", "ssid", g_variant_new_string(ssid));
2861         if (peer_uri)
2862                 g_variant_builder_add(builder, "{sv}", "peer_uri", g_variant_new_string(peer_uri));
2863         g_variant_builder_add(builder, "{sv}", "peer_id", g_variant_new_uint32(peer_id));
2864         if (net_role)
2865                 g_variant_builder_add(builder, "{sv}", "net_role", g_variant_new_string(net_role));
2866         if (akm)
2867                 g_variant_builder_add(builder, "{sv}", "akm", g_variant_new_string(akm));
2868         if (configurator_key)
2869                 g_variant_builder_add(builder, "{sv}", "configurator_key", g_variant_new_string(configurator_key));
2870         if (pass)
2871                 g_variant_builder_add(builder, "{sv}", "pass", g_variant_new_string(pass));
2872         params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
2873         g_variant_builder_unref(builder);
2874
2875         message = _net_invoke_dbus_method(network_info,
2876                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE,
2877                         "DppStartConfiguratorInitiator", params, &Error);
2878
2879         if (message == NULL) {
2880                 WIFI_LOG(WIFI_ERROR, "Failed to DppStartConfiguratorInitiator");
2881                 __NETWORK_FUNC_EXIT__;
2882                 return Error;
2883         }
2884
2885         g_variant_unref(message);
2886         WIFI_LOG(WIFI_INFO, "Successfully DppStartConfiguratorInitiator");
2887
2888         __NETWORK_FUNC_EXIT__;
2889         return Error;
2890 }
2891
2892 int _net_dbus_dpp_start_enrollee_initiator(network_info_s *network_info,
2893                 const gchar *peer_uri, guint32 peer_id)
2894 {
2895         __NETWORK_FUNC_ENTER__;
2896         GVariant *params = NULL;
2897         GVariantBuilder *builder;
2898         GVariant *message = NULL;
2899         net_err_e Error = NET_ERR_NONE;
2900
2901         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
2902         if (peer_uri)
2903                 g_variant_builder_add(builder, "{sv}", "peer_uri", g_variant_new_string(peer_uri));
2904         g_variant_builder_add(builder, "{sv}", "peer_id", g_variant_new_uint32(peer_id));
2905         params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
2906         g_variant_builder_unref(builder);
2907
2908         message = _net_invoke_dbus_method(network_info,
2909                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE,
2910                         "DppStartEnrolleeInitiator", params, &Error);
2911
2912         if (message == NULL) {
2913                 WIFI_LOG(WIFI_ERROR, "Failed to DppStartEnrolleeInitiator");
2914                 __NETWORK_FUNC_EXIT__;
2915                 return Error;
2916         }
2917
2918         g_variant_unref(message);
2919         WIFI_LOG(WIFI_INFO, "Successfully DppStartEnrolleeInitiator");
2920
2921         __NETWORK_FUNC_EXIT__;
2922         return Error;
2923 }
2924
2925 int _net_dbus_dpp_start_configurator_responder(network_info_s *network_info,
2926                 const gchar *group_id, const gchar *ssid, const gchar *net_role, const gchar *akm,
2927                 const gchar *auth_key, const gchar *configurator_key, const gchar *pass)
2928 {
2929         __NETWORK_FUNC_ENTER__;
2930         GVariant *params = NULL;
2931         GVariantBuilder *builder;
2932         GVariant *message = NULL;
2933         net_err_e Error = NET_ERR_NONE;
2934
2935         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
2936         if (group_id)
2937                 g_variant_builder_add(builder, "{sv}", "group_id", g_variant_new_string(group_id));
2938         if (ssid)
2939                 g_variant_builder_add(builder, "{sv}", "ssid", g_variant_new_string(ssid));
2940         if (net_role)
2941                 g_variant_builder_add(builder, "{sv}", "net_role", g_variant_new_string(net_role));
2942         if (akm)
2943                 g_variant_builder_add(builder, "{sv}", "akm", g_variant_new_string(akm));
2944         if (auth_key)
2945                 g_variant_builder_add(builder, "{sv}", "auth_key", g_variant_new_string(auth_key));
2946         if (configurator_key)
2947                 g_variant_builder_add(builder, "{sv}", "configurator_key", g_variant_new_string(configurator_key));
2948         if (pass)
2949                 g_variant_builder_add(builder, "{sv}", "pass", g_variant_new_string(pass));
2950         params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
2951         g_variant_builder_unref(builder);
2952
2953         message = _net_invoke_dbus_method(network_info,
2954                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE,
2955                         "DppStartConfiguratorResponder", params, &Error);
2956
2957         if (message == NULL) {
2958                 WIFI_LOG(WIFI_ERROR, "Failed to DppStartConfiguratorResponder");
2959                 __NETWORK_FUNC_EXIT__;
2960                 return Error;
2961         }
2962
2963         g_variant_unref(message);
2964         WIFI_LOG(WIFI_INFO, "Successfully DppStartConfiguratorResponder");
2965
2966         __NETWORK_FUNC_EXIT__;
2967         return Error;
2968 }
2969
2970 int _net_dbus_dpp_start_enrollee_responder(network_info_s *network_info,
2971                 const gchar *auth_key)
2972 {
2973         __NETWORK_FUNC_ENTER__;
2974         GVariant *params = NULL;
2975         GVariantBuilder *builder;
2976         GVariant *message = NULL;
2977         net_err_e Error = NET_ERR_NONE;
2978
2979         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
2980         if (auth_key)
2981                 g_variant_builder_add(builder, "{sv}", "auth_key", g_variant_new_string(auth_key));
2982         params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
2983         g_variant_builder_unref(builder);
2984
2985         message = _net_invoke_dbus_method(network_info,
2986                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE,
2987                         "DppStartEnrolleeResponder", params,  &Error);
2988
2989         if (message == NULL) {
2990                 WIFI_LOG(WIFI_ERROR, "Failed to DppStartEnrolleeResponder");
2991                 __NETWORK_FUNC_EXIT__;
2992                 return Error;
2993         }
2994
2995         g_variant_unref(message);
2996         WIFI_LOG(WIFI_INFO, "Successfully DppStartEnrolleeResponder");
2997
2998         __NETWORK_FUNC_EXIT__;
2999         return Error;
3000 }
3001
3002 int _net_dbus_dpp_stop(network_info_s *network_info,
3003                 guint32 peer_id, guint32 own_id, gboolean is_initiator)
3004 {
3005         __NETWORK_FUNC_ENTER__;
3006         GVariant *params = NULL;
3007         GVariantBuilder *builder;
3008         GVariant *message = NULL;
3009         net_err_e Error = NET_ERR_NONE;
3010
3011         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
3012
3013         g_variant_builder_add(builder, "{sv}", "peer_id", g_variant_new_uint32(peer_id));
3014         g_variant_builder_add(builder, "{sv}", "own_id", g_variant_new_uint32(own_id));
3015         g_variant_builder_add(builder, "{sv}", "is_initiator", g_variant_new_boolean(is_initiator));
3016
3017         params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
3018         g_variant_builder_unref(builder);
3019
3020         message = _net_invoke_dbus_method(network_info,
3021                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE,
3022                         "DppStop", params, &Error);
3023
3024         if (message == NULL) {
3025                 WIFI_LOG(WIFI_ERROR, "Failed to stop DPP");
3026                 __NETWORK_FUNC_EXIT__;
3027                 return Error;
3028         }
3029
3030         g_variant_unref(message);
3031         WIFI_LOG(WIFI_INFO, "Successfully stop DPP");
3032
3033         __NETWORK_FUNC_EXIT__;
3034         return Error;
3035 }
3036
3037 int _net_dbus_tdls_disconnect(network_info_s *network_info, const char* peer_mac_addr)
3038 {
3039         __NETWORK_FUNC_ENTER__;
3040
3041         net_err_e Error = NET_ERR_NONE;
3042         GVariant *message = NULL;
3043         GVariant *params = NULL;
3044         const char *method = "TdlsDisconnect";
3045         gint32 ret = -1;
3046
3047         params = g_variant_new("(ss)", network_info->interface_name, peer_mac_addr);
3048
3049         message = _net_invoke_dbus_method(network_info,
3050                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
3051                         NETCONFIG_WIFI_INTERFACE, method,
3052                         params, &Error);
3053
3054         if (message == NULL) {
3055                 WIFI_LOG(WIFI_ERROR, "Failed to TDLS Disconnect Request");
3056                 __NETWORK_FUNC_EXIT__;
3057                 return Error;
3058         }
3059
3060         g_variant_get(message, "(i)", &ret);
3061
3062         WIFI_LOG(WIFI_INFO, "[%s] success", method);
3063         WIFI_LOG(WIFI_INFO, ", status [%d]", ret);
3064
3065         /**
3066          * Below are the expected error codes
3067          * 0x00 - NETCONFIG_ERROR_TDLS_NO_ERROR
3068          * 0x01 - NETCONFIG_ERROR_INTERNAL
3069          * 0x04 - NETCONFIG_ERROR_TDLS_ALREADY_DONE
3070          */
3071         if (ret == 0x00 || ret == 0x04)
3072                 Error = NET_ERR_NONE;
3073         else
3074                 Error = NET_ERR_UNKNOWN;
3075
3076         g_variant_unref(message);
3077         __NETWORK_FUNC_EXIT__;
3078
3079         return Error;
3080 }
3081
3082 int _net_dbus_tdls_connected_peer(network_info_s *network_info,
3083                 char** peer_mac_addr)
3084 {
3085         __NETWORK_FUNC_ENTER__;
3086
3087         net_err_e Error = NET_ERR_NONE;
3088         GVariant *message = NULL;
3089         const char *method = "TdlsConnectedPeer";
3090
3091         if (NULL == peer_mac_addr) {
3092                         WIFI_LOG(WIFI_ERROR, "Invalid Parameter");
3093                         __NETWORK_FUNC_EXIT__;
3094                         return NET_ERR_INVALID_PARAM;
3095         }
3096
3097         message = _net_invoke_dbus_method(network_info,
3098                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
3099                         NETCONFIG_WIFI_INTERFACE, method,
3100                         g_variant_new("(s)", network_info->interface_name),
3101                         &Error);
3102
3103         if (message == NULL) {
3104                 WIFI_LOG(WIFI_ERROR, "Failed to Get Peer Connected Mac address");
3105                 __NETWORK_FUNC_EXIT__;
3106                 return Error;
3107         }
3108
3109         g_variant_get(message, "(s)", peer_mac_addr);
3110
3111         WIFI_LOG(WIFI_INFO, "[%s] success", method);
3112         WIFI_LOG(WIFI_INFO, "TDLS Peer Mac address [%s]", *peer_mac_addr);
3113
3114         g_variant_unref(message);
3115         __NETWORK_FUNC_EXIT__;
3116
3117         return Error;
3118 }
3119
3120 int _net_dbus_tdls_connect(network_info_s *network_info, const char *peer_mac_addr)
3121 {
3122
3123         __NETWORK_FUNC_ENTER__;
3124
3125         net_err_e Error = NET_ERR_NONE;
3126         GVariant *message = NULL;
3127         GVariant *params = NULL;
3128         const char *method = "TdlsConnect";
3129         gint32 ret = -1;
3130
3131         params = g_variant_new("(ss)", network_info->interface_name, peer_mac_addr);
3132
3133         message = _net_invoke_dbus_method(network_info,
3134                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
3135                         NETCONFIG_WIFI_INTERFACE, method,
3136                         params, &Error);
3137
3138         if (message == NULL) {
3139                 WIFI_LOG(WIFI_ERROR, "Failed to TDLS Connect Request");
3140                 __NETWORK_FUNC_EXIT__;
3141                 return Error;
3142         }
3143
3144         g_variant_get(message, "(i)", &ret);
3145
3146         WIFI_LOG(WIFI_INFO, "[%s] success", method);
3147         WIFI_LOG(WIFI_INFO, ", status [%d]", ret);
3148
3149         /**
3150          * Below are the expected error codes
3151          * 0x00 - NETCONFIG_ERROR_TDLS_NO_ERROR
3152          * 0x01 - NETCONFIG_ERROR_INTERNAL
3153          */
3154         if (ret == 0x00)
3155                 Error = NET_ERR_NONE;
3156         else
3157                 Error = NET_ERR_UNKNOWN;
3158
3159         g_variant_unref(message);
3160         __NETWORK_FUNC_EXIT__;
3161
3162         return Error;
3163 }
3164
3165 int _net_dbus_tdls_discover(network_info_s *network_info, const char *peer_mac_addr)
3166 {
3167
3168         __NETWORK_FUNC_ENTER__;
3169
3170         net_err_e Error = NET_ERR_NONE;
3171         GVariant *message = NULL;
3172         GVariant *params = NULL;
3173         const char *method = "TdlsDiscover";
3174         gint32 ret = -1;
3175
3176         params = g_variant_new("(ss)", network_info->interface_name, peer_mac_addr);
3177
3178         message = _net_invoke_dbus_method(network_info,
3179                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
3180                         NETCONFIG_WIFI_INTERFACE, method,
3181                         params, &Error);
3182
3183         if (message == NULL) {
3184                 WIFI_LOG(WIFI_ERROR, "Failed to request TDLS discover : Error [%d]", Error);
3185                 __NETWORK_FUNC_EXIT__;
3186                 return Error;
3187         }
3188
3189         g_variant_get(message, "(i)", &ret);
3190
3191         WIFI_LOG(WIFI_INFO, "[%s] success", method);
3192         WIFI_LOG(WIFI_INFO, ", status [%d]", ret);
3193
3194         /**
3195          * Below are the expected error codes
3196          * 0x00 - NETCONFIG_ERROR_TDLS_NO_ERROR
3197          * 0x01 - NETCONFIG_ERROR_INTERNAL
3198          * 0x04 - NETCONFIG_ERROR_TDLS_ALREADY_DONE
3199          */
3200         if (ret == 0x00)
3201                 Error = NET_ERR_NONE;
3202         else if (ret == 0x01)
3203                 Error = NET_ERR_FAIL_TDLS_DISCOVER;
3204         else if (ret == 0x04) /* 0x04: TDLS Discovery in Progress at lower layer */
3205                 Error = NET_ERR_IN_PROGRESS;
3206         else
3207                 Error = NET_ERR_UNKNOWN;
3208
3209         __NETWORK_FUNC_EXIT__;
3210
3211         return Error;
3212 }
3213
3214 int _net_dbus_tdls_enable_channel_switch(network_info_s *network_info,
3215                 const char* peer_mac_addr, int freq)
3216 {
3217         __NETWORK_FUNC_ENTER__;
3218
3219         net_err_e Error = NET_ERR_NONE;
3220         GVariant *message = NULL;
3221         GVariant *params = NULL;
3222         gint32 ret = -1;
3223
3224         params = g_variant_new("(ssi)", network_info->interface_name, peer_mac_addr, freq);
3225
3226         message = _net_invoke_dbus_method(network_info,
3227                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
3228                         NETCONFIG_WIFI_INTERFACE, "TdlsChannelSwitch",
3229                         params, &Error);
3230
3231         if (message == NULL) {
3232                 WIFI_LOG(WIFI_ERROR, "Failed to Enable TDLS Channel Switch Request");
3233                 __NETWORK_FUNC_EXIT__;
3234                 return Error;
3235         }
3236
3237         g_variant_get(message, "(i)", &ret);
3238
3239         WIFI_LOG(WIFI_INFO, "Status [%d]", ret);
3240
3241         if (ret == 0)
3242                 Error = NET_ERR_NONE;
3243         else
3244                 Error = NET_ERR_UNKNOWN;
3245
3246         g_variant_unref(message);
3247         __NETWORK_FUNC_EXIT__;
3248
3249         return Error;
3250 }
3251
3252 int _net_dbus_tdls_disable_channel_switch(network_info_s *network_info,
3253                 const char* peer_mac_addr)
3254 {
3255         __NETWORK_FUNC_ENTER__;
3256
3257         net_err_e Error = NET_ERR_NONE;
3258         GVariant *message = NULL;
3259         GVariant *params = NULL;
3260         gint32 ret = -1;
3261
3262         params = g_variant_new("(ss)", network_info->interface_name, peer_mac_addr);
3263
3264         message = _net_invoke_dbus_method(network_info,
3265                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
3266                         NETCONFIG_WIFI_INTERFACE, "TdlsCancelChannelSwitch",
3267                         params, &Error);
3268
3269         if (message == NULL) {
3270                 WIFI_LOG(WIFI_ERROR, "Failed to Disable TDLS Channel Switch Request");
3271                 __NETWORK_FUNC_EXIT__;
3272                 return Error;
3273         }
3274
3275         g_variant_get(message, "(i)", &ret);
3276
3277         WIFI_LOG(WIFI_INFO, "Status [%d]", ret);
3278
3279         if (ret == 0)
3280                 Error = NET_ERR_NONE;
3281         else
3282                 Error = NET_ERR_UNKNOWN;
3283
3284         g_variant_unref(message);
3285         __NETWORK_FUNC_EXIT__;
3286
3287         return Error;
3288 }
3289
3290
3291
3292 int _net_dbus_config_get_id_list(network_info_s *network_info, GSList **list)
3293 {
3294         __NETWORK_FUNC_ENTER__;
3295
3296         net_err_e Error = NET_ERR_NONE;
3297         GVariant *message = NULL;
3298         GVariantIter *iter = NULL;
3299         gchar *config_id = NULL;
3300
3301         message = _net_invoke_dbus_method(network_info,
3302                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
3303                         NETCONFIG_WIFI_INTERFACE, "GetConfigIds",
3304                         g_variant_new("(s)", network_info->interface_name), &Error);
3305
3306         if (message == NULL) {
3307                 WIFI_LOG(WIFI_ERROR, "Failed to GetConfigIds");
3308                 __NETWORK_FUNC_EXIT__;
3309                 return Error;
3310         }
3311
3312         g_variant_get(message, "(as)", &iter);
3313         while (g_variant_iter_loop(iter, "s", &config_id))
3314                 *list = g_slist_append(*list, g_strdup(config_id));
3315
3316         g_variant_iter_free(iter);
3317         g_variant_unref(message);
3318
3319         __NETWORK_FUNC_EXIT__;
3320
3321         return Error;
3322 }
3323
3324 int _net_dbus_config_set_field(network_info_s *network_info,
3325                 const gchar *config_id, const gchar *key, const gchar *value)
3326 {
3327         __NETWORK_FUNC_ENTER__;
3328
3329         net_err_e Error = NET_ERR_NONE;
3330         GVariant *message = NULL;
3331
3332         message = _net_invoke_dbus_method(network_info,
3333                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
3334                         NETCONFIG_WIFI_INTERFACE, "SetConfigField",
3335                         g_variant_new("(sss)", config_id, key, value), &Error);
3336
3337         if (message == NULL) {
3338                 WIFI_LOG(WIFI_ERROR, "Failed to SetConfigField");
3339                 __NETWORK_FUNC_EXIT__;
3340                 return Error;
3341         }
3342
3343         g_variant_unref(message);
3344
3345         __NETWORK_FUNC_EXIT__;
3346
3347         return Error;
3348 }
3349
3350 int _net_dbus_config_get_passphrase(network_info_s *network_info,
3351                 const gchar *config_id, gchar **passphrase)
3352 {
3353         __NETWORK_FUNC_ENTER__;
3354
3355         net_err_e Error = NET_ERR_NONE;
3356         GVariant *message = NULL;
3357         gchar *val = NULL;
3358
3359         message = _net_invoke_dbus_method(network_info,
3360                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
3361                         NETCONFIG_WIFI_INTERFACE, "GetConfigPassphrase",
3362                         g_variant_new("(s)", config_id), &Error);
3363
3364         if (message == NULL) {
3365                 WIFI_LOG(WIFI_ERROR, "Failed to GetConfigPassphrase");
3366                 __NETWORK_FUNC_EXIT__;
3367                 return Error;
3368         }
3369
3370         g_variant_get(message, "(s)", &val);
3371
3372         *passphrase = g_strdup(val);
3373         g_free(val);
3374
3375         g_variant_unref(message);
3376
3377         __NETWORK_FUNC_EXIT__;
3378
3379         return Error;
3380 }
3381
3382 int _net_dbus_config_save_configurations(network_info_s *network_info,
3383                 const gchar *config_id, const gchar *name, const gchar *ssid, const gchar *passphrase,
3384                 const gchar *proxy_address, net_ip_info_config_s *ip_info, guint32 frequency,
3385                 gboolean is_hidden, gboolean is_created)
3386 {
3387         __NETWORK_FUNC_ENTER__;
3388
3389         net_err_e Error = NET_ERR_NONE;
3390         GVariantBuilder *b = NULL;
3391         GVariant *params = NULL;
3392         GVariant *message = NULL;
3393         const char *manual_method = "manual";
3394         const char *dhcp_method = "dhcp";
3395         int i;
3396         char *dns_address = NULL, *temp = NULL;
3397
3398         b = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
3399         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_NAME, g_variant_new_string(name));
3400         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_SSID, g_variant_new_string(ssid));
3401         if (passphrase != NULL)
3402                 g_variant_builder_add(b, "{sv}", WIFI_CONFIG_PASSPHRASE, g_variant_new_string(passphrase));
3403         if (proxy_address != NULL)
3404                 g_variant_builder_add(b, "{sv}", WIFI_CONFIG_PROXYADDRESS, g_variant_new_string(proxy_address));
3405         if (is_hidden == TRUE)
3406                 g_variant_builder_add(b, "{sv}", WIFI_CONFIG_HIDDEN, g_variant_new_string("TRUE"));
3407         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_FREQUENCY, g_variant_new_uint32(frequency));
3408         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_CREATED, g_variant_new_boolean(is_created));
3409
3410         switch (ip_info->ip_type) {
3411         case NET_IP_CONFIG_TYPE_STATIC:
3412                 g_variant_builder_add(b, "{sv}", WIFI_CONFIG_IPV4_METHOD,
3413                                                   g_variant_new_string(manual_method));
3414
3415                 if (ip_info->ip_address)
3416                         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_IPV4_ADDRESS,
3417                                                   g_variant_new_string(ip_info->ip_address));
3418
3419                 if (ip_info->subnet_mask)
3420                         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_IPV4_SUBNET_MASK,
3421                                                   g_variant_new_string(ip_info->subnet_mask));
3422
3423                 if (ip_info->prefix_length > 0)
3424                         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_IPV6_PREFIX_LEN,
3425                                                   g_variant_new_int32(ip_info->prefix_length));
3426
3427                 if (ip_info->gateway_address)
3428                         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_IPV4_GATEWAY_ADDRESS,
3429                                           g_variant_new_string(ip_info->gateway_address));
3430
3431                 if (ip_info->dns_type == NET_DNS_CONFIG_TYPE_STATIC)
3432                         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_IPV4_DNS_METHOD,
3433                                                   g_variant_new_string(manual_method));
3434
3435                 for (i = 0; i < ip_info->dns_count; i++) {
3436                         if (temp)
3437                                 dns_address = g_strdup_printf("%s%s;", temp,
3438                                                                           ip_info->dns_address[i]);
3439                         else
3440                                 dns_address = g_strdup_printf("%s;", ip_info->dns_address[i]);
3441
3442                         g_free(temp);
3443                         temp = dns_address;
3444                 }
3445
3446                 if (ip_info->dns_count > 0)
3447                         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_DNS_ADDRESS,
3448                                                   g_variant_new_string(dns_address));
3449
3450                 g_free(dns_address);
3451
3452                 break;
3453         case NET_IP_CONFIG_TYPE_DYNAMIC:
3454                         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_IPV4_METHOD,
3455                                                           g_variant_new_string(dhcp_method));
3456
3457                 if (ip_info->dns_type == NET_DNS_CONFIG_TYPE_DYNAMIC)
3458                         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_IPV4_DNS_METHOD,
3459                                                           g_variant_new_string(dhcp_method));
3460
3461                 else if (ip_info->dns_type == NET_DNS_CONFIG_TYPE_STATIC) {
3462                         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_IPV4_DNS_METHOD,
3463                                                                   g_variant_new_string(manual_method));
3464
3465                         for (i = 0; i < ip_info->dns_count; i++) {
3466                                 if (temp)
3467                                         dns_address = g_strdup_printf("%s%s;", temp,
3468                                                                                                   ip_info->dns_address[i]);
3469                                 else
3470                                         dns_address = g_strdup_printf("%s;",
3471                                                                                                   ip_info->dns_address[i]);
3472
3473                                 g_free(temp);
3474                                 temp = dns_address;
3475                         }
3476
3477                         if (ip_info->dns_count > 0)
3478                                 g_variant_builder_add(b, "{sv}", WIFI_CONFIG_DNS_ADDRESS,
3479                                                                           g_variant_new_string(dns_address));
3480
3481                         g_free(dns_address);
3482                 }
3483                 break;
3484         default:
3485                 break;
3486         }
3487
3488         params = g_variant_new("(ss@a{sv})", network_info->interface_name,
3489                 config_id, g_variant_builder_end(b));
3490         g_variant_builder_unref(b);
3491
3492         message = _net_invoke_dbus_method(network_info,
3493                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
3494                         NETCONFIG_WIFI_INTERFACE, "SaveConfiguration",
3495                         params, &Error);
3496
3497         if (message == NULL) {
3498                 WIFI_LOG(WIFI_ERROR, "Failed to SaveConfiguration");
3499                 __NETWORK_FUNC_EXIT__;
3500                 return Error;
3501         }
3502
3503         g_variant_unref(message);
3504
3505         __NETWORK_FUNC_EXIT__;
3506
3507         return Error;
3508 }
3509
3510 int _net_dbus_config_save_eap_configurations(network_info_s *network_info,
3511                 const gchar *config_id, const gchar *name, const gchar *ssid, const gchar *passphrase,
3512                 const gchar *proxy_address, net_eap_config_s *eap_config, guint32 frequency,
3513                 gboolean is_hidden, gboolean is_created)
3514 {
3515         __NETWORK_FUNC_ENTER__;
3516
3517         net_err_e Error = NET_ERR_NONE;
3518         GVariantBuilder *b = NULL;
3519         GVariant *params = NULL;
3520         GVariant *message = NULL;
3521
3522         b = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
3523         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_NAME, g_variant_new_string(name));
3524         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_SSID, g_variant_new_string(ssid));
3525         if (passphrase != NULL)
3526                 g_variant_builder_add(b, "{sv}", WIFI_CONFIG_PASSPHRASE, g_variant_new_string(passphrase));
3527         if (proxy_address != NULL)
3528                 g_variant_builder_add(b, "{sv}", WIFI_CONFIG_PROXYADDRESS, g_variant_new_string(proxy_address));
3529         if (is_hidden == TRUE)
3530                 g_variant_builder_add(b, "{sv}", WIFI_CONFIG_HIDDEN, g_variant_new_string("TRUE"));
3531         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_FREQUENCY, g_variant_new_uint32(frequency));
3532         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_CREATED, g_variant_new_boolean(is_created));
3533
3534         if (eap_config != NULL) {
3535                 gchar* auth_type = NULL;
3536                 gchar* eap_type = NULL;
3537                 if (eap_config->anonymous_identity != NULL)
3538                         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_ANONYMOUS_IDENTITY, g_variant_new_string(eap_config->anonymous_identity));
3539                 if (eap_config->ca_cert != NULL)
3540                         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_CACERT, g_variant_new_string(eap_config->ca_cert));
3541                 if (eap_config->client_cert != NULL)
3542                         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_CLIENTCERT, g_variant_new_string(eap_config->client_cert));
3543                 if (eap_config->private_key != NULL)
3544                         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_PRIVATEKEY, g_variant_new_string(eap_config->private_key));
3545                 if (eap_config->private_key_password != NULL)
3546                         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_PRIVATEKEY_PASSWORD, g_variant_new_string(eap_config->private_key_password));
3547                 if (eap_config->identity != NULL)
3548                         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_IDENTITY, g_variant_new_string(eap_config->identity));
3549                 if (eap_config->subject_match != NULL)
3550                         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_SUBJECT_MATCH, g_variant_new_string(eap_config->subject_match));
3551
3552                 auth_type = __net_wifi_eap_auth_type_to_string(eap_config->eap_auth_type);
3553                 if (auth_type != NULL)
3554                         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_AUTH_TYPE, g_variant_new_string(auth_type));
3555
3556                 eap_type = __net_wifi_eap_type_to_string(eap_config->eap_type);
3557                 if (eap_type != NULL)
3558                         g_variant_builder_add(b, "{sv}", WIFI_CONFIG_EAP_TYPE, g_variant_new_string(eap_type));
3559
3560                 g_free(auth_type);
3561                 g_free(eap_type);
3562         }
3563
3564         params = g_variant_new("(ss@a{sv})", network_info->interface_name,
3565                 config_id, g_variant_builder_end(b));
3566         g_variant_builder_unref(b);
3567
3568         message = _net_invoke_dbus_method(network_info,
3569                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
3570                         NETCONFIG_WIFI_INTERFACE, "SaveEapConfiguration",
3571                         params, &Error);
3572
3573         if (message == NULL) {
3574                 WIFI_LOG(WIFI_ERROR, "Failed to SaveEapConfiguration");
3575                 __NETWORK_FUNC_EXIT__;
3576                 return Error;
3577         }
3578
3579         g_variant_unref(message);
3580
3581         __NETWORK_FUNC_EXIT__;
3582
3583         return Error;
3584 }
3585
3586 int _net_dbus_config_remove_configurations(network_info_s *network_info,
3587                 const gchar *config_id)
3588 {
3589         __NETWORK_FUNC_ENTER__;
3590
3591         net_err_e Error = NET_ERR_NONE;
3592         GVariant *message = NULL;
3593
3594         message = _net_invoke_dbus_method(network_info,
3595                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
3596                         NETCONFIG_WIFI_INTERFACE, "RemoveConfiguration",
3597                         g_variant_new("(ss)", network_info->interface_name, config_id),
3598                         &Error);
3599
3600         if (message == NULL) {
3601                 WIFI_LOG(WIFI_ERROR, "Failed to RemoveConfiguration");
3602                 __NETWORK_FUNC_EXIT__;
3603                 return Error;
3604         }
3605
3606         g_variant_unref(message);
3607
3608         __NETWORK_FUNC_EXIT__;
3609
3610         return Error;
3611 }
3612
3613 int _net_dbus_config_load_configurations(network_info_s *network_info,
3614                 const gchar *config_id, gchar **name, gchar **passphrase,
3615                 net_wifi_security_type_e *security_type, gchar **proxy_address,
3616                 gboolean *is_hidden, net_ip_info_config_s **ip_info,
3617                 guint32 *frequency, void *last_error)
3618 {
3619         __NETWORK_FUNC_ENTER__;
3620
3621         net_err_e Error = NET_ERR_NONE;
3622         GVariant *message = NULL;
3623         GVariantIter *iter;
3624         gchar *field;
3625         GVariant *value;
3626         int *wifi_last_error = (int *)last_error;
3627         int order = 0;
3628
3629         message = _net_invoke_dbus_method(network_info,
3630                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
3631                         NETCONFIG_WIFI_INTERFACE, "LoadConfiguration",
3632                         g_variant_new("(ss)", network_info->interface_name, config_id),
3633                         &Error);
3634
3635         if (message == NULL) {
3636                 WIFI_LOG(WIFI_ERROR, "Failed to LoadConfiguration");
3637                 __NETWORK_FUNC_EXIT__;
3638                 return Error;
3639         }
3640
3641         g_variant_get(message, "(a{sv})", &iter);
3642         while (g_variant_iter_loop(iter, "{sv}", &field, &value)) {
3643                 if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
3644                         if (g_strcmp0(field, WIFI_CONFIG_NAME) == 0) {
3645                                 *name = g_strdup(g_variant_get_string(value, NULL));
3646                         } else if (g_strcmp0(field, WIFI_CONFIG_PASSPHRASE) == 0) {
3647                                 *passphrase = g_strdup(g_variant_get_string(value, NULL));
3648                         } else if (g_strcmp0(field, WIFI_CONFIG_SECURITY_TYPE) == 0) {
3649                                 *security_type = __net_wifi_security_type_to_int(g_variant_get_string(value, NULL));
3650                         } else if (g_strcmp0(field, WIFI_CONFIG_HIDDEN) == 0) {
3651                                 const gchar *r_hidden = g_variant_get_string(value, NULL);
3652                                 if (g_strcmp0(r_hidden, "TRUE") == 0)
3653                                         *is_hidden = TRUE;
3654                                 else
3655                                         *is_hidden = FALSE;
3656                         } else if (g_strcmp0(field, WIFI_CONFIG_FREQUENCY) == 0) {
3657                                 *frequency = g_variant_get_uint32(value);
3658                         } else if (g_strcmp0(field, WIFI_CONFIG_PROXYADDRESS) == 0) {
3659                                 const gchar *r_proxy_address = g_variant_get_string(value, NULL);
3660                                 if (g_strcmp0(r_proxy_address, "NONE") == 0)
3661                                         *proxy_address = NULL;
3662                                 else
3663                                         *proxy_address = g_strdup(r_proxy_address);
3664                         } else if (g_strcmp0(field, WIFI_CONFIG_IPV4_METHOD) == 0) {
3665                                 const gchar *type = g_variant_get_string(value, NULL);
3666                                 if (g_strcmp0(type, "manual") == 0)
3667                                         (*ip_info)->ip_type = NET_IP_CONFIG_TYPE_STATIC;
3668                                 else if (g_strcmp0(type, "dhcp") == 0)
3669                                         (*ip_info)->ip_type = NET_IP_CONFIG_TYPE_DYNAMIC;
3670                         } else if (g_strcmp0(field, WIFI_CONFIG_IPV4_ADDRESS) == 0) {
3671                                 const gchar *ip_address = g_variant_get_string(value, NULL);
3672                                 (*ip_info)->ip_address = g_strdup(ip_address);
3673                         } else if (g_strcmp0(field, WIFI_CONFIG_IPV4_SUBNET_MASK) == 0) {
3674                                 const gchar *subnet_mask = g_variant_get_string(value, NULL);
3675                                 (*ip_info)->subnet_mask = g_strdup(subnet_mask);
3676                         } else if (g_strcmp0(field, WIFI_CONFIG_IPV6_PREFIX_LEN) == 0) {
3677                                 int prefix_len = g_variant_get_int32(value);
3678                                 (*ip_info)->prefix_length = prefix_len;
3679                         } else if (g_strcmp0(field, WIFI_CONFIG_IPV4_GATEWAY_ADDRESS) == 0) {
3680                                 const gchar *gateway_address = g_variant_get_string(value, NULL);
3681                                 (*ip_info)->gateway_address = g_strdup(gateway_address);
3682                         } else if (g_strcmp0(field, WIFI_CONFIG_IPV4_DNS_METHOD) == 0) {
3683                                 const gchar *type = g_variant_get_string(value, NULL);
3684                                 if (g_strcmp0(type, "manual") == 0)
3685                                         (*ip_info)->dns_type = NET_DNS_CONFIG_TYPE_STATIC;
3686                                 else if (g_strcmp0(type, "dhcp") == 0)
3687                                         (*ip_info)->dns_type = NET_DNS_CONFIG_TYPE_DYNAMIC;
3688                         } else if (g_strcmp0(field, WIFI_CONFIG_DNS_ADDRESS) == 0) {
3689                                 const gchar *dns_address = g_variant_get_string(value, NULL);
3690                                 (*ip_info)->dns_address[order] = g_strdup(dns_address);
3691                                 order += 1;
3692                                 (*ip_info)->dns_count = order;
3693                         } else if (g_strcmp0(field, WIFI_CONFIG_FAILURE) == 0) {
3694                                 *wifi_last_error = __net_wifi_last_error_to_enum(g_variant_get_string(value, NULL));
3695                         }
3696                 }
3697         }
3698
3699         g_variant_iter_free(iter);
3700         g_variant_unref(message);
3701
3702         __NETWORK_FUNC_EXIT__;
3703
3704         return Error;
3705 }
3706
3707 int _net_dbus_config_load_eap_configurations(network_info_s *network_info,
3708                 const gchar *config_id, gchar **name, net_wifi_security_type_e *security_type,
3709                 gchar **proxy_address, gboolean *is_hidden, net_eap_config_s **eap_config,
3710                 guint32 *frequency, void *last_error)
3711 {
3712         __NETWORK_FUNC_ENTER__;
3713
3714         net_err_e Error = NET_ERR_NONE;
3715         GVariant *message = NULL;
3716         GVariantIter *iter;
3717         gchar *field;
3718         GVariant *value;
3719         int *wifi_last_error = (int *)last_error;
3720
3721         message = _net_invoke_dbus_method(network_info,
3722                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
3723                         NETCONFIG_WIFI_INTERFACE, "LoadEapConfiguration",
3724                         g_variant_new("(ss)", network_info->interface_name, config_id),
3725                         &Error);
3726
3727         if (message == NULL) {
3728                 WIFI_LOG(WIFI_ERROR, "Failed to LoadEapConfiguration");
3729                 __NETWORK_FUNC_EXIT__;
3730                 return Error;
3731         }
3732
3733         g_variant_get(message, "(a{sv})", &iter);
3734         while (g_variant_iter_loop(iter, "{sv}", &field, &value)) {
3735                 if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
3736                         if (g_strcmp0(field, WIFI_CONFIG_NAME) == 0) {
3737                                 *name = g_strdup(g_variant_get_string(value, NULL));
3738                         } else if (g_strcmp0(field, WIFI_CONFIG_SECURITY_TYPE) == 0) {
3739                                 *security_type = __net_wifi_security_type_to_int(g_variant_get_string(value, NULL));
3740                         } else if (g_strcmp0(field, WIFI_CONFIG_HIDDEN) == 0) {
3741                                 const gchar *r_hidden = g_variant_get_string(value, NULL);
3742                                 if (g_strcmp0(r_hidden, "TRUE") == 0)
3743                                         *is_hidden = TRUE;
3744                                 else
3745                                         *is_hidden = FALSE;
3746                         } else if (g_strcmp0(field, WIFI_CONFIG_FREQUENCY) == 0) {
3747                                 *frequency = g_variant_get_uint32(value);
3748                         } else if (g_strcmp0(field, WIFI_CONFIG_PROXYADDRESS) == 0) {
3749                                 const gchar *r_proxy_address = g_variant_get_string(value, NULL);
3750                                 if (g_strcmp0(r_proxy_address, "NONE") == 0)
3751                                         *proxy_address = NULL;
3752                                 else
3753                                         *proxy_address = g_strdup(r_proxy_address);
3754                         } else if (g_strcmp0(field, WIFI_CONFIG_EAP_ANONYMOUS_IDENTITY) == 0) {
3755                                 const gchar *anonymous_identity = g_variant_get_string(value, NULL);
3756                                 (*eap_config)->anonymous_identity = g_strdup(anonymous_identity);
3757                         } else if (g_strcmp0(field, WIFI_CONFIG_EAP_CACERT) == 0) {
3758                                 const gchar *ca_cert = g_variant_get_string(value, NULL);
3759                                 (*eap_config)->ca_cert = g_strdup(ca_cert);
3760                         } else if (g_strcmp0(field, WIFI_CONFIG_EAP_CLIENTCERT) == 0) {
3761                                 const gchar *client_cert = g_variant_get_string(value, NULL);
3762                                 (*eap_config)->client_cert = g_strdup(client_cert);
3763                         } else if (g_strcmp0(field, WIFI_CONFIG_EAP_PRIVATEKEY) == 0) {
3764                                 const gchar *private_key = g_variant_get_string(value, NULL);
3765                                 (*eap_config)->private_key = g_strdup(private_key);
3766                         } else if (g_strcmp0(field, WIFI_CONFIG_EAP_IDENTITY) == 0) {
3767                                 const gchar *identity = g_variant_get_string(value, NULL);
3768                                 (*eap_config)->identity = g_strdup(identity);
3769                         } else if (g_strcmp0(field, WIFI_CONFIG_EAP_TYPE) == 0) {
3770                                 const gchar *eap_type = g_variant_get_string(value, NULL);
3771                                 (*eap_config)->eap_type = __net_wifi_eap_type_to_int(eap_type);
3772                         } else if (g_strcmp0(field, WIFI_CONFIG_EAP_AUTH_TYPE) == 0) {
3773                                 const gchar *auth_type = g_variant_get_string(value, NULL);
3774                                 (*eap_config)->eap_auth_type = __net_wifi_eap_auth_type_to_int(auth_type);
3775                         } else if (g_strcmp0(field, WIFI_CONFIG_EAP_SUBJECT_MATCH) == 0) {
3776                                 const gchar *subject_match = g_variant_get_string(value, NULL);
3777                                 (*eap_config)->subject_match = g_strdup(subject_match);
3778                         } else if (g_strcmp0(field, WIFI_CONFIG_FAILURE) == 0) {
3779                                 *wifi_last_error = __net_wifi_last_error_to_enum(g_variant_get_string(value, NULL));
3780                         }
3781                 }
3782         }
3783         g_variant_iter_free(iter);
3784         g_variant_unref(message);
3785
3786         __NETWORK_FUNC_EXIT__;
3787
3788         return Error;
3789 }
3790
3791 int _net_dbus_device_policy_get_wifi(network_info_s *network_info, int *state)
3792 {
3793         __NETWORK_FUNC_ENTER__;
3794
3795         net_err_e Error = NET_ERR_NONE;
3796         GVariant *message = NULL;
3797
3798         if (state == NULL) {
3799                 WIFI_LOG(WIFI_ERROR, "Invalid Parameter");
3800                 __NETWORK_FUNC_EXIT__;
3801                 return NET_ERR_INVALID_PARAM;
3802         }
3803
3804         message = _net_invoke_dbus_method(network_info,
3805                         NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH,
3806                         NETCONFIG_NETWORK_INTERFACE, "DevicePolicyGetWifi",
3807                         NULL, &Error);
3808
3809         if (message == NULL) {
3810                 WIFI_LOG(WIFI_ERROR, "Failed to get wifi device policy");
3811                 return Error;
3812         }
3813
3814         g_variant_get(message, "(i)", state);
3815
3816         WIFI_LOG(WIFI_INFO, "Wifi device policy state [%d]", *state);
3817
3818         g_variant_unref(message);
3819
3820         __NETWORK_FUNC_EXIT__;
3821         return Error;
3822 }
3823
3824 int _net_dbus_device_policy_get_wifi_profile(network_info_s *network_info,
3825                 int *state)
3826 {
3827         __NETWORK_FUNC_ENTER__;
3828
3829         net_err_e Error = NET_ERR_NONE;
3830         GVariant *message = NULL;
3831
3832         if (state == NULL) {
3833                 WIFI_LOG(WIFI_ERROR, "Invalid Parameter");
3834                 __NETWORK_FUNC_EXIT__;
3835                 return NET_ERR_INVALID_PARAM;
3836         }
3837
3838         message = _net_invoke_dbus_method(network_info,
3839                         NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH,
3840                         NETCONFIG_NETWORK_INTERFACE, "DevicePolicyGetWifiProfile",
3841                         NULL, &Error);
3842
3843         if (message == NULL) {
3844                 WIFI_LOG(WIFI_ERROR, "Failed to get wifi device policy");
3845                 return Error;
3846         }
3847
3848         g_variant_get(message, "(i)", state);
3849
3850         WIFI_LOG(WIFI_INFO, "Wifi profile device policy state [%d]", *state);
3851
3852         g_variant_unref(message);
3853
3854         __NETWORK_FUNC_EXIT__;
3855         return Error;
3856 }
3857
3858 int _net_dbus_resume_bgscan(network_info_s *network_info)
3859 {
3860         __NETWORK_FUNC_ENTER__;
3861
3862         net_err_e Error = NET_ERR_NONE;
3863         GVariant *params = NULL;
3864         GVariant *message = NULL;
3865
3866         params = g_variant_new("(s)", network_info->interface_name);
3867
3868         message = _net_invoke_dbus_method(network_info,
3869                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
3870                         NETCONFIG_WIFI_INTERFACE, "ResumeBgscan",
3871                         params, &Error);
3872
3873         if (Error != NET_ERR_NONE)
3874                 WIFI_LOG(WIFI_ERROR, "_net_invoke_dbus_method failed");
3875
3876         if (message != NULL)
3877                 g_variant_unref(message);
3878
3879         __NETWORK_FUNC_EXIT__;
3880         return Error;
3881 }
3882
3883 int _net_dbus_pause_bgscan(network_info_s *network_info)
3884 {
3885         __NETWORK_FUNC_ENTER__;
3886
3887         net_err_e Error = NET_ERR_NONE;
3888         GVariant *params = NULL;
3889         GVariant *message = NULL;
3890
3891         params = g_variant_new("(s)", network_info->interface_name);
3892
3893         message = _net_invoke_dbus_method(network_info,
3894                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
3895                         NETCONFIG_WIFI_INTERFACE, "PauseBgscan",
3896                         params, &Error);
3897
3898         if (Error != NET_ERR_NONE)
3899                 WIFI_LOG(WIFI_ERROR, "_net_invoke_dbus_method failed");
3900
3901         if (message != NULL)
3902                 g_variant_unref(message);
3903
3904         __NETWORK_FUNC_EXIT__;
3905         return Error;
3906 }
3907
3908 int _net_dbus_get_autoscan(network_info_s *network_info, gboolean *autoscan)
3909 {
3910         __NETWORK_FUNC_ENTER__;
3911
3912         GVariant *params = NULL;
3913         GVariant *message = NULL;
3914         net_err_e Error = NET_ERR_NONE;
3915
3916         params = g_variant_new("(s)", network_info->interface_name);
3917
3918         message = _net_invoke_dbus_method(network_info,
3919                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
3920                         NETCONFIG_WIFI_INTERFACE, "GetAutoscan",
3921                         params, &Error);
3922         if (message == NULL) {
3923                 WIFI_LOG(WIFI_ERROR, "Failed to Get Passpoint");
3924                 __NETWORK_FUNC_EXIT__;
3925                 return Error;
3926         }
3927
3928         /** Check Reply */
3929         int result = 0;
3930         g_variant_get(message, "(b)", &result);
3931         *autoscan = result;
3932
3933         WIFI_LOG(WIFI_INFO, "Get Auto scan state Result: %d", result);
3934
3935         g_variant_unref(message);
3936
3937         __NETWORK_FUNC_EXIT__;
3938         return Error;
3939 }
3940
3941 int _net_dbus_get_autoscanmode(network_info_s *network_info,
3942                 unsigned int *autoscanmode)
3943 {
3944         __NETWORK_FUNC_ENTER__;
3945
3946         GVariant *params = NULL;
3947         GVariant *message = NULL;
3948         net_err_e Error = NET_ERR_NONE;
3949
3950         params = g_variant_new("(s)", network_info->interface_name);
3951
3952         message = _net_invoke_dbus_method(network_info,
3953                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
3954                         NETCONFIG_WIFI_INTERFACE, "GetAutoscanmode",
3955                         params, &Error);
3956         if (message == NULL) {
3957                 WIFI_LOG(WIFI_ERROR, "Failed to Get Passpoint");
3958                 __NETWORK_FUNC_EXIT__;
3959                 return Error;
3960         }
3961
3962         /** Check Reply */
3963         int result = 0;
3964         g_variant_get(message, "(u)", &result);
3965         *autoscanmode = result;
3966
3967         WIFI_LOG(WIFI_INFO, "Get Auto scan Mode Result: %d", result);
3968
3969         g_variant_unref(message);
3970
3971         __NETWORK_FUNC_EXIT__;
3972         return Error;
3973 }
3974
3975 static void __net_multi_scan_request_reply(GObject *source_object, GAsyncResult *res,
3976                 gpointer user_data)
3977 {
3978         __NETWORK_FUNC_ENTER__;
3979
3980         GDBusConnection *conn = NULL;
3981         GError *error = NULL;
3982         GVariant *reply;
3983         net_err_e Error = NET_ERR_NONE;
3984         net_event_info_s *event_data = NULL;
3985         network_info_s *network_info = (network_info_s *)user_data;
3986         network_request_table_s *request_table;
3987
3988         event_data = g_try_malloc0(sizeof(net_event_info_s));
3989         if (event_data == NULL) {
3990                 __NETWORK_FUNC_EXIT__;
3991                 return;
3992         }
3993
3994         conn = G_DBUS_CONNECTION(source_object);
3995         reply = g_dbus_connection_call_finish(conn, res, &error);
3996
3997         if (error != NULL) {
3998                 WIFI_LOG(WIFI_ERROR, "Scan failed. Error [%s]",
3999                                 error->message);
4000                 Error = __net_error_string_to_enum(error->message);
4001                 if (error->code == G_IO_ERROR_CANCELLED) {
4002                         WIFI_LOG(WIFI_INFO, "Ignore multi scan request reply, as operation is cancelled");
4003                         g_error_free(error);
4004                         __NETWORK_FUNC_EXIT__;
4005                         return;
4006                 }
4007
4008                 g_error_free(error);
4009         }
4010
4011         if (reply)
4012                 g_variant_unref(reply);
4013
4014         request_table = network_info->request_table;
4015
4016         if (Error == NET_ERR_IN_PROGRESS) {
4017                 /* should retry scan after receiving scan result */
4018                 if (request_table[NETWORK_REQUEST_TYPE_MULTI_SCAN].flag == TRUE) {
4019                         WIFI_LOG(WIFI_INFO, "Multi Scan pending");
4020                         network_info->scan_pending = TRUE;
4021                 }
4022         } else if (Error != NET_ERR_NONE) {
4023                 WIFI_LOG(WIFI_ERROR, "Multi Scan failed. Error [%d]", Error);
4024                 g_slist_free_full(request_table[NETWORK_REQUEST_TYPE_MULTI_SCAN].multi_scan_list, g_free);
4025
4026                 if (request_table[NETWORK_REQUEST_TYPE_MULTI_SCAN].flag == TRUE) {
4027                         memset(&request_table[NETWORK_REQUEST_TYPE_MULTI_SCAN],
4028                                         0, sizeof(network_request_table_s));
4029
4030                         event_data->Event = NET_EVENT_WIFI_MULTI_SCAN_RSP;
4031                         event_data->Datalength = 0;
4032                         event_data->Data = NULL;
4033                         event_data->Error = Error;
4034
4035                         if (network_info->event_callback)
4036                                 network_info->event_callback(event_data, network_info->user_data);
4037
4038                         g_free(event_data);
4039
4040                         __NETWORK_FUNC_EXIT__;
4041                         return;
4042                 }
4043
4044         } else
4045                 WIFI_LOG(WIFI_INFO, "Multi Scan Request success");
4046
4047         g_free(event_data);
4048         __NETWORK_FUNC_EXIT__;
4049 }
4050
4051 int _net_dbus_multi_scan_request(network_info_s *network_info,
4052                 GSList *multi_scan_list)
4053 {
4054         __NETWORK_FUNC_ENTER__;
4055
4056         net_err_e Error = NET_ERR_NONE;
4057         GSList *list = NULL;
4058         GVariant *params = NULL;
4059         GVariantBuilder *builder;
4060         char ssid[NET_WLAN_ESSID_LEN + 1] = {0, };
4061         char freq[NET_WLAN_FREQ_LEN] = {0, };
4062
4063         WIFI_LOG(WIFI_INFO, "multi_scan_type:%d, Number of elements in a list:%d",
4064                         network_info->request_table[NETWORK_REQUEST_TYPE_MULTI_SCAN].multi_scan_type,
4065                         g_slist_length(multi_scan_list));
4066
4067         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
4068
4069         if (network_info->request_table[NETWORK_REQUEST_TYPE_MULTI_SCAN].multi_scan_type == WIFI_MULTI_SCAN_SSID) {
4070                 for (list = multi_scan_list; list; list = list->next) {
4071                         WIFI_LOG(WIFI_INFO, "AP name: %s", ((wifi_manager_multi_scan_ap_s *)list->data)->str);
4072                         g_strlcpy(ssid, ((wifi_manager_multi_scan_ap_s *)list->data)->str, NET_WLAN_ESSID_LEN + 1);
4073                         g_variant_builder_add(builder, "{sv}", "SSID", g_variant_new_string(ssid));
4074                 }
4075         } else if (network_info->request_table[NETWORK_REQUEST_TYPE_MULTI_SCAN].multi_scan_type == WIFI_MULTI_SCAN_FREQ) {
4076                 for (list = multi_scan_list; list; list = list->next) {
4077                         WIFI_LOG(WIFI_INFO, "Freq: %s", ((wifi_manager_multi_scan_ap_s *)list->data)->str);
4078                         g_strlcpy(freq, ((wifi_manager_multi_scan_ap_s *)list->data)->str, NET_WLAN_FREQ_LEN);
4079                         g_variant_builder_add(builder, "{sv}", "Frequency", g_variant_new_string(freq));
4080                 }
4081         } else {
4082                 for (list = multi_scan_list; list; list = list->next) {
4083                         if (((wifi_manager_multi_scan_ap_s *)list->data)->flag == true) {
4084                                 WIFI_LOG(WIFI_INFO, "[Mixed]AP name: %s", ((wifi_manager_multi_scan_ap_s *)list->data)->str);
4085                                 g_strlcpy(ssid, ((wifi_manager_multi_scan_ap_s *)list->data)->str, NET_WLAN_ESSID_LEN + 1);
4086                                 g_variant_builder_add(builder, "{sv}", "SSID_Mixed", g_variant_new_string(ssid));
4087                         } else {
4088                                 WIFI_LOG(WIFI_INFO, "[Mixed]Freq: %s", ((wifi_manager_multi_scan_ap_s *)list->data)->str);
4089                                 g_strlcpy(freq, ((wifi_manager_multi_scan_ap_s *)list->data)->str, NET_WLAN_FREQ_LEN);
4090                                 g_variant_builder_add(builder, "{sv}", "Frequency_Mixed", g_variant_new_string(freq));
4091                         }
4092                 }
4093         }
4094
4095         params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
4096         g_variant_builder_unref(builder);
4097
4098         Error = _net_invoke_dbus_method_nonblock(network_info,
4099                         CONNMAN_SERVICE, CONNMAN_WIFI_TECHNOLOGY_PREFIX,
4100                         CONNMAN_TECHNOLOGY_INTERFACE, "SpecificScan",
4101                         params, DBUS_REPLY_TIMEOUT,
4102                         __net_multi_scan_request_reply);
4103
4104         if (Error == NET_ERR_IN_PROGRESS)
4105                 Error = NET_ERR_NONE; //LCOV_EXCL_LINE
4106
4107         __NETWORK_FUNC_EXIT__;
4108         return Error;
4109 }
4110
4111 int _net_dbus_get_max_scan_ssids(network_info_s *network_info, int *max_scan_ssids)
4112 {
4113         __NETWORK_FUNC_ENTER__;
4114
4115         net_err_e Error = NET_ERR_NONE;
4116         GVariant *message = NULL;
4117         GVariant *value = NULL;
4118         GVariantIter *iter = NULL;
4119         gchar *key = NULL;
4120
4121         message = _net_invoke_dbus_method(network_info,
4122                         CONNMAN_SERVICE, CONNMAN_WIFI_TECHNOLOGY_PREFIX,
4123                         CONNMAN_TECHNOLOGY_INTERFACE, "GetMaxScanSsid",
4124                         NULL, &Error);
4125         if (message == NULL) {
4126                 WIFI_LOG(WIFI_ERROR, "Failed to get Max scan SSIDs.");
4127                 *max_scan_ssids = 0;
4128
4129                 __NETWORK_FUNC_EXIT__;
4130                 return Error;
4131         }
4132
4133         g_variant_get(message, "(a{sv})", &iter);
4134
4135         while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
4136                 if (g_strcmp0(key, "MaxScanSSID") == 0) {
4137                         *max_scan_ssids = g_variant_get_int32(value);
4138                         WIFI_LOG(WIFI_INFO, "Successfully get Max scan SSIDs: %d", *max_scan_ssids);
4139                         g_variant_unref(value);
4140                         g_free(key);
4141                         break;
4142                 }
4143         }
4144
4145         g_variant_iter_free(iter);
4146         g_variant_unref(message);
4147
4148         __NETWORK_FUNC_EXIT__;
4149         return Error;
4150 }
4151 //LCOV_EXCL_STOP
4152
4153 int _net_dbus_set_mac_policy(network_info_s *network_info, unsigned int policy)
4154 {
4155         __NETWORK_FUNC_ENTER__;
4156
4157         net_err_e Error = NET_ERR_NONE;
4158         GVariant *message = NULL;
4159
4160         const char *prop_key = "MacPolicy";
4161         const char *method = "SetProperty";
4162         GVariant *params = NULL;
4163
4164         WIFI_LOG(WIFI_INFO, "MacPolicy [%u]", policy);
4165
4166         params = g_variant_new("(sv)", prop_key, g_variant_new_uint32(policy));
4167
4168         message = _net_invoke_dbus_method(network_info,
4169                         CONNMAN_SERVICE, CONNMAN_WIFI_TECHNOLOGY_PREFIX,
4170                         CONNMAN_TECHNOLOGY_INTERFACE,
4171                         method, params, &Error);
4172
4173         if (message == NULL) {
4174                 WIFI_LOG(WIFI_ERROR, "Failed to set mac policy");
4175                 __NETWORK_FUNC_EXIT__;
4176                 return Error;
4177         }
4178
4179         g_variant_unref(message);
4180
4181         __NETWORK_FUNC_EXIT__;
4182         return Error;
4183 }
4184
4185 int _net_dbus_get_mac_policy(network_info_s *network_info, unsigned int *policy)
4186 {
4187         __NETWORK_FUNC_ENTER__;
4188
4189         net_err_e Error = NET_ERR_NONE;
4190         GVariant *message = NULL;
4191         GVariant *value = NULL;
4192         GVariantIter *iter = NULL;
4193         gchar *key = NULL;
4194
4195         message = _net_invoke_dbus_method(network_info,
4196                         CONNMAN_SERVICE, CONNMAN_WIFI_TECHNOLOGY_PREFIX,
4197                         CONNMAN_TECHNOLOGY_INTERFACE, "GetProperties",
4198                         NULL, &Error);
4199
4200         if (message == NULL) {
4201                 WIFI_LOG(WIFI_ERROR, "Failed to get properties");
4202
4203                 __NETWORK_FUNC_EXIT__;
4204                 return Error;
4205         }
4206
4207         g_variant_get(message, "(a{sv})", &iter);
4208
4209         while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
4210                 if (g_strcmp0(key, "MacPolicy") == 0) {
4211                         *policy = g_variant_get_uint32(value);
4212                         WIFI_LOG(WIFI_INFO, "Successfully get mac policy: %u", *policy);
4213
4214                         g_variant_unref(value);
4215                         g_free(key);
4216                         break;
4217                 }
4218         }
4219
4220         g_variant_iter_free(iter);
4221         g_variant_unref(message);
4222
4223         __NETWORK_FUNC_EXIT__;
4224         return Error;
4225 }
4226
4227 int _net_dbus_set_preassoc_mac_policy(network_info_s *network_info, unsigned int policy)
4228 {
4229         __NETWORK_FUNC_ENTER__;
4230
4231         net_err_e Error = NET_ERR_NONE;
4232         GVariant *message = NULL;
4233
4234         const char *prop_key = "PreassocMacPolicy";
4235         const char *method = "SetProperty";
4236         GVariant *params = NULL;
4237
4238         WIFI_LOG(WIFI_INFO, "PreassocMacPolicy [%u]", policy);
4239
4240         params = g_variant_new("(sv)", prop_key, g_variant_new_uint32(policy));
4241
4242         message = _net_invoke_dbus_method(network_info,
4243                         CONNMAN_SERVICE, CONNMAN_WIFI_TECHNOLOGY_PREFIX,
4244                         CONNMAN_TECHNOLOGY_INTERFACE,
4245                         method, params, &Error);
4246
4247         if (message == NULL) {
4248                 WIFI_LOG(WIFI_ERROR, "Failed to set preassoc mac policy");
4249                 __NETWORK_FUNC_EXIT__;
4250                 return Error;
4251         }
4252
4253         g_variant_unref(message);
4254
4255         __NETWORK_FUNC_EXIT__;
4256         return Error;
4257 }
4258
4259 int _net_dbus_get_preassoc_mac_policy(network_info_s *network_info, unsigned int *policy)
4260 {
4261         __NETWORK_FUNC_ENTER__;
4262
4263         net_err_e Error = NET_ERR_NONE;
4264         GVariant *message = NULL;
4265         GVariant *value = NULL;
4266         GVariantIter *iter = NULL;
4267         gchar *key = NULL;
4268
4269         message = _net_invoke_dbus_method(network_info,
4270                         CONNMAN_SERVICE, CONNMAN_WIFI_TECHNOLOGY_PREFIX,
4271                         CONNMAN_TECHNOLOGY_INTERFACE, "GetProperties",
4272                         NULL, &Error);
4273
4274         if (message == NULL) {
4275                 WIFI_LOG(WIFI_ERROR, "Failed to get properties");
4276
4277                 __NETWORK_FUNC_EXIT__;
4278                 return Error;
4279         }
4280
4281         g_variant_get(message, "(a{sv})", &iter);
4282
4283         while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
4284                 if (g_strcmp0(key, "PreassocMacPolicy") == 0) {
4285                         *policy = g_variant_get_uint32(value);
4286                         WIFI_LOG(WIFI_INFO, "Successfully get preassoc mac policy: %u", *policy);
4287
4288                         g_variant_unref(value);
4289                         g_free(key);
4290                         break;
4291                 }
4292         }
4293
4294         g_variant_iter_free(iter);
4295         g_variant_unref(message);
4296
4297         __NETWORK_FUNC_EXIT__;
4298         return Error;
4299 }
4300
4301 int _net_dbus_set_random_mac_lifetime(network_info_s *network_info, unsigned int lifetime)
4302 {
4303         __NETWORK_FUNC_ENTER__;
4304
4305         net_err_e Error = NET_ERR_NONE;
4306         GVariant *message = NULL;
4307
4308         const char *prop_key = "RandomMacLifetime";
4309         const char *method = "SetProperty";
4310         GVariant *params = NULL;
4311
4312         WIFI_LOG(WIFI_INFO, "RandomMacLifetime [%u]", lifetime);
4313
4314         params = g_variant_new("(sv)", prop_key, g_variant_new_uint32(lifetime));
4315
4316         message = _net_invoke_dbus_method(network_info,
4317                         CONNMAN_SERVICE, CONNMAN_WIFI_TECHNOLOGY_PREFIX,
4318                         CONNMAN_TECHNOLOGY_INTERFACE,
4319                         method, params, &Error);
4320
4321         if (message == NULL) {
4322                 WIFI_LOG(WIFI_ERROR, "Failed to set random mac lifetime");
4323                 __NETWORK_FUNC_EXIT__;
4324                 return Error;
4325         }
4326
4327         g_variant_unref(message);
4328
4329         __NETWORK_FUNC_EXIT__;
4330         return Error;
4331 }
4332
4333 int _net_dbus_get_random_mac_lifetime(network_info_s *network_info, unsigned int *lifetime)
4334 {
4335         __NETWORK_FUNC_ENTER__;
4336
4337         net_err_e Error = NET_ERR_NONE;
4338         GVariant *message = NULL;
4339         GVariant *value = NULL;
4340         GVariantIter *iter = NULL;
4341         gchar *key = NULL;
4342
4343         message = _net_invoke_dbus_method(network_info,
4344                         CONNMAN_SERVICE, CONNMAN_WIFI_TECHNOLOGY_PREFIX,
4345                         CONNMAN_TECHNOLOGY_INTERFACE, "GetProperties",
4346                         NULL, &Error);
4347
4348         if (message == NULL) {
4349                 WIFI_LOG(WIFI_ERROR, "Failed to get properties");
4350
4351                 __NETWORK_FUNC_EXIT__;
4352                 return Error;
4353         }
4354
4355         g_variant_get(message, "(a{sv})", &iter);
4356
4357         while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
4358                 if (g_strcmp0(key, "RandomMacLifetime") == 0) {
4359                         *lifetime = g_variant_get_uint32(value);
4360                         WIFI_LOG(WIFI_INFO, "Successfully get random mac lifetime: %u", *lifetime);
4361
4362                         g_variant_unref(value);
4363                         g_free(key);
4364                         break;
4365                 }
4366         }
4367
4368         g_variant_iter_free(iter);
4369         g_variant_unref(message);
4370
4371         __NETWORK_FUNC_EXIT__;
4372         return Error;
4373 }
4374
4375 int _net_dbus_set_country_code(network_info_s *network_info, const char *country)
4376 {
4377         __NETWORK_FUNC_ENTER__;
4378
4379         net_err_e Error = NET_ERR_NONE;
4380         GVariant *message = NULL;
4381
4382         const char *prop_key = "CountryCode";
4383         const char *method = "SetProperty";
4384         GVariant *params = NULL;
4385
4386         params = g_variant_new("(sv)", prop_key, g_variant_new_string(country));
4387
4388         message = _net_invoke_dbus_method(network_info,
4389                         CONNMAN_SERVICE, CONNMAN_WIFI_TECHNOLOGY_PREFIX,
4390                         CONNMAN_TECHNOLOGY_INTERFACE,
4391                         method, params, &Error);
4392
4393         if (message == NULL) {
4394                 WIFI_LOG(WIFI_ERROR, "Failed to set country code");
4395                 __NETWORK_FUNC_EXIT__;
4396                 return Error;
4397         }
4398
4399         g_variant_unref(message);
4400
4401         __NETWORK_FUNC_EXIT__;
4402         return Error;
4403 }
4404
4405 int _net_dbus_get_country_code(network_info_s *network_info, char **country)
4406 {
4407         __NETWORK_FUNC_ENTER__;
4408
4409         net_err_e Error = NET_ERR_NONE;
4410         GVariant *message = NULL;
4411         GVariant *value = NULL;
4412         GVariantIter *iter = NULL;
4413         gchar *key = NULL;
4414
4415         message = _net_invoke_dbus_method(network_info,
4416                         CONNMAN_SERVICE, CONNMAN_WIFI_TECHNOLOGY_PREFIX,
4417                         CONNMAN_TECHNOLOGY_INTERFACE, "GetProperties",
4418                         NULL, &Error);
4419
4420         if (message == NULL) {
4421                 WIFI_LOG(WIFI_ERROR, "Failed to get properties");
4422
4423                 __NETWORK_FUNC_EXIT__;
4424                 return Error;
4425         }
4426
4427         g_variant_get(message, "(a{sv})", &iter);
4428
4429         while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
4430                 if (g_strcmp0(key, "CountryCode") == 0) {
4431                         const gchar *str = g_variant_get_string(value, NULL);
4432                         *country = g_strdup(str);
4433                         WIFI_LOG(WIFI_INFO, "Successfully get country code: %s", *country);
4434
4435                         g_variant_unref(value);
4436                         g_free(key);
4437                         break;
4438                 }
4439         }
4440
4441         g_variant_iter_free(iter);
4442         g_variant_unref(message);
4443
4444         __NETWORK_FUNC_EXIT__;
4445         return Error;
4446 }
4447
4448 int _net_dbus_get_vconf_value(network_info_s *network_info,
4449                 const char *key, const char *type, int *ret, int *int_value, char **str_value)
4450 {
4451         __NETWORK_FUNC_ENTER__;
4452
4453         net_err_e ret_error = NET_ERR_NONE;
4454         GVariant *message = NULL;
4455         GVariant *params = NULL;
4456
4457         params = g_variant_new("(ss)", key, type);
4458         message = _net_invoke_dbus_method(network_info,
4459                         NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH,
4460                         NETCONFIG_NETWORK_INTERFACE, "RequestVconfValue",
4461                         params, &ret_error);
4462
4463         if (message == NULL) {
4464                 WIFI_LOG(WIFI_ERROR, "Failed to get vconf value, key: %s", key);
4465                 __NETWORK_FUNC_EXIT__;
4466                 return ret_error;
4467         }
4468
4469         g_variant_get(message, "(iis)", ret, int_value, str_value);
4470
4471         WIFI_LOG(WIFI_INFO, "Vconf key: %s, type: %s, ret: %d, int_value: %d, str_value: %s",
4472                         key, type, *ret, *int_value, *str_value);
4473
4474         g_variant_unref(message);
4475
4476         __NETWORK_FUNC_EXIT__;
4477         return ret_error;
4478 }