src/network-dbus-request.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.tizenopensource.org/license
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 #ifdef __cplusplus
  19 extern "C"
  20 {
  21 #endif /* __cplusplus */
  22
  23
  24 /*****************************************************************************
  25  *      Standard headers
  26  *****************************************************************************/
  27 #include <stdio.h>
  28 #include <errno.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <glib.h>
  32 #include <dbus/dbus-glib.h>
  33 #include <dbus/dbus.h>
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36 #include <vconf.h>
  37
  38 /*****************************************************************************
  39  *      Platform headers
  40  *****************************************************************************/
  41
  42 #include "network-internal.h"
  43 #include "network-dbus-request.h"
  44
  45 /*****************************************************************************
  46  *      Macros and Typedefs
  47  *****************************************************************************/
  48
  49 #define DBUS_REPLY_TIMEOUT (120 * 1000)
  50
  51 /*****************************************************************************
  52  *      Local Functions Declaration
  53  *****************************************************************************/
  54
  55 static int __net_error_string_to_enum(const char* error);
  56 static int __net_netconfig_error_string_to_enum(const char* error);
  57 static int _net_get_error_from_message(DBusMessage *message);
  58 static int _net_get_error_from_netconfig_message(DBusMessage *message);
  59 static void __net_open_connection_reply(DBusPendingCall *call, void *user_data);
  60 static void __net_close_connection_reply(DBusPendingCall *call, void *user_data);
  61 static void __net_wifi_power_reply(DBusPendingCall *call, void *user_data);
  62
  63 /*****************************************************************************
  64  *      Global Functions
  65  *****************************************************************************/
  66
  67
  68 /*****************************************************************************
  69  *      Global Variables
  70  *****************************************************************************/
  71
  72 struct dbus_pending_call_data {
  73         DBusPendingCall *pcall;
  74         dbus_bool_t is_used;
  75 };
  76
  77 static struct dbus_pending_call_data network_dbus_pending_call_data = {
  78         NULL,
  79         FALSE
  80 };
  81
  82 /*****************************************************************************
  83  *      Extern Variables
  84  *****************************************************************************/
  85
  86 extern network_info_t NetworkInfo;
  87 extern network_request_table_t request_table[NETWORK_REQUEST_TYPE_MAX];
  88
  89
  90 /*****************************************************************************
  91  *      Extern Functions
  92  *****************************************************************************/
  93
  94 /*****************************************************************************
  95  *      Local Functions Definition
  96  *****************************************************************************/
  97
  98 static int __net_error_string_to_enum(const char* error)
  99 {
 100         NETWORK_LOG(NETWORK_HIGH, "Passed error value [%s]\n", error);
 101
 102         if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".NoReply"))
 103                 return NET_ERR_TIME_OUT;
 104         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".Failed"))
 105                 return NET_ERR_UNKNOWN;
 106         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".UnknownMethod"))
 107                 return NET_ERR_UNKNOWN_METHOD;
 108         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".InvalidArguments"))
 109                 return NET_ERR_INVALID_PARAM;
 110         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".PermissionDenied"))
 111                 return NET_ERR_ACCESS_DENIED;
 112         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".PassphraseRequired"))
 113                 return NET_ERR_INVALID_OPERATION;
 114         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".NotRegistered"))
 115                 return NET_ERR_INVALID_OPERATION;
 116         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".NotUnique"))
 117                 return NET_ERR_INVALID_OPERATION;
 118         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".NotSupported"))
 119                 return NET_ERR_NOT_SUPPORTED;
 120         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".NotImplemented"))
 121                 return NET_ERR_NOT_SUPPORTED;
 122         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".NotFound"))
 123                 return NET_ERR_NOT_SUPPORTED;
 124         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".NoCarrier"))
 125                 return NET_ERR_NOT_SUPPORTED;
 126         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".InProgress"))
 127                 return NET_ERR_IN_PROGRESS;
 128         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".AlreadyExists"))
 129                 return NET_ERR_INVALID_OPERATION;
 130         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".AlreadyEnabled"))
 131                 return NET_ERR_INVALID_OPERATION;
 132         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".AlreadyDisabled"))
 133                 return NET_ERR_INVALID_OPERATION;
 134         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".AlreadyConnected"))
 135                 return NET_ERR_ACTIVE_CONNECTION_EXISTS;
 136         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".NotConnected"))
 137                 return NET_ERR_NO_ACTIVE_CONNECTIONS;
 138         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".OperationAborted"))
 139                 return NET_ERR_OPERATION_ABORTED;
 140         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".OperationTimeout"))
 141                 return NET_ERR_TIME_OUT;
 142         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".InvalidService"))
 143                 return NET_ERR_NO_SERVICE;
 144         else if (NULL != strstr(error, CONNMAN_ERROR_INTERFACE ".InvalidProperty"))
 145                 return NET_ERR_INVALID_OPERATION;
 146         return NET_ERR_UNKNOWN;
 147 }
 148
 149 static int __net_netconfig_error_string_to_enum(const char* error)
 150 {
 151         NETWORK_LOG(NETWORK_HIGH, "Passed error value [%s]\n", error);
 152
 153         if (error == NULL)
 154                 return NET_ERR_UNKNOWN;
 155
 156         if (NULL != strstr(error, ".WifiDriverFailed"))
 157                 return NET_ERR_WIFI_DRIVER_FAILURE;
 158         else if (NULL != strstr(error, ".SecurityRestricted"))
 159                 return NET_ERR_SECURITY_RESTRICTED;
 160         return NET_ERR_UNKNOWN;
 161 }
 162
 163 static int _net_get_error_from_message(DBusMessage *message)
 164 {
 165         __NETWORK_FUNC_ENTER__;
 166
 167         int MessageType = 0;
 168
 169         MessageType = dbus_message_get_type(message);
 170
 171         if (MessageType == DBUS_MESSAGE_TYPE_ERROR) {
 172                 const char* ptr = dbus_message_get_error_name(message);
 173                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Error message received [%s]\n", ptr);
 174                 __NETWORK_FUNC_EXIT__;
 175                 return __net_error_string_to_enum(ptr);
 176         }
 177
 178         __NETWORK_FUNC_EXIT__;
 179         return NET_ERR_NONE;
 180 }
 181
 182 static int _net_get_error_from_netconfig_message(DBusMessage *message)
 183 {
 184         __NETWORK_FUNC_ENTER__;
 185
 186         int MessageType = 0;
 187
 188         MessageType = dbus_message_get_type(message);
 189
 190         if (MessageType == DBUS_MESSAGE_TYPE_ERROR) {
 191                 const char* ptr = dbus_message_get_error_name(message);
 192                 const char* err_msg = _net_get_string(message);
 193                 NETWORK_LOG(NETWORK_ERROR,
 194                                 "Error!!! Error message received [%s] [%s]\n", ptr, err_msg);
 195                 __NETWORK_FUNC_EXIT__;
 196                 return __net_netconfig_error_string_to_enum(err_msg);
 197         }
 198
 199         __NETWORK_FUNC_EXIT__;
 200         return NET_ERR_NONE;
 201 }
 202
 203 static void __net_open_connection_reply(DBusPendingCall *call, void *user_data)
 204 {
 205         __NETWORK_FUNC_ENTER__;
 206
 207         NETWORK_LOG(NETWORK_LOW, "__net_open_connection_reply() called\n");
 208
 209         net_event_info_t event_data = {0,};
 210         net_profile_info_t prof_info;
 211         network_request_table_t *open_info = &request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION];
 212         network_request_table_t *wps_info = &request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS];
 213
 214         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 215         net_err_t Error = _net_get_error_from_message(reply);
 216
 217         if (Error == NET_ERR_NONE)
 218                 goto done;
 219
 220         NETWORK_LOG(NETWORK_ERROR,
 221                 "Error!!! Connection open failed. Error code : [%d]\n", Error);
 222
 223         if (open_info->flag == TRUE) {
 224                 net_device_t device_type = _net_get_tech_type_from_path(open_info->ProfileName);
 225
 226                 if (Error == NET_ERR_IN_PROGRESS &&
 227                     device_type == NET_DEVICE_CELLULAR)
 228                         goto done;
 229
 230                 snprintf(event_data.ProfileName,
 231                         NET_PROFILE_NAME_LEN_MAX + 1, "%s",
 232                         open_info->ProfileName);
 233
 234                 memset(open_info, 0, sizeof(network_request_table_t));
 235
 236                 event_data.Error = Error;
 237
 238                 if (Error == NET_ERR_ACTIVE_CONNECTION_EXISTS) {
 239                         Error = net_get_profile_info(event_data.ProfileName, &prof_info);
 240
 241                         if (device_type == NET_DEVICE_CELLULAR)
 242                                 event_data.Error = NET_ERR_NONE;
 243
 244                         if (Error != NET_ERR_NONE) {
 245                                 NETWORK_LOG(NETWORK_ERROR,
 246                                         "Error!!! net_get_profile_info() failed [%s]\n",
 247                                         _net_print_error(Error));
 248                                 event_data.Datalength = 0;
 249                                 event_data.Data = NULL;
 250                         } else {
 251                                 event_data.Datalength = sizeof(net_profile_info_t);
 252                                 event_data.Data = &prof_info;
 253                         }
 254                 }
 255
 256                 event_data.Event = NET_EVENT_OPEN_RSP;
 257                 NETWORK_LOG(NETWORK_LOW, "Sending NET_EVENT_OPEN_RSP Error = %s\n",
 258                                 _net_print_error(event_data.Error));
 259                 _net_client_callback(&event_data);
 260         } else if (wps_info->flag == TRUE) {
 261
 262                 snprintf(event_data.ProfileName,
 263                         NET_PROFILE_NAME_LEN_MAX + 1, "%s",
 264                         wps_info->ProfileName);
 265
 266                 memset(wps_info, 0, sizeof(network_request_table_t));
 267
 268                 event_data.Error = Error;
 269
 270                 if (Error == NET_ERR_ACTIVE_CONNECTION_EXISTS) {
 271                         Error = net_get_profile_info(event_data.ProfileName, &prof_info);
 272                         if (Error != NET_ERR_NONE) {
 273                                 NETWORK_LOG(NETWORK_ERROR,
 274                                         "Error!!! net_get_profile_info() failed [%s]\n",
 275                                         _net_print_error(Error));
 276                                 event_data.Datalength = 0;
 277                                 event_data.Data = NULL;
 278                         } else {
 279                                 event_data.Datalength = sizeof(net_profile_info_t);
 280                                 event_data.Data = &prof_info;
 281                         }
 282                 }
 283
 284                 event_data.Event = NET_EVENT_WIFI_WPS_RSP;
 285
 286                 NETWORK_LOG(NETWORK_LOW, "Sending NET_EVENT_WIFI_WPS_RSP Error = %s\n",
 287                                 _net_print_error(event_data.Error));
 288                 _net_client_callback(&event_data);
 289         }
 290
 291 done:
 292         dbus_message_unref(reply);
 293         dbus_pending_call_unref(call);
 294
 295         network_dbus_pending_call_data.is_used = FALSE;
 296         network_dbus_pending_call_data.pcall = NULL;
 297
 298         __NETWORK_FUNC_EXIT__;
 299 }
 300
 301 static void __net_close_connection_reply(DBusPendingCall *call, void *user_data)
 302 {
 303         __NETWORK_FUNC_ENTER__;
 304
 305         NETWORK_LOG(NETWORK_LOW, "__net_close_connection_reply() called\n");
 306
 307         net_event_info_t event_data = {0,};
 308         network_request_table_t *close_info = &request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION];
 309
 310         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 311         net_err_t Error = _net_get_error_from_message(reply);
 312
 313         if (Error == NET_ERR_NONE)
 314                 goto done;
 315
 316         NETWORK_LOG(NETWORK_ERROR,
 317                 "Error!!! Connection close failed. Error code : [%d]\n", Error);
 318
 319         if (close_info->flag == TRUE) {
 320                 net_device_t device_type = _net_get_tech_type_from_path(close_info->ProfileName);
 321
 322                 if (Error == NET_ERR_ACTIVE_CONNECTION_EXISTS &&
 323                     device_type == NET_DEVICE_CELLULAR)
 324                         Error = NET_ERR_NONE;
 325
 326                 snprintf(event_data.ProfileName,
 327                         NET_PROFILE_NAME_LEN_MAX + 1, "%s",
 328                         close_info->ProfileName);
 329
 330                 memset(close_info, 0, sizeof(network_request_table_t));
 331
 332                 event_data.Error = Error;
 333                 event_data.Datalength = 0;
 334                 event_data.Data = NULL;
 335                 event_data.Event = NET_EVENT_CLOSE_RSP;
 336                 NETWORK_LOG(NETWORK_LOW, "Sending NET_EVENT_CLOSE_RSP Error = %s\n",
 337                                 _net_print_error(event_data.Error));
 338                 _net_client_callback(&event_data);
 339         }
 340
 341 done:
 342         dbus_message_unref(reply);
 343         dbus_pending_call_unref(call);
 344
 345         network_dbus_pending_call_data.is_used = FALSE;
 346         network_dbus_pending_call_data.pcall = NULL;
 347
 348         __NETWORK_FUNC_EXIT__;
 349 }
 350
 351 static void __net_wifi_power_reply(DBusPendingCall *call, void *user_data)
 352 {
 353         __NETWORK_FUNC_ENTER__;
 354
 355         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 356         net_err_t Error = _net_get_error_from_netconfig_message(reply);
 357
 358         if (Error == NET_ERR_NONE)
 359                 goto done;
 360
 361         net_event_info_t event_data = {0,};
 362         net_wifi_state_t wifi_state = WIFI_UNKNOWN;
 363
 364         NETWORK_LOG(NETWORK_ERROR,
 365                 "Error!!! Wifi Power on/off failed. Error code : [%d]\n", Error);
 366
 367         if (request_table[NETWORK_REQUEST_TYPE_WIFI_POWER].flag == TRUE) {
 368                 memset(&request_table[NETWORK_REQUEST_TYPE_WIFI_POWER],
 369                                 0, sizeof(network_request_table_t));
 370
 371                 event_data.Event = NET_EVENT_WIFI_POWER_RSP;
 372                 event_data.Error = Error;
 373                 event_data.Datalength = sizeof(net_wifi_state_t);
 374                 event_data.Data = &wifi_state;
 375                 NETWORK_LOG(NETWORK_LOW,
 376                         "Sending NET_EVENT_WIFI_POWER_RSP Error = %d\n", event_data.Error);
 377                 _net_client_callback(&event_data);
 378         }
 379
 380 done:
 381         dbus_message_unref(reply);
 382         dbus_pending_call_unref(call);
 383
 384         network_dbus_pending_call_data.is_used = FALSE;
 385         network_dbus_pending_call_data.pcall = NULL;
 386
 387         __NETWORK_FUNC_EXIT__;
 388 }
 389
 390 static int __net_append_argument(DBusMessageIter *iter, int ArgType, const char *Value)
 391 {
 392         __NETWORK_FUNC_ENTER__;
 393
 394         double Double = 0;
 395         unsigned char ByteValue = 0;
 396         dbus_bool_t booleanvalue = 0;
 397
 398         dbus_uint16_t Uint16 = 0;
 399         dbus_int16_t Int16 = 0;
 400         dbus_uint32_t Uint32 = 0;
 401         dbus_int32_t Int32 = 0;
 402
 403         switch(ArgType) {
 404         case DBUS_TYPE_BYTE:
 405                 ByteValue = strtoul(Value, NULL, 0);
 406                 dbus_message_iter_append_basic(iter, DBUS_TYPE_BYTE, &ByteValue);
 407                 break;
 408
 409         case DBUS_TYPE_DOUBLE:
 410                 Double = strtod(Value, NULL);
 411                 dbus_message_iter_append_basic(iter, DBUS_TYPE_DOUBLE, &Double);
 412                 break;
 413
 414         case DBUS_TYPE_INT16:
 415                 Int16 = strtol(Value, NULL, 0);
 416                 dbus_message_iter_append_basic(iter, DBUS_TYPE_INT16, &Int16);
 417                 break;
 418
 419         case DBUS_TYPE_UINT16:
 420                 Uint16 = strtoul(Value, NULL, 0);
 421                 dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT16, &Uint16);
 422                 break;
 423
 424         case DBUS_TYPE_INT32:
 425                 Int32 = strtol(Value, NULL, 0);
 426                 dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &Int32);
 427                 break;
 428
 429         case DBUS_TYPE_UINT32:
 430                 Uint32 = strtoul(Value, NULL, 0);
 431                 dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &Uint32);
 432                 break;
 433
 434         case DBUS_TYPE_STRING:
 435                 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &Value);
 436                 break;
 437
 438         case DBUS_TYPE_OBJECT_PATH:
 439                 dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &Value);
 440                 break;
 441
 442         case DBUS_TYPE_BOOLEAN:
 443                 if( strcmp (Value, "true") == 0 ) {
 444                         booleanvalue = TRUE;
 445                         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &booleanvalue);
 446                 } else if( strcmp (Value, "false") == 0 ) {
 447                         booleanvalue = FALSE;
 448                         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &booleanvalue);
 449                 } else {
 450                         NETWORK_LOG(NETWORK_ERROR, "Error!!! Expected \"true\" or \"false\" instead of \"%s\"\n", Value);
 451                         __NETWORK_FUNC_EXIT__;
 452                         return NET_ERR_UNKNOWN;
 453                 }
 454                 break;
 455
 456         default:
 457                 NETWORK_LOG( NETWORK_ERROR, "Error!!! Unsupported data ArgType %c\n", (char) ArgType);
 458                 __NETWORK_FUNC_EXIT__;
 459                 return NET_ERR_UNKNOWN;
 460         }
 461
 462         __NETWORK_FUNC_EXIT__;
 463         return NET_ERR_NONE;
 464 }
 465
 466 static int __net_append_array(DBusMessageIter *iter, int ArgType, const char *Value)
 467 {
 468         __NETWORK_FUNC_ENTER__;
 469
 470         const char *Val = NULL;
 471         char *saveptr = NULL;
 472         char *DupValue = strdup(Value);
 473
 474         Val = strtok_r(DupValue, ",", &saveptr);
 475         while(Val != NULL) {
 476                 if( __net_append_argument(iter, ArgType, Val) != NET_ERR_NONE ) {
 477                         NET_MEMFREE(DupValue);
 478                         __NETWORK_FUNC_EXIT__;
 479                         return  NET_ERR_UNKNOWN;
 480                 }
 481                 Val = strtok_r(NULL, ",", &saveptr);
 482         }
 483         NET_MEMFREE(DupValue);
 484
 485         __NETWORK_FUNC_EXIT__;
 486         return NET_ERR_NONE;
 487 }
 488
 489 static int __net_append_dict(DBusMessageIter *iter, int KeyType, int ValueType, const char *Value)
 490 {
 491         __NETWORK_FUNC_ENTER__;
 492
 493         const char *Val = NULL;
 494         char *saveptr = NULL;
 495         char *DupValue = strdup(Value);
 496
 497         Val = strtok_r(DupValue, ",", &saveptr);
 498         while(Val != NULL) {
 499                 DBusMessageIter SubIter;
 500
 501                 dbus_message_iter_open_container(iter,
 502                                 DBUS_TYPE_DICT_ENTRY,
 503                                 NULL,
 504                                 &SubIter);
 505
 506                 if( __net_append_argument (&SubIter, KeyType, Val) != NET_ERR_NONE ) {
 507                         NETWORK_LOG(NETWORK_ERROR, "Error!!! __net_append_argument() failed\n");
 508                         NET_MEMFREE(DupValue);
 509                         __NETWORK_FUNC_EXIT__;
 510                         return  NET_ERR_UNKNOWN;
 511                 }
 512
 513                 Val = strtok_r(NULL, ",", &saveptr);
 514                 if(Val == NULL) {
 515                         NETWORK_LOG(NETWORK_ERROR, "Error!!! Crashed dictionary data\n");
 516                         NET_MEMFREE(DupValue);
 517                         __NETWORK_FUNC_EXIT__;
 518                         return NET_ERR_UNKNOWN;
 519                 }
 520
 521                 if( __net_append_argument (&SubIter, ValueType, Val) != NET_ERR_NONE ) {
 522                         NETWORK_LOG(NETWORK_ERROR, "Error!!! __net_append_argument() failed\n");
 523                         NET_MEMFREE(DupValue);
 524                         __NETWORK_FUNC_EXIT__;
 525                         return  NET_ERR_UNKNOWN;
 526                 }
 527
 528                 dbus_message_iter_close_container (iter, &SubIter);
 529                 Val = strtok_r(NULL, ",", &saveptr);
 530         }
 531         NET_MEMFREE(DupValue);
 532         __NETWORK_FUNC_EXIT__;
 533         return  NET_ERR_NONE;
 534 }
 535
 536 static int __net_datatype_from_stringname(const char *Args)
 537 {
 538         __NETWORK_FUNC_ENTER__;
 539
 540         int ArgType = 0;
 541
 542         if( !strcmp(Args, CONNMAN_CLIENT_DBUS_TYPE_STRING) )
 543                 ArgType = DBUS_TYPE_STRING;
 544         else if( !strcmp(Args, CONNMAN_CLIENT_DBUS_TYPE_INT16) )
 545                 ArgType = DBUS_TYPE_INT16;
 546         else if( !strcmp(Args, CONNMAN_CLIENT_DBUS_TYPE_UINT16) )
 547                 ArgType = DBUS_TYPE_UINT16;
 548         else if( !strcmp(Args, CONNMAN_CLIENT_DBUS_TYPE_INT32) )
 549                 ArgType = DBUS_TYPE_INT32;
 550         else if( !strcmp(Args, CONNMAN_CLIENT_DBUS_TYPE_UINT32) )
 551                 ArgType = DBUS_TYPE_UINT32;
 552         else if( !strcmp(Args, CONNMAN_CLIENT_DBUS_TYPE_INT64) )
 553                 ArgType = DBUS_TYPE_INT64;
 554         else if( !strcmp(Args, CONNMAN_CLIENT_DBUS_TYPE_UINT64) )
 555                 ArgType = DBUS_TYPE_UINT64;
 556         else if( !strcmp(Args, CONNMAN_CLIENT_DBUS_TYPE_DOUBLE) )
 557                 ArgType = DBUS_TYPE_DOUBLE;
 558         else if( !strcmp(Args, CONNMAN_CLIENT_DBUS_TYPE_BYTE) )
 559                 ArgType = DBUS_TYPE_BYTE;
 560         else if( !strcmp(Args, CONNMAN_CLIENT_DBUS_TYPE_BOOLEAN) )
 561                 ArgType = DBUS_TYPE_BOOLEAN;
 562         else if( !strcmp(Args, CONNMAN_CLIENT_DBUS_TYPE_OBJECT_PATH) )
 563                 ArgType = DBUS_TYPE_OBJECT_PATH;
 564         else {
 565                 NETWORK_LOG( NETWORK_ERROR, "Error!!! Unknown Argument Type \"%s\"\n", Args);
 566                 __NETWORK_FUNC_EXIT__;
 567                 return NET_ERR_UNKNOWN;
 568         }
 569
 570         __NETWORK_FUNC_EXIT__;
 571         return ArgType;
 572 }
 573
 574
 575 /*****************************************************************************
 576  *      Global Functions Definition
 577  *****************************************************************************/
 578
 579 DBusMessage *_net_invoke_dbus_method(const char* dest, DBusConnection *connection,
 580                 const char* path, char* interface_name, char* method, int *dbus_error)
 581 {
 582         __NETWORK_FUNC_ENTER__;
 583
 584         DBusError error;
 585         DBusMessage *reply = NULL;
 586         DBusMessage *message = NULL;
 587
 588         *dbus_error = NET_ERR_NONE;
 589
 590         message = dbus_message_new_method_call(dest, path, interface_name, method);
 591         if (message == NULL) {
 592                 NETWORK_LOG(NETWORK_ERROR, "Error!!! dbus_message_new_method_call() failed\n");
 593                 __NETWORK_FUNC_EXIT__;
 594                 return NULL;
 595         }
 596
 597         dbus_error_init(&error);
 598
 599         reply = dbus_connection_send_with_reply_and_block(connection,
 600                         message, DBUS_REPLY_TIMEOUT, &error);
 601         if (reply == NULL) {
 602                 if (dbus_error_is_set(&error) == TRUE) {
 603                         NETWORK_LOG(NETWORK_ERROR,
 604                                         "Error!!! dbus_connection_send_with_reply_and_block() failed. dbus error [%s: %s]\n",
 605                                         error.name, error.message);
 606                         *dbus_error = __net_error_string_to_enum(error.name);
 607                         dbus_error_free(&error);
 608                 } else {
 609                         NETWORK_LOG(NETWORK_ERROR, "Error!!! dbus_connection_send_with_reply_and_block() failed\n");
 610                         *dbus_error = NET_ERR_UNKNOWN;
 611                 }
 612
 613                 dbus_message_unref(message);
 614                 __NETWORK_FUNC_EXIT__;
 615                 return NULL;
 616         }
 617
 618         dbus_message_unref(message);
 619
 620         __NETWORK_FUNC_EXIT__;
 621         return reply;
 622 }
 623
 624 int _net_invoke_dbus_method_nonblock(const char* dest, DBusConnection *connection,
 625                 const char* path, char* interface_name, char* method,
 626                 DBusPendingCallNotifyFunction notify_func)
 627 {
 628         __NETWORK_FUNC_ENTER__;
 629
 630         DBusMessage *message = NULL;
 631         DBusPendingCall *call;
 632         dbus_bool_t result;
 633
 634         message = dbus_message_new_method_call(dest, path, interface_name, method);
 635         if (message == NULL) {
 636                 NETWORK_LOG(NETWORK_ERROR, "Error!!! dbus_message_new_method_call() Failed\n");
 637                 __NETWORK_FUNC_EXIT__;
 638                 return NET_ERR_UNKNOWN;
 639         }
 640
 641         result = dbus_connection_send_with_reply(connection,
 642                         message, &call, DBUS_REPLY_TIMEOUT);
 643
 644         if (result == FALSE || call == NULL) {
 645                 NETWORK_LOG(NETWORK_ERROR, "Error!!! dbus_connection_send_with_reply() Failed\n");
 646                 dbus_message_unref(message);
 647                 return NET_ERR_UNKNOWN;
 648         }
 649
 650         dbus_pending_call_set_notify(call, notify_func, NULL, NULL);
 651         network_dbus_pending_call_data.pcall = call;
 652         network_dbus_pending_call_data.is_used = TRUE;
 653
 654         dbus_message_unref(message);
 655
 656         __NETWORK_FUNC_EXIT__;
 657         return NET_ERR_NONE;
 658 }
 659
 660
 661 int _net_send_dbus_request(const char* destination, char *param_array[], DBusMessage** result)
 662 {
 663         __NETWORK_FUNC_ENTER__;
 664
 665         DBusConnection *connection = NULL;
 666         DBusError error;
 667         DBusMessage *message = NULL;
 668         net_err_t Error = NET_ERR_NONE;
 669         char *RequestMethod = NULL;
 670         int i = 0;
 671         const char *path = NULL;
 672         const char *name = NULL;
 673         int param_count = 0;
 674         // const char *destination = CONNMAN_SERVICE;
 675         DBusMessageIter iter;
 676
 677         for (param_count = 0; param_array[param_count] != NULL; param_count++) {
 678                 NETWORK_LOG(NETWORK_HIGH, "[%s]\n", param_array[param_count]);
 679         }
 680         NETWORK_LOG(NETWORK_HIGH, "Total Arguments [%d]\n", param_count);
 681
 682         path = param_array[i++]; /** 0th is path */
 683         name = param_array[i++]; /** 1st is request name */
 684
 685         if ((strlen(path) == 0) || (strlen(name) == 0) ) {
 686                 NETWORK_LOG(NETWORK_ASSERT, "Error!!! Invalid parameters passed path [%s], requested name [%s]\n",
 687                                 path, name);
 688                 __NETWORK_FUNC_EXIT__;
 689                 return NET_ERR_INVALID_PARAM;
 690         }
 691
 692         dbus_error_init(&error);
 693
 694         connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
 695         if (connection == NULL) {
 696                 NETWORK_LOG(NETWORK_EXCEPTION, "Error!!! Failed to get system dbus, error [%s]\n",
 697                                 error.message);
 698                 dbus_error_free(&error);
 699                 __NETWORK_FUNC_EXIT__;
 700                 return NET_ERR_UNKNOWN;
 701         }
 702
 703         RequestMethod = strrchr(name, '.');
 704         if (RequestMethod == NULL) {
 705                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Invalid method in \"%s\"\n", name);
 706                 dbus_connection_unref(connection);
 707                 __NETWORK_FUNC_EXIT__;
 708                 return NET_ERR_UNKNOWN;
 709         }
 710
 711         *RequestMethod = '\0';
 712         message = dbus_message_new_method_call(NULL, path, name, RequestMethod + 1);
 713
 714         if (message == NULL) {
 715                 NETWORK_LOG(NETWORK_ERROR, "Error!!! dbus_message_new_method_call() failed\n");
 716                 __NETWORK_FUNC_EXIT__;
 717                 Error = NET_ERR_UNKNOWN;
 718                 goto end_error;
 719         }
 720
 721         if (destination && !dbus_message_set_destination(message, destination)) {
 722                 NETWORK_LOG(NETWORK_EXCEPTION, "Error!!! dbus_message_set_destination() failed\n");
 723                 __NETWORK_FUNC_EXIT__;
 724                 Error = NET_ERR_UNKNOWN;
 725                 goto end_error;
 726         }
 727
 728         dbus_message_iter_init_append(message, &iter);
 729
 730         /** Two arguments name and path already extracted, so i == 2 */
 731         while (i < param_count) {
 732                 char *Args = NULL;
 733                 char *Ch = NULL;
 734                 int ArgType = 0;
 735                 int SecondaryType = 0;
 736                 int ContainerType = 0;
 737                 DBusMessageIter *TargetIter = NULL;
 738                 DBusMessageIter ContainerIter;
 739
 740                 ArgType = DBUS_TYPE_INVALID;
 741                 Args = param_array[i++];
 742                 Ch = strchr (Args, ':');
 743
 744                 if (Ch == NULL) {
 745                         NETWORK_LOG(NETWORK_ERROR, "Error!!! Invalid data format[\"%s\"]\n", Args);
 746                         Error = NET_ERR_UNKNOWN;
 747                         goto end_error;
 748                 }
 749
 750                 *(Ch++) = 0;
 751
 752                 if (strcmp(Args, CONNMAN_CLIENT_DBUS_TYPE_VARIANT) == 0) {
 753                         ContainerType = DBUS_TYPE_VARIANT;
 754                 } else if (strcmp(Args, CONNMAN_CLIENT_DBUS_TYPE_ARRAY) == 0) {
 755                         ContainerType = DBUS_TYPE_ARRAY;
 756                 } else if (strcmp(Args, CONNMAN_CLIENT_DBUS_TYPE_DICT_ENTRY) == 0) {
 757                         ContainerType = DBUS_TYPE_DICT_ENTRY;
 758                 } else {
 759                         ContainerType = DBUS_TYPE_INVALID;
 760                 }
 761
 762                 if (ContainerType != DBUS_TYPE_INVALID) {
 763                         Args = Ch;
 764                         Ch = strchr(Args, ':');
 765                         if (Ch == NULL) {
 766                                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Invalid data format[\"%s\"]\n", Args);
 767                                 Error = NET_ERR_UNKNOWN;
 768                                 goto end_error;
 769                         }
 770                         *(Ch++) = 0;
 771                 }
 772
 773                 if (Args[0] == 0) {
 774                         ArgType = DBUS_TYPE_STRING;
 775                 } else {
 776                         ArgType = __net_datatype_from_stringname(Args);
 777                         if (ArgType == NET_ERR_UNKNOWN) {
 778                                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Unknown data type\n");
 779                                 Error = NET_ERR_UNKNOWN;
 780                                 goto end_error;
 781                         }
 782                 }
 783
 784                 if (ContainerType == DBUS_TYPE_DICT_ENTRY) {
 785                         char Signature[5] = "";
 786                         Args = Ch;
 787                         Ch = strchr (Ch, ':');
 788
 789                         if (Ch == NULL) {
 790                                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Invalid data format[\"%s\"]\n", Args);
 791                                 Error = NET_ERR_UNKNOWN;
 792                                 goto end_error;
 793                         }
 794
 795                         *(Ch++) = 0;
 796                         SecondaryType = __net_datatype_from_stringname(Args);
 797
 798                         if (SecondaryType == NET_ERR_UNKNOWN) {
 799                                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Unknown datatype\n");
 800                                 Error = NET_ERR_UNKNOWN;
 801                                 goto end_error;
 802                         }
 803
 804                         Signature[0] = DBUS_DICT_ENTRY_BEGIN_CHAR;
 805                         Signature[1] = ArgType;
 806                         Signature[2] = SecondaryType;
 807                         Signature[3] = DBUS_DICT_ENTRY_END_CHAR;
 808                         Signature[4] = '\0';
 809
 810                         dbus_message_iter_open_container(&iter,
 811                                         DBUS_TYPE_ARRAY,
 812                                         Signature,
 813                                         &ContainerIter);
 814                         TargetIter = &ContainerIter;
 815                 } else if (ContainerType != DBUS_TYPE_INVALID) {
 816                         char Signature[2] = "";
 817                         Signature[0] = ArgType;
 818                         Signature[1] = '\0';
 819
 820                         dbus_message_iter_open_container(&iter,
 821                                         ContainerType,
 822                                         Signature,
 823                                         &ContainerIter);
 824                         TargetIter = &ContainerIter;
 825                 } else {
 826                         TargetIter = &iter;
 827                 }
 828
 829                 if (ContainerType == DBUS_TYPE_ARRAY) {
 830                         if (__net_append_array(TargetIter, ArgType, Ch) != NET_ERR_NONE) {
 831                                 NETWORK_LOG(NETWORK_ERROR, "Error!!! __net_append_array() failed\n");
 832                                 Error = NET_ERR_UNKNOWN;
 833                                 goto end_error;
 834                         }
 835                 } else if (ContainerType == DBUS_TYPE_DICT_ENTRY) {
 836                         if (__net_append_dict(TargetIter, ArgType, SecondaryType, Ch) != NET_ERR_NONE) {
 837                                 NETWORK_LOG(NETWORK_ERROR, "Error!!! __net_append_dict() failed\n");
 838                                 Error = NET_ERR_UNKNOWN;
 839                                 goto end_error;
 840                         }
 841                 } else {
 842                         if (__net_append_argument(TargetIter, ArgType, Ch) != NET_ERR_NONE) {
 843                                 NETWORK_LOG(NETWORK_ERROR, "Error!!! __net_append_argument() failed\n");
 844                                 Error = NET_ERR_UNKNOWN;
 845                                 goto end_error;
 846                         }
 847                 }
 848
 849                 if (ContainerType != DBUS_TYPE_INVALID) {
 850                         dbus_message_iter_close_container(&iter, &ContainerIter);
 851                 }
 852         }
 853
 854         DBusMessage *reply = NULL;
 855
 856         dbus_error_init (&error);
 857
 858         reply = dbus_connection_send_with_reply_and_block(connection,
 859                         message,
 860                         DBUS_REPLY_TIMEOUT,
 861                         &error);
 862         if (reply == NULL) {
 863                 if (dbus_error_is_set(&error) == TRUE) {
 864                         NETWORK_LOG(NETWORK_ERROR,
 865                                         "Error!!! dbus_connection_send_with_reply_and_block() failed, Error[%s: %s]\n",
 866                                         error.name,
 867                                         error.message);
 868                         Error = __net_error_string_to_enum(error.name);
 869                         dbus_error_free(&error);
 870                 } else
 871                         Error = NET_ERR_UNKNOWN;
 872
 873                 goto end_error;
 874         } else {
 875                 if (result != NULL) {
 876                         *result = reply;
 877                 } else {
 878                         dbus_message_unref(reply);
 879                 }
 880         }
 881
 882 end_error:
 883         dbus_message_unref(message);
 884         dbus_connection_unref(connection);
 885
 886         if (Error == NET_ERR_NONE)
 887                 NETWORK_LOG(NETWORK_HIGH, "Successfully requested\n");
 888
 889         __NETWORK_FUNC_EXIT__;
 890         return Error;
 891 }
 892
 893
 894 int _net_dbus_open_connection(const char* profile_name)
 895 {
 896         __NETWORK_FUNC_ENTER__;
 897
 898         net_err_t Error = NET_ERR_NONE;
 899         DBusConnection* conn = NULL;
 900
 901         conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
 902
 903         if (conn == NULL) {
 904                 NETWORK_LOG(NETWORK_EXCEPTION, "Error!!! Can't get on system bus\n");
 905                 __NETWORK_FUNC_EXIT__;
 906                 return NET_ERR_UNKNOWN;
 907         }
 908
 909         NETWORK_LOG(NETWORK_HIGH,  "Requesting [%s %s]\n",
 910                         profile_name, CONNMAN_SERVICE_INTERFACE ".Connect");
 911
 912         Error = _net_invoke_dbus_method_nonblock(CONNMAN_SERVICE, conn, profile_name,
 913                         CONNMAN_SERVICE_INTERFACE, "Connect", __net_open_connection_reply);
 914
 915         dbus_connection_unref(conn);
 916
 917         __NETWORK_FUNC_EXIT__;
 918         return Error;
 919 }
 920
 921
 922 int _net_dbus_close_connection(const char* profile_name)
 923 {
 924         __NETWORK_FUNC_ENTER__;
 925
 926         net_err_t Error = NET_ERR_NONE;
 927         DBusConnection* conn = NULL;
 928
 929         conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
 930
 931         if (conn == NULL) {
 932                 NETWORK_LOG(NETWORK_EXCEPTION, "Error!!! Can't get on system bus\n");
 933                 __NETWORK_FUNC_EXIT__;
 934                 return NET_ERR_UNKNOWN;
 935         }
 936
 937         NETWORK_LOG(NETWORK_HIGH,  "Requesting [%s %s]\n",
 938                         profile_name, CONNMAN_SERVICE_INTERFACE ".Disconnect");
 939
 940         Error = _net_invoke_dbus_method_nonblock(CONNMAN_SERVICE, conn, profile_name,
 941                         CONNMAN_SERVICE_INTERFACE, "Disconnect", __net_close_connection_reply);
 942
 943         dbus_connection_unref(conn);
 944
 945         __NETWORK_FUNC_EXIT__;
 946         return Error;
 947 }
 948
 949
 950 int _net_dbus_scan_request(void)
 951 {
 952         __NETWORK_FUNC_ENTER__;
 953
 954         net_err_t Error = NET_ERR_NONE;
 955
 956         /** dbus-send --system --print-reply --dest=net.connman / net.connman.Manager.RequestScan string:wifi */
 957         char request[] = CONNMAN_MANAGER_INTERFACE ".RequestScan";
 958         char param1[] = "string:wifi";
 959         char path[CONNMAN_MAX_BUFLEN] = "/";
 960         char* param_array[] = {NULL, NULL, NULL, NULL};
 961         param_array[0] = path;
 962         param_array[1] = request;
 963         param_array[2] = param1;
 964
 965         NETWORK_LOG(NETWORK_HIGH, "path [%s]\n", path);
 966         NETWORK_LOG(NETWORK_HIGH, "Requesting [%s %s %s]\n", param_array[0], param_array[1], param_array[2]);
 967
 968         if( (Error = _net_send_dbus_request(CONNMAN_SERVICE, param_array, NULL)) != NET_ERR_NONE ) {
 969                 NETWORK_LOG(NETWORK_ERROR, "Error!!! _net_send_dbus_request failed\n");
 970                 __NETWORK_FUNC_EXIT__;
 971                 return Error;
 972         }
 973
 974         __NETWORK_FUNC_EXIT__;
 975         return NET_ERR_NONE;
 976 }
 977
 978 int _net_dbus_provision_service(gchar * config_str, int len)
 979 {
 980         __NETWORK_FUNC_ENTER__;
 981
 982         net_err_t Error = NET_ERR_NONE;
 983
 984         /** dbus-send --system --print-reply --dest=net.connman / net.connman.Manager.ProvisionService string:xxx..*/
 985         char request[] = CONNMAN_MANAGER_INTERFACE ".ProvisionService";
 986         char *param1 = NULL;
 987         int param1_len = len + strlen("string:");
 988         char path[CONNMAN_MAX_BUFLEN] = "/";
 989         char* param_array[] = {NULL, NULL, NULL, NULL};
 990
 991         param1 = (char*)calloc(param1_len, sizeof(char));
 992         if(param1 == NULL)
 993                 return NET_ERR_UNKNOWN;
 994
 995         snprintf(param1, param1_len, "string:%s", config_str);
 996
 997         param_array[0] = path;
 998         param_array[1] = request;
 999         param_array[2] = param1;
1000
1001         if( (Error = _net_send_dbus_request(CONNMAN_SERVICE, param_array, NULL)) != NET_ERR_NONE ) {
1002                 NETWORK_LOG(NETWORK_ERROR, "Error!!! _net_send_dbus_request failed\n");
1003                 NET_MEMFREE(param1);
1004                 __NETWORK_FUNC_EXIT__;
1005                 return Error;
1006         }
1007
1008         NET_MEMFREE(param1);
1009         __NETWORK_FUNC_EXIT__;
1010         return NET_ERR_NONE;
1011 }
1012
1013
1014 int _net_dbus_set_bgscan_mode(net_wifi_background_scan_mode_t mode)
1015 {
1016         __NETWORK_FUNC_ENTER__;
1017
1018         /** TODO device interface missing */
1019
1020         net_err_t Error = NET_ERR_NONE;
1021         /** dbus-send --system --print-reply --dest=net.connman / net.connman.Manager.SetProperty string:ScanMode variant:uint16:0/1/2 */
1022         char request[] = NETCONFIG_WIFI_INTERFACE ".SetBgscan";
1023         char param1[64] = "";
1024         char path[CONNMAN_MAX_BUFLEN] = NETCONFIG_WIFI_PATH;
1025         char* param_array[] = {NULL, NULL, NULL, NULL};
1026
1027         NETWORK_LOG(NETWORK_HIGH, "path [%s]\n", path);
1028
1029         snprintf(param1, 64, "uint32:%d", mode);
1030
1031         param_array[0] = path;
1032         param_array[1] = request;
1033         param_array[2] = param1;
1034
1035         NETWORK_LOG(NETWORK_HIGH,  "Requesting [%s %s %s]\n",
1036                 param_array[0],
1037                 param_array[1],
1038                 param_array[2]
1039                 );
1040
1041         Error = _net_send_dbus_request(NETCONFIG_SERVICE, param_array, NULL);
1042         if (Error != NET_ERR_NONE) {
1043                 NETWORK_LOG(NETWORK_ERROR,  "Error!!! Request failed\n");
1044                 __NETWORK_FUNC_EXIT__;
1045                 return Error;
1046         }
1047
1048         __NETWORK_FUNC_EXIT__;
1049         return NET_ERR_NONE;
1050 }
1051
1052 int _net_dbus_get_technology_state(network_get_tech_state_info_t* tech_state)
1053 {
1054         __NETWORK_FUNC_ENTER__;
1055
1056         net_err_t Error = NET_ERR_NONE;
1057         DBusConnection* conn = NULL;
1058         DBusMessage *message = NULL;
1059
1060         if ((tech_state == NULL) || (strlen(tech_state->technology) == 0)) {
1061                 NETWORK_LOG(NETWORK_EXCEPTION, "Error!!! Invalid parameter\n");
1062                 __NETWORK_FUNC_EXIT__;
1063                 return NET_ERR_INVALID_PARAM;
1064         }
1065
1066         conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
1067         if (conn == NULL) {
1068                 NETWORK_LOG(NETWORK_EXCEPTION,
1069                                 "Error!!! Can't get on system bus\n");
1070                 __NETWORK_FUNC_EXIT__;
1071                 return NET_ERR_UNKNOWN;
1072         }
1073
1074         if (strcmp(tech_state->technology, "wifi") == 0) {
1075                 int hotspot_state = 0;
1076                 vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &hotspot_state);
1077
1078                 if (hotspot_state & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI)
1079                         goto done;
1080         }
1081
1082         message = _net_invoke_dbus_method(CONNMAN_SERVICE, conn, CONNMAN_MANAGER_PATH,
1083                         CONNMAN_MANAGER_INTERFACE, "GetProperties", &Error);
1084
1085         if (message == NULL) {
1086                 NETWORK_LOG(NETWORK_ERROR,
1087                                 "Error!!! Failed to get technology info\n");
1088                 goto done;
1089         }
1090
1091         Error = _net_get_tech_state(message, tech_state);
1092
1093         NETWORK_LOG(NETWORK_HIGH,
1094                         "technology [%s]\n"
1095                         "AvailableTechnology [%d]\n"
1096                         "EnabledTechnology [%d]\n"
1097                         "ConnectedTechnology [%d]\n"
1098                         "DefaultTechnology [%d]\n",
1099                         tech_state->technology,
1100                         tech_state->AvailableTechnology,
1101                         tech_state->EnabledTechnology,
1102                         tech_state->ConnectedTechnology,
1103                         tech_state->DefaultTechnology);
1104
1105         dbus_message_unref(message);
1106
1107 done:
1108         dbus_connection_unref(conn);
1109         __NETWORK_FUNC_EXIT__;
1110         return Error;
1111 }
1112
1113
1114 int _net_dbus_get_network_status(net_device_t device_type, net_cm_network_status_t* network_status)
1115 {
1116         __NETWORK_FUNC_ENTER__;
1117
1118         net_err_t Error = NET_ERR_NONE;
1119         network_get_tech_state_info_t tech_state = {{0,},};
1120
1121         if (device_type == NET_DEVICE_WIFI)
1122                 snprintf(tech_state.technology, NET_TECH_LENGTH_MAX, "%s", "wifi");
1123         else if (device_type == NET_DEVICE_CELLULAR)
1124                 snprintf(tech_state.technology, NET_TECH_LENGTH_MAX, "%s", "cellular");
1125         else {
1126                 Error = NET_ERR_INVALID_PARAM;
1127                 goto done;
1128         }
1129
1130         Error = _net_dbus_get_technology_state(&tech_state);
1131         if (Error != NET_ERR_NONE) {
1132                 NETWORK_LOG(NETWORK_ERROR,
1133                         "Error!!! _net_dbus_get_technology_state() failed. Error [%s]\n",
1134                         _net_print_error(Error));
1135                 goto done;
1136         }
1137
1138         if (tech_state.ConnectedTechnology == TRUE)
1139                 *network_status = NET_STATUS_AVAILABLE;
1140         else
1141                 *network_status = NET_STATUS_UNAVAILABLE;
1142
1143 done:
1144         __NETWORK_FUNC_EXIT__;
1145         return Error;
1146 }
1147
1148
1149 int _net_dbus_get_state(char* state)
1150 {
1151         __NETWORK_FUNC_ENTER__;
1152
1153         net_err_t Error = NET_ERR_NONE;
1154         DBusConnection* conn = NULL;
1155         DBusMessage *message = NULL;
1156         char *net_state = NULL;
1157
1158         conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
1159         if (conn == NULL) {
1160                 NETWORK_LOG(NETWORK_EXCEPTION,
1161                                 "Error!!! Can't get on system bus\n");
1162                 __NETWORK_FUNC_EXIT__;
1163                 return NET_ERR_UNKNOWN;
1164         }
1165
1166         message = _net_invoke_dbus_method(
1167                         CONNMAN_SERVICE, conn, CONNMAN_MANAGER_PATH,
1168                         CONNMAN_MANAGER_INTERFACE, "GetState", &Error);
1169         if (message == NULL) {
1170                 NETWORK_LOG(NETWORK_ERROR,
1171                                 "Error!!! Failed to get service properties\n");
1172                 dbus_connection_unref(conn);
1173                 __NETWORK_FUNC_EXIT__;
1174                 return Error;
1175         }
1176
1177         net_state = _net_get_string(message);
1178         snprintf(state, strlen(net_state)+1, "%s", net_state);
1179
1180         NETWORK_LOG( NETWORK_HIGH, "State : [%s]\n", state);
1181
1182         dbus_message_unref(message);
1183         dbus_connection_unref(conn);
1184
1185         __NETWORK_FUNC_EXIT__;
1186         return Error;
1187 }
1188
1189
1190 int _net_dbus_connect_service(const net_wifi_connect_service_info_t* wifi_connection_info)
1191 {
1192         __NETWORK_FUNC_ENTER__;
1193
1194         net_err_t Error = NET_ERR_NONE;
1195         DBusError error;
1196
1197         const char *prop_type = "Type";
1198         const char *prop_mode = "Mode";
1199         const char *prop_ssid = "SSID";
1200         const char *prop_security = "Security";
1201         const char *prop_passphrase = "Passphrase";
1202
1203         DBusMessage* msg = NULL;
1204         DBusMessage* reply = NULL;
1205         DBusMessageIter dict, entry, array,value;
1206         DBusConnection* conn = NULL;
1207
1208         conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
1209         if(conn == NULL) {
1210                 NETWORK_LOG(NETWORK_EXCEPTION, "Error!!! Can't get on system bus\n");
1211                 __NETWORK_FUNC_EXIT__;
1212                 return NET_ERR_UNKNOWN;
1213         }
1214
1215         msg = dbus_message_new_method_call(CONNMAN_SERVICE, CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE, "ConnectService");
1216         if(msg == NULL) {
1217                 NETWORK_LOG(NETWORK_EXCEPTION, "Error!!! dbus_message_new_method_call() failed\n");
1218                 __NETWORK_FUNC_EXIT__;
1219                 return NET_ERR_UNKNOWN;
1220         }
1221
1222         dbus_message_iter_init_append(msg, &array);
1223         dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY, "{sv}", &dict);
1224
1225         dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, 0, &entry);
1226         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &prop_type);
1227         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, DBUS_TYPE_STRING_AS_STRING, &value);
1228         dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &wifi_connection_info->type);
1229         dbus_message_iter_close_container(&entry, &value);
1230         dbus_message_iter_close_container(&dict, &entry);
1231
1232         dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, 0, &entry);
1233         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &prop_mode);
1234         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, DBUS_TYPE_STRING_AS_STRING, &value);
1235         dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &wifi_connection_info->mode);
1236         dbus_message_iter_close_container(&entry, &value);
1237         dbus_message_iter_close_container(&dict, &entry);
1238
1239         dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, 0, &entry);
1240         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &prop_ssid);
1241         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, DBUS_TYPE_STRING_AS_STRING, &value);
1242         dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &wifi_connection_info->ssid);
1243         dbus_message_iter_close_container(&entry, &value);
1244         dbus_message_iter_close_container(&dict, &entry);
1245
1246         dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, 0, &entry);
1247         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &prop_security);
1248         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, DBUS_TYPE_STRING_AS_STRING, &value);
1249         dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &wifi_connection_info->security);
1250         dbus_message_iter_close_container(&entry, &value);
1251         dbus_message_iter_close_container(&dict, &entry);
1252
1253         if( strcmp(wifi_connection_info->security, "ieee8021x") == 0 ) {
1254                 /** TODO Handle EAP */
1255         } else {
1256                 /** none, wep, psk, rsn */
1257                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, 0, &entry);
1258                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &prop_passphrase);
1259                 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, DBUS_TYPE_STRING_AS_STRING, &value);
1260                 dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &wifi_connection_info->passphrase);
1261                 dbus_message_iter_close_container(&entry, &value);
1262                 dbus_message_iter_close_container(&dict, &entry);
1263         }
1264
1265         dbus_message_iter_close_container(&array, &dict);
1266
1267         dbus_error_init(&error);
1268         reply = dbus_connection_send_with_reply_and_block(conn,
1269                         msg,
1270                         6 * DBUS_REPLY_TIMEOUT, /** Special case - here profile is created and returned so this need more time */
1271                         &error);
1272
1273         if(reply == NULL) {
1274                 if( dbus_error_is_set(&error) == TRUE ) {
1275                         NETWORK_LOG(NETWORK_ERROR,
1276                                         "Error!!! dbus_connection_send_with_reply_and_block() failed, Error[%s: %s]\n",
1277                                         error.name,
1278                                         error.message);
1279                         Error = __net_error_string_to_enum(error.name);
1280                         dbus_error_free(&error);
1281                         dbus_message_unref(msg);
1282                         __NETWORK_FUNC_EXIT__;
1283                         return Error;
1284                 }
1285                 dbus_message_unref(msg);
1286                 __NETWORK_FUNC_EXIT__;
1287                 return NET_ERR_UNKNOWN;
1288         } else {
1289                 char *ProfileName = NULL;
1290                 ProfileName = _net_get_object(reply);
1291                 NETWORK_LOG(NETWORK_HIGH, "ObjectPath/ProfileName [%s]\n", ProfileName);
1292         }
1293
1294         dbus_message_unref(reply);
1295         dbus_message_unref(msg);
1296
1297         NETWORK_LOG(NETWORK_HIGH, "Successfully configured\n");
1298
1299         dbus_connection_unref(conn);
1300         __NETWORK_FUNC_EXIT__;
1301         return Error;
1302 }
1303
1304
1305 int _net_dbus_set_profile_ipv4(net_profile_info_t* prof_info, char* profile_name)
1306 {
1307         __NETWORK_FUNC_ENTER__;
1308
1309         net_err_t Error = NET_ERR_NONE;
1310         DBusError error;
1311         const char *manual_method = "manual";
1312         const char *dhcp_method = "dhcp";
1313         const char *off_method = "off";
1314
1315         const char *prop_ipv4_configuration = "IPv4.Configuration";
1316         const char *prop_method = "Method";
1317         const char *prop_address = "Address";
1318         const char *prop_gateway = "Gateway";
1319         const char *prop_netmask = "Netmask";
1320
1321         char ip_buffer[NETPM_IPV4_STR_LEN_MAX+1] = "";
1322         char netmask_buffer[NETPM_IPV4_STR_LEN_MAX+1] = "";
1323         char gateway_buffer[NETPM_IPV4_STR_LEN_MAX+1] = "";
1324
1325         char *ipaddress = ip_buffer;
1326         char *netmask = netmask_buffer;
1327         char *gateway = gateway_buffer;
1328
1329         DBusMessage *msg = NULL;
1330         DBusMessage *reply = NULL;
1331         DBusMessageIter itr, variant, dict, entry;
1332         DBusConnection* conn = NULL;
1333
1334         if ((prof_info == NULL) || (profile_name == NULL) || (strlen(profile_name) == 0)) {
1335                 NETWORK_LOG(NETWORK_ASSERT,  "Error!!! Invalid argument\n");
1336                 __NETWORK_FUNC_EXIT__;
1337                 return NET_ERR_INVALID_PARAM;
1338         }
1339
1340         snprintf(ip_buffer, NETPM_IPV4_STR_LEN_MAX + 1, "%s",
1341                         inet_ntoa(prof_info->ProfileInfo.Wlan.net_info.IpAddr.Data.Ipv4));
1342         snprintf(netmask_buffer, NETPM_IPV4_STR_LEN_MAX + 1, "%s",
1343                         inet_ntoa(prof_info->ProfileInfo.Wlan.net_info.SubnetMask.Data.Ipv4));
1344         snprintf(gateway_buffer, NETPM_IPV4_STR_LEN_MAX + 1, "%s",
1345                         inet_ntoa(prof_info->ProfileInfo.Wlan.net_info.GatewayAddr.Data.Ipv4));
1346
1347         NETWORK_LOG(NETWORK_ASSERT, "ipaddress : %s, netmask : %s, gateway : %s\n",
1348                         ipaddress, netmask, gateway);
1349
1350         conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
1351         if (conn == NULL) {
1352                 NETWORK_LOG(NETWORK_ERROR,  "Error!!! Can't get on system bus\n");
1353                 __NETWORK_FUNC_EXIT__;
1354                 return NET_ERR_UNKNOWN;
1355         }
1356
1357         /** Send ipaddress, netmask, gateway configuration */
1358         msg = dbus_message_new_method_call(CONNMAN_SERVICE,
1359                         profile_name, CONNMAN_SERVICE_INTERFACE, "SetProperty");
1360         if (msg == NULL) {
1361                 NETWORK_LOG( NETWORK_ERROR,  "Error!!! dbus_message_new_method_call() failed\n");
1362                 dbus_connection_unref(conn);
1363                 __NETWORK_FUNC_EXIT__;
1364                 return NET_ERR_UNKNOWN;
1365         }
1366         NETWORK_LOG(NETWORK_ASSERT, "DBus Message 1/2 : %s %s %s %s\n", CONNMAN_SERVICE,
1367                         profile_name, CONNMAN_SERVICE_INTERFACE, "SetProperty");
1368
1369         dbus_message_iter_init_append(msg, &itr);
1370         dbus_message_iter_append_basic(&itr, DBUS_TYPE_STRING, &prop_ipv4_configuration);
1371
1372         dbus_message_iter_open_container
1373                 (&itr, DBUS_TYPE_VARIANT,
1374                  (DBUS_TYPE_ARRAY_AS_STRING
1375                   DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1376                   DBUS_TYPE_STRING_AS_STRING
1377                   DBUS_TYPE_STRING_AS_STRING
1378                   DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
1379                  &variant);
1380         dbus_message_iter_open_container
1381                 (&variant, DBUS_TYPE_ARRAY,
1382                  (DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1383                   DBUS_TYPE_STRING_AS_STRING
1384                   DBUS_TYPE_STRING_AS_STRING
1385                   DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
1386                  &dict);
1387
1388         if (prof_info->ProfileInfo.Wlan.net_info.IpConfigType == NET_IP_CONFIG_TYPE_DYNAMIC ||
1389             prof_info->ProfileInfo.Wlan.net_info.IpConfigType == NET_IP_CONFIG_TYPE_AUTO_IP) {
1390                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1391                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &prop_method);
1392                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &dhcp_method);
1393                 dbus_message_iter_close_container(&dict, &entry);
1394                 NETWORK_LOG(NETWORK_ASSERT,  "DBus Message 2/2 : %s %s\n", prop_method, dhcp_method);
1395         } else if (prof_info->ProfileInfo.Wlan.net_info.IpConfigType == NET_IP_CONFIG_TYPE_OFF) {
1396                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1397                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &prop_method);
1398                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &off_method);
1399                 dbus_message_iter_close_container(&dict, &entry);
1400                 NETWORK_LOG(NETWORK_ASSERT,  "DBus Message 2/2 : %s %s\n", prop_method, off_method);
1401         } else if (prof_info->ProfileInfo.Wlan.net_info.IpConfigType == NET_IP_CONFIG_TYPE_STATIC) {
1402                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1403                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &prop_method);
1404                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &manual_method);
1405                 dbus_message_iter_close_container(&dict, &entry);
1406
1407                 if (strlen(ipaddress) >= NETPM_IPV4_STR_LEN_MIN) {
1408                         dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1409                         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &prop_address);
1410                         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &ipaddress);
1411                         dbus_message_iter_close_container(&dict, &entry);
1412                 }
1413
1414                 if (strlen(netmask) >= NETPM_IPV4_STR_LEN_MIN) {
1415                         dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1416                         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &prop_netmask);
1417                         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &netmask);
1418                         dbus_message_iter_close_container(&dict, &entry);
1419                 }
1420
1421                 if (strlen(gateway) >= NETPM_IPV4_STR_LEN_MIN) {
1422                         dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1423                         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &prop_gateway);
1424                         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &gateway);
1425                         dbus_message_iter_close_container(&dict, &entry);
1426                 }
1427                 NETWORK_LOG(NETWORK_ASSERT,  "DBus Message 2/2 : %s %s %s %s %s %s %s %s\n",
1428                                 prop_method, manual_method, prop_address, ipaddress,
1429                                 prop_netmask, netmask, prop_gateway, gateway);
1430         } else {
1431                 NETWORK_LOG(NETWORK_ASSERT,  "Error!!! Invalid argument\n");
1432                 __NETWORK_FUNC_EXIT__;
1433                 return NET_ERR_INVALID_PARAM;
1434         }
1435
1436         dbus_message_iter_close_container(&variant, &dict);
1437         dbus_message_iter_close_container(&itr, &variant);
1438
1439         dbus_error_init(&error);
1440
1441         reply = dbus_connection_send_with_reply_and_block(conn,
1442                         msg, DBUS_REPLY_TIMEOUT,
1443                         &error);
1444
1445         if (reply == NULL) {
1446                 if (dbus_error_is_set (&error) == TRUE) {
1447                         NETWORK_LOG(NETWORK_ERROR,
1448                                 "Error!!! dbus_connection_send_with_reply_and_block() failed, Error[%s: %s]\n",
1449                                 error.name,
1450                                 error.message);
1451                         Error = __net_error_string_to_enum(error.name);
1452                         dbus_error_free(&error);
1453                         dbus_message_unref(msg);
1454                         __NETWORK_FUNC_EXIT__;
1455                         return Error;
1456                 }
1457
1458                 dbus_message_unref(msg);
1459                 __NETWORK_FUNC_EXIT__;
1460                 return NET_ERR_UNKNOWN;
1461         }
1462
1463         dbus_message_unref(reply);
1464         dbus_message_unref(msg);
1465
1466         NETWORK_LOG(NETWORK_HIGH, "Successfully configured IPv4.Configuration\n");
1467
1468         dbus_connection_unref(conn);
1469
1470         __NETWORK_FUNC_EXIT__;
1471         return NET_ERR_NONE;
1472 }
1473
1474 int _net_dbus_set_profile_dns(net_profile_info_t* prof_info, char* profile_name)
1475 {
1476         __NETWORK_FUNC_ENTER__;
1477
1478         net_err_t Error = NET_ERR_NONE;
1479         DBusError error;
1480
1481         const char *prop_nameserver_configuration = "Nameservers.Configuration";
1482         char dns_buffer[NET_DNS_ADDR_MAX][NETPM_IPV4_STR_LEN_MAX+1];
1483         char *dns_address[NET_DNS_ADDR_MAX];
1484
1485         DBusMessage *msg = NULL;
1486         DBusMessage *reply = NULL;
1487         DBusMessageIter itr;
1488         DBusConnection* conn = NULL;
1489         int i = 0;
1490
1491         if ((prof_info == NULL) || (profile_name == NULL) || (strlen(profile_name) == 0) ||
1492             (prof_info->ProfileInfo.Wlan.net_info.DnsCount > NET_DNS_ADDR_MAX)) {
1493                 NETWORK_LOG(NETWORK_ASSERT,  "Error!!! Invalid parameter\n");
1494                 __NETWORK_FUNC_EXIT__;
1495                 return NET_ERR_INVALID_PARAM;
1496         }
1497
1498         for (i = 0;i < prof_info->ProfileInfo.Wlan.net_info.DnsCount;i++) {
1499                 dns_buffer[i][0] = '\0';
1500                 dns_address[i] = NULL;
1501
1502                 snprintf(dns_buffer[i],  NETPM_IPV4_STR_LEN_MAX + 1, "%s",
1503                                 inet_ntoa(prof_info->ProfileInfo.Wlan.net_info.DnsAddr[i].Data.Ipv4));
1504                 if (strlen(dns_buffer[i]) >= NETPM_IPV4_STR_LEN_MIN)
1505                         dns_address[i] = dns_buffer[i];
1506         }
1507
1508         conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
1509         if (conn == NULL) {
1510                 NETWORK_LOG(NETWORK_ERROR,  "Error!!! Can't get on system bus\n");
1511                 __NETWORK_FUNC_EXIT__;
1512                 return NET_ERR_UNKNOWN;
1513         }
1514
1515         if (prof_info->ProfileInfo.Wlan.net_info.IpConfigType == NET_IP_CONFIG_TYPE_STATIC) {
1516                 msg = dbus_message_new_method_call(CONNMAN_SERVICE,
1517                                 profile_name, CONNMAN_SERVICE_INTERFACE, "SetProperty");
1518
1519                 if (msg == NULL) {
1520                         NETWORK_LOG(NETWORK_ERROR,
1521                                         "Error!!! dbus_message_new_method_call() failed\n");
1522                         __NETWORK_FUNC_EXIT__;
1523                         return NET_ERR_UNKNOWN;
1524                 }
1525
1526                 dbus_message_iter_init_append(msg, &itr);
1527                 dbus_message_iter_append_basic(&itr, DBUS_TYPE_STRING, &prop_nameserver_configuration);
1528
1529                 DBusMessageIter value, array;
1530                 dbus_message_iter_open_container(&itr, DBUS_TYPE_VARIANT,
1531                                 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING, &value);
1532
1533                 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
1534                                 DBUS_TYPE_STRING_AS_STRING, &array);
1535
1536                 for (i = 0;i < prof_info->ProfileInfo.Wlan.net_info.DnsCount;i++) {
1537                         dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING, &(dns_address[i]));
1538                 }
1539
1540                 dbus_message_iter_close_container(&value, &array);
1541                 dbus_message_iter_close_container(&itr, &value);
1542
1543                 dbus_error_init(&error);
1544
1545                 reply = dbus_connection_send_with_reply_and_block(conn,
1546                                 msg, DBUS_REPLY_TIMEOUT,
1547                                 &error);
1548
1549                 if (reply == NULL) {
1550                         if (dbus_error_is_set (&error) == TRUE) {
1551                                 NETWORK_LOG(NETWORK_ERROR,
1552                                                 "Error!!! dbus_connection_send_with_reply_and_block() failed, Error[%s: %s]\n",
1553                                                 error.name,
1554                                                 error.message);
1555                                 Error = __net_error_string_to_enum(error.name);
1556                                 dbus_error_free(&error);
1557                                 dbus_message_unref(msg);
1558                                 __NETWORK_FUNC_EXIT__;
1559                                 return Error;
1560                         }
1561                         dbus_message_unref(msg);
1562                         __NETWORK_FUNC_EXIT__;
1563                         return NET_ERR_UNKNOWN;
1564                 }
1565                 dbus_message_unref(reply);
1566                 dbus_message_unref(msg);
1567                 NETWORK_LOG(NETWORK_HIGH, "Successfully configured Nameservers.Configuration\n");
1568         }
1569
1570         __NETWORK_FUNC_EXIT__;
1571         return NET_ERR_NONE;
1572 }
1573
1574 int _net_dbus_set_proxy(net_profile_info_t* prof_info, char* profile_name)
1575 {
1576         __NETWORK_FUNC_ENTER__;
1577
1578         net_err_t Error = NET_ERR_NONE;
1579         DBusError error;
1580
1581         const char *direct_method = "direct"; /* not method[] as gcc screws it with dbus */
1582         const char *auto_method = "auto"; /* not method[] as gcc screws it with dbus */
1583         const char *manual_method = "manual"; /* not method[] as gcc screws it with dbus */
1584
1585         const char *prop_proxy_configuration = "Proxy.Configuration";
1586         const char *prop_method = "Method";
1587         const char *prop_url = "URL";
1588         const char *prop_servers = "Servers";
1589
1590         char proxy_buffer[NET_PROXY_LEN_MAX+1] = "";
1591         char *proxy_address = proxy_buffer;
1592
1593         DBusMessage *msg = NULL;
1594         DBusMessage *reply = NULL;
1595         DBusMessageIter itr, variant, dict, entry, sub_variant, str_array;
1596         DBusConnection* conn = NULL;
1597
1598         snprintf(proxy_buffer, NET_PROXY_LEN_MAX + 1, "%s", prof_info->ProfileInfo.Wlan.net_info.ProxyAddr);
1599
1600         NETWORK_LOG(NETWORK_ASSERT, "Method : %d, proxy address : %s\n",
1601                         prof_info->ProfileInfo.Wlan.net_info.ProxyMethod, proxy_address);
1602
1603         if ((prof_info == NULL) || (profile_name == NULL) || (strlen(profile_name) == 0)) {
1604                 NETWORK_LOG(NETWORK_ASSERT,  "Error!!! Invalid argument\n");
1605                 __NETWORK_FUNC_EXIT__;
1606                 return NET_ERR_INVALID_PARAM;
1607         }
1608
1609         conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
1610         if (conn == NULL) {
1611                 NETWORK_LOG(NETWORK_ERROR,  "Error!!! Can't get on system bus\n");
1612                 __NETWORK_FUNC_EXIT__;
1613                 return NET_ERR_UNKNOWN;
1614         }
1615
1616         /** Send proxy method, url, servers configuration */
1617         msg = dbus_message_new_method_call(CONNMAN_SERVICE, profile_name,
1618                         CONNMAN_SERVICE_INTERFACE, "SetProperty");
1619         if (msg == NULL) {
1620                 NETWORK_LOG(NETWORK_ERROR,  "Error!!! dbus_message_new_method_call() failed\n");
1621                 __NETWORK_FUNC_EXIT__;
1622                 return NET_ERR_UNKNOWN;
1623         }
1624
1625         dbus_message_iter_init_append(msg, &itr);
1626         dbus_message_iter_append_basic(&itr, DBUS_TYPE_STRING, &prop_proxy_configuration);
1627
1628         dbus_message_iter_open_container
1629                 (&itr, DBUS_TYPE_VARIANT,
1630                  (DBUS_TYPE_ARRAY_AS_STRING
1631                   DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1632                   DBUS_TYPE_STRING_AS_STRING
1633                   DBUS_TYPE_VARIANT_AS_STRING
1634                   DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
1635                  &variant);
1636         dbus_message_iter_open_container
1637                 (&variant, DBUS_TYPE_ARRAY,
1638                  (DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1639                   DBUS_TYPE_STRING_AS_STRING
1640                   DBUS_TYPE_VARIANT_AS_STRING
1641                   DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
1642                  &dict);
1643
1644         dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1645         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &prop_method);
1646
1647         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
1648                         DBUS_TYPE_STRING_AS_STRING, &sub_variant);
1649
1650         switch (prof_info->ProfileInfo.Wlan.net_info.ProxyMethod) {
1651         case NET_PROXY_TYPE_AUTO:
1652                 dbus_message_iter_append_basic(&sub_variant, DBUS_TYPE_STRING, &auto_method);
1653                 break;
1654         case NET_PROXY_TYPE_MANUAL:
1655                 dbus_message_iter_append_basic(&sub_variant, DBUS_TYPE_STRING, &manual_method);
1656                 break;
1657         default:
1658                 dbus_message_iter_append_basic(&sub_variant, DBUS_TYPE_STRING, &direct_method);
1659                 break;
1660         }
1661
1662         dbus_message_iter_close_container(&entry, &sub_variant);
1663         dbus_message_iter_close_container(&dict, &entry);
1664
1665         if (prof_info->ProfileInfo.Wlan.net_info.ProxyMethod == NET_PROXY_TYPE_AUTO) {
1666                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1667                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &prop_url);
1668
1669                 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
1670                                 DBUS_TYPE_STRING_AS_STRING, &sub_variant);
1671                 dbus_message_iter_append_basic(&sub_variant, DBUS_TYPE_STRING, &proxy_address);
1672
1673                 dbus_message_iter_close_container(&entry, &sub_variant);
1674                 dbus_message_iter_close_container(&dict, &entry);
1675         }
1676
1677         if (prof_info->ProfileInfo.Wlan.net_info.ProxyMethod == NET_PROXY_TYPE_MANUAL) {
1678                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1679                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &prop_servers);
1680
1681                 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
1682                                 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING, &sub_variant);
1683
1684                 dbus_message_iter_open_container(&sub_variant, DBUS_TYPE_ARRAY,
1685                                 DBUS_TYPE_STRING_AS_STRING, &str_array);
1686                 dbus_message_iter_append_basic(&str_array, DBUS_TYPE_STRING, &proxy_address);
1687
1688                 dbus_message_iter_close_container(&sub_variant, &str_array);
1689                 dbus_message_iter_close_container(&entry, &sub_variant);
1690                 dbus_message_iter_close_container(&dict, &entry);
1691         }
1692
1693         dbus_message_iter_close_container(&variant, &dict);
1694         dbus_message_iter_close_container(&itr, &variant);
1695
1696         dbus_error_init(&error);
1697
1698         reply = dbus_connection_send_with_reply_and_block(conn,
1699                         msg, DBUS_REPLY_TIMEOUT,
1700                         &error);
1701
1702         if (reply == NULL) {
1703                 if (dbus_error_is_set(&error) == TRUE) {
1704                         NETWORK_LOG( NETWORK_ERROR,
1705                                         "Error!!! dbus_connection_send_with_reply_and_block() failed, Error[%s: %s]\n",
1706                                         error.name,
1707                                         error.message);
1708                         Error = __net_error_string_to_enum(error.name);
1709                         dbus_error_free(&error);
1710                         dbus_message_unref(msg);
1711                         __NETWORK_FUNC_EXIT__;
1712                         return Error;
1713                 }
1714
1715                 dbus_message_unref(msg);
1716                 __NETWORK_FUNC_EXIT__;
1717                 return NET_ERR_UNKNOWN;
1718         }
1719
1720         dbus_message_unref(reply);
1721         dbus_message_unref(msg);
1722
1723         NETWORK_LOG( NETWORK_HIGH, "Successfully configured Proxy.Configuration\n");
1724
1725         dbus_connection_unref(conn);
1726
1727         __NETWORK_FUNC_EXIT__;
1728         return NET_ERR_NONE;
1729 }
1730
1731
1732 int _net_dbus_add_pdp_profile(net_profile_info_t *prof_info)
1733 {
1734         __NETWORK_FUNC_ENTER__;
1735
1736         net_err_t Error = NET_ERR_NONE;
1737         DBusError error;
1738         const char *service_type = "svc_ctg_id";
1739         const char *home_url = "home_url";
1740         const char *proxy_addr = "proxy_addr";
1741         const char *auth_pwd = "auth_pwd";
1742         const char *auth_type = "auth_type";
1743         const char *auth_id = "auth_id";
1744         const char *apn = "apn";
1745
1746         char buff_svc_type[10] = "";
1747         char buff_auth_type[10] = "";
1748         char *temp_ptr = NULL;
1749
1750         DBusMessage *msg = NULL;
1751         DBusMessage *reply = NULL;
1752         DBusMessageIter iter, dict, entry;
1753         DBusConnection* conn = NULL;
1754
1755         if (prof_info == NULL) {
1756                 NETWORK_LOG(NETWORK_ASSERT, "Error!!! Invalid argument\n");
1757                 __NETWORK_FUNC_EXIT__;
1758                 return NET_ERR_INVALID_PARAM;
1759         }
1760
1761         conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
1762         if (conn == NULL) {
1763                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Can't get on system bus\n");
1764                 __NETWORK_FUNC_EXIT__;
1765                 return NET_ERR_UNKNOWN;
1766         }
1767
1768         /** Create message */
1769         msg = dbus_message_new_method_call(TELEPHONY_SERVCE,
1770                         TELEPHONY_MASTER_PATH, TELEPHONY_MASTER_INTERFACE, "AddProfile");
1771         if (msg == NULL) {
1772                 NETWORK_LOG(NETWORK_ERROR, "Error!!! dbus_message_new_method_call() failed\n");
1773                 dbus_connection_unref(conn);
1774                 __NETWORK_FUNC_EXIT__;
1775                 return NET_ERR_UNKNOWN;
1776         }
1777
1778         NETWORK_LOG(NETWORK_ASSERT, "DBus Message 1/2 : %s %s %s %s\n", TELEPHONY_SERVCE,
1779                         TELEPHONY_MASTER_PATH, TELEPHONY_MASTER_INTERFACE, ".AddProfile");
1780
1781         dbus_message_iter_init_append(msg, &iter);
1782
1783         dbus_message_iter_open_container
1784                 (&iter, DBUS_TYPE_ARRAY,
1785                  (DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1786                   DBUS_TYPE_STRING_AS_STRING
1787                   DBUS_TYPE_STRING_AS_STRING
1788                   DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
1789                  &dict);
1790
1791         if (prof_info->ProfileInfo.Pdp.ServiceType > NET_SERVICE_UNKNOWN &&
1792             prof_info->ProfileInfo.Pdp.ServiceType <= NET_SERVICE_PREPAID_MMS) {
1793                 snprintf(buff_svc_type, 10, "%d", prof_info->ProfileInfo.Pdp.ServiceType);
1794                 temp_ptr = buff_svc_type;
1795
1796                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1797                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &service_type);
1798                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &temp_ptr);
1799                 dbus_message_iter_close_container(&dict, &entry);
1800
1801                 NETWORK_LOG(NETWORK_ASSERT, "DBus Message 2/2 : %s : %s\n",
1802                                 service_type, temp_ptr);
1803         }
1804
1805         if (strlen(prof_info->ProfileInfo.Pdp.HomeURL) > 0) {
1806                 temp_ptr = prof_info->ProfileInfo.Pdp.HomeURL;
1807
1808                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1809                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &home_url);
1810                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &temp_ptr);
1811                 dbus_message_iter_close_container(&dict, &entry);
1812
1813                 NETWORK_LOG(NETWORK_ASSERT, "DBus Message 2/2 : %s : %s\n",
1814                                 home_url, temp_ptr);
1815         }
1816
1817         if (strlen(prof_info->ProfileInfo.Pdp.net_info.ProxyAddr) > 0) {
1818                 temp_ptr = prof_info->ProfileInfo.Pdp.net_info.ProxyAddr;
1819
1820                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1821                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &proxy_addr);
1822                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &temp_ptr);
1823                 dbus_message_iter_close_container(&dict, &entry);
1824
1825                 NETWORK_LOG(NETWORK_ASSERT, "DBus Message 2/2 : %s : %s\n",
1826                                 proxy_addr, temp_ptr);
1827         }
1828
1829         if (strlen(prof_info->ProfileInfo.Pdp.AuthInfo.Password) > 0) {
1830                 temp_ptr = prof_info->ProfileInfo.Pdp.AuthInfo.Password;
1831
1832                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1833                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &auth_pwd);
1834                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &temp_ptr);
1835                 dbus_message_iter_close_container(&dict, &entry);
1836
1837                 NETWORK_LOG(NETWORK_ASSERT, "DBus Message 2/2 : %s : %s\n",
1838                                 auth_pwd, temp_ptr);
1839         }
1840
1841         if (strlen(prof_info->ProfileInfo.Pdp.AuthInfo.UserName) > 0) {
1842                 temp_ptr = prof_info->ProfileInfo.Pdp.AuthInfo.UserName;
1843
1844                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1845                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &auth_id);
1846                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &temp_ptr);
1847                 dbus_message_iter_close_container(&dict, &entry);
1848
1849                 NETWORK_LOG(NETWORK_ASSERT, "DBus Message 2/2 : %s : %s\n",
1850                                 auth_id, temp_ptr);
1851         }
1852
1853         if (prof_info->ProfileInfo.Pdp.AuthInfo.AuthType >= NET_PDP_AUTH_NONE &&
1854             prof_info->ProfileInfo.Pdp.AuthInfo.AuthType <= NET_PDP_AUTH_CHAP) {
1855                 snprintf(buff_auth_type, 10, "%d", prof_info->ProfileInfo.Pdp.AuthInfo.AuthType);
1856                 temp_ptr = buff_auth_type;
1857
1858                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1859                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &auth_type);
1860                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &temp_ptr);
1861                 dbus_message_iter_close_container(&dict, &entry);
1862
1863                 NETWORK_LOG(NETWORK_ASSERT, "DBus Message 2/2 : %s : %s\n",
1864                                 auth_type, temp_ptr);
1865         }
1866
1867         if (strlen(prof_info->ProfileInfo.Pdp.Apn) > 0) {
1868                 temp_ptr = prof_info->ProfileInfo.Pdp.Apn;
1869
1870                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1871                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &apn);
1872                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &temp_ptr);
1873                 dbus_message_iter_close_container(&dict, &entry);
1874
1875                 NETWORK_LOG(NETWORK_ASSERT, "DBus Message 2/2 : %s : %s\n",
1876                                 apn, temp_ptr);
1877         }
1878
1879         dbus_message_iter_close_container(&iter, &dict);
1880         dbus_error_init(&error);
1881
1882         /** Send message */
1883         reply = dbus_connection_send_with_reply_and_block(conn,
1884                         msg, DBUS_REPLY_TIMEOUT,
1885                         &error);
1886
1887         /** Check Error */
1888         if (reply == NULL) {
1889                 if (dbus_error_is_set (&error) == TRUE) {
1890                         NETWORK_LOG(NETWORK_ERROR,
1891                                 "Error!!! dbus_connection_send_with_reply_and_block() failed, Error[%s: %s]\n",
1892                                 error.name,
1893                                 error.message);
1894                         Error = __net_error_string_to_enum(error.name);
1895                         dbus_error_free(&error);
1896                         dbus_message_unref(msg);
1897                         __NETWORK_FUNC_EXIT__;
1898                         return Error;
1899                 }
1900
1901                 dbus_message_unref(msg);
1902                 dbus_connection_unref(conn);
1903                 __NETWORK_FUNC_EXIT__;
1904                 return NET_ERR_UNKNOWN;
1905         } else
1906                 NETWORK_LOG(NETWORK_HIGH, "Successfully requested : Add PDP profile\n");
1907
1908         /** Check Reply */
1909         DBusMessageIter iter2;
1910         int add_result = 0;
1911
1912         dbus_message_iter_init(reply, &iter2);
1913         if (dbus_message_iter_get_arg_type(&iter2) == DBUS_TYPE_BOOLEAN) {
1914                 dbus_message_iter_get_basic(&iter2, &add_result);
1915                 NETWORK_LOG(NETWORK_HIGH, "Profile add result : %d\n", add_result);
1916         }
1917
1918         if (add_result)
1919                 Error = NET_ERR_NONE;
1920         else
1921                 Error = NET_ERR_UNKNOWN;
1922
1923         dbus_message_unref(reply);
1924         dbus_message_unref(msg);
1925         dbus_connection_unref(conn);
1926
1927         __NETWORK_FUNC_EXIT__;
1928         return Error;
1929 }
1930
1931
1932 int _net_dbus_modify_pdp_profile(net_profile_info_t *prof_info, const char *profile_name)
1933 {
1934         __NETWORK_FUNC_ENTER__;
1935
1936         net_err_t Error = NET_ERR_NONE;
1937
1938         DBusError error;
1939         const char *service_type = "svc_ctg_id";
1940         const char *home_url = "home_url";
1941         const char *proxy_addr = "proxy_addr";
1942         const char *auth_pwd = "auth_pwd";
1943         const char *auth_type = "auth_type";
1944         const char *auth_id = "auth_id";
1945         const char *apn = "apn";
1946
1947         char buff_svc_type[10] = "";
1948         char buff_auth_type[10] = "";
1949         char *temp_ptr = NULL;
1950
1951         DBusMessage *msg = NULL;
1952         DBusMessage *reply = NULL;
1953         DBusMessageIter iter, dict, entry;
1954         DBusConnection* conn = NULL;
1955
1956         if ((prof_info == NULL) || (profile_name == NULL)) {
1957                 NETWORK_LOG(NETWORK_ASSERT, "Error!!! Invalid argument\n");
1958                 __NETWORK_FUNC_EXIT__;
1959                 return NET_ERR_INVALID_PARAM;
1960         }
1961
1962         conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
1963         if (conn == NULL) {
1964                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Can't get on system bus\n");
1965                 __NETWORK_FUNC_EXIT__;
1966                 return NET_ERR_UNKNOWN;
1967         }
1968
1969         /** Create message */
1970         msg = dbus_message_new_method_call(TELEPHONY_SERVCE,
1971                         profile_name, TELEPHONY_PROFILE_INTERFACE, "ModifyProfile");
1972         if (msg == NULL) {
1973                 NETWORK_LOG(NETWORK_ERROR, "Error!!! dbus_message_new_method_call() failed\n");
1974                 dbus_connection_unref(conn);
1975                 __NETWORK_FUNC_EXIT__;
1976                 return NET_ERR_UNKNOWN;
1977         }
1978
1979         NETWORK_LOG(NETWORK_ASSERT, "DBus Message 1/2 : %s %s %s %s\n", TELEPHONY_SERVCE,
1980                         profile_name, TELEPHONY_PROFILE_INTERFACE, ".ModifyProfile");
1981
1982         dbus_message_iter_init_append(msg, &iter);
1983
1984         dbus_message_iter_open_container
1985                 (&iter, DBUS_TYPE_ARRAY,
1986                  (DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1987                   DBUS_TYPE_STRING_AS_STRING
1988                   DBUS_TYPE_STRING_AS_STRING
1989                   DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
1990                  &dict);
1991
1992         if (prof_info->ProfileInfo.Pdp.ServiceType > NET_SERVICE_UNKNOWN &&
1993             prof_info->ProfileInfo.Pdp.ServiceType <= NET_SERVICE_PREPAID_MMS) {
1994                 snprintf(buff_svc_type, 10, "%d", prof_info->ProfileInfo.Pdp.ServiceType);
1995                 temp_ptr = buff_svc_type;
1996
1997                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1998                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &service_type);
1999                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &temp_ptr);
2000                 dbus_message_iter_close_container(&dict, &entry);
2001
2002                 NETWORK_LOG(NETWORK_ASSERT, "DBus Message 2/2 : %s : %s\n",
2003                                 service_type, temp_ptr);
2004         }
2005
2006         if (strlen(prof_info->ProfileInfo.Pdp.HomeURL) > 0) {
2007                 temp_ptr = prof_info->ProfileInfo.Pdp.HomeURL;
2008
2009                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
2010                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &home_url);
2011                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &temp_ptr);
2012                 dbus_message_iter_close_container(&dict, &entry);
2013
2014                 NETWORK_LOG(NETWORK_ASSERT, "DBus Message 2/2 : %s : %s\n",
2015                                 home_url, temp_ptr);
2016         }
2017
2018         if (strlen(prof_info->ProfileInfo.Pdp.net_info.ProxyAddr) > 0) {
2019                 temp_ptr = prof_info->ProfileInfo.Pdp.net_info.ProxyAddr;
2020
2021                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
2022                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &proxy_addr);
2023                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &temp_ptr);
2024                 dbus_message_iter_close_container(&dict, &entry);
2025
2026                 NETWORK_LOG(NETWORK_ASSERT, "DBus Message 2/2 : %s : %s\n",
2027                                 proxy_addr, temp_ptr);
2028         }
2029
2030         if (strlen(prof_info->ProfileInfo.Pdp.AuthInfo.Password) > 0) {
2031                 temp_ptr = prof_info->ProfileInfo.Pdp.AuthInfo.Password;
2032
2033                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
2034                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &auth_pwd);
2035                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &temp_ptr);
2036                 dbus_message_iter_close_container(&dict, &entry);
2037
2038                 NETWORK_LOG(NETWORK_ASSERT, "DBus Message 2/2 : %s : %s\n",
2039                                 auth_pwd, temp_ptr);
2040         }
2041
2042         if (strlen(prof_info->ProfileInfo.Pdp.AuthInfo.UserName) > 0) {
2043                 temp_ptr = prof_info->ProfileInfo.Pdp.AuthInfo.UserName;
2044
2045                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
2046                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &auth_id);
2047                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &temp_ptr);
2048                 dbus_message_iter_close_container(&dict, &entry);
2049
2050                 NETWORK_LOG(NETWORK_ASSERT, "DBus Message 2/2 : %s : %s\n",
2051                                 auth_id, temp_ptr);
2052         }
2053
2054         if (prof_info->ProfileInfo.Pdp.AuthInfo.AuthType >= NET_PDP_AUTH_NONE &&
2055             prof_info->ProfileInfo.Pdp.AuthInfo.AuthType <= NET_PDP_AUTH_CHAP) {
2056                 snprintf(buff_auth_type, 10, "%d", prof_info->ProfileInfo.Pdp.AuthInfo.AuthType);
2057                 temp_ptr = buff_auth_type;
2058
2059                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
2060                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &auth_type);
2061                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &temp_ptr);
2062                 dbus_message_iter_close_container(&dict, &entry);
2063
2064                 NETWORK_LOG(NETWORK_ASSERT, "DBus Message 2/2 : %s : %s\n",
2065                                 auth_type, temp_ptr);
2066         }
2067
2068         if (strlen(prof_info->ProfileInfo.Pdp.Apn) > 0) {
2069                 temp_ptr = prof_info->ProfileInfo.Pdp.Apn;
2070
2071                 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
2072                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &apn);
2073                 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &temp_ptr);
2074                 dbus_message_iter_close_container(&dict, &entry);
2075
2076                 NETWORK_LOG(NETWORK_ASSERT, "DBus Message 2/2 : %s : %s\n",
2077                                 apn, temp_ptr);
2078         }
2079
2080         dbus_message_iter_close_container(&iter, &dict);
2081         dbus_error_init(&error);
2082
2083         /** Send message */
2084         reply = dbus_connection_send_with_reply_and_block(conn,
2085                         msg, DBUS_REPLY_TIMEOUT,
2086                         &error);
2087
2088         /** Check Error */
2089         if (reply == NULL) {
2090                 if (dbus_error_is_set (&error) == TRUE) {
2091                         NETWORK_LOG(NETWORK_ERROR,
2092                                 "Error!!! dbus_connection_send_with_reply_and_block() failed, Error[%s: %s]\n",
2093                                 error.name,
2094                                 error.message);
2095                         Error = __net_error_string_to_enum(error.name);
2096                         dbus_error_free(&error);
2097                         dbus_message_unref(msg);
2098                         __NETWORK_FUNC_EXIT__;
2099                         return Error;
2100                 }
2101
2102                 dbus_message_unref(msg);
2103                 dbus_connection_unref(conn);
2104                 __NETWORK_FUNC_EXIT__;
2105                 return NET_ERR_UNKNOWN;
2106         } else
2107                 NETWORK_LOG(NETWORK_HIGH, "Successfully requested : Modify PDP profile\n");
2108
2109         /** Check Reply */
2110         DBusMessageIter iter2;
2111         int add_result = 0;
2112
2113         dbus_message_iter_init(reply, &iter2);
2114         if (dbus_message_iter_get_arg_type(&iter2) == DBUS_TYPE_BOOLEAN) {
2115                 dbus_message_iter_get_basic(&iter2, &add_result);
2116                 NETWORK_LOG(NETWORK_HIGH, "Profile modify result : %d\n", add_result);
2117         }
2118
2119         if (add_result)
2120                 Error = NET_ERR_NONE;
2121         else
2122                 Error = NET_ERR_UNKNOWN;
2123
2124         dbus_message_unref(reply);
2125         dbus_message_unref(msg);
2126         dbus_connection_unref(conn);
2127
2128         __NETWORK_FUNC_EXIT__;
2129         return Error;
2130 }
2131
2132
2133 int _net_dbus_load_wifi_driver(void)
2134 {
2135         __NETWORK_FUNC_ENTER__;
2136
2137         net_err_t Error = NET_ERR_NONE;
2138         DBusConnection* conn = NULL;
2139
2140         conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
2141
2142         if (conn == NULL) {
2143                 NETWORK_LOG(NETWORK_EXCEPTION, "Error!!! Can't get on system bus\n");
2144                 __NETWORK_FUNC_EXIT__;
2145                 return NET_ERR_UNKNOWN;
2146         }
2147
2148         NETWORK_LOG(NETWORK_HIGH,  "Requesting [%s %s]\n",
2149                         NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE ".LoadDriver");
2150
2151         Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE, conn, NETCONFIG_WIFI_PATH,
2152                         NETCONFIG_WIFI_INTERFACE, "LoadDriver", __net_wifi_power_reply);
2153
2154         dbus_connection_unref(conn);
2155
2156         __NETWORK_FUNC_EXIT__;
2157         return Error;
2158 }
2159
2160 int _net_dbus_remove_wifi_driver(void)
2161 {
2162         __NETWORK_FUNC_ENTER__;
2163
2164         net_err_t Error = NET_ERR_NONE;
2165         DBusConnection* conn = NULL;
2166
2167         conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
2168
2169         if (conn == NULL) {
2170                 NETWORK_LOG(NETWORK_EXCEPTION, "Error!!! Can't get on system bus\n");
2171                 __NETWORK_FUNC_EXIT__;
2172                 return NET_ERR_UNKNOWN;
2173         }
2174
2175         NETWORK_LOG(NETWORK_HIGH,  "Requesting [%s %s]\n",
2176                         NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE ".RemoveDriver");
2177
2178         Error = _net_invoke_dbus_method_nonblock(NETCONFIG_SERVICE, conn, NETCONFIG_WIFI_PATH,
2179                         NETCONFIG_WIFI_INTERFACE, "RemoveDriver", __net_wifi_power_reply);
2180
2181         dbus_connection_unref(conn);
2182
2183         __NETWORK_FUNC_EXIT__;
2184         return Error;
2185 }
2186
2187 dbus_bool_t _net_dbus_is_pending_call_used(void)
2188 {
2189         return network_dbus_pending_call_data.is_used;
2190 }
2191
2192 void _net_dbus_set_pending_call_used(dbus_bool_t used)
2193 {
2194         network_dbus_pending_call_data.is_used = used;
2195 }
2196
2197 DBusPendingCall *_net_dbus_get_pending_call(void)
2198 {
2199         return network_dbus_pending_call_data.pcall;
2200 }
2201
2202 void _net_dbus_set_pending_call(DBusPendingCall *call)
2203 {
2204         network_dbus_pending_call_data.pcall = call;
2205 }
2206
2207 #ifdef __cplusplus
2208 }
2209 #endif /* __cplusplus */