src/network-dbus-request.c

   1 /*
   2  * Network Client Library
   3  *
   4  * Copyright 2012 Samsung Electronics Co., Ltd
   5  *
   6  * Licensed under the Flora License, Version 1.1 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.tizenopensource.org/license
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <arpa/inet.h>
  21 #include <netinet/in.h>
  22
  23 #include "network-internal.h"
  24 #include "network-dbus-request.h"
  25
  26 /*****************************************************************************
  27  * Macros and Typedefs
  28  *****************************************************************************/
  29 #define DBUS_REPLY_TIMEOUT (120 * 1000)
  30
  31 /*****************************************************************************
  32  * Extern Variables
  33  *****************************************************************************/
  34 extern __thread network_info_t NetworkInfo;
  35 extern __thread network_request_table_t request_table[NETWORK_REQUEST_TYPE_MAX];
  36
  37 static int __net_error_string_to_enum(const char *error)
  38 {
  39         NETWORK_LOG(NETWORK_LOW, "Passed error value [%s]", error);
  40
  41         if (NULL != strstr(error, "NoReply"))
  42                 return NET_ERR_TIME_OUT;
  43         else if (NULL != strstr(error, "Failed"))
  44                 return NET_ERR_UNKNOWN;
  45         else if (NULL != strstr(error, "UnknownMethod"))
  46                 return NET_ERR_UNKNOWN_METHOD;
  47         else if (NULL != strstr(error, "InvalidArguments"))
  48                 return NET_ERR_INVALID_PARAM;
  49         else if (NULL != strstr(error, "AccessDenied"))
  50                 return NET_ERR_ACCESS_DENIED;
  51         else if (NULL != strstr(error, "PermissionDenied"))
  52                 return NET_ERR_ACCESS_DENIED;
  53         else if (NULL != strstr(error, "PassphraseRequired"))
  54                 return NET_ERR_INVALID_OPERATION;
  55         else if (NULL != strstr(error, "NotRegistered"))
  56                 return NET_ERR_INVALID_OPERATION;
  57         else if (NULL != strstr(error, "NotUnique"))
  58                 return NET_ERR_INVALID_OPERATION;
  59         else if (NULL != strstr(error, "NotSupported"))
  60                 return NET_ERR_NOT_SUPPORTED;
  61         else if (NULL != strstr(error, "NotImplemented"))
  62                 return NET_ERR_NOT_SUPPORTED;
  63         else if (NULL != strstr(error, "NotFound"))
  64                 return NET_ERR_NOT_SUPPORTED;
  65         else if (NULL != strstr(error, "NoCarrier"))
  66                 return NET_ERR_NOT_SUPPORTED;
  67         else if (NULL != strstr(error, "InProgress"))
  68                 return NET_ERR_IN_PROGRESS;
  69         else if (NULL != strstr(error, "AlreadyExists"))
  70                 return NET_ERR_INVALID_OPERATION;
  71         else if (NULL != strstr(error, "AlreadyEnabled"))
  72                 return NET_ERR_INVALID_OPERATION;
  73         else if (NULL != strstr(error, "AlreadyDisabled"))
  74                 return NET_ERR_INVALID_OPERATION;
  75         else if (NULL != strstr(error, "AlreadyConnected"))
  76                 return NET_ERR_ACTIVE_CONNECTION_EXISTS;
  77         else if (NULL != strstr(error, "NotConnected"))
  78                 return NET_ERR_NO_ACTIVE_CONNECTIONS;
  79         else if (NULL != strstr(error, "OperationAborted"))
  80                 return NET_ERR_OPERATION_ABORTED;
  81         else if (NULL != strstr(error, "OperationTimeout"))
  82                 return NET_ERR_TIME_OUT;
  83         else if (NULL != strstr(error, "InvalidService"))
  84                 return NET_ERR_NO_SERVICE;
  85         else if (NULL != strstr(error, "InvalidProperty"))
  86                 return NET_ERR_INVALID_OPERATION;
  87         return NET_ERR_UNKNOWN;
  88 }
  89
  90 static int __net_netconfig_error_string_to_enum(const char* error)
  91 {
  92         NETWORK_LOG(NETWORK_ERROR, "Passed error value [%s]", error);
  93
  94         if (error == NULL)
  95                 return NET_ERR_UNKNOWN;
  96
  97         if (NULL != strstr(error, ".WifiDriverFailed"))
  98                 return NET_ERR_WIFI_DRIVER_FAILURE;
  99         else if (NULL != strstr(error, ".PermissionDenied"))
 100                 return NET_ERR_SECURITY_RESTRICTED;
 101         else if (NULL != strstr(error, ".InProgress"))
 102                 return NET_ERR_WIFI_DRIVER_LOAD_INPROGRESS;
 103         else if (NULL != strstr(error, ".AccessDenied"))
 104                 return NET_ERR_ACCESS_DENIED;
 105         return NET_ERR_UNKNOWN;
 106 }
 107
 108 static void __net_open_connection_reply(GObject *source_object, GAsyncResult *res, gpointer user_data)
 109 {
 110         __NETWORK_FUNC_ENTER__;
 111
 112         net_event_info_t event_data = { 0, };
 113         net_profile_info_t prof_info;
 114         network_request_table_t *open_info =
 115                         &request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION];
 116         network_request_table_t *wps_info =
 117                         &request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS];
 118         GDBusConnection *conn = NULL;
 119         GError *error = NULL;
 120         net_err_t Error = NET_ERR_NONE;
 121
 122         NETWORK_LOG(NETWORK_LOW, "__net_open_connection_reply() called");
 123
 124         conn = G_DBUS_CONNECTION(source_object);
 125         g_dbus_connection_call_finish(conn, res, &error);
 126
 127         if (error != NULL) {
 128                 Error = __net_error_string_to_enum(error->message);
 129                 g_error_free(error);
 130         }
 131
 132         if (Error == NET_ERR_NONE)
 133                 goto done;
 134
 135         NETWORK_LOG(NETWORK_ERROR, "Connection open failed[%d]", Error);
 136
 137         if (open_info->flag == TRUE) {
 138                 net_device_t device_type =
 139                                 _net_get_tech_type_from_path(open_info->ProfileName);
 140
 141                 if (Error == NET_ERR_IN_PROGRESS && device_type == NET_DEVICE_CELLULAR)
 142                         goto done;
 143
 144                 g_strlcpy(event_data.ProfileName, open_info->ProfileName,
 145                                 NET_PROFILE_NAME_LEN_MAX + 1);
 146                 memset(open_info, 0, sizeof(network_request_table_t));
 147
 148                 event_data.Error = Error;
 149
 150                 if (Error == NET_ERR_ACTIVE_CONNECTION_EXISTS) {
 151                         Error = net_get_profile_info(event_data.ProfileName, &prof_info);
 152
 153                         if (device_type == NET_DEVICE_CELLULAR)
 154                                 event_data.Error = NET_ERR_NONE;
 155
 156                         if (Error != NET_ERR_NONE) {
 157                                 NETWORK_LOG(NETWORK_ERROR, "Fail to get profile info[%s]",
 158                                                 _net_print_error(Error));
 159
 160                                 event_data.Datalength = 0;
 161                                 event_data.Data = NULL;
 162                         } else {
 163                                 event_data.Datalength = sizeof(net_profile_info_t);
 164                                 event_data.Data = &prof_info;
 165                         }
 166                 }
 167
 168                 event_data.Event = NET_EVENT_OPEN_RSP;
 169                 NETWORK_LOG(NETWORK_LOW, "Sending NET_EVENT_OPEN_RSP Error[%s]",
 170                                 _net_print_error(event_data.Error));
 171         } else if (wps_info->flag == TRUE) {
 172                 g_strlcpy(event_data.ProfileName, wps_info->ProfileName,
 173                                 NET_PROFILE_NAME_LEN_MAX + 1);
 174                 memset(wps_info, 0, sizeof(network_request_table_t));
 175
 176                 event_data.Error = Error;
 177
 178                 if (Error == NET_ERR_ACTIVE_CONNECTION_EXISTS) {
 179                         Error = net_get_profile_info(event_data.ProfileName, &prof_info);
 180                         if (Error != NET_ERR_NONE) {
 181                                 NETWORK_LOG(NETWORK_ERROR, "Fail to get profile info[%s]",
 182                                                 _net_print_error(Error));
 183
 184                                 event_data.Datalength = 0;
 185                                 event_data.Data = NULL;
 186                         } else {
 187                                 event_data.Datalength = sizeof(net_profile_info_t);
 188                                 event_data.Data = &prof_info;
 189                         }
 190                 }
 191
 192                 event_data.Event = NET_EVENT_WIFI_WPS_RSP;
 193
 194                 NETWORK_LOG(NETWORK_LOW, "Sending NET_EVENT_WIFI_WPS_RSP Error[%s]",
 195                                 _net_print_error(event_data.Error));
 196         } else {
 197                 _net_dbus_pending_call_unref();
 198
 199                 __NETWORK_FUNC_EXIT__;
 200                 return;
 201         }
 202
 203 done:
 204         _net_dbus_pending_call_unref();
 205
 206         _net_client_callback(&event_data);
 207
 208         __NETWORK_FUNC_EXIT__;
 209 }
 210
 211 static void __net_close_connection_reply(GObject *source_object, GAsyncResult *res, gpointer user_data)
 212 {
 213         __NETWORK_FUNC_ENTER__;
 214
 215         NETWORK_LOG(NETWORK_LOW, "__net_close_connection_reply() called");
 216
 217         net_event_info_t event_data = { 0, };
 218         network_request_table_t *close_info =
 219                         &request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION];
 220
 221         GDBusConnection *conn = NULL;
 222         GError *error = NULL;
 223         net_err_t Error = NET_ERR_NONE;
 224
 225         conn = G_DBUS_CONNECTION(source_object);
 226         g_dbus_connection_call_finish(conn, res, &error);
 227         if (error != NULL) {
 228                 Error = __net_error_string_to_enum(error->message);
 229                 g_error_free(error);
 230         }
 231
 232         if (Error == NET_ERR_NONE)
 233                 goto done;
 234
 235         NETWORK_LOG(NETWORK_ERROR, "Connection close failed[%d]", Error);
 236
 237         if (close_info->flag == TRUE) {
 238                 net_device_t device_type =
 239                                 _net_get_tech_type_from_path(close_info->ProfileName);
 240
 241                 if (Error == NET_ERR_ACTIVE_CONNECTION_EXISTS &&
 242                                 device_type == NET_DEVICE_CELLULAR)
 243                         Error = NET_ERR_NONE;
 244
 245                 g_strlcpy(event_data.ProfileName, close_info->ProfileName,
 246                                 NET_PROFILE_NAME_LEN_MAX + 1);
 247                 memset(close_info, 0, sizeof(network_request_table_t));
 248
 249                 event_data.Error = Error;
 250                 event_data.Datalength = 0;
 251                 event_data.Data = NULL;
 252                 event_data.Event = NET_EVENT_CLOSE_RSP;
 253
 254                 NETWORK_LOG(NETWORK_LOW, "Sending NET_EVENT_CLOSE_RSP Error[%s]",
 255                                 _net_print_error(event_data.Error));
 256         } else {
 257                 _net_dbus_pending_call_unref();
 258
 259                 __NETWORK_FUNC_EXIT__;
 260                 return;
 261         }
 262
 263 done:
 264         _net_dbus_pending_call_unref();
 265
 266         _net_client_callback(&event_data);
 267
 268         __NETWORK_FUNC_EXIT__;
 269 }
 270
 271 static void __net_wifi_power_reply(GObject *source_object, GAsyncResult *res, gpointer user_data)
 272 {
 273         __NETWORK_FUNC_ENTER__;
 274
 275         GDBusConnection *conn = NULL;
 276         GError *error = NULL;
 277         net_err_t Error = NET_ERR_NONE;
 278         net_event_info_t event_data = { 0, };
 279
 280         NETWORK_LOG(NETWORK_LOW, "__net_wifi_power_reply() called");
 281
 282         conn = G_DBUS_CONNECTION(source_object);
 283         g_dbus_connection_call_finish(conn, res, &error);
 284         if (error != NULL) {
 285                 Error = __net_netconfig_error_string_to_enum(error->message);
 286                 g_error_free(error);
 287         }
 288
 289         if (Error != NET_ERR_NONE) {
 290                 NETWORK_LOG(NETWORK_ERROR,
 291                                 "Wi-Fi power operation failed. Error [%d]", Error);
 292
 293                 if (Error != NET_ERR_WIFI_DRIVER_LOAD_INPROGRESS) {
 294                         if (request_table[NETWORK_REQUEST_TYPE_WIFI_POWER].flag == TRUE) {
 295                                 memset(&request_table[NETWORK_REQUEST_TYPE_WIFI_POWER],
 296                                                 0, sizeof(network_request_table_t));
 297
 298                                 event_data.Event = NET_EVENT_WIFI_POWER_RSP;
 299
 300                                 NETWORK_LOG(NETWORK_LOW,
 301                                                 "Sending NET_EVENT_WIFI_POWER_RSP Wi-Fi: %d Error = %d",
 302                                                 NetworkInfo.wifi_state, Error);
 303
 304                                 event_data.Datalength = sizeof(net_wifi_state_t);
 305                                 event_data.Data = &(NetworkInfo.wifi_state);
 306                                 event_data.Error = Error;
 307                         }
 308                 }
 309         } else {
 310                 _net_dbus_pending_call_unref();
 311
 312                 __NETWORK_FUNC_EXIT__;
 313                 return;
 314         }
 315
 316         _net_dbus_pending_call_unref();
 317
 318         _net_client_callback(&event_data);
 319
 320         __NETWORK_FUNC_EXIT__;
 321 }
 322
 323 static void __net_reset_cellular_reply(GObject *source_object, GAsyncResult *res, gpointer user_data)
 324 {
 325         __NETWORK_FUNC_ENTER__;
 326
 327         int rv;
 328         net_event_info_t event_data = { 0, };
 329         GDBusConnection *conn = NULL;
 330         GVariant *dbus_result;
 331         GError *error = NULL;
 332         net_err_t Error = NET_ERR_NONE;
 333
 334         NETWORK_LOG(NETWORK_LOW, "__net_reset_cellular_reply() called");
 335
 336         conn = G_DBUS_CONNECTION(source_object);
 337         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 338         if (error != NULL) {
 339                 Error = __net_error_string_to_enum(error->message);
 340                 g_error_free(error);
 341
 342                 NETWORK_LOG(NETWORK_ERROR, "Error code: [%d]", Error);
 343         }
 344
 345         if (request_table[NETWORK_REQUEST_TYPE_RESET_DEFAULT].flag == TRUE) {
 346                 memset(&request_table[NETWORK_REQUEST_TYPE_RESET_DEFAULT],
 347                                                 0, sizeof(network_request_table_t));
 348                 event_data.Event = NET_EVENT_CELLULAR_RESET_DEFAULT_RSP;
 349
 350                 if (Error == NET_ERR_NONE) {
 351                         g_variant_get(dbus_result, "(b)", &rv);
 352
 353                         NETWORK_LOG(NETWORK_LOW, "Reply: %s", rv ? "TRUE" : "FALSE");
 354
 355                         if (rv)
 356                                 event_data.Error = NET_ERR_NONE;
 357                         else
 358                                 event_data.Error = NET_ERR_UNKNOWN;
 359                 } else
 360                         event_data.Error = Error;
 361
 362                 NETWORK_LOG(NETWORK_LOW, "Sending NET_EVENT_CELLULAR_RESET_DEFAULT_RSP Error = %s",
 363                                 _net_print_error(event_data.Error));
 364         } else {
 365                 _net_dbus_pending_call_unref();
 366
 367                 __NETWORK_FUNC_EXIT__;
 368                 return;
 369         }
 370
 371         _net_dbus_pending_call_unref();
 372
 373         _net_client_callback(&event_data);
 374
 375         __NETWORK_FUNC_EXIT__;
 376 }
 377
 378 static void __net_specific_scan_wifi_reply(GObject *source_object, GAsyncResult *res, gpointer user_data)
 379 {
 380         __NETWORK_FUNC_ENTER__;
 381
 382         GDBusConnection *conn = NULL;
 383         GError *error = NULL;
 384         net_err_t Error = NET_ERR_NONE;
 385         net_event_info_t event_data = { 0, };
 386
 387         conn = G_DBUS_CONNECTION(source_object);
 388         g_dbus_connection_call_finish(conn, res, &error);
 389         if (error != NULL) {
 390                 Error = __net_netconfig_error_string_to_enum(error->message);
 391                 g_error_free(error);
 392         }
 393
 394         if (Error != NET_ERR_NONE)
 395                 NETWORK_LOG(NETWORK_ERROR, "Find specific AP failed[%d]", Error);
 396         else
 397                 NETWORK_LOG(NETWORK_LOW, "Specific AP found");
 398
 399         if (request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN].flag == TRUE) {
 400                 if (NET_ERR_NONE != Error) {
 401                         /* An error occurred.
 402                          * So lets reset specific scan request entry in the request table */
 403                         memset(&request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN],
 404                                         0, sizeof(network_request_table_t));
 405                 }
 406
 407                 event_data.Event = NET_EVENT_SPECIFIC_SCAN_RSP;
 408
 409                 NETWORK_LOG(NETWORK_LOW,
 410                                 "Sending NET_EVENT_SPECIFIC_SCAN_RSP Wi-Fi: %d Error[%d]",
 411                                 NetworkInfo.wifi_state, Error);
 412
 413                 event_data.Datalength = sizeof(net_wifi_state_t);
 414                 event_data.Data = &(NetworkInfo.wifi_state);
 415                 event_data.Error = Error;
 416
 417                 _net_dbus_pending_call_unref();
 418                 _net_client_callback(&event_data);
 419         } else {
 420                 _net_dbus_pending_call_unref();
 421                 __NETWORK_FUNC_EXIT__;
 422                 return;
 423         }
 424
 425         __NETWORK_FUNC_EXIT__;
 426 }
 427
 428 static void __net_wps_scan_wifi_reply(GObject *source_object, GAsyncResult *res, gpointer user_data)
 429 {
 430         __NETWORK_FUNC_ENTER__;
 431
 432         GDBusConnection *conn = NULL;
 433         GError *error = NULL;
 434         net_err_t Error = NET_ERR_NONE;
 435         net_event_info_t event_data = { 0, };
 436
 437         conn = G_DBUS_CONNECTION(source_object);
 438         g_dbus_connection_call_finish(conn, res, &error);
 439         if (error != NULL) {
 440                 Error = __net_netconfig_error_string_to_enum(error->message);
 441                 g_error_free(error);
 442         }
 443
 444         if (Error != NET_ERR_NONE) {
 445                 NETWORK_LOG(NETWORK_ERROR, "WPS scan failed[%d]", Error);
 446
 447                 if (request_table[NETWORK_REQUEST_TYPE_WPS_SCAN].flag == TRUE) {
 448                         memset(&request_table[NETWORK_REQUEST_TYPE_WPS_SCAN],
 449                                         0, sizeof(network_request_table_t));
 450
 451                         event_data.Event = NET_EVENT_WPS_SCAN_IND;
 452                         event_data.Datalength = 0;
 453                         event_data.Data = NULL;
 454                         event_data.Error = Error;
 455
 456                         _net_dbus_pending_call_unref();
 457
 458                         _net_client_callback(&event_data);
 459
 460                         __NETWORK_FUNC_EXIT__;
 461                         return;
 462                 }
 463         } else
 464                 NETWORK_LOG(NETWORK_LOW, "WPS scan succeed");
 465
 466         _net_dbus_pending_call_unref();
 467
 468         __NETWORK_FUNC_EXIT__;
 469 }
 470
 471 static void __net_set_passpoint_reply(GObject *source_object, GAsyncResult *res, gpointer user_data)
 472 {
 473         __NETWORK_FUNC_ENTER__;
 474
 475         GDBusConnection *conn = NULL;
 476         GError *error = NULL;
 477         net_err_t Error = NET_ERR_NONE;
 478
 479         conn = G_DBUS_CONNECTION(source_object);
 480         g_dbus_connection_call_finish(conn, res, &error);
 481         if (error != NULL) {
 482                 Error = __net_netconfig_error_string_to_enum(error->message);
 483                 g_error_free(error);
 484         }
 485
 486         if (Error != NET_ERR_NONE)
 487                 NETWORK_LOG(NETWORK_ERROR, "set passpoint failed[%d]", Error);
 488         else
 489                 NETWORK_LOG(NETWORK_LOW, "set passpoint succeeded");
 490
 491         _net_dbus_pending_call_unref();
 492
 493         __NETWORK_FUNC_EXIT__;
 494 }
 495
 496 static void __net_set_default_reply(GObject *source_object, GAsyncResult *res, gpointer user_data)
 497 {
 498         __NETWORK_FUNC_ENTER__;
 499
 500         int rv;
 501         net_event_info_t event_data = { 0, };
 502         GDBusConnection *conn = NULL;
 503         GVariant *dbus_result;
 504         GError *error = NULL;
 505         net_err_t Error = NET_ERR_NONE;
 506
 507         NETWORK_LOG(NETWORK_LOW, "__net_set_default_reply() called");
 508
 509         conn = G_DBUS_CONNECTION(source_object);
 510         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
 511         if (error != NULL) {
 512                 Error = __net_error_string_to_enum(error->message);
 513                 g_error_free(error);
 514
 515                 NETWORK_LOG(NETWORK_ERROR, "Error code[%d]", Error);
 516         }
 517
 518         if (request_table[NETWORK_REQUEST_TYPE_SET_DEFAULT].flag == TRUE) {
 519                 memset(&request_table[NETWORK_REQUEST_TYPE_SET_DEFAULT],
 520                                                 0, sizeof(network_request_table_t));
 521                 event_data.Event = NET_EVENT_CELLULAR_SET_DEFAULT_RSP;
 522
 523                 if (Error == NET_ERR_NONE) {
 524                         g_variant_get(dbus_result, "(b)", &rv);
 525
 526                         NETWORK_LOG(NETWORK_LOW, "Reply: %s", rv ? "TRUE" : "FALSE");
 527
 528                         if (rv)
 529                                 event_data.Error = NET_ERR_NONE;
 530                         else
 531                                 event_data.Error = NET_ERR_UNKNOWN;
 532                 } else
 533                         event_data.Error = Error;
 534
 535                 NETWORK_LOG(NETWORK_LOW, "Sending NET_EVENT_CELLULAR_SET_DEFAULT_RSP Error[%s]",
 536                                 _net_print_error(event_data.Error));
 537         } else {
 538                 _net_dbus_pending_call_unref();
 539
 540                 __NETWORK_FUNC_EXIT__;
 541                 return;
 542         }
 543
 544         _net_dbus_pending_call_unref();
 545
 546         _net_client_callback(&event_data);
 547
 548         __NETWORK_FUNC_EXIT__;
 549 }
 550
 551 static char *__net_make_group_name(const char *ssid,
 552                 const char *net_mode, const char *sec)
 553 {
 554         char *buf = NULL;
 555         const char *hidden_str = "hidden";
 556         const char *g_sec;
 557         char ssid_hex[NET_WLAN_ESSID_LEN * 2 + 1] = { 0, };
 558         int i;
 559         int ssid_len = 0;
 560         int actual_len = 0;
 561         int buf_len = 0;
 562
 563         if (net_mode == NULL || sec == NULL)
 564                 return NULL;
 565
 566         if (NULL != ssid) {
 567                 ssid_len = strlen(ssid);
 568                 actual_len = ssid_len * 2;
 569         } else {
 570                 ssid_len = strlen(hidden_str);
 571                 actual_len = ssid_len;
 572         }
 573
 574         if (g_strcmp0(net_mode, "managed") != 0)
 575                 return NULL;
 576
 577         if (!g_strcmp0(sec, "wpa") || !g_strcmp0(sec, "rsn"))
 578                 g_sec = "psk";
 579         else
 580                 g_sec = sec;
 581
 582         buf_len = actual_len + strlen(net_mode) + strlen(g_sec) + 4;
 583
 584         buf = g_try_malloc0(buf_len);
 585         if (buf == NULL)
 586                 return NULL;
 587
 588         if (NULL != ssid) {
 589                 for (i = 0; i < ssid_len; i++)
 590                         g_snprintf(ssid_hex + i * 2, 3, "%02x", ssid[i]);
 591         } else {
 592                 g_snprintf(ssid_hex, strlen(hidden_str) + 1, "%s", hidden_str);
 593         }
 594
 595         g_snprintf(buf, buf_len, "_%s_%s_%s", ssid_hex, net_mode, g_sec);
 596
 597         NETWORK_LOG(NETWORK_LOW, "Group name: %s", buf);
 598
 599         return buf;
 600 }
 601
 602 static int __net_dbus_set_agent_field_and_connect(
 603                 const char *key, const char *value, const char *profilename)
 604 {
 605         __NETWORK_FUNC_ENTER__;
 606
 607         net_err_t Error = NET_ERR_NONE;
 608         GVariant *params = NULL;
 609         GVariantBuilder *builder;
 610
 611         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 612         g_variant_builder_add(builder, "{sv}", key, g_variant_new_string(value));
 613
 614         params = g_variant_new("(o@a{sv})",
 615                         profilename, g_variant_builder_end(builder));
 616         g_variant_builder_unref(builder);
 617
 618         Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE,
 619                         NETCONFIG_WIFI_PATH,
 620                         CONNMAN_AGENT_INTERFACE, "SetField", params,
 621                         DBUS_REPLY_TIMEOUT, __net_open_connection_reply);
 622
 623         __NETWORK_FUNC_EXIT__;
 624         return Error;
 625 }
 626
 627 /*****************************************************************************
 628  * Global Functions Definition
 629  *****************************************************************************/
 630 GVariant *_net_invoke_dbus_method(const char *dest, const char *path,
 631                 const char *interface_name, const char *method,
 632                 GVariant *params, int *dbus_error)
 633 {
 634         __NETWORK_FUNC_ENTER__;
 635
 636         GError *error = NULL;
 637         GVariant *reply = NULL;
 638         *dbus_error = NET_ERR_NONE;
 639         GDBusConnection *connection;
 640
 641         connection = _net_dbus_get_gdbus_conn();
 642         if (connection == NULL) {
 643                 NETWORK_LOG(NETWORK_ERROR, "GDBusconnection is NULL");
 644                 *dbus_error = NET_ERR_APP_NOT_REGISTERED;
 645                 return reply;
 646         }
 647
 648         reply = g_dbus_connection_call_sync(connection,
 649                         dest,
 650                         path,
 651                         interface_name,
 652                         method,
 653                         params,
 654                         NULL,
 655                         G_DBUS_CALL_FLAGS_NONE,
 656                         DBUS_REPLY_TIMEOUT,
 657                         _net_dbus_get_gdbus_cancellable(),
 658                         &error);
 659         if (reply == NULL) {
 660                 if (error != NULL) {
 661                         SECURE_NETWORK_LOG(NETWORK_ERROR,
 662                                                 "g_dbus_connection_call_sync() failed"
 663                                                 "error [%d: %s]", error->code, error->message);
 664                         *dbus_error = __net_error_string_to_enum(error->message);
 665                         g_error_free(error);
 666                 } else {
 667                         NETWORK_LOG(NETWORK_ERROR,
 668                                         "g_dbus_connection_call_sync() failed");
 669                         *dbus_error = NET_ERR_UNKNOWN;
 670                 }
 671
 672                 __NETWORK_FUNC_EXIT__;
 673                 return NULL;
 674         }
 675
 676         __NETWORK_FUNC_EXIT__;
 677         return reply;
 678 }
 679
 680 int _net_invoke_dbus_method_nonblock(const char *dest, const char *path,
 681                 const char *interface_name, const char *method,
 682                 GVariant *params, int timeout,
 683                 GAsyncReadyCallback notify_func)
 684 {
 685         __NETWORK_FUNC_ENTER__;
 686
 687         GDBusConnection *connection;
 688
 689         connection = _net_dbus_get_gdbus_conn();
 690         if (connection == NULL) {
 691                 NETWORK_LOG(NETWORK_ERROR, "GDBusconnection is NULL");
 692                 return NET_ERR_APP_NOT_REGISTERED;
 693         }
 694
 695         g_dbus_connection_call(connection,
 696                                                         dest,
 697                                                         path,
 698                                                         interface_name,
 699                                                         method,
 700                                                         params,
 701                                                         NULL,
 702                                                         G_DBUS_CALL_FLAGS_NONE,
 703                                                         timeout,
 704                                                         _net_dbus_get_gdbus_cancellable(),
 705                                                         (GAsyncReadyCallback) notify_func,
 706                                                         NULL);
 707
 708         if (notify_func != NULL)
 709                 _net_dbus_pending_call_ref();
 710
 711         __NETWORK_FUNC_EXIT__;
 712         return NET_ERR_NONE;
 713 }
 714
 715 int _net_dbus_open_connection(const char* profile_name)
 716 {
 717         __NETWORK_FUNC_ENTER__;
 718
 719         net_err_t Error = NET_ERR_NONE;
 720
 721         /* use DBus signal than reply pending because of performance reason */
 722         Error = _net_invoke_dbus_method_nonblock(CONNMAN_SERVICE, profile_name,
 723                         CONNMAN_SERVICE_INTERFACE, "Connect", NULL,
 724                         DBUS_REPLY_TIMEOUT, __net_open_connection_reply);
 725
 726         __NETWORK_FUNC_EXIT__;
 727         return Error;
 728 }
 729
 730 int _net_dbus_close_connection(const char* profile_name)
 731 {
 732         __NETWORK_FUNC_ENTER__;
 733
 734         net_err_t Error = NET_ERR_NONE;
 735
 736         /* use DBus signal than reply pending because of performance reason */
 737         Error = _net_invoke_dbus_method_nonblock(CONNMAN_SERVICE, profile_name,
 738                         CONNMAN_SERVICE_INTERFACE, "Disconnect", NULL,
 739                         DBUS_REPLY_TIMEOUT, __net_close_connection_reply);
 740
 741         __NETWORK_FUNC_EXIT__;
 742         return Error;
 743 }
 744
 745 int _net_dbus_scan_request(void)
 746 {
 747         __NETWORK_FUNC_ENTER__;
 748
 749         net_err_t Error = NET_ERR_NONE;
 750
 751         /* use DBus signal than reply pending because of performance reason */
 752         Error = _net_invoke_dbus_method_nonblock(CONNMAN_SERVICE,
 753                         CONNMAN_WIFI_TECHNOLOGY_PREFIX,
 754                         CONNMAN_TECHNOLOGY_INTERFACE, "Scan", NULL,
 755                         DBUS_REPLY_TIMEOUT, NULL);
 756
 757         if (Error == NET_ERR_IN_PROGRESS)
 758                 Error = NET_ERR_NONE;
 759
 760         __NETWORK_FUNC_EXIT__;
 761         return Error;
 762 }
 763
 764 int _net_dbus_set_default(const char* profile_name)
 765 {
 766         __NETWORK_FUNC_ENTER__;
 767
 768         net_err_t Error = NET_ERR_NONE;
 769
 770         Error = _net_invoke_dbus_method_nonblock(TELEPHONY_SERVICE,
 771                         profile_name, TELEPHONY_PROFILE_INTERFACE,
 772                         "SetDefaultConnection", NULL, DBUS_REPLY_TIMEOUT,
 773                         __net_set_default_reply);
 774
 775         __NETWORK_FUNC_EXIT__;
 776         return Error;
 777 }
 778
 779 int _net_dbus_set_bgscan_mode(net_wifi_background_scan_mode_t mode)
 780 {
 781         __NETWORK_FUNC_ENTER__;
 782
 783         net_err_t Error = NET_ERR_NONE;
 784         GVariant *message = NULL;
 785         GVariant *params;
 786
 787         char path[CONNMAN_MAX_BUFLEN] = NETCONFIG_WIFI_PATH;
 788
 789         params = g_variant_new("(u)", mode);
 790
 791         message = _net_invoke_dbus_method(NETCONFIG_SERVICE, path,
 792                         NETCONFIG_WIFI_INTERFACE, "SetBgscan", params, &Error);
 793
 794         if (Error != NET_ERR_NONE)
 795                 NETWORK_LOG(NETWORK_ERROR, "_net_invoke_dbus_method failed");
 796
 797         if (message != NULL)
 798                 g_variant_unref(message);
 799
 800         __NETWORK_FUNC_EXIT__;
 801         return Error;
 802 }
 803
 804 int _net_dbus_get_technology_state(network_tech_state_info_t* tech_state)
 805 {
 806         __NETWORK_FUNC_ENTER__;
 807
 808         net_err_t Error = NET_ERR_NONE;
 809         GVariant *message = NULL;
 810
 811         if ((tech_state == NULL) || (strlen(tech_state->technology) == 0)) {
 812                 NETWORK_LOG(NETWORK_ERROR, "Invalid parameter");
 813                 __NETWORK_FUNC_EXIT__;
 814                 return NET_ERR_INVALID_PARAM;
 815         }
 816
 817         message = _net_invoke_dbus_method(CONNMAN_SERVICE,
 818                         CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE,
 819                         "GetTechnologies", NULL, &Error);
 820         if (message == NULL) {
 821                 NETWORK_LOG(NETWORK_ERROR, "Failed to get technology info");
 822                 goto done;
 823         }
 824
 825         Error = _net_get_tech_state(message, tech_state);
 826
 827         g_variant_unref(message);
 828
 829 done:
 830         __NETWORK_FUNC_EXIT__;
 831         return Error;
 832 }
 833
 834 int _net_dbus_get_network_status(net_device_t device_type, net_cm_network_status_t* network_status)
 835 {
 836         __NETWORK_FUNC_ENTER__;
 837
 838         net_err_t Error = NET_ERR_NONE;
 839         network_tech_state_info_t tech_state = {{0,},};
 840
 841         if (device_type == NET_DEVICE_WIFI)
 842                 g_strlcpy(tech_state.technology, "wifi", NET_TECH_LENGTH_MAX);
 843         else if (device_type == NET_DEVICE_CELLULAR)
 844                 g_strlcpy(tech_state.technology, "cellular", NET_TECH_LENGTH_MAX);
 845         else if (device_type == NET_DEVICE_ETHERNET)
 846                 g_strlcpy(tech_state.technology, "ethernet", NET_TECH_LENGTH_MAX);
 847         else if (device_type == NET_DEVICE_BLUETOOTH)
 848                 g_strlcpy(tech_state.technology, "bluetooth", NET_TECH_LENGTH_MAX);
 849         else {
 850                 Error = NET_ERR_INVALID_PARAM;
 851                 goto done;
 852         }
 853
 854         Error = _net_dbus_get_technology_state(&tech_state);
 855         if (Error != NET_ERR_NONE) {
 856                 NETWORK_LOG(NETWORK_ERROR,
 857                         "_net_dbus_get_technology_state() failed. Error [%s]",
 858                         _net_print_error(Error));
 859                 goto done;
 860         }
 861
 862         if (tech_state.Connected == TRUE)
 863                 *network_status = NET_STATUS_AVAILABLE;
 864         else
 865                 *network_status = NET_STATUS_UNAVAILABLE;
 866
 867 done:
 868         __NETWORK_FUNC_EXIT__;
 869         return Error;
 870 }
 871
 872 int _net_dbus_get_tech_status(net_device_t device_type, net_tech_info_t* tech_status)
 873 {
 874         __NETWORK_FUNC_ENTER__;
 875
 876         net_err_t Error = NET_ERR_NONE;
 877         network_tech_state_info_t tech_state = {{0,},};
 878
 879         if (device_type == NET_DEVICE_WIFI)
 880                 g_strlcpy(tech_state.technology, "wifi", NET_TECH_LENGTH_MAX);
 881         else if (device_type == NET_DEVICE_CELLULAR)
 882                 g_strlcpy(tech_state.technology, "cellular", NET_TECH_LENGTH_MAX);
 883         else if (device_type == NET_DEVICE_ETHERNET)
 884                 g_strlcpy(tech_state.technology, "ethernet", NET_TECH_LENGTH_MAX);
 885         else if (device_type == NET_DEVICE_BLUETOOTH)
 886                 g_strlcpy(tech_state.technology, "bluetooth", NET_TECH_LENGTH_MAX);
 887         else {
 888                 Error = NET_ERR_INVALID_PARAM;
 889                 goto done;
 890         }
 891
 892         Error = _net_dbus_get_technology_state(&tech_state);
 893         if (Error != NET_ERR_NONE) {
 894                 NETWORK_LOG(NETWORK_ERROR,
 895                         "_net_dbus_get_technology_state() failed. Error [%s]",
 896                         _net_print_error(Error));
 897                 goto done;
 898         }
 899
 900         if (tech_state.Powered == TRUE)
 901                 tech_status->powered = TRUE;
 902         else
 903                 tech_status->powered = FALSE;
 904
 905         if (tech_state.Connected == TRUE)
 906                 tech_status->connected = TRUE;
 907         else
 908                 tech_status->connected = FALSE;
 909
 910 done:
 911         __NETWORK_FUNC_EXIT__;
 912         return Error;
 913 }
 914
 915 int _net_dbus_get_wifi_state(char **wifi_state)
 916 {
 917         __NETWORK_FUNC_ENTER__;
 918
 919         net_err_t Error = NET_ERR_NONE;
 920         GVariant *message = NULL;
 921         const char *method = "GetWifiState";
 922
 923         if (NULL == wifi_state) {
 924                         NETWORK_LOG(NETWORK_ERROR, "Invalid Parameter\n");
 925                         __NETWORK_FUNC_EXIT__;
 926                         return NET_ERR_INVALID_PARAM;
 927         }
 928
 929         message = _net_invoke_dbus_method(
 930                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
 931                         NETCONFIG_WIFI_INTERFACE, method, NULL, &Error);
 932
 933         if (message == NULL) {
 934                 NETWORK_LOG(NETWORK_ERROR, "Failed to get wifi state\n");
 935                 __NETWORK_FUNC_EXIT__;
 936                 return Error;
 937         }
 938
 939         g_variant_get(message, "(s)", wifi_state);
 940         g_variant_unref(message);
 941
 942         __NETWORK_FUNC_EXIT__;
 943
 944         return Error;
 945 }
 946
 947 int _net_dbus_get_statistics(net_device_t device_type, net_statistics_type_e statistics_type, unsigned long long *size)
 948 {
 949         net_err_t Error = NET_ERR_NONE;
 950         GVariant *message = NULL;
 951         char *method = NULL;
 952
 953         if (device_type == NET_DEVICE_WIFI) {
 954                 switch (statistics_type) {
 955                 case NET_STATISTICS_TYPE_LAST_RECEIVED_DATA:
 956                         method = "GetWifiLastRxBytes";
 957                         break;
 958                 case NET_STATISTICS_TYPE_LAST_SENT_DATA:
 959                         method = "GetWifiLastTxBytes";
 960                         break;
 961                 case NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
 962                         method = "GetWifiTotalRxBytes";
 963                         break;
 964                 case NET_STATISTICS_TYPE_TOTAL_SENT_DATA:
 965                         method = "GetWifiTotalTxBytes";
 966                         break;
 967                 default:
 968                         NETWORK_LOG(NETWORK_ERROR, "Invalid profile name");
 969                         return NET_ERR_INVALID_PARAM;
 970                 }
 971         } else {
 972                 NETWORK_LOG(NETWORK_ERROR, "Invalid profile name");
 973                 return NET_ERR_INVALID_PARAM;
 974         }
 975
 976         message = _net_invoke_dbus_method(
 977                         NETCONFIG_SERVICE, NETCONFIG_STATISTICS_PATH,
 978                         NETCONFIG_STATISTICS_INTERFACE, method, NULL, &Error);
 979         if (message == NULL) {
 980                 NETWORK_LOG(NETWORK_ERROR, "Failed to get service properties");
 981                 return Error;
 982         }
 983
 984         g_variant_get(message, "(t)", size);
 985
 986         NETWORK_LOG(NETWORK_LOW, "success [%s] statistics size: [%llu]", method, *size);
 987         g_variant_unref(message);
 988
 989         return Error;
 990 }
 991
 992 int _net_dbus_set_statistics(net_device_t device_type, net_statistics_type_e statistics_type)
 993 {
 994         net_err_t Error = NET_ERR_NONE;
 995         GVariant *message = NULL;
 996         char *method = NULL;
 997
 998         if (device_type == NET_DEVICE_CELLULAR) {
 999                 switch (statistics_type) {
1000                 case NET_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1001                         method = "ResetCellularLastRxBytes";
1002                         break;
1003                 case NET_STATISTICS_TYPE_LAST_SENT_DATA:
1004                         method = "ResetCellularLastTxBytes";
1005                         break;
1006                 case NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1007                         method = "ResetCellularTotalRxBytes";
1008                         break;
1009                 case NET_STATISTICS_TYPE_TOTAL_SENT_DATA:
1010                         method = "ResetCellularTotalTxBytes";
1011                         break;
1012                 default:
1013                         NETWORK_LOG(NETWORK_ERROR, "Invalid profile name");
1014                         return NET_ERR_INVALID_PARAM;
1015                 }
1016         } else if (device_type == NET_DEVICE_WIFI) {
1017                 switch (statistics_type) {
1018                 case NET_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1019                         method = "ResetWifiLastRxBytes";
1020                         break;
1021                 case NET_STATISTICS_TYPE_LAST_SENT_DATA:
1022                         method = "ResetWifiLastTxBytes";
1023                         break;
1024                 case NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1025                         method = "ResetWifiTotalRxBytes";
1026                         break;
1027                 case NET_STATISTICS_TYPE_TOTAL_SENT_DATA:
1028                         method = "ResetWifiTotalTxBytes";
1029                         break;
1030                 default:
1031                         NETWORK_LOG(NETWORK_ERROR, "Invalid profile name");
1032                         return NET_ERR_INVALID_PARAM;
1033                 }
1034         } else {
1035                 NETWORK_LOG(NETWORK_ERROR, "Invalid profile name");
1036                 return NET_ERR_INVALID_PARAM;
1037         }
1038
1039         message = _net_invoke_dbus_method(
1040                         NETCONFIG_SERVICE, NETCONFIG_STATISTICS_PATH,
1041                         NETCONFIG_STATISTICS_INTERFACE, method, NULL, &Error);
1042         if (message == NULL) {
1043                 NETWORK_LOG(NETWORK_ERROR, "Failed to get service properties");
1044                 return Error;
1045         }
1046
1047         NETWORK_LOG(NETWORK_LOW, "reset [%s] statistics success", method);
1048         g_variant_unref(message);
1049
1050         return Error;
1051 }
1052
1053 int _net_dbus_get_state(char* state)
1054 {
1055         __NETWORK_FUNC_ENTER__;
1056
1057         net_err_t Error = NET_ERR_NONE;
1058         GVariant *message = NULL;
1059         GVariant *value = NULL;
1060         GVariantIter *iter = NULL;
1061         gchar *key = NULL;
1062         const gchar *net_state = NULL;
1063
1064         message = _net_invoke_dbus_method(
1065                         CONNMAN_SERVICE, CONNMAN_MANAGER_PATH,
1066                         CONNMAN_MANAGER_INTERFACE, "GetProperties", NULL, &Error);
1067         if (message == NULL) {
1068                 NETWORK_LOG(NETWORK_ERROR, "Failed to get service properties");
1069
1070                 __NETWORK_FUNC_EXIT__;
1071                 return Error;
1072         }
1073
1074         g_variant_get(message, "(a{sv})", &iter);
1075
1076         while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
1077                 if (g_strcmp0(key, "State") == 0) {
1078                         net_state = g_variant_get_string(value, NULL);
1079                         g_strlcpy(state, net_state, CONNMAN_STATE_STRLEN);
1080                         g_variant_unref(value);
1081                         g_free(key);
1082                         break;
1083                 }
1084         }
1085
1086         NETWORK_LOG(NETWORK_LOW, "State: %s", state);
1087
1088         g_variant_iter_free(iter);
1089         g_variant_unref(message);
1090
1091         __NETWORK_FUNC_EXIT__;
1092         return Error;
1093 }
1094
1095 int _net_dbus_get_ethernet_cable_state(int *state)
1096 {
1097         __NETWORK_FUNC_ENTER__;
1098
1099         net_err_t Error = NET_ERR_NONE;
1100         GVariant *message = NULL;
1101
1102         if (state == NULL) {
1103                 NETWORK_LOG(NETWORK_ERROR, "Invalid Parameter\n");
1104                 __NETWORK_FUNC_EXIT__;
1105                 return NET_ERR_INVALID_PARAM;
1106         }
1107
1108         message = _net_invoke_dbus_method(NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH,
1109                         NETCONFIG_NETWORK_INTERFACE, "EthernetCableState", NULL, &Error);
1110
1111         if (message == NULL) {
1112                 NETWORK_LOG(NETWORK_ERROR, "Failed to get Ethernet Module State\n");
1113                 return Error;
1114         }
1115
1116         g_variant_get(message, "(i)", state);
1117
1118         NETWORK_LOG(NETWORK_LOW, "Ethernet Cable State [%d]\n", *state);
1119
1120         g_variant_unref(message);
1121
1122         __NETWORK_FUNC_EXIT__;
1123         return Error;
1124 }
1125
1126 int _net_dbus_set_eap_config_fields_and_connect(
1127                 const net_wifi_connect_service_info_t *wifi_info,
1128                 const char *profilename)
1129 {
1130         __NETWORK_FUNC_ENTER__;
1131
1132         net_err_t Error = NET_ERR_NONE;
1133         GVariant *params = NULL;
1134         GVariantBuilder *builder;
1135
1136         builder = g_variant_builder_new(G_VARIANT_TYPE("a{ss}"));
1137         g_variant_builder_add(builder, "{ss}", CONNMAN_CONFIG_FIELD_TYPE, "wifi");
1138
1139         if (wifi_info->ssid)
1140                 g_variant_builder_add(builder, "{ss}",
1141                                 CONNMAN_CONFIG_FIELD_NAME, wifi_info->ssid);
1142
1143         if (wifi_info->eap_type)
1144                 g_variant_builder_add(builder, "{ss}",
1145                                 CONNMAN_CONFIG_FIELD_EAP_METHOD, wifi_info->eap_type);
1146
1147         if (wifi_info->eap_keymgmt_type)
1148                 g_variant_builder_add(builder, "{ss}",
1149                                 CONNMAN_CONFIG_FIELD_EAP_KEYMGMT_TYPE, wifi_info->eap_keymgmt_type);
1150
1151         if (wifi_info->identity)
1152                 g_variant_builder_add(builder, "{ss}",
1153                                 CONNMAN_CONFIG_FIELD_IDENTITY, wifi_info->identity);
1154
1155         if (wifi_info->password)
1156                 g_variant_builder_add(builder, "{ss}",
1157                                 CONNMAN_CONFIG_FIELD_PASSPHRASE, wifi_info->password);
1158
1159         if (wifi_info->eap_auth &&
1160                         g_strcmp0(wifi_info->eap_auth, "NONE") != 0)
1161                 g_variant_builder_add(builder, "{ss}",
1162                                 CONNMAN_CONFIG_FIELD_PHASE2, wifi_info->eap_auth);
1163
1164         if (wifi_info->ca_cert_file)
1165                 g_variant_builder_add(builder, "{ss}",
1166                                 CONNMAN_CONFIG_FIELD_CA_CERT_FILE, wifi_info->ca_cert_file);
1167
1168         if (wifi_info->client_cert_file)
1169                 g_variant_builder_add(builder, "{ss}",
1170                                 CONNMAN_CONFIG_FIELD_CLIENT_CERT_FILE,
1171                                 wifi_info->client_cert_file);
1172
1173         if (wifi_info->private_key_file)
1174                 g_variant_builder_add(builder, "{ss}",
1175                                 CONNMAN_CONFIG_FIELD_PVT_KEY_FILE,
1176                                 wifi_info->private_key_file);
1177
1178         if (wifi_info->private_key_password)
1179                 g_variant_builder_add(builder, "{ss}",
1180                                 CONNMAN_CONFIG_FIELD_PVT_KEY_PASSPHRASE,
1181                                 wifi_info->private_key_password);
1182
1183         params = g_variant_new("(o@a{ss})",
1184                         profilename, g_variant_builder_end(builder));
1185         g_variant_builder_unref(builder);
1186
1187         Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE,
1188                         NETCONFIG_WIFI_PATH,
1189                         NETCONFIG_WIFI_INTERFACE, "CreateEapConfig", params,
1190                         DBUS_REPLY_TIMEOUT, __net_open_connection_reply);
1191
1192         __NETWORK_FUNC_EXIT__;
1193         return Error;
1194 }
1195
1196 int _net_dbus_set_agent_passphrase_and_connect(
1197                 const char *passphrase, const char *profilename)
1198 {
1199         __NETWORK_FUNC_ENTER__;
1200
1201         net_err_t Error = NET_ERR_NONE;
1202
1203         if (NULL == passphrase || strlen(passphrase) <= 0 || NULL == profilename) {
1204                 NETWORK_LOG(NETWORK_ERROR, "Invalid parameter");
1205                 return NET_ERR_INVALID_PARAM;
1206         }
1207
1208         Error = __net_dbus_set_agent_field_and_connect(
1209                         NETCONFIG_AGENT_FIELD_PASSPHRASE,
1210                         passphrase,
1211                         profilename);
1212         if (NET_ERR_NONE != Error) {
1213                 NETWORK_LOG(NETWORK_ERROR, "Configuration failed(%d)", Error);
1214                 return Error;
1215         }
1216
1217         __NETWORK_FUNC_EXIT__;
1218         return Error;
1219 }
1220
1221 int _net_dbus_set_agent_fields_and_connect(const char *ssid,
1222                 const char *passphrase, const char *profilename)
1223 {
1224         __NETWORK_FUNC_ENTER__;
1225
1226         net_err_t Error = NET_ERR_NONE;
1227
1228         /* If OPEN network, passphrase can be NULL */
1229         if (NULL == ssid || strlen(ssid) <= 0 || NULL == profilename) {
1230                 NETWORK_LOG(NETWORK_ERROR, "Invalid parameter");
1231                 return NET_ERR_INVALID_PARAM;
1232         }
1233
1234         GVariant *params = NULL;
1235         GVariantBuilder *builder;
1236
1237         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1238         g_variant_builder_add(builder, "{sv}", NETCONFIG_AGENT_FIELD_SSID,
1239                         g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, ssid,
1240                                         strlen(ssid), sizeof(guchar)));
1241
1242         if (passphrase)
1243                 g_variant_builder_add(builder, "{sv}", NETCONFIG_AGENT_FIELD_PASSPHRASE,
1244                                 g_variant_new_string(passphrase));
1245
1246         params = g_variant_new("(o@a{sv})",
1247                         profilename, g_variant_builder_end(builder));
1248         g_variant_builder_unref(builder);
1249
1250         Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE,
1251                         NETCONFIG_WIFI_PATH,
1252                         CONNMAN_AGENT_INTERFACE, "SetField", params,
1253                         DBUS_REPLY_TIMEOUT, __net_open_connection_reply);
1254         if (NET_ERR_NONE != Error) {
1255                 NETWORK_LOG(NETWORK_ERROR, "Configuration failed(%d)", Error);
1256                 return Error;
1257         }
1258
1259         __NETWORK_FUNC_EXIT__;
1260         return Error;
1261 }
1262
1263 int _net_dbus_get_wps_pin(char **wps_pin)
1264 {
1265         __NETWORK_FUNC_ENTER__;
1266         net_err_t error = NET_ERR_NONE;
1267         GVariant *params = NULL;
1268         GVariant *reply = NULL;
1269         gchar *value = NULL;
1270         char *path = NULL;
1271
1272         params = g_variant_new("(s)", "wlan0");
1273         reply = _net_invoke_dbus_method(SUPPLICANT_SERVICE, SUPPLICANT_PATH,
1274                         SUPPLICANT_INTERFACE, "GetInterface", params, &error);
1275         if (reply == NULL) {
1276                 NETWORK_LOG(NETWORK_ERROR, "Failed to get Wi-Fi interface");
1277                 return error;
1278         }
1279         g_variant_get(reply, "(o)", &path);
1280
1281         reply = _net_invoke_dbus_method(SUPPLICANT_SERVICE, path,
1282                         SUPPLICANT_INTERFACE ".Interface.WPS", "GetPin", NULL, &error);
1283         if (reply == NULL) {
1284                 NETWORK_LOG(NETWORK_ERROR, "Failed to get wps pin");
1285                 return error;
1286         }
1287         g_variant_get(reply, "(s)", &value);
1288         *wps_pin = g_strdup_printf("%s", value);
1289         g_variant_unref(reply);
1290
1291         __NETWORK_FUNC_EXIT__;
1292         return error;
1293 }
1294
1295 int _net_dbus_set_agent_wps_pbc_and_connect(const char *profilename)
1296 {
1297         __NETWORK_FUNC_ENTER__;
1298
1299         net_err_t Error = NET_ERR_NONE;
1300
1301         Error = __net_dbus_set_agent_field_and_connect(
1302                         NETCONFIG_AGENT_FIELD_WPS_PBC,
1303                         "enable",
1304                         profilename);
1305         if (NET_ERR_NONE != Error) {
1306                 NETWORK_LOG(NETWORK_ERROR, "PBC configuration failed(%d)", Error);
1307                 return Error;
1308         }
1309
1310         __NETWORK_FUNC_EXIT__;
1311         return Error;
1312 }
1313
1314 int _net_dbus_set_agent_wps_pin_and_connect(
1315                 const char *wps_pin, const char *profilename)
1316 {
1317         __NETWORK_FUNC_ENTER__;
1318
1319         net_err_t Error = NET_ERR_NONE;
1320
1321         if (NULL == wps_pin || strlen(wps_pin) <= 0) {
1322                 NETWORK_LOG(NETWORK_ERROR, "Invalid param ");
1323                 return NET_ERR_INVALID_PARAM;
1324         }
1325
1326         Error = __net_dbus_set_agent_field_and_connect(
1327                         NETCONFIG_AGENT_FIELD_WPS_PIN,
1328                         wps_pin,
1329                         profilename);
1330         if (NET_ERR_NONE != Error) {
1331                 NETWORK_LOG(NETWORK_ERROR, "PIN configuration failed(%d)", Error);
1332                 return Error;
1333         }
1334
1335         __NETWORK_FUNC_EXIT__;
1336         return Error;
1337 }
1338
1339 int _net_dbus_connect_service(const net_wifi_connect_service_info_t *wifi_connection_info)
1340 {
1341         __NETWORK_FUNC_ENTER__;
1342
1343         net_err_t Error = NET_ERR_NONE;
1344         char *grp_name = NULL;
1345         int profile_count = 0;
1346         net_profile_info_t* profile_info = NULL;
1347         int i = 0;
1348
1349         /* Get group name with prefix 'ssid' in hex */
1350         grp_name = __net_make_group_name(wifi_connection_info->is_hidden == TRUE ?
1351                                 NULL : wifi_connection_info->ssid,
1352                         wifi_connection_info->mode,
1353                         wifi_connection_info->security);
1354         if (NULL == grp_name) {
1355                 NETWORK_LOG(NETWORK_ERROR, "Failed to make a group name");
1356
1357                 __NETWORK_FUNC_EXIT__;
1358                 return NET_ERR_UNKNOWN;
1359         }
1360
1361         Error = _net_get_profile_list(NET_DEVICE_WIFI, &profile_info, &profile_count);
1362         if (NET_ERR_NONE != Error) {
1363                 NETWORK_LOG(NETWORK_ERROR,
1364                                 "_net_get_profile_list fail. Error [%s]",
1365                                 _net_print_error(Error));
1366
1367                 goto error;
1368         }
1369
1370         for (i = 0; i < profile_count; i++) {
1371                 if (g_strstr_len(profile_info[i].ProfileName,
1372                                 NET_PROFILE_NAME_LEN_MAX+1, grp_name) != NULL) {
1373                         NETWORK_LOG(NETWORK_ERROR, "Found profile %s",
1374                                         profile_info[i].ProfileName);
1375
1376                         if (profile_info[i].ProfileState == NET_STATE_TYPE_READY ||
1377                                         profile_info[i].ProfileState == NET_STATE_TYPE_ONLINE) {
1378                                 NETWORK_LOG(NETWORK_ERROR, "Already profile is connected");
1379                                 Error = NET_ERR_ACTIVE_CONNECTION_EXISTS;
1380
1381                                 goto error;
1382                         }
1383
1384                         break;
1385                 }
1386         }
1387
1388         if (i >= profile_count) {
1389                 NETWORK_LOG(NETWORK_ERROR, "No matching profile found");
1390                 Error = NET_ERR_NO_SERVICE;
1391
1392                 goto error;
1393         }
1394
1395         if (wifi_connection_info->is_hidden == TRUE) {
1396                 int target = 0;
1397                 char *target_name = __net_make_group_name(wifi_connection_info->ssid,
1398                                 wifi_connection_info->mode,
1399                                 wifi_connection_info->security);
1400
1401                 for (target = 0; target < profile_count; target++) {
1402                         if (g_strstr_len(profile_info[target].ProfileName,
1403                                         NET_PROFILE_NAME_LEN_MAX+1, target_name) != NULL) {
1404                                 g_strlcpy(request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].ProfileName,
1405                                                 profile_info[target].ProfileName, NET_PROFILE_NAME_LEN_MAX+1);
1406
1407                                 break;
1408                         }
1409                 }
1410
1411                 g_free(target_name);
1412         } else {
1413                 g_strlcpy(request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].ProfileName,
1414                                 profile_info[i].ProfileName, NET_PROFILE_NAME_LEN_MAX+1);
1415         }
1416
1417         if (g_strcmp0(wifi_connection_info->security, "ieee8021x") == 0) {
1418                 /* Create the EAP config file */
1419                 Error = _net_dbus_set_eap_config_fields_and_connect(
1420                                 wifi_connection_info, profile_info[i].ProfileName);
1421                 if (NET_ERR_NONE != Error) {
1422                         NETWORK_LOG(NETWORK_ERROR, "Fail to create eap_config");
1423
1424                         goto error;
1425                 }
1426         } else if (wifi_connection_info->is_hidden == TRUE) {
1427                 Error = _net_dbus_set_agent_fields_and_connect(
1428                                 wifi_connection_info->ssid,
1429                                 wifi_connection_info->passphrase,
1430                                 profile_info[i].ProfileName);
1431         } else if (g_strcmp0(wifi_connection_info->security, "none") != 0) {
1432                 Error = _net_dbus_set_agent_passphrase_and_connect(
1433                                 wifi_connection_info->passphrase, profile_info[i].ProfileName);
1434                 if (NET_ERR_NONE != Error) {
1435                         NETWORK_LOG(NETWORK_ERROR, "Fail to set agent_passphrase");
1436
1437                         goto error;
1438                 }
1439         } else
1440                 Error = _net_dbus_open_connection(profile_info[i].ProfileName);
1441
1442 error:
1443         if (NET_ERR_NONE != Error) {
1444                 NETWORK_LOG(NETWORK_ERROR,
1445                                 "Failed to request open connection, Error [%s]",
1446                                 _net_print_error(Error));
1447
1448                 memset(&request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION],
1449                                 0, sizeof(network_request_table_t));
1450         }
1451
1452         NET_MEMFREE(profile_info);
1453         g_free(grp_name);
1454
1455         __NETWORK_FUNC_EXIT__;
1456         return Error;
1457 }
1458
1459 int _net_dbus_set_profile_ipv4(net_profile_info_t* prof_info, char* profile_name)
1460 {
1461         __NETWORK_FUNC_ENTER__;
1462
1463         net_err_t Error = NET_ERR_NONE;
1464
1465         const char *manual_method = "manual";
1466         const char *dhcp_method = "dhcp";
1467         const char *off_method = "off";
1468
1469         const char *prop_ipv4_configuration = "IPv4.Configuration";
1470         const char *prop_method = "Method";
1471         const char *prop_address = "Address";
1472         const char *prop_gateway = "Gateway";
1473         const char *prop_netmask = "Netmask";
1474
1475         char ip_buffer[NETPM_IPV4_STR_LEN_MAX+1] = "";
1476         char netmask_buffer[NETPM_IPV4_STR_LEN_MAX+1] = "";
1477         char gateway_buffer[NETPM_IPV4_STR_LEN_MAX+1] = "";
1478
1479         char *ipaddress = ip_buffer;
1480         char *netmask = netmask_buffer;
1481         char *gateway = gateway_buffer;
1482
1483         GVariant *params = NULL;
1484         GVariantBuilder *builder;
1485         net_dev_info_t *profile_net_info  = NULL;
1486
1487         GVariant *message = NULL;
1488
1489         NETWORK_LOG(NETWORK_HIGH, "profile_name: [%s]", profile_name);
1490
1491         if ((prof_info == NULL) || (profile_name == NULL) || (strlen(profile_name) == 0)) {
1492                 NETWORK_LOG(NETWORK_ERROR, "Invalid argument");
1493                 __NETWORK_FUNC_EXIT__;
1494                 return NET_ERR_INVALID_PARAM;
1495         }
1496
1497         if (prof_info->profile_type == NET_DEVICE_WIFI)
1498                 profile_net_info = &(prof_info->ProfileInfo.Wlan.net_info);
1499         else if (prof_info->profile_type == NET_DEVICE_ETHERNET)
1500                 profile_net_info = &(prof_info->ProfileInfo.Ethernet.net_info);
1501         else {
1502                 NETWORK_LOG(NETWORK_ERROR, "Invalid Profile Type\n");
1503                 __NETWORK_FUNC_EXIT__;
1504                 return NET_ERR_INVALID_PARAM;
1505         }
1506
1507         g_strlcpy(ip_buffer,
1508                         inet_ntoa(profile_net_info->IpAddr.Data.Ipv4),
1509                         NETPM_IPV4_STR_LEN_MAX + 1);
1510
1511         g_strlcpy(netmask_buffer,
1512                         inet_ntoa(profile_net_info->SubnetMask.Data.Ipv4),
1513                         NETPM_IPV4_STR_LEN_MAX + 1);
1514
1515         g_strlcpy(gateway_buffer,
1516                         inet_ntoa(profile_net_info->GatewayAddr.Data.Ipv4),
1517                         NETPM_IPV4_STR_LEN_MAX + 1);
1518
1519         SECURE_NETWORK_LOG(NETWORK_LOW, "ip: %s, netmask: %s, gateway: %s",
1520                         ipaddress, netmask, gateway);
1521
1522         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1523
1524         if (profile_net_info->IpConfigType == NET_IP_CONFIG_TYPE_DYNAMIC ||
1525             profile_net_info->IpConfigType == NET_IP_CONFIG_TYPE_AUTO_IP) {
1526
1527                 g_variant_builder_add(builder, "{sv}", prop_method, g_variant_new_string(dhcp_method));
1528
1529         } else if (profile_net_info->IpConfigType == NET_IP_CONFIG_TYPE_OFF) {
1530
1531                 g_variant_builder_add(builder, "{sv}", prop_method, g_variant_new_string(off_method));
1532
1533         } else if (profile_net_info->IpConfigType == NET_IP_CONFIG_TYPE_STATIC) {
1534
1535                 g_variant_builder_add(builder, "{sv}", prop_method, g_variant_new_string(manual_method));
1536
1537                 if (strlen(ipaddress) >= NETPM_IPV4_STR_LEN_MIN)
1538                         g_variant_builder_add(builder, "{sv}", prop_address, g_variant_new_string(ipaddress));
1539
1540                 if (strlen(netmask) >= NETPM_IPV4_STR_LEN_MIN)
1541                         g_variant_builder_add(builder, "{sv}", prop_netmask, g_variant_new_string(netmask));
1542
1543                 if (strlen(gateway) >= NETPM_IPV4_STR_LEN_MIN)
1544                         g_variant_builder_add(builder, "{sv}", prop_gateway, g_variant_new_string(gateway));
1545
1546         } else {
1547                 NETWORK_LOG(NETWORK_ERROR, "Invalid argument");
1548                 __NETWORK_FUNC_EXIT__;
1549                 return NET_ERR_INVALID_PARAM;
1550         }
1551
1552         params = g_variant_new("(sv)",
1553                         prop_ipv4_configuration, g_variant_builder_end(builder));
1554         g_variant_builder_unref(builder);
1555
1556         message = _net_invoke_dbus_method(CONNMAN_SERVICE, profile_name,
1557                         CONNMAN_SERVICE_INTERFACE, "SetProperty", params,
1558                         &Error);
1559         if (message == NULL) {
1560                 NETWORK_LOG(NETWORK_ERROR, "Failed to set IPv4 Property");
1561                 __NETWORK_FUNC_EXIT__;
1562                 return Error;
1563         }
1564
1565         g_variant_unref(message);
1566         NETWORK_LOG(NETWORK_HIGH, "Successfully configured IPv4.Configuration\n");
1567
1568         __NETWORK_FUNC_EXIT__;
1569         return Error;
1570 }
1571
1572 int _net_dbus_set_profile_ipv6(net_profile_info_t* prof_info, char* profile_name)
1573 {
1574         __NETWORK_FUNC_ENTER__;
1575
1576         const char *manual_method = "manual";
1577         const char *auto_method = "auto";
1578         const char *off_method = "off";
1579
1580         const char *prop_ipv6_configuration = "IPv6.Configuration";
1581         const char *prop_method = "Method";
1582         const char *prop_address = "Address";
1583         const char *prop_gateway = "Gateway";
1584         const char *prop_prefixlen = "PrefixLength";
1585
1586         char ipaddr6[INET6_ADDRSTRLEN];
1587         char gwaddr6[INET6_ADDRSTRLEN];
1588         char prefixlen[INET6_ADDRSTRLEN];
1589
1590         char *ip6_ptr = ipaddr6;
1591         char *gw6_ptr = gwaddr6;
1592         char *prlen_ptr = prefixlen;
1593
1594         net_err_t Error = NET_ERR_NONE;
1595         GVariant *params = NULL;
1596         GVariantBuilder *builder;
1597         GVariant *message = NULL;
1598         net_dev_info_t *profile_net_info  = NULL;
1599
1600         if ((prof_info == NULL) || (profile_name == NULL) || (strlen(profile_name) == 0)) {
1601                 NETWORK_LOG(NETWORK_ERROR,  "Error!!! Invalid argument\n");
1602                 __NETWORK_FUNC_EXIT__;
1603                 return NET_ERR_INVALID_PARAM;
1604         }
1605
1606         if (prof_info->profile_type == NET_DEVICE_WIFI)
1607                 profile_net_info = &(prof_info->ProfileInfo.Wlan.net_info);
1608         else if (prof_info->profile_type == NET_DEVICE_ETHERNET)
1609                 profile_net_info = &(prof_info->ProfileInfo.Ethernet.net_info);
1610         else {
1611                 NETWORK_LOG(NETWORK_ERROR, "Invalid Profile Type\n");
1612                 __NETWORK_FUNC_EXIT__;
1613                 return NET_ERR_INVALID_PARAM;
1614         }
1615
1616         inet_ntop(AF_INET6, &profile_net_info->IpAddr6.Data.Ipv6, ipaddr6,
1617                         INET6_ADDRSTRLEN);
1618         inet_ntop(AF_INET6, &profile_net_info->GatewayAddr6.Data.Ipv6, gwaddr6,
1619                         INET6_ADDRSTRLEN);
1620         g_snprintf(prefixlen, INET6_ADDRSTRLEN, "%d",
1621                         profile_net_info->PrefixLen6);
1622
1623         NETWORK_LOG(NETWORK_HIGH, "ipaddress : %s, prefix_len : %s, gateway :"
1624                         " %s\n", ip6_ptr, prlen_ptr, gw6_ptr);
1625
1626         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1627
1628         if (profile_net_info->IpConfigType6 == NET_IP_CONFIG_TYPE_DYNAMIC ||
1629                 profile_net_info->IpConfigType6 == NET_IP_CONFIG_TYPE_AUTO_IP) {
1630
1631                 g_variant_builder_add(builder, "{sv}", prop_method,
1632                                 g_variant_new_string(auto_method));
1633
1634         } else if (profile_net_info->IpConfigType6 == NET_IP_CONFIG_TYPE_OFF) {
1635
1636                 g_variant_builder_add(builder, "{sv}", prop_method,
1637                                 g_variant_new_string(off_method));
1638
1639                 NETWORK_LOG(NETWORK_HIGH, "DBus Message 2/2: %s %s\n",
1640                                 prop_method, off_method);
1641         } else if (profile_net_info->IpConfigType6 == NET_IP_CONFIG_TYPE_STATIC) {
1642
1643                 g_variant_builder_add(builder, "{sv}", prop_method,
1644                                 g_variant_new_string(manual_method));
1645
1646                 if (strlen(ipaddr6) >= NETPM_IPV6_STR_LEN_MIN) {
1647                         g_variant_builder_add(builder, "{sv}", prop_address,
1648                                         g_variant_new_string(ip6_ptr));
1649                 }
1650
1651                 if (profile_net_info->PrefixLen6 <= NETPM_IPV6_MAX_PREFIX_LEN) {
1652                         g_variant_builder_add(builder, "{sv}", prop_prefixlen,
1653                                         g_variant_new_string(prlen_ptr));
1654                 }
1655
1656                 if (strlen(gwaddr6) >= NETPM_IPV6_STR_LEN_MIN) {
1657                         g_variant_builder_add(builder, "{sv}", prop_gateway,
1658                                         g_variant_new_string(gw6_ptr));
1659                 }
1660                 NETWORK_LOG(NETWORK_HIGH, "DBus Message 2/2: %s %s %s %s %s %s"
1661                                 " %s %s\n", prop_method, manual_method,
1662                                 prop_address, ipaddr6, prop_prefixlen,
1663                                 prefixlen, prop_gateway, gwaddr6);
1664         } else {
1665                 NETWORK_LOG(NETWORK_ERROR, "Invalid argument\n");
1666                 __NETWORK_FUNC_EXIT__;
1667                 return NET_ERR_INVALID_PARAM;
1668         }
1669
1670         params = g_variant_new("(sv)", prop_ipv6_configuration,
1671                         g_variant_builder_end(builder));
1672         g_variant_builder_unref(builder);
1673
1674         message = _net_invoke_dbus_method(CONNMAN_SERVICE, profile_name,
1675                         CONNMAN_SERVICE_INTERFACE, "SetProperty", params,
1676                         &Error);
1677         if (message == NULL) {
1678                 NETWORK_LOG(NETWORK_ERROR, "Failed to set IPv6 Property");
1679                 __NETWORK_FUNC_EXIT__;
1680                 return Error;
1681         }
1682
1683         g_variant_unref(message);
1684         NETWORK_LOG(NETWORK_HIGH, "Successfully configured IPv6.Configuration\n");
1685
1686         __NETWORK_FUNC_EXIT__;
1687         return Error;
1688 }
1689
1690 int _net_dbus_set_profile_dns(net_profile_info_t* prof_info, char* profile_name)
1691 {
1692         __NETWORK_FUNC_ENTER__;
1693
1694         const char *prop_nameserver_configuration = "Nameservers.Configuration";
1695         char dns_buffer[NET_DNS_ADDR_MAX][NETPM_IPV4_STR_LEN_MAX+1];
1696         char *dns_address[NET_DNS_ADDR_MAX];
1697         net_err_t Error = NET_ERR_NONE;
1698         GVariant *params = NULL;
1699         GVariantBuilder *builder;
1700         int i = 0;
1701         net_dev_info_t *profile_net_info  = NULL;
1702         GVariant *message = NULL;
1703
1704         if ((prof_info == NULL) || (profile_name == NULL) || (strlen(profile_name) == 0)) {
1705                 NETWORK_LOG(NETWORK_ERROR, "Invalid parameter");
1706                 __NETWORK_FUNC_EXIT__;
1707                 return NET_ERR_INVALID_PARAM;
1708         }
1709
1710         if (prof_info->profile_type == NET_DEVICE_WIFI)
1711                 profile_net_info = &(prof_info->ProfileInfo.Wlan.net_info);
1712         else if (prof_info->profile_type == NET_DEVICE_ETHERNET)
1713                 profile_net_info = &(prof_info->ProfileInfo.Ethernet.net_info);
1714         else {
1715                 NETWORK_LOG(NETWORK_ERROR, "Invalid Profile Type\n");
1716                 __NETWORK_FUNC_EXIT__;
1717                 return NET_ERR_INVALID_PARAM;
1718         }
1719         if (profile_net_info->DnsCount > NET_DNS_ADDR_MAX) {
1720                         NETWORK_LOG(NETWORK_ERROR, "Invalid parameter\n");
1721                         __NETWORK_FUNC_EXIT__;
1722                         return NET_ERR_INVALID_PARAM;
1723         }
1724
1725         for (i = 0; i < profile_net_info->DnsCount; i++) {
1726                 dns_buffer[i][0] = '\0';
1727                 dns_address[i] = NULL;
1728
1729                 if (profile_net_info->DnsAddr[i].Data.Ipv4.s_addr != 0)
1730                         g_strlcpy(dns_buffer[i],
1731                                         inet_ntoa(profile_net_info->DnsAddr[i].Data.Ipv4),
1732                                         NETPM_IPV4_STR_LEN_MAX + 1);
1733
1734                 dns_address[i] = dns_buffer[i];
1735         }
1736
1737         if (profile_net_info->IpConfigType == NET_IP_CONFIG_TYPE_STATIC) {
1738
1739                 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1740                 for (i = 0; i < profile_net_info->DnsCount; i++)
1741                         g_variant_builder_add(builder, "s", dns_address[i]);
1742
1743                 params = g_variant_new("(sv)", prop_nameserver_configuration, g_variant_builder_end(builder));
1744                 g_variant_builder_unref(builder);
1745
1746                 message = _net_invoke_dbus_method(CONNMAN_SERVICE, profile_name,
1747                                 CONNMAN_SERVICE_INTERFACE, "SetProperty", params,
1748                                 &Error);
1749                 if (message == NULL) {
1750                         NETWORK_LOG(NETWORK_ERROR, "Failed to set "
1751                                         "Nameservers.Configuration");
1752                         __NETWORK_FUNC_EXIT__;
1753                         return Error;
1754                 }
1755                 NETWORK_LOG(NETWORK_HIGH, "Successfully configured Nameservers.Configuration\n");
1756                 g_variant_unref(message);
1757         }
1758
1759         __NETWORK_FUNC_EXIT__;
1760         return Error;
1761 }
1762
1763 int _net_dbus_set_proxy(net_profile_info_t* prof_info, char* profile_name)
1764 {
1765         __NETWORK_FUNC_ENTER__;
1766
1767         net_err_t Error = NET_ERR_NONE;
1768
1769         const char *direct_method = "direct";
1770         const char *auto_method = "auto";
1771         const char *manual_method = "manual";
1772
1773         const char *prop_proxy_configuration = "Proxy.Configuration";
1774         const char *prop_method = "Method";
1775         const char *prop_url = "URL";
1776         const char *prop_servers = "Servers";
1777
1778         char proxy_buffer[NET_PROXY_LEN_MAX+1] = "";
1779         char *proxy_address = proxy_buffer;
1780
1781         GVariant *params = NULL;
1782         GVariantBuilder *builder;
1783         GVariantBuilder *builder_sub;
1784         net_dev_info_t *profile_net_info  = NULL;
1785
1786         GVariant *message = NULL;
1787
1788         if ((prof_info == NULL) || (profile_name == NULL) || (strlen(profile_name) == 0)) {
1789                 NETWORK_LOG(NETWORK_ERROR, "Invalid argument");
1790                 __NETWORK_FUNC_EXIT__;
1791                 return NET_ERR_INVALID_PARAM;
1792         }
1793
1794         if (prof_info->profile_type == NET_DEVICE_WIFI)
1795                 profile_net_info = &(prof_info->ProfileInfo.Wlan.net_info);
1796         else if (prof_info->profile_type == NET_DEVICE_ETHERNET)
1797                 profile_net_info = &(prof_info->ProfileInfo.Ethernet.net_info);
1798         else {
1799                 NETWORK_LOG(NETWORK_ERROR, "Invalid Profile Type\n");
1800                 __NETWORK_FUNC_EXIT__;
1801                 return NET_ERR_INVALID_PARAM;
1802         }
1803
1804         g_strlcpy(proxy_buffer,
1805                         profile_net_info->ProxyAddr, NET_PROXY_LEN_MAX+1);
1806
1807         SECURE_NETWORK_LOG(NETWORK_LOW, "method: %d, proxy address: %s, Profile Name %s",
1808                         profile_net_info->ProxyMethod, proxy_address, profile_net_info->ProfileName);
1809
1810         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1811
1812         switch (profile_net_info->ProxyMethod) {
1813         case NET_PROXY_TYPE_AUTO:
1814                 g_variant_builder_add(builder, "{sv}", prop_method, g_variant_new_string(auto_method));
1815                 break;
1816         case NET_PROXY_TYPE_MANUAL:
1817                 g_variant_builder_add(builder, "{sv}", prop_method, g_variant_new_string(manual_method));
1818                 break;
1819         default:
1820                 g_variant_builder_add(builder, "{sv}", prop_method, g_variant_new_string(direct_method));
1821                 break;
1822         }
1823
1824         if (profile_net_info->ProxyMethod == NET_PROXY_TYPE_AUTO &&
1825                         proxy_address[0] != '\0') {
1826                 g_variant_builder_add(builder, "{sv}", prop_url, g_variant_new_string(proxy_address));
1827         }
1828
1829         if (profile_net_info->ProxyMethod == NET_PROXY_TYPE_MANUAL &&
1830                         proxy_address[0] != '\0') {
1831                 builder_sub = g_variant_builder_new(G_VARIANT_TYPE("as"));
1832                 g_variant_builder_add(builder_sub, "s", proxy_address);
1833                 g_variant_builder_add(builder, "{sv}", prop_servers, g_variant_builder_end(builder_sub));
1834                 g_variant_builder_unref(builder_sub);
1835         }
1836
1837         params = g_variant_new("(sv)", prop_proxy_configuration, g_variant_builder_end(builder));
1838         g_variant_builder_unref(builder);
1839
1840         message = _net_invoke_dbus_method(CONNMAN_SERVICE, profile_name,
1841                         CONNMAN_SERVICE_INTERFACE, "SetProperty", params,
1842                         &Error);
1843         if (message == NULL) {
1844                 NETWORK_LOG(NETWORK_ERROR, "Failed to set Proxy Configuration");
1845                 __NETWORK_FUNC_EXIT__;
1846                 return Error;
1847         }
1848         NETWORK_LOG(NETWORK_HIGH, "Successfully configured Proxy.Configuration\n");
1849         g_variant_unref(message);
1850
1851         __NETWORK_FUNC_EXIT__;
1852         return Error;
1853 }
1854
1855
1856 int _net_dbus_add_pdp_profile(net_profile_info_t *prof_info)
1857 {
1858         __NETWORK_FUNC_ENTER__;
1859
1860         net_err_t Error = NET_ERR_NONE;
1861         const char *service_type = "svc_ctg_id";
1862         const char *home_url = "home_url";
1863         const char *proxy_addr = "proxy_addr";
1864         const char *auth_pwd = "auth_pwd";
1865         const char *auth_type = "auth_type";
1866         const char *auth_id = "auth_id";
1867         const char *apn = "apn";
1868         const char *keyword = "profile_name";
1869         const char *pdp_protocol = "pdp_protocol";
1870         const char *roam_pdp_protocol = "roam_pdp_protocol";
1871
1872         char buff_pdn_type[10] = "";
1873         char buff_roam_pdn_type[10] = "";
1874         char buff_svc_type[10] = "";
1875         char buff_auth_type[10] = "";
1876         char *temp_ptr = NULL;
1877
1878         GVariant *params = NULL;
1879         GVariantBuilder *builder;
1880         GVariant *message = NULL;
1881
1882         if (prof_info == NULL) {
1883                 NETWORK_LOG(NETWORK_ERROR, "Invalid argument");
1884                 __NETWORK_FUNC_EXIT__;
1885                 return NET_ERR_INVALID_PARAM;
1886         }
1887
1888 #if defined TIZEN_DUALSIM_ENABLE
1889         if (prof_info->ProfileInfo.Pdp.PSModemPath[0] != '/' ||
1890                 (g_str_has_suffix(prof_info->ProfileInfo.Pdp.PSModemPath, "0") != TRUE &&
1891                 g_str_has_suffix(prof_info->ProfileInfo.Pdp.PSModemPath, "1") != TRUE)) {
1892                 NETWORK_LOG(NETWORK_ERROR, "Invalid modem path: %s",
1893                                                 prof_info->ProfileInfo.Pdp.PSModemPath);
1894
1895                 __NETWORK_FUNC_EXIT__;
1896                 return NET_ERR_INVALID_PARAM;
1897         }
1898 #endif
1899
1900         builder = g_variant_builder_new(G_VARIANT_TYPE("a{ss}"));
1901
1902         g_snprintf(buff_svc_type, 10, "%d", prof_info->ProfileInfo.Pdp.ServiceType);
1903         temp_ptr = buff_svc_type;
1904
1905         g_variant_builder_add(builder, "{ss}", service_type, temp_ptr);
1906
1907         if (strlen(prof_info->ProfileInfo.Pdp.HomeURL) > 0) {
1908                 temp_ptr = prof_info->ProfileInfo.Pdp.HomeURL;
1909
1910                 g_variant_builder_add(builder, "{ss}", home_url, temp_ptr);
1911         }
1912
1913         if (strlen(prof_info->ProfileInfo.Pdp.net_info.ProxyAddr) > 0) {
1914                 temp_ptr = prof_info->ProfileInfo.Pdp.net_info.ProxyAddr;
1915
1916                 g_variant_builder_add(builder, "{ss}", proxy_addr, temp_ptr);
1917         }
1918
1919         if (strlen(prof_info->ProfileInfo.Pdp.AuthInfo.Password) > 0) {
1920                 temp_ptr = prof_info->ProfileInfo.Pdp.AuthInfo.Password;
1921
1922                 g_variant_builder_add(builder, "{ss}", auth_pwd, temp_ptr);
1923         }
1924
1925         if (strlen(prof_info->ProfileInfo.Pdp.AuthInfo.UserName) > 0) {
1926                 temp_ptr = prof_info->ProfileInfo.Pdp.AuthInfo.UserName;
1927
1928                 g_variant_builder_add(builder, "{ss}", auth_id, temp_ptr);
1929         }
1930
1931         if (prof_info->ProfileInfo.Pdp.AuthInfo.AuthType >= NET_PDP_AUTH_NONE &&
1932                         prof_info->ProfileInfo.Pdp.AuthInfo.AuthType <= NET_PDP_AUTH_CHAP) {
1933                 g_snprintf(buff_auth_type, 10, "%d",
1934                                 prof_info->ProfileInfo.Pdp.AuthInfo.AuthType);
1935
1936                 temp_ptr = buff_auth_type;
1937
1938                 g_variant_builder_add(builder, "{ss}", auth_type, temp_ptr);
1939         }
1940
1941         if (strlen(prof_info->ProfileInfo.Pdp.Apn) > 0) {
1942                 temp_ptr = prof_info->ProfileInfo.Pdp.Apn;
1943
1944                 g_variant_builder_add(builder, "{ss}", apn, temp_ptr);
1945         }
1946
1947         if (prof_info->ProfileInfo.Pdp.PdnType == NET_PDN_TYPE_IPV4 ||
1948                 prof_info->ProfileInfo.Pdp.PdnType == NET_PDN_TYPE_IPV6 ||
1949             prof_info->ProfileInfo.Pdp.PdnType == NET_PDN_TYPE_IPV4_IPV6) {
1950                 g_snprintf(buff_pdn_type, 10, "%d",
1951                                                 prof_info->ProfileInfo.Pdp.PdnType);
1952                 temp_ptr = buff_pdn_type;
1953
1954                 g_variant_builder_add(builder, "{ss}", pdp_protocol, temp_ptr);
1955         }
1956
1957         if (prof_info->ProfileInfo.Pdp.RoamPdnType == NET_PDN_TYPE_IPV4 ||
1958                 prof_info->ProfileInfo.Pdp.RoamPdnType == NET_PDN_TYPE_IPV6 ||
1959             prof_info->ProfileInfo.Pdp.RoamPdnType == NET_PDN_TYPE_IPV4_IPV6) {
1960                 g_snprintf(buff_roam_pdn_type, 10, "%d",
1961                                                 prof_info->ProfileInfo.Pdp.RoamPdnType);
1962                 temp_ptr = buff_roam_pdn_type;
1963
1964                 g_variant_builder_add(builder, "{ss}", roam_pdp_protocol, temp_ptr);
1965         }
1966
1967         if (strlen(prof_info->ProfileInfo.Pdp.Keyword) > 0) {
1968                 temp_ptr = prof_info->ProfileInfo.Pdp.Keyword;
1969
1970                 g_variant_builder_add(builder, "{ss}", keyword, temp_ptr);
1971         }
1972
1973         params = g_variant_new("(@a{ss})", g_variant_builder_end(builder));
1974         g_variant_builder_unref(builder);
1975
1976         message = _net_invoke_dbus_method(TELEPHONY_SERVICE,
1977                         prof_info->ProfileInfo.Pdp.PSModemPath,
1978                         TELEPHONY_MODEM_INTERFACE, "AddProfile", params,
1979                         &Error);
1980
1981         if (message == NULL) {
1982                 NETWORK_LOG(NETWORK_ERROR, "Failed to Add Profile");
1983                 __NETWORK_FUNC_EXIT__;
1984                 return Error;
1985         }
1986
1987         /** Check Reply */
1988         int add_result = 0;
1989
1990         g_variant_get(message, "(b)", &add_result);
1991         if (add_result)
1992                 Error = NET_ERR_NONE;
1993         else
1994                 Error = NET_ERR_UNKNOWN;
1995
1996         g_variant_unref(message);
1997
1998         __NETWORK_FUNC_EXIT__;
1999         return Error;
2000 }
2001
2002 int _net_dbus_reset_pdp_profile(int type, const char * modem_path)
2003 {
2004         __NETWORK_FUNC_ENTER__;
2005
2006         net_err_t Error = NET_ERR_NONE;
2007
2008         GVariant *params = NULL;
2009
2010         params = g_variant_new("(i)", type);
2011
2012         if (modem_path) {
2013         Error = _net_invoke_dbus_method_nonblock(TELEPHONY_SERVICE,
2014                                 modem_path,
2015                                 TELEPHONY_MODEM_INTERFACE,
2016                                 "ResetProfile",
2017                                 params,
2018                                 DBUS_REPLY_TIMEOUT,
2019                                 __net_reset_cellular_reply);
2020         } else {
2021                 Error = _net_invoke_dbus_method_nonblock(TELEPHONY_SERVICE,
2022                                 TELEPHONY_MASTER_PATH,
2023                                 TELEPHONY_MODEM_INTERFACE,
2024                                 "ResetProfile",
2025                                 params,
2026                                 DBUS_REPLY_TIMEOUT,
2027                                 __net_reset_cellular_reply);
2028         }
2029
2030         __NETWORK_FUNC_EXIT__;
2031         return Error;
2032
2033 }
2034
2035 int _net_dbus_modify_pdp_profile(net_profile_info_t *prof_info, const char *profile_name)
2036 {
2037         __NETWORK_FUNC_ENTER__;
2038
2039         net_err_t Error = NET_ERR_NONE;
2040
2041         const char *service_type = "svc_ctg_id";
2042         const char *home_url = "home_url";
2043         const char *proxy_addr = "proxy_addr";
2044         const char *auth_pwd = "auth_pwd";
2045         const char *auth_type = "auth_type";
2046         const char *auth_id = "auth_id";
2047         const char *apn = "apn";
2048         const char *keyword = "keyword";
2049         const char *default_conn = "default_internet_conn";
2050         const char *hidden = "hidden";
2051         const char *editable = "editable";
2052         const char *pdp_protocol = "pdp_protocol";
2053         const char *roam_pdp_protocol = "roam_pdp_protocol";
2054
2055         char buff_pdn_type[10] = "";
2056         char buff_roam_pdn_type[10] = "";
2057         char buff_svc_type[10] = "";
2058         char buff_auth_type[10] = "";
2059         char *temp_ptr = NULL;
2060
2061         GVariant *params = NULL;
2062         GVariantBuilder *builder;
2063         GVariant *message = NULL;
2064
2065         if ((prof_info == NULL) || (profile_name == NULL)) {
2066                 NETWORK_LOG(NETWORK_ERROR, "Invalid argument");
2067                 __NETWORK_FUNC_EXIT__;
2068                 return NET_ERR_INVALID_PARAM;
2069         }
2070
2071         builder = g_variant_builder_new(G_VARIANT_TYPE("a{ss}"));
2072
2073
2074         g_snprintf(buff_svc_type, 10, "%d", prof_info->ProfileInfo.Pdp.ServiceType);
2075         temp_ptr = buff_svc_type;
2076
2077         g_variant_builder_add(builder, "{ss}", service_type, temp_ptr);
2078
2079         if (strlen(prof_info->ProfileInfo.Pdp.HomeURL) > 0) {
2080                 temp_ptr = prof_info->ProfileInfo.Pdp.HomeURL;
2081
2082                 g_variant_builder_add(builder, "{ss}", home_url, temp_ptr);
2083         }
2084
2085         if (strlen(prof_info->ProfileInfo.Pdp.net_info.ProxyAddr) > 0) {
2086                 temp_ptr = prof_info->ProfileInfo.Pdp.net_info.ProxyAddr;
2087
2088                 g_variant_builder_add(builder, "{ss}", proxy_addr, temp_ptr);
2089         } else
2090                 g_variant_builder_add(builder, "{ss}", proxy_addr, "");
2091
2092         if (strlen(prof_info->ProfileInfo.Pdp.AuthInfo.Password) > 0) {
2093                 temp_ptr = prof_info->ProfileInfo.Pdp.AuthInfo.Password;
2094
2095                 g_variant_builder_add(builder, "{ss}", auth_pwd, temp_ptr);
2096         }
2097
2098         if (strlen(prof_info->ProfileInfo.Pdp.AuthInfo.UserName) > 0) {
2099                 temp_ptr = prof_info->ProfileInfo.Pdp.AuthInfo.UserName;
2100
2101                 g_variant_builder_add(builder, "{ss}", auth_id, temp_ptr);
2102         }
2103
2104         if (prof_info->ProfileInfo.Pdp.AuthInfo.AuthType >= NET_PDP_AUTH_NONE &&
2105             prof_info->ProfileInfo.Pdp.AuthInfo.AuthType <= NET_PDP_AUTH_CHAP) {
2106                 g_snprintf(buff_auth_type, 10, "%d",
2107                                 prof_info->ProfileInfo.Pdp.AuthInfo.AuthType);
2108                 temp_ptr = buff_auth_type;
2109
2110                 g_variant_builder_add(builder, "{ss}", auth_type, temp_ptr);
2111         }
2112
2113         if (strlen(prof_info->ProfileInfo.Pdp.Apn) > 0) {
2114                 temp_ptr = prof_info->ProfileInfo.Pdp.Apn;
2115
2116                 g_variant_builder_add(builder, "{ss}", apn, temp_ptr);
2117         }
2118
2119         if (prof_info->ProfileInfo.Pdp.PdnType == NET_PDN_TYPE_IPV4 ||
2120                 prof_info->ProfileInfo.Pdp.PdnType == NET_PDN_TYPE_IPV6 ||
2121             prof_info->ProfileInfo.Pdp.PdnType == NET_PDN_TYPE_IPV4_IPV6) {
2122                 g_snprintf(buff_pdn_type, 10, "%d",
2123                                                 prof_info->ProfileInfo.Pdp.PdnType);
2124                 temp_ptr = buff_pdn_type;
2125
2126                 g_variant_builder_add(builder, "{ss}", pdp_protocol, temp_ptr);
2127         }
2128
2129         if (prof_info->ProfileInfo.Pdp.RoamPdnType == NET_PDN_TYPE_IPV4 ||
2130                 prof_info->ProfileInfo.Pdp.RoamPdnType == NET_PDN_TYPE_IPV6 ||
2131             prof_info->ProfileInfo.Pdp.RoamPdnType == NET_PDN_TYPE_IPV4_IPV6) {
2132                 g_snprintf(buff_roam_pdn_type, 10, "%d",
2133                                                 prof_info->ProfileInfo.Pdp.RoamPdnType);
2134                 temp_ptr = buff_roam_pdn_type;
2135
2136                 g_variant_builder_add(builder, "{ss}", roam_pdp_protocol, temp_ptr);
2137         }
2138
2139         if (strlen(prof_info->ProfileInfo.Pdp.Keyword) > 0) {
2140                 temp_ptr = prof_info->ProfileInfo.Pdp.Keyword;
2141
2142                 g_variant_builder_add(builder, "{ss}", keyword, temp_ptr);
2143         }
2144
2145         if (prof_info->ProfileInfo.Pdp.Hidden)
2146                 temp_ptr = "TRUE";
2147         else
2148                 temp_ptr = "FALSE";
2149
2150         g_variant_builder_add(builder, "{ss}", hidden, temp_ptr);
2151
2152         if (prof_info->ProfileInfo.Pdp.Editable)
2153                 temp_ptr = "TRUE";
2154         else
2155                 temp_ptr = "FALSE";
2156
2157         g_variant_builder_add(builder, "{ss}", editable, temp_ptr);
2158
2159         if (prof_info->ProfileInfo.Pdp.DefaultConn)
2160                 temp_ptr = "TRUE";
2161         else
2162                 temp_ptr = "FALSE";
2163
2164         g_variant_builder_add(builder, "{ss}", default_conn, temp_ptr);
2165
2166         params = g_variant_new("(@a{ss})", g_variant_builder_end(builder));
2167         g_variant_builder_unref(builder);
2168
2169         message = _net_invoke_dbus_method(TELEPHONY_SERVICE, profile_name,
2170                         TELEPHONY_PROFILE_INTERFACE, "ModifyProfile", params,
2171                         &Error);
2172         if (message == NULL) {
2173                 NETWORK_LOG(NETWORK_ERROR, "Failed to Modify Profile");
2174                 __NETWORK_FUNC_EXIT__;
2175                 return Error;
2176         }
2177
2178         /** Check Reply */
2179         int add_result = 0;
2180         g_variant_get(message, "(b)", &add_result);
2181         NETWORK_LOG(NETWORK_HIGH, "Profile modify result: %d", add_result);
2182
2183         if (add_result)
2184                 Error = NET_ERR_NONE;
2185         else
2186                 Error = NET_ERR_UNKNOWN;
2187
2188         g_variant_unref(message);
2189
2190         __NETWORK_FUNC_EXIT__;
2191         return Error;
2192 }
2193
2194 int _net_dbus_load_wifi_driver(gboolean wifi_picker_test)
2195 {
2196         __NETWORK_FUNC_ENTER__;
2197
2198         net_err_t Error = NET_ERR_NONE;
2199         GVariant *params;
2200
2201         params = g_variant_new("(b)", wifi_picker_test);
2202
2203         /* use DBus signal than reply pending because of performance reason */
2204         Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE,
2205                         NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE,
2206                         "LoadDriver", params, DBUS_REPLY_TIMEOUT,
2207                         __net_wifi_power_reply);
2208
2209         __NETWORK_FUNC_EXIT__;
2210         return Error;
2211 }
2212
2213 int _net_dbus_remove_wifi_driver(void)
2214 {
2215         __NETWORK_FUNC_ENTER__;
2216
2217         net_err_t Error = NET_ERR_NONE;
2218
2219         /* use DBus signal than reply pending because of performance reason */
2220         Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE,
2221                         NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE,
2222                         "RemoveDriver", NULL, DBUS_REPLY_TIMEOUT,
2223                         __net_wifi_power_reply);
2224
2225         __NETWORK_FUNC_EXIT__;
2226         return Error;
2227 }
2228
2229 int _net_dbus_specific_scan_request(const char *ssid)
2230 {
2231         __NETWORK_FUNC_ENTER__;
2232
2233         GVariant *params = NULL;
2234         net_err_t Error = NET_ERR_NONE;
2235
2236         params = g_variant_new("(s)", ssid);
2237
2238         Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE,
2239                         NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE,
2240                         "RequestSpecificScan", params, 6 * DBUS_REPLY_TIMEOUT,
2241                         __net_specific_scan_wifi_reply);
2242
2243         __NETWORK_FUNC_EXIT__;
2244         return Error;
2245 }
2246
2247 int _net_dbus_wps_scan_request(void)
2248 {
2249         __NETWORK_FUNC_ENTER__;
2250         net_err_t Error = NET_ERR_NONE;
2251
2252         Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE,
2253                         NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE,
2254                         "RequestWpsScan", NULL, 6 * DBUS_REPLY_TIMEOUT,
2255                         __net_wps_scan_wifi_reply);
2256
2257         __NETWORK_FUNC_EXIT__;
2258         return Error;
2259 }
2260
2261 int _net_dbus_get_passpoint(int *enabled)
2262 {
2263         __NETWORK_FUNC_ENTER__;
2264
2265         GVariant *message = NULL;
2266         net_err_t Error = NET_ERR_NONE;
2267
2268         message = _net_invoke_dbus_method(NETCONFIG_SERVICE,
2269                         NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE,
2270                         "GetPasspoint", NULL, &Error);
2271         if (message == NULL) {
2272                 NETWORK_LOG(NETWORK_ERROR, "Failed to Get Passpoint");
2273                 __NETWORK_FUNC_EXIT__;
2274                 return Error;
2275         }
2276
2277         /** Check Reply */
2278         int result = 0;
2279         g_variant_get(message, "(i)", &result);
2280         *enabled = result;
2281
2282         NETWORK_LOG(NETWORK_HIGH, "Get passpoint result: %d", result);
2283
2284         g_variant_unref(message);
2285
2286         __NETWORK_FUNC_EXIT__;
2287         return Error;
2288 }
2289
2290 int _net_dbus_set_passpoint(int enable)
2291 {
2292         __NETWORK_FUNC_ENTER__;
2293
2294         GVariant *params;
2295         net_err_t Error = NET_ERR_NONE;
2296
2297         params = g_variant_new("(i)", enable);
2298
2299         Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE,
2300                         NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE,
2301                         "SetPasspoint", params, 6 * DBUS_REPLY_TIMEOUT,
2302                         __net_set_passpoint_reply);
2303
2304         __NETWORK_FUNC_EXIT__;
2305         return Error;
2306 }
2307
2308 #if defined TIZEN_TV
2309 static void __net_wps_cancel_reply(GObject *source_object,
2310                 GAsyncResult *res, gpointer user_data)
2311 {
2312         __NETWORK_FUNC_ENTER__;
2313
2314         NETWORK_LOG(NETWORK_LOW, "__net_wps_cancel_wifi_reply() called\n");
2315
2316         GDBusConnection *conn = NULL;
2317         GVariant *dbus_result = NULL;
2318         GError *error = NULL;
2319
2320         conn = G_DBUS_CONNECTION(source_object);
2321         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
2322
2323         if (error != NULL) {
2324                 NETWORK_LOG(NETWORK_ERROR, "error msg - [%s]\n", error->message);
2325                 g_error_free(error);
2326         }
2327
2328         if (dbus_result)
2329                 g_variant_unref(dbus_result);
2330
2331         _net_dbus_pending_call_unref();
2332
2333         __NETWORK_FUNC_EXIT__;
2334 }
2335
2336
2337 int _net_dbus_cancel_wps(void)
2338 {
2339         __NETWORK_FUNC_ENTER__;
2340
2341         net_err_t Error = NET_ERR_NONE;
2342
2343         Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE,
2344                         NETCONFIG_WIFI_PATH, NETCONFIG_TV_PROFILE_INTERFACE,
2345                         "RequestWpsCancel", NULL, DBUS_REPLY_TIMEOUT,
2346                         __net_wps_cancel_reply);
2347
2348         __NETWORK_FUNC_EXIT__;
2349         return Error;
2350
2351 }
2352
2353 static int __net_dbus_set_agent_field(const char *key, const char *value)
2354 {
2355         __NETWORK_FUNC_ENTER__;
2356
2357         GVariant *params = NULL;
2358         GVariantBuilder *builder;
2359         net_err_t Error = NET_ERR_NONE;
2360         GVariant *message = NULL;
2361
2362         char path[CONNMAN_MAX_BUFLEN] = NETCONFIG_WIFI_PATH;
2363
2364         builder = g_variant_builder_new(G_VARIANT_TYPE("a{ss}"));
2365         g_variant_builder_add(builder, "{ss}", key, value);
2366
2367         params = g_variant_new("(@a{ss})", g_variant_builder_end(builder));
2368         g_variant_builder_unref(builder);
2369
2370         message = _net_invoke_dbus_method(NETCONFIG_SERVICE, path,
2371                         CONNMAN_AGENT_INTERFACE, "SetField", params, &Error);
2372
2373         if (Error != NET_ERR_NONE)
2374                 NETWORK_LOG(NETWORK_ERROR, "_net_invoke_dbus_method failed");
2375
2376         if (message != NULL)
2377                 g_variant_unref(message);
2378         else
2379                  NETWORK_LOG(NETWORK_ERROR, "Failed to set agent field");
2380
2381         __NETWORK_FUNC_EXIT__;
2382         return NET_ERR_NONE;
2383 }
2384
2385 static void __net_wps_connect_wifi_reply(GObject *source_object,
2386                                                 GAsyncResult *res, gpointer user_data)
2387 {
2388         __NETWORK_FUNC_ENTER__;
2389
2390         int callback_flag = FALSE;
2391         GDBusConnection *conn = NULL;
2392         GError *error = NULL;
2393         GVariant *dbus_result = NULL;
2394         net_event_info_t event_data;
2395         net_err_t Error = NET_ERR_NONE;
2396         network_request_table_t *wps_info =
2397                         &request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS];
2398         memset(&event_data, 0, sizeof(event_data));
2399
2400         conn = G_DBUS_CONNECTION(source_object);
2401         dbus_result = g_dbus_connection_call_finish(conn, res, &error);
2402
2403         if (error != NULL) {
2404                 NETWORK_LOG(NETWORK_HIGH, "error msg - [%s]\n", error->message);
2405                 Error = __net_error_string_to_enum(error->message);
2406                 g_error_free(error);
2407         } else
2408                 NETWORK_LOG(NETWORK_LOW, "error msg is NULL\n");
2409
2410         if (dbus_result)
2411                 g_variant_unref(dbus_result);
2412
2413         if (Error == NET_ERR_NONE)
2414                 goto done;
2415
2416         NETWORK_LOG(NETWORK_ERROR, "Connection open failed. Error [%d]\n", Error);
2417
2418         memset(wps_info, 0, sizeof(network_request_table_t));
2419
2420         event_data.Error = Error;
2421         event_data.Event = NET_EVENT_WIFI_WPS_RSP;
2422
2423         NETWORK_LOG(NETWORK_HIGH, "Sending NET_EVENT_WIFI_WPS_RSP Error = %s\n",
2424                         _net_print_error(event_data.Error));
2425
2426         callback_flag = TRUE;
2427
2428 done:
2429         _net_dbus_pending_call_unref();
2430
2431         if (callback_flag)
2432                 _net_client_callback(&event_data);
2433
2434         __NETWORK_FUNC_EXIT__;
2435 }
2436
2437 int _net_dbus_open_connection_without_ssid()
2438 {
2439         __NETWORK_FUNC_ENTER__;
2440
2441         net_err_t Error = NET_ERR_NONE;
2442         GVariant *params = NULL;
2443
2444         params = g_variant_new("(s)", "PBC");
2445         NETWORK_LOG(NETWORK_ERROR, "Invoke wps connection without ssid");
2446
2447         Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE,
2448                         NETCONFIG_WIFI_PATH, NETCONFIG_TV_PROFILE_INTERFACE,
2449                         "RequestWpsConnect", params, DBUS_REPLY_TIMEOUT,
2450                         __net_wps_connect_wifi_reply);
2451
2452         __NETWORK_FUNC_EXIT__;
2453         return Error;
2454 }
2455
2456
2457 int _net_dbus_open_pin_connection_without_ssid(const char *pin)
2458 {
2459         __NETWORK_FUNC_ENTER__;
2460
2461         net_err_t Error = NET_ERR_NONE;
2462
2463         GVariant *params = NULL;
2464         params = g_variant_new("(s)", pin);
2465
2466         Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE,
2467                         NETCONFIG_WIFI_PATH, NETCONFIG_TV_PROFILE_INTERFACE,
2468                         "RequestWpsConnect", params, DBUS_REPLY_TIMEOUT,
2469                         __net_wps_connect_wifi_reply);
2470
2471
2472         __NETWORK_FUNC_EXIT__;
2473         return Error;
2474 }
2475
2476 int _net_dbus_set_agent_wps_pbc(void)
2477 {
2478         __NETWORK_FUNC_ENTER__;
2479
2480         int ret_val;
2481
2482         ret_val = __net_dbus_set_agent_field(NETCONFIG_AGENT_FIELD_WPS_PBC, "enable");
2483         if (NET_ERR_NONE != ret_val) {
2484                 NETWORK_LOG(NETWORK_ERROR, "__net_dbus_set_agent_field failed. Error = %d \n", ret_val);
2485                 return ret_val;
2486         }
2487
2488         NETWORK_LOG(NETWORK_HIGH, "Successfully sent wps pbc\n");
2489
2490         __NETWORK_FUNC_EXIT__;
2491         return NET_ERR_NONE;
2492 }
2493
2494 int _net_dbus_set_agent_wps_pin(const char *wps_pin)
2495 {
2496         __NETWORK_FUNC_ENTER__;
2497
2498         int ret_val;
2499
2500         if (NULL == wps_pin || strlen(wps_pin) <= 0) {
2501                 NETWORK_LOG(NETWORK_ERROR, "Invalid param \n");
2502                 return NET_ERR_INVALID_PARAM;
2503         }
2504
2505         ret_val = __net_dbus_set_agent_field(NETCONFIG_AGENT_FIELD_WPS_PIN, wps_pin);
2506         if (NET_ERR_NONE != ret_val) {
2507                 NETWORK_LOG(NETWORK_ERROR, "__net_dbus_set_agent_field failed. Error = %d \n", ret_val);
2508                 return ret_val;
2509         }
2510
2511         NETWORK_LOG(NETWORK_HIGH, "Successfully sent wps pin\n");
2512
2513         __NETWORK_FUNC_EXIT__;
2514         return NET_ERR_NONE;
2515 }
2516 #endif
2517
2518 int _net_dbus_tdls_disconnect(const char* peer_mac_addr)
2519 {
2520
2521         __NETWORK_FUNC_ENTER__;
2522
2523         net_err_t Error = NET_ERR_NONE;
2524         GVariant *message = NULL;
2525         GVariant *params = NULL;
2526         const char *method = "TdlsDisconnect";
2527         gint32 ret = -1;
2528
2529         params = g_variant_new("(s)", peer_mac_addr);
2530
2531         message = _net_invoke_dbus_method(
2532                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
2533                         NETCONFIG_WIFI_INTERFACE, method, params, &Error);
2534
2535         if (message == NULL) {
2536                 NETWORK_LOG(NETWORK_ERROR, "Failed to TDLS Disconnect Request\n");
2537                 __NETWORK_FUNC_EXIT__;
2538                 return Error;
2539         }
2540
2541         g_variant_get(message, "(i)", &ret);
2542
2543         NETWORK_LOG(NETWORK_HIGH, "Status [%d]\n", ret);
2544
2545         if (ret)
2546                 Error = NET_ERR_NONE;
2547         else
2548                 Error = NET_ERR_UNKNOWN;
2549
2550         g_variant_unref(message);
2551         __NETWORK_FUNC_EXIT__;
2552
2553         return Error;
2554 }
2555
2556 int _net_dbus_tdls_connected_peer(char** peer_mac_addr)
2557 {
2558
2559         __NETWORK_FUNC_ENTER__;
2560
2561         net_err_t Error = NET_ERR_NONE;
2562         GVariant *message = NULL;
2563         const char *method = "TdlsConnectedPeer";
2564
2565
2566         if (NULL == peer_mac_addr) {
2567                         NETWORK_LOG(NETWORK_ERROR, "Invalid Parameter\n");
2568                         __NETWORK_FUNC_EXIT__;
2569                         return NET_ERR_INVALID_PARAM;
2570         }
2571
2572         message = _net_invoke_dbus_method(
2573                         NETCONFIG_SERVICE, NETCONFIG_WIFI_PATH,
2574                         NETCONFIG_WIFI_INTERFACE, method, NULL, &Error);
2575
2576         if (message == NULL) {
2577                 NETWORK_LOG(NETWORK_ERROR, "Failed to Get Peer Connected Mac address\n");
2578                 __NETWORK_FUNC_EXIT__;
2579                 return Error;
2580         }
2581
2582         g_variant_get(message, "(s)", peer_mac_addr);
2583
2584         NETWORK_LOG(NETWORK_HIGH, "TDLS Peer Mac address [%s]\n", *peer_mac_addr);
2585
2586         g_variant_unref(message);
2587         __NETWORK_FUNC_EXIT__;
2588
2589         return Error;
2590 }
2591
2592 int _net_dbus_device_policy_get_wifi(int *state)
2593 {
2594         __NETWORK_FUNC_ENTER__;
2595
2596         net_err_t Error = NET_ERR_NONE;
2597         GVariant *message = NULL;
2598
2599         if (state == NULL) {
2600                 NETWORK_LOG(NETWORK_ERROR, "Invalid Parameter\n");
2601                 __NETWORK_FUNC_EXIT__;
2602                 return NET_ERR_INVALID_PARAM;
2603         }
2604
2605         message = _net_invoke_dbus_method(NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH,
2606                         NETCONFIG_NETWORK_INTERFACE, "DevicePolicyGetWifi", NULL, &Error);
2607
2608         if (message == NULL) {
2609                 NETWORK_LOG(NETWORK_ERROR, "Failed to get wifi device policy\n");
2610                 return Error;
2611         }
2612
2613         g_variant_get(message, "(i)", state);
2614
2615         NETWORK_LOG(NETWORK_LOW, "Wifi device policy state [%d]\n", *state);
2616
2617         g_variant_unref(message);
2618
2619         __NETWORK_FUNC_EXIT__;
2620         return Error;
2621 }
2622
2623 int _net_dbus_device_policy_get_wifi_profile(int *state)
2624 {
2625         __NETWORK_FUNC_ENTER__;
2626
2627         net_err_t Error = NET_ERR_NONE;
2628         GVariant *message = NULL;
2629
2630         if (state == NULL) {
2631                 NETWORK_LOG(NETWORK_ERROR, "Invalid Parameter\n");
2632                 __NETWORK_FUNC_EXIT__;
2633                 return NET_ERR_INVALID_PARAM;
2634         }
2635
2636         message = _net_invoke_dbus_method(NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH,
2637                         NETCONFIG_NETWORK_INTERFACE, "DevicePolicyGetWifiProfile", NULL, &Error);
2638
2639         if (message == NULL) {
2640                 NETWORK_LOG(NETWORK_ERROR, "Failed to get wifi device policy\n");
2641                 return Error;
2642         }
2643
2644         g_variant_get(message, "(i)", state);
2645
2646         NETWORK_LOG(NETWORK_LOW, "Wifi profile device policy state [%d]\n", *state);
2647
2648         g_variant_unref(message);
2649
2650         __NETWORK_FUNC_EXIT__;
2651         return Error;
2652 }