src/dbus.c

   1 /*
   2  * Network Configuration Module
   3  *
   4  * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Danny JS Seo <S.Seo@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <stdlib.h>
  25
  26 #include "dbus.h"
  27 #include "log.h"
  28 #include "netconfig.h"
  29
  30 #define NETCONFIG_DBUS_REPLY_TIMEOUT (10 * 1000)
  31
  32 #define DBUS_PARAM_TYPE_STRING          "string"
  33 #define DBUS_PARAM_TYPE_INT16           "int16"
  34 #define DBUS_PARAM_TYPE_UINT16          "uint16"
  35 #define DBUS_PARAM_TYPE_INT32           "int32"
  36 #define DBUS_PARAM_TYPE_UINT32          "uint32"
  37 #define DBUS_PARAM_TYPE_INT64           "int64"
  38 #define DBUS_PARAM_TYPE_UINT64          "uint64"
  39 #define DBUS_PARAM_TYPE_DOUBLE          "double"
  40 #define DBUS_PARAM_TYPE_BYTE            "byte"
  41 #define DBUS_PARAM_TYPE_BOOLEAN         "boolean"
  42 #define DBUS_PARAM_TYPE_OBJECT_PATH     "objpath"
  43
  44 static int __neconfig_dbus_datatype_from_stringname(const char *Args)
  45 {
  46         int ArgType = 0;
  47
  48         if (!strcmp(Args, DBUS_PARAM_TYPE_STRING))
  49                 ArgType = DBUS_TYPE_STRING;
  50         else if (!strcmp(Args, DBUS_PARAM_TYPE_INT16))
  51                 ArgType = DBUS_TYPE_INT16;
  52         else if (!strcmp(Args, DBUS_PARAM_TYPE_UINT16))
  53                 ArgType = DBUS_TYPE_UINT16;
  54         else if (!strcmp(Args, DBUS_PARAM_TYPE_INT32))
  55                 ArgType = DBUS_TYPE_INT32;
  56         else if (!strcmp(Args, DBUS_PARAM_TYPE_UINT32))
  57                 ArgType = DBUS_TYPE_UINT32;
  58         else if (!strcmp(Args, DBUS_PARAM_TYPE_INT64))
  59                 ArgType = DBUS_TYPE_INT64;
  60         else if (!strcmp(Args, DBUS_PARAM_TYPE_UINT64))
  61                 ArgType = DBUS_TYPE_UINT64;
  62         else if (!strcmp(Args, DBUS_PARAM_TYPE_DOUBLE))
  63                 ArgType = DBUS_TYPE_DOUBLE;
  64         else if (!strcmp(Args, DBUS_PARAM_TYPE_BYTE))
  65                 ArgType = DBUS_TYPE_BYTE;
  66         else if (!strcmp(Args, DBUS_PARAM_TYPE_BOOLEAN))
  67                 ArgType = DBUS_TYPE_BOOLEAN;
  68         else if (!strcmp(Args, DBUS_PARAM_TYPE_OBJECT_PATH))
  69                 ArgType = DBUS_TYPE_OBJECT_PATH;
  70         else {
  71                 ERR("Error!!! Unknown Argument Type \"%s\"", Args);
  72
  73                 return -1;
  74         }
  75
  76         return ArgType;
  77 }
  78
  79 static int __netconfig_dbus_append_argument(DBusMessageIter *iter, int ArgType,
  80                 const char *Value)
  81 {
  82         double Double = 0;
  83         unsigned char ByteValue = 0;
  84         dbus_bool_t booleanvalue = 0;
  85         dbus_uint16_t Uint16 = 0;
  86         dbus_int16_t Int16 = 0;
  87         dbus_uint32_t Uint32 = 0;
  88         dbus_int32_t Int32 = 0;
  89
  90         switch (ArgType) {
  91         case DBUS_TYPE_BYTE:
  92                 ByteValue = strtoul(Value, NULL, 0);
  93                 dbus_message_iter_append_basic(iter, DBUS_TYPE_BYTE, &ByteValue);
  94                 break;
  95
  96         case DBUS_TYPE_DOUBLE:
  97                 Double = strtod(Value, NULL);
  98                 dbus_message_iter_append_basic(iter, DBUS_TYPE_DOUBLE, &Double);
  99                 break;
 100
 101         case DBUS_TYPE_INT16:
 102                 Int16 = strtol(Value, NULL, 0);
 103                 dbus_message_iter_append_basic(iter, DBUS_TYPE_INT16, &Int16);
 104                 break;
 105
 106         case DBUS_TYPE_UINT16:
 107                 Uint16 = strtoul(Value, NULL, 0);
 108                 dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT16, &Uint16);
 109                 break;
 110
 111         case DBUS_TYPE_INT32:
 112                 Int32 = strtol(Value, NULL, 0);
 113                 dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &Int32);
 114                 break;
 115
 116         case DBUS_TYPE_UINT32:
 117                 Uint32 = strtoul(Value, NULL, 0);
 118                 dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &Uint32);
 119                 break;
 120
 121         case DBUS_TYPE_STRING:
 122                 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &Value);
 123                 break;
 124
 125         case DBUS_TYPE_OBJECT_PATH:
 126                 dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &Value);
 127                 break;
 128
 129         case DBUS_TYPE_BOOLEAN:
 130                 if (strcmp(Value, "true") == 0) {
 131                         booleanvalue = TRUE;
 132                         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &booleanvalue);
 133                 } else if (strcmp(Value, "false") == 0) {
 134                         booleanvalue = FALSE;
 135                         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &booleanvalue);
 136                 } else {
 137                         ERR("Error!!! Expected \"true\" or \"false\" instead of \"%s\"", Value);
 138
 139                         return -1;
 140                 }
 141                 break;
 142
 143         default:
 144                 ERR("Error!!! Unsupported data ArgType %c", (char)ArgType);
 145
 146                 return -1;
 147         }
 148
 149         return 0;
 150 }
 151
 152 static int __netconfig_dbus_append_array(DBusMessageIter *iter, int ArgType,
 153                 const char *Value)
 154 {
 155         const char *Val = NULL;
 156         char *DupValue = strdup(Value);
 157         Val = strtok(DupValue, ",");
 158
 159         while (Val != NULL) {
 160                 if (__netconfig_dbus_append_argument(iter, ArgType, Val) != 0) {
 161                         g_free(DupValue);
 162                         DupValue = NULL;
 163
 164                         return -1;
 165                 }
 166
 167                 Val = strtok(NULL, ",");
 168         }
 169
 170         g_free(DupValue);
 171         DupValue = NULL;
 172         return 0;
 173 }
 174
 175 static int __netconfig_dbus_append_dict(DBusMessageIter *iter, int KeyType,
 176                 int ValueType, const char *Value)
 177 {
 178         const char *Val = NULL;
 179         char *DupValue = strdup(Value);
 180         Val = strtok(DupValue, ",");
 181
 182         while (Val != NULL) {
 183                 DBusMessageIter SubIter;
 184                 dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY,
 185                                 NULL, &SubIter);
 186
 187                 if (__netconfig_dbus_append_argument(&SubIter, KeyType, Val) != 0) {
 188                         ERR("Error!!! network_append_argument() failed");
 189                         g_free(DupValue);
 190                         DupValue = NULL;
 191                         return -1;
 192                 }
 193
 194                 Val = strtok(NULL, ",");
 195                 if (Val == NULL) {
 196                         ERR("Error!!! Mal-formed dictionary data");
 197                         g_free(DupValue);
 198                         DupValue = NULL;
 199                         return -1;
 200                 }
 201
 202                 if (__netconfig_dbus_append_argument(&SubIter, ValueType, Val) != 0) {
 203                         ERR("Error!!! network_append_argument() failed");
 204                         g_free(DupValue);
 205                         DupValue = NULL;
 206                         return -1;
 207                 }
 208
 209                 dbus_message_iter_close_container(iter, &SubIter);
 210
 211                 Val = strtok(NULL, ",");
 212         }
 213
 214         g_free(DupValue);
 215         DupValue = NULL;
 216         return 0;
 217 }
 218
 219 char *netconfig_dbus_get_string(DBusMessage * msg)
 220 {
 221         DBusMessageIter args;
 222         char *sigvalue = NULL;
 223
 224         /** read these parameters */
 225         if (!dbus_message_iter_init(msg, &args))
 226                 DBG("Message does not have parameters");
 227         else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
 228                 DBG("Argument is not string");
 229         else
 230                 dbus_message_iter_get_basic(&args, &sigvalue);
 231
 232         return sigvalue;
 233 }
 234
 235 DBusMessage *netconfig_dbus_send_request(const char *destination, char *param_array[])
 236 {
 237         DBusConnection *connection = NULL;
 238         DBusError error;
 239         DBusMessage *message = NULL;
 240         char *RequestMethod = NULL;
 241         int i = 0;
 242         const char *path = NULL;
 243         const char *name = NULL;
 244         int param_count = 0;
 245         DBusMessageIter iter;
 246         DBusMessage *reply = NULL;
 247
 248         DBG("Send DBus request to %s", destination);
 249
 250         for (param_count = 0; param_array[param_count] != NULL;
 251                         param_count++)
 252                 DBG("[%s]", param_array[param_count]);
 253
 254         DBG("Total Arguments [%d]", param_count);
 255         path = param_array[i++];
 256
 257         /** 0th is path */
 258         name = param_array[i++];/** 1st is request name */
 259         if ((strlen(path) == 0) || (strlen(name) == 0)) {
 260                 ERR("Error!!! Invalid parameters passed path [%s], request name [%s]",
 261                                 path, name);
 262
 263                 goto end_error;
 264         }
 265
 266         dbus_error_init(&error);
 267
 268         connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
 269         if (connection == NULL) {
 270                 ERR("Error!!! Failed to get system DBus, error [%s]",
 271                                 error.message);
 272                 dbus_error_free(&error);
 273
 274                 goto end_error;
 275         }
 276
 277         RequestMethod = strrchr(name, '.');
 278         if (RequestMethod == NULL) {
 279                 ERR("Error!!! Invalid method in \"%s\"", name);
 280
 281                 goto end_error;
 282         }
 283
 284         *RequestMethod = '\0';
 285         message = dbus_message_new_method_call(NULL, path, name,
 286                         RequestMethod + 1);
 287         if (message == NULL) {
 288                 ERR("Error!!! dbus_message_new_method_call() failed");
 289
 290                 goto end_error;
 291         }
 292
 293         if (destination && !dbus_message_set_destination(message, destination)) {
 294                 ERR("Error!!! dbus_message_set_destination() failed");
 295
 296                 goto end_error;
 297         }
 298
 299         dbus_message_iter_init_append(message, &iter);
 300
 301         /** Two args name and path already extracted, so i == 2 */
 302         while (i < param_count) {
 303                 char *Args = NULL;
 304                 char *Ch = NULL;
 305                 int ArgType = 0;
 306                 int SecondaryType = 0;
 307                 int ContainerType = 0;
 308                 DBusMessageIter *TargetIter = NULL;
 309                 DBusMessageIter ContainerIter;
 310                 ArgType = DBUS_TYPE_INVALID;
 311
 312                 Args = param_array[i++];
 313                 Ch = strchr(Args, ':');
 314                 if (Ch == NULL) {
 315                         ERR("Error!!! Invalid data format[\"%s\"]", Args);
 316
 317                         goto end_error;
 318                 }
 319
 320                 *(Ch++) = 0;
 321                 if (strcmp(Args, "variant") == 0)
 322                         ContainerType = DBUS_TYPE_VARIANT;
 323                 else if (strcmp(Args, "array") == 0)
 324                         ContainerType = DBUS_TYPE_ARRAY;
 325                 else if (strcmp(Args, "dict") == 0)
 326                         ContainerType = DBUS_TYPE_DICT_ENTRY;
 327                 else
 328                         ContainerType = DBUS_TYPE_INVALID;
 329
 330                 if (ContainerType != DBUS_TYPE_INVALID) {
 331                         Args = Ch;
 332                         Ch = strchr(Args, ':');
 333                         if (Ch == NULL) {
 334                                 ERR("Error!!! Invalid data format[\"%s\"]", Args);
 335
 336                                 goto end_error;
 337                         }
 338
 339                         *(Ch++) = 0;
 340                 }
 341
 342                 if (Args[0] == 0)
 343                         ArgType = DBUS_TYPE_STRING;
 344                 else {
 345                         ArgType = __neconfig_dbus_datatype_from_stringname(Args);
 346
 347                         if (ArgType == -1) {
 348                                 ERR("Error!!! Unknown data type");
 349
 350                                 goto end_error;
 351                         }
 352                 }
 353
 354                 if (ContainerType == DBUS_TYPE_DICT_ENTRY) {
 355                         char Signature[5] = "";
 356                         Args = Ch;
 357                         Ch = strchr(Ch, ':');
 358                         if (Ch == NULL) {
 359                                 ERR("Error!!! Invalid data format[\"%s\"]", Args);
 360
 361                                 goto end_error;
 362                         }
 363
 364                         *(Ch++) = 0;
 365                         SecondaryType = __neconfig_dbus_datatype_from_stringname(Args);
 366                         if (SecondaryType == -1) {
 367                                 ERR("Error!!! Unknown data type");
 368
 369                                 goto end_error;
 370                         }
 371
 372                         Signature[0] = DBUS_DICT_ENTRY_BEGIN_CHAR;
 373                         Signature[1] = ArgType;
 374                         Signature[2] = SecondaryType;
 375                         Signature[3] = DBUS_DICT_ENTRY_END_CHAR;
 376                         Signature[4] = '\0';
 377
 378                         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
 379                                         Signature, &ContainerIter);
 380
 381                         TargetIter = &ContainerIter;
 382                 } else if (ContainerType != DBUS_TYPE_INVALID) {
 383                         char Signature[2] = "";
 384                         Signature[0] = ArgType;
 385                         Signature[1] = '\0';
 386
 387                         dbus_message_iter_open_container(&iter, ContainerType,
 388                                         Signature, &ContainerIter);
 389
 390                         TargetIter = &ContainerIter;
 391                 } else
 392                         TargetIter = &iter;
 393
 394                 if (ContainerType == DBUS_TYPE_ARRAY) {
 395                         if (__netconfig_dbus_append_array(TargetIter, ArgType, Ch) != 0) {
 396                                 ERR("Error!!! network_append_array() failed");
 397
 398                                 goto end_error;
 399                         }
 400                 } else if (ContainerType == DBUS_TYPE_DICT_ENTRY) {
 401                         if (__netconfig_dbus_append_dict(TargetIter, ArgType, SecondaryType, Ch) != 0) {
 402                                 ERR("Error!!! network_append_dict() failed");
 403
 404                                 goto end_error;
 405                         }
 406                 } else {
 407                         if (__netconfig_dbus_append_argument(TargetIter, ArgType, Ch) != 0) {
 408                                 ERR("Error!!! network_append_array() failed");
 409
 410                                 goto end_error;
 411                         }
 412                 }
 413
 414                 if (ContainerType != DBUS_TYPE_INVALID) {
 415                         dbus_message_iter_close_container(&iter, &ContainerIter);
 416                 }
 417         }
 418
 419         dbus_error_init(&error);
 420
 421         reply = dbus_connection_send_with_reply_and_block(connection, message,
 422                         NETCONFIG_DBUS_REPLY_TIMEOUT, &error);
 423
 424         if (reply == NULL) {
 425                 if (dbus_error_is_set(&error) == TRUE) {
 426                         ERR("Error!!! dbus_connection_send_with_reply_and_block() failed, Error[%s: %s]",
 427                                         error.name, error.message);
 428
 429                         dbus_error_free(&error);
 430
 431                         goto end_error;
 432                 }
 433         }
 434
 435         dbus_message_unref(message);
 436         dbus_connection_unref(connection);
 437
 438         return reply;
 439
 440 end_error:
 441
 442         if (message != NULL)
 443                 dbus_message_unref(message);
 444         if (connection != NULL)
 445                 dbus_connection_unref(connection);
 446
 447         return NULL;
 448 }
 449
 450 DBusMessage *netconfig_invoke_dbus_method(const char *dest, DBusConnection *connection,
 451                 const char *path, const char *interface_name, const char *method)
 452 {
 453         DBusError error;
 454         DBusMessage *reply = NULL;
 455         DBusMessage *message = NULL;
 456
 457         message = dbus_message_new_method_call(dest, path, interface_name, method);
 458         if (message == NULL) {
 459                 ERR("Error!!! Failed to GetProperties");
 460                 return NULL;
 461         }
 462
 463         dbus_error_init(&error);
 464
 465         reply = dbus_connection_send_with_reply_and_block(connection, message,
 466                         NETCONFIG_DBUS_REPLY_TIMEOUT, &error);
 467
 468         if (reply == NULL) {
 469                 if (dbus_error_is_set(&error) == TRUE) {
 470                         ERR("Error!!! dbus_connection_send_with_reply_and_block() failed. DBus error [%s: %s]",
 471                                         error.name, error.message);
 472
 473                         dbus_error_free(&error);
 474                 } else
 475                         ERR("Error!!! Failed to get properties");
 476
 477                 dbus_message_unref(message);
 478
 479                 return NULL;
 480         }
 481
 482         dbus_message_unref(message);
 483
 484         return reply;
 485 }
 486
 487 void setup_dbus(gpointer data, gpointer user_data)
 488 {
 489         struct dbus_input_arguments *args;
 490         DBusMessageIter *iter;
 491
 492         if (data != NULL && user_data != NULL) {
 493                 args = (struct dbus_input_arguments *)data;
 494                 iter = (DBusMessageIter *) user_data;
 495
 496                 dbus_message_iter_append_basic(iter, args->type,
 497                                 &(args->data));
 498         }
 499 }
 500
 501 DBusMessage *netconfig_supplicant_invoke_dbus_method(const char *dest,
 502                 DBusConnection *connection,
 503                 const char *path, const char *interface_name,
 504                 const char *method, GList *args)
 505 {
 506         DBusError error;
 507         DBusMessageIter iter;
 508         DBusMessage *reply = NULL;
 509         DBusMessage *message = NULL;
 510
 511         message = dbus_message_new_method_call(dest, path, interface_name, method);
 512         if (message == NULL) {
 513                 ERR("Error!!! DBus method call fail");
 514                 return NULL;
 515         }
 516
 517         dbus_message_iter_init_append(message, &iter);
 518
 519         if (args != NULL)
 520                 g_list_foreach(args, setup_dbus, (gpointer) &iter);
 521
 522         dbus_error_init(&error);
 523
 524         reply = dbus_connection_send_with_reply_and_block(connection, message,
 525                         NETCONFIG_DBUS_REPLY_TIMEOUT, &error);
 526
 527         if (reply == NULL) {
 528                 if (dbus_error_is_set(&error) == TRUE) {
 529                         ERR("Error!!! dbus_connection_send_with_reply_and_block() failed. DBus error [%s: %s]",
 530                                         error.name, error.message);
 531
 532                         dbus_error_free(&error);
 533                 } else
 534                         ERR("Error!!! Failed to get properties");
 535
 536                 dbus_message_unref(message);
 537
 538                 return NULL;
 539         }
 540
 541         dbus_message_unref(message);
 542
 543         return reply;
 544 }
 545
 546 char *netconfig_wifi_get_connected_service_name(DBusMessage *message)
 547 {
 548         int is_connected = 0;
 549         char *essid_name = NULL;
 550         DBusMessageIter iter, array;
 551
 552         dbus_message_iter_init(message, &iter);
 553         dbus_message_iter_recurse(&iter, &array);
 554
 555         while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
 556                 DBusMessageIter entry, string;
 557                 const char *key = NULL;
 558
 559                 dbus_message_iter_recurse(&array, &entry);
 560                 dbus_message_iter_get_basic(&entry, &key);
 561
 562                 if (g_str_equal(key, "State") == TRUE && is_connected == 0) {
 563                         dbus_message_iter_next(&entry);
 564                         dbus_message_iter_recurse(&entry, &string);
 565
 566                         if (dbus_message_iter_get_arg_type(&string) == DBUS_TYPE_STRING) {
 567                                 dbus_message_iter_get_basic(&string, &key);
 568
 569                                 if (g_str_equal(key, "ready") == TRUE || g_str_equal(key, "online") == TRUE)
 570                                         is_connected = 1;
 571                         }
 572                 } else if (g_str_equal(key, "Name") == TRUE) {
 573                         dbus_message_iter_next(&entry);
 574                         dbus_message_iter_recurse(&entry, &string);
 575
 576                         if (dbus_message_iter_get_arg_type(&string) == DBUS_TYPE_STRING) {
 577                                 dbus_message_iter_get_basic(&string, &key);
 578
 579                                 essid_name = (char *)g_strdup(key);
 580                         }
 581                 }
 582
 583                 dbus_message_iter_next(&array);
 584         }
 585
 586         if (is_connected == 1 && essid_name != NULL)
 587                 return essid_name;
 588
 589         if (essid_name != NULL)
 590                 g_free(essid_name);
 591
 592         return NULL;
 593 }
 594
 595 void netconfig_dbus_parse_recursive(DBusMessageIter *iter,
 596                 netconfig_dbus_result_type result_type, void *data)
 597 {
 598         unsigned char *bgscan_mode = NULL;
 599         static dbus_bool_t default_tech_flag = FALSE;
 600         char *default_tech = NULL;
 601
 602         if (result_type == NETCONFIG_DBUS_RESULT_GET_BGSCAN_MODE)
 603                 bgscan_mode = (unsigned char *)data;
 604         else if (result_type == NETCONFIG_DBUS_RESULT_DEFAULT_TECHNOLOGY)
 605                 default_tech = (char *)data;
 606
 607         do {
 608                 int ArgType = dbus_message_iter_get_arg_type(iter);
 609
 610                 if (ArgType == DBUS_TYPE_INVALID)
 611                         break;
 612
 613                 switch (ArgType) {
 614                 case DBUS_TYPE_BYTE:
 615                 {
 616                         unsigned char Value = 0;
 617
 618                         dbus_message_iter_get_basic(iter, &Value);
 619
 620                         *bgscan_mode = Value;
 621                         INFO("BG scan mode: %d, %d", *bgscan_mode, Value);
 622                         break;
 623                 }
 624
 625                 case DBUS_TYPE_STRING:
 626                 {
 627                         char *Value = NULL;
 628
 629                         dbus_message_iter_get_basic(iter, &Value);
 630
 631                         INFO("result type: %d, string: %s", result_type, Value);
 632                         if (result_type == NETCONFIG_DBUS_RESULT_DEFAULT_TECHNOLOGY) {
 633                                 if (strcmp(Value, "DefaultTechnology") == 0) {
 634                                         default_tech_flag = TRUE;
 635                                 } else {
 636                                         if (default_tech_flag == TRUE) {
 637                                                 sprintf(default_tech, "%s", Value);
 638                                                 INFO("default technology: %s", default_tech);
 639                                                 default_tech_flag =     FALSE;
 640                                         }
 641                                 }
 642                         }
 643                         break;
 644                 }
 645
 646                 case DBUS_TYPE_SIGNATURE:
 647                 {
 648                         char *Value = NULL;
 649
 650                         dbus_message_iter_get_basic(iter, &Value);
 651                         break;
 652                 }
 653
 654                 case DBUS_TYPE_OBJECT_PATH:
 655                 {
 656                         char *Value = NULL;
 657
 658                         dbus_message_iter_get_basic(iter, &Value);
 659                         break;
 660                 }
 661
 662                 case DBUS_TYPE_INT16:
 663                 {
 664                         dbus_int16_t Value = 0;
 665
 666                         dbus_message_iter_get_basic(iter, &Value);
 667                         break;
 668                 }
 669
 670                 case DBUS_TYPE_UINT16:
 671                 {
 672                         dbus_uint16_t Value = 0;
 673
 674                         dbus_message_iter_get_basic(iter, &Value);
 675                         break;
 676                 }
 677
 678                 case DBUS_TYPE_INT32:
 679                 {
 680                         dbus_int32_t Value = 0;
 681
 682                         dbus_message_iter_get_basic(iter, &Value);
 683                         break;
 684                 }
 685
 686                 case DBUS_TYPE_UINT32:
 687                 {
 688                         dbus_uint32_t Value = 0;
 689
 690                         dbus_message_iter_get_basic(iter, &Value);
 691                         break;
 692                 }
 693
 694                 case DBUS_TYPE_INT64:
 695                 {
 696                         dbus_int64_t Value = 0;
 697
 698                         dbus_message_iter_get_basic(iter, &Value);
 699                         break;
 700                 }
 701
 702                 case DBUS_TYPE_UINT64:
 703                 {
 704                         dbus_uint64_t Value = 0;
 705
 706                         dbus_message_iter_get_basic(iter, &Value);
 707                         break;
 708                 }
 709
 710                 case DBUS_TYPE_DOUBLE:
 711                 {
 712                         double Value = 0;
 713
 714                         dbus_message_iter_get_basic(iter, &Value);
 715                         break;
 716                 }
 717
 718                 case DBUS_TYPE_BOOLEAN:
 719                 {
 720                         dbus_bool_t Value = 0;
 721
 722                         dbus_message_iter_get_basic(iter, &Value);
 723                         break;
 724                 }
 725
 726                 case DBUS_TYPE_VARIANT:
 727                 {
 728                         DBusMessageIter SubIter;
 729
 730                         dbus_message_iter_recurse(iter, &SubIter);
 731                         netconfig_dbus_parse_recursive(&SubIter,
 732                                         result_type, data);
 733                         break;
 734                 }
 735
 736                 case DBUS_TYPE_ARRAY:
 737                 {
 738                         int CurrentType = 0;
 739                         DBusMessageIter SubIter;
 740
 741                         dbus_message_iter_recurse(iter, &SubIter);
 742                         CurrentType = dbus_message_iter_get_arg_type(&SubIter);
 743
 744                         while (CurrentType != DBUS_TYPE_INVALID) {
 745                                 netconfig_dbus_parse_recursive(&SubIter,
 746                                                 result_type, data);
 747
 748                                 dbus_message_iter_next(&SubIter);
 749                                 CurrentType = dbus_message_iter_get_arg_type(&SubIter);
 750                         }
 751                         break;
 752                 }
 753
 754                 case DBUS_TYPE_DICT_ENTRY:
 755                 {
 756                         DBusMessageIter SubIter;
 757
 758                         dbus_message_iter_recurse(iter, &SubIter);
 759                         netconfig_dbus_parse_recursive(&SubIter, result_type, data);
 760
 761                         dbus_message_iter_next(&SubIter);
 762                         netconfig_dbus_parse_recursive(&SubIter, result_type, data);
 763                         break;
 764                 }
 765
 766                 case DBUS_TYPE_STRUCT:
 767                 {
 768                         int CurrentType = 0;
 769                         DBusMessageIter SubIter;
 770
 771                         dbus_message_iter_recurse(iter, &SubIter);
 772
 773                         while ((CurrentType = dbus_message_iter_get_arg_type(&SubIter))
 774                                         != DBUS_TYPE_INVALID) {
 775                                 netconfig_dbus_parse_recursive(&SubIter, result_type, data);
 776
 777                                 dbus_message_iter_next(&SubIter);
 778                         }
 779                         break;
 780                 }
 781
 782                 default:
 783                         ERR("Error!!! Invalid Argument Type [%c]", ArgType);
 784                 }
 785         } while (dbus_message_iter_next(iter));
 786 }
 787
 788 DBusGConnection *netconfig_setup_dbus(void)
 789 {
 790         DBusGConnection* connection = NULL;
 791         GError *error = NULL;
 792         DBusGProxy *proxy;
 793         guint rv = 0;
 794
 795         connection = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
 796         if (connection == NULL) {
 797                 ERR("Fail to get DBus(%s)", error->message);
 798                 return connection;
 799         }
 800
 801         INFO("Successfully get system DBus connection(%p)", connection);
 802
 803         proxy = dbus_g_proxy_new_for_name(connection, "org.freedesktop.DBus",
 804                         "/org/freedesktop/DBus",
 805                         "org.freedesktop.DBus");
 806
 807         if (!dbus_g_proxy_call(proxy, "RequestName", &error,
 808                         G_TYPE_STRING, NETCONFIG_SERVICE, G_TYPE_UINT, 0,
 809                         G_TYPE_INVALID, G_TYPE_UINT, &rv,
 810                         G_TYPE_INVALID)) {
 811                 ERR("Failed to acquire service(%s) error(%s)",
 812                                 NETCONFIG_SERVICE, error->message);
 813
 814                 dbus_g_connection_unref(connection);
 815
 816                 return NULL;
 817         }
 818
 819         if (rv != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
 820                 ERR("Service name is already in use");
 821
 822                 dbus_g_connection_unref(connection);
 823
 824                 return NULL;
 825         }
 826
 827         return connection;
 828 }