client/vc_dbus.c

   1 /*
   2 * Copyright (c) 2011-2015 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the License);
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an AS IS BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17
  18 #include "vc_client.h"
  19 #include "vc_dbus.h"
  20 #include "vc_main.h"
  21
  22
  23 static int g_waiting_time = 3000;
  24
  25 static Ecore_Fd_Handler* g_fd_handler = NULL;
  26
  27 static DBusConnection* g_conn_sender = NULL;
  28 static DBusConnection* g_conn_listener = NULL;
  29
  30 extern int __vc_cb_error(int pid, int reason);
  31
  32 extern void __vc_cb_result();
  33
  34
  35 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
  36 {
  37         if (NULL == g_conn_listener)    return ECORE_CALLBACK_RENEW;
  38
  39         dbus_connection_read_write_dispatch(g_conn_listener, 50);
  40
  41         DBusMessage* msg = NULL;
  42         msg = dbus_connection_pop_message(g_conn_listener);
  43
  44         /* loop again if we haven't read a message */
  45         if (NULL == msg) {
  46                 return ECORE_CALLBACK_RENEW;
  47         }
  48
  49         DBusError err;
  50         dbus_error_init(&err);
  51
  52         char if_name[64];
  53         snprintf(if_name, 64, "%s", VC_CLIENT_SERVICE_INTERFACE);
  54
  55         if (dbus_message_is_method_call(msg, if_name, VCD_METHOD_HELLO)) {
  56                 SLOG(LOG_DEBUG, TAG_VCC, "===== Get Hello");
  57                 int pid = 0;
  58                 int response = -1;
  59
  60                 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
  61
  62                 if (dbus_error_is_set(&err)) {
  63                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
  64                         dbus_error_free(&err);
  65                 }
  66
  67                 if (pid > 0) {
  68                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc get hello : pid(%d) ", pid);
  69                         response = 1;
  70
  71                 } else {
  72                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc get hello : invalid pid ");
  73                 }
  74
  75                 DBusMessage* reply = NULL;
  76                 reply = dbus_message_new_method_return(msg);
  77
  78                 if (NULL != reply) {
  79                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
  80
  81                         if (!dbus_connection_send(g_conn_listener, reply, NULL))
  82                                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc get hello : fail to send reply");
  83                         else
  84                                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc get hello : result(%d)", response);
  85
  86                         dbus_connection_flush(g_conn_listener);
  87                         dbus_message_unref(reply);
  88                 } else {
  89                         SLOG(LOG_ERROR, TAG_VCC, ">>>> vc get hello : fail to create reply message");
  90                 }
  91
  92                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
  93                 SLOG(LOG_DEBUG, TAG_VCC, " ");
  94         } /* VCD_METHOD_HELLO */
  95
  96         else if (dbus_message_is_method_call(msg, if_name, VCD_METHOD_RESULT)) {
  97                 SLOG(LOG_DEBUG, TAG_VCC, "===== Get Client Result");
  98
  99                 __vc_cb_result();
 100
 101                 /*
 102                 reply = dbus_message_new_method_return(msg);
 103
 104                 if (NULL != reply) {
 105                         if (!dbus_connection_send(g_conn_listener, reply, NULL))
 106                                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc get result : fail to send reply");
 107                         else
 108                                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc get result");
 109
 110                         dbus_connection_flush(g_conn_listener);
 111                         dbus_message_unref(reply);
 112                 } else {
 113                         SLOG(LOG_ERROR, TAG_VCC, ">>>> vc get result : fail to create reply message");
 114                 }
 115                 */
 116
 117                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 118                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 119
 120         }/* VCD_METHOD_RESULT */
 121
 122         else if (dbus_message_is_method_call(msg, if_name, VCD_METHOD_ERROR)) {
 123                 SLOG(LOG_DEBUG, TAG_VCC, "===== Get Error");
 124                 int pid;
 125                 int reason;
 126                 char* err_msg;
 127
 128                 dbus_message_get_args(msg, &err,
 129                         DBUS_TYPE_INT32, &pid,
 130                         DBUS_TYPE_INT32, &reason,
 131                         DBUS_TYPE_STRING, &err_msg,
 132                         DBUS_TYPE_INVALID);
 133
 134                 if (dbus_error_is_set(&err)) {
 135                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc Get Error message : Get arguments error (%s)", err.message);
 136                         dbus_error_free(&err);
 137                 } else {
 138                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc Get Error message : pid(%d), reason(%d), msg(%s)", pid, reason, err_msg);
 139                         __vc_cb_error(pid, reason);
 140                 }
 141
 142                 /*
 143                 reply = dbus_message_new_method_return(msg);
 144
 145                 if (NULL != reply) {
 146                         if (!dbus_connection_send(g_conn_listener, reply, NULL))
 147                                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc Error message : fail to send reply");
 148                         else
 149                                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc Error message");
 150
 151                         dbus_connection_flush(g_conn_listener);
 152                         dbus_message_unref(reply);
 153                 } else {
 154                         SLOG(LOG_ERROR, TAG_VCC, ">>>> vc Error message : fail to create reply message");
 155                 }
 156                 */
 157
 158                 SLOG(LOG_DEBUG, TAG_VCC, "=====");
 159                 SLOG(LOG_DEBUG, TAG_VCC, " ");
 160         }/* VCD_METHOD_ERROR */
 161
 162         /* free the message */
 163         dbus_message_unref(msg);
 164
 165         return ECORE_CALLBACK_PASS_ON;
 166 }
 167
 168 int vc_dbus_open_connection()
 169 {
 170         if (NULL != g_conn_sender && NULL != g_conn_listener) {
 171                 SLOG(LOG_WARN, TAG_VCC, "already existed connection ");
 172                 return 0;
 173         }
 174
 175         DBusError err;
 176         int ret;
 177
 178         /* initialise the error value */
 179         dbus_error_init(&err);
 180
 181         /* connect to the DBUS system bus, and check for errors */
 182         g_conn_sender = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
 183
 184         if (dbus_error_is_set(&err)) {
 185                 SLOG(LOG_ERROR, TAG_VCC, "Dbus Connection Error (%s)", err.message);
 186                 dbus_error_free(&err);
 187         }
 188
 189         if (NULL == g_conn_sender) {
 190                 SLOG(LOG_ERROR, TAG_VCC, "Fail to get dbus connection ");
 191                 return VC_ERROR_OPERATION_FAILED;
 192         }
 193
 194         g_conn_listener = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
 195
 196         if (dbus_error_is_set(&err)) {
 197                 SLOG(LOG_ERROR, TAG_VCC, "Dbus Connection Error (%s)", err.message);
 198                 dbus_error_free(&err);
 199         }
 200
 201         if (NULL == g_conn_listener) {
 202                 SLOG(LOG_ERROR, TAG_VCC, "Fail to get dbus connection ");
 203                 return VC_ERROR_OPERATION_FAILED;
 204         }
 205
 206         int pid = getpid();
 207
 208         char service_name[64];
 209         memset(service_name, '\0', 64);
 210         snprintf(service_name, 64, "%s", VC_CLIENT_SERVICE_NAME);
 211
 212         SLOG(LOG_DEBUG, TAG_VCC, "service name is %s", service_name);
 213
 214         /* register our name on the bus, and check for errors */
 215         ret = dbus_bus_request_name(g_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
 216
 217         if (dbus_error_is_set(&err)) {
 218                 SLOG(LOG_ERROR, TAG_VCC, "Name Error (%s)", err.message);
 219                 dbus_error_free(&err);
 220         }
 221
 222         if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
 223                 SLOG(LOG_ERROR, TAG_VCC, "fail dbus_bus_request_name()");
 224                 return -2;
 225         }
 226
 227         if( NULL != g_fd_handler ) {
 228                 SLOG(LOG_WARN, TAG_VCC, "The handler already exists.");
 229                 return 0;
 230         }
 231
 232         char rule[128];
 233         snprintf(rule, 128, "type='signal',interface='%s'", VC_CLIENT_SERVICE_INTERFACE);
 234
 235         /* add a rule for which messages we want to see */
 236         dbus_bus_add_match(g_conn_listener, rule, &err);
 237         dbus_connection_flush(g_conn_listener);
 238
 239         if (dbus_error_is_set(&err))
 240         {
 241                 SLOG(LOG_ERROR, TAG_VCC, "Match Error (%s)", err.message);
 242                 dbus_error_free(&err);
 243                 return VC_ERROR_OPERATION_FAILED;
 244         }
 245
 246         int fd = 0;
 247         if (1 != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
 248                 SLOG(LOG_ERROR, TAG_VCC, "fail to get fd from dbus ");
 249                 return VC_ERROR_OPERATION_FAILED;
 250         } else {
 251                 SLOG(LOG_DEBUG, TAG_VCC, "Get fd from dbus : %d", fd);
 252         }
 253
 254         g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
 255         if (NULL == g_fd_handler) {
 256                 SLOG(LOG_ERROR, TAG_VCC, "fail to get fd handler from ecore ");
 257                 return VC_ERROR_OPERATION_FAILED;
 258         }
 259
 260         return 0;
 261 }
 262
 263 int vc_dbus_close_connection()
 264 {
 265         DBusError err;
 266         dbus_error_init(&err);
 267
 268         if (NULL != g_fd_handler) {
 269                 ecore_main_fd_handler_del(g_fd_handler);
 270                 g_fd_handler = NULL;
 271         }
 272
 273         int pid = getpid();
 274
 275         char service_name[64];
 276         memset(service_name, '\0', 64);
 277         snprintf(service_name, 64, "%s", VC_CLIENT_SERVICE_NAME);
 278
 279         dbus_bus_release_name(g_conn_listener, service_name, &err);
 280
 281         if (dbus_error_is_set(&err)) {
 282                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 283                 dbus_error_free(&err);
 284         }
 285
 286         g_conn_sender = NULL;
 287         g_conn_listener = NULL;
 288
 289         return 0;
 290 }
 291
 292 int vc_dbus_reconnect()
 293 {
 294         bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
 295         bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
 296         SLOG(LOG_DEBUG, TAG_VCC, "[DBUS] Sender(%s) Listener(%s)",
 297                  sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
 298
 299         if (false == sender_connected || false == listener_connected) {
 300                 vc_dbus_close_connection();
 301
 302                 if (0 != vc_dbus_open_connection()) {
 303                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to reconnect");
 304                         return -1;
 305                 }
 306
 307                 SLOG(LOG_DEBUG, TAG_VCC, "[DBUS] Reconnect");
 308         }
 309         return 0;
 310 }
 311
 312 int vc_dbus_request_hello()
 313 {
 314         DBusMessage* msg;
 315
 316         msg = dbus_message_new_method_call(
 317                 VC_SERVER_SERVICE_NAME,
 318                 VC_SERVER_SERVICE_OBJECT_PATH,
 319                 VC_SERVER_SERVICE_INTERFACE,
 320                 VC_METHOD_HELLO);
 321
 322         if (NULL == msg) {
 323                 SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc hello : Fail to make message");
 324                 return VC_ERROR_OPERATION_FAILED;
 325         }
 326
 327         DBusError err;
 328         dbus_error_init(&err);
 329
 330         DBusMessage* result_msg = NULL;
 331         int result = 0;
 332
 333         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, 500, &err);
 334
 335         if (dbus_error_is_set(&err)) {
 336                 dbus_error_free(&err);
 337         }
 338
 339         dbus_message_unref(msg);
 340
 341         if (NULL != result_msg) {
 342                 dbus_message_unref(result_msg);
 343                 result = 0;
 344         } else {
 345                 result = VC_ERROR_TIMED_OUT;
 346         }
 347
 348         return result;
 349 }
 350
 351
 352 int vc_dbus_request_initialize(int pid, int* mgr_pid)
 353 {
 354         DBusMessage* msg;
 355
 356         msg = dbus_message_new_method_call(
 357                 VC_SERVER_SERVICE_NAME,
 358                 VC_SERVER_SERVICE_OBJECT_PATH,
 359                 VC_SERVER_SERVICE_INTERFACE,
 360                 VC_METHOD_INITIALIZE);
 361
 362         if (NULL == msg) {
 363                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc initialize : Fail to make message ");
 364                 return VC_ERROR_OPERATION_FAILED;
 365         } else {
 366                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc initialize : pid(%d)", pid);
 367         }
 368
 369         dbus_message_append_args( msg,
 370                 DBUS_TYPE_INT32, &pid,
 371                 DBUS_TYPE_INVALID);
 372
 373         DBusError err;
 374         dbus_error_init(&err);
 375
 376         DBusMessage* result_msg;
 377         int result = VC_ERROR_OPERATION_FAILED;
 378
 379         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 380         dbus_message_unref(msg);
 381
 382         if (dbus_error_is_set(&err)) {
 383                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 384                 dbus_error_free(&err);
 385         }
 386
 387         if (NULL != result_msg) {
 388                 int tmp = -1;
 389                 dbus_message_get_args(result_msg, &err,
 390                         DBUS_TYPE_INT32, &result,
 391                         DBUS_TYPE_INT32, &tmp,
 392                         DBUS_TYPE_INVALID);
 393
 394                 if (dbus_error_is_set(&err)) {
 395                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 396                         dbus_error_free(&err);
 397                         result = VC_ERROR_OPERATION_FAILED;
 398                 }
 399
 400                 dbus_message_unref(result_msg);
 401
 402                 if (0 == result) {
 403                         *mgr_pid = tmp;
 404                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc initialize : result = %d mgr = %d", result, *mgr_pid);
 405                 } else {
 406                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc initialize : result = %d", result);
 407                 }
 408         } else {
 409                 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL ");
 410                 vc_dbus_reconnect();
 411                 result = VC_ERROR_TIMED_OUT;
 412         }
 413
 414         return result;
 415 }
 416
 417 int vc_dbus_request_finalize(int pid)
 418 {
 419         DBusMessage* msg;
 420
 421         msg = dbus_message_new_method_call(
 422                 VC_SERVER_SERVICE_NAME,
 423                 VC_SERVER_SERVICE_OBJECT_PATH,
 424                 VC_SERVER_SERVICE_INTERFACE,
 425                 VC_METHOD_FINALIZE);
 426
 427         if (NULL == msg) {
 428                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc finalize : Fail to make message ");
 429                 return VC_ERROR_OPERATION_FAILED;
 430         } else {
 431                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc finalize : pid(%d)", pid);
 432         }
 433
 434         dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 435
 436         DBusError err;
 437         dbus_error_init(&err);
 438
 439         DBusMessage* result_msg;
 440         int result = VC_ERROR_OPERATION_FAILED;
 441
 442         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 443         dbus_message_unref(msg);
 444
 445         if (dbus_error_is_set(&err)) {
 446                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 447                 dbus_error_free(&err);
 448         }
 449
 450         if (NULL != result_msg) {
 451                 dbus_message_get_args(result_msg, &err,
 452                                 DBUS_TYPE_INT32, &result,
 453                                 DBUS_TYPE_INVALID);
 454
 455                 if (dbus_error_is_set(&err)) {
 456                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 457                         dbus_error_free(&err);
 458                         result = VC_ERROR_OPERATION_FAILED;
 459                 }
 460
 461                 dbus_message_unref(result_msg);
 462
 463                 if (0 == result) {
 464                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc finalize : result = %d", result);
 465                 } else {
 466                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc finalize : result = %d", result);
 467                 }
 468         } else {
 469                 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL ");
 470                 vc_dbus_reconnect();
 471                 result = VC_ERROR_TIMED_OUT;
 472         }
 473
 474         return result;
 475 }
 476
 477 int vc_dbus_request_set_exclusive_command(int pid, bool value)
 478 {
 479         DBusMessage* msg;
 480
 481         msg = dbus_message_new_method_call(
 482                 VC_SERVER_SERVICE_NAME,
 483                 VC_SERVER_SERVICE_OBJECT_PATH,
 484                 VC_SERVER_SERVICE_INTERFACE,
 485                 VC_METHOD_SET_EXCLUSIVE_CMD);
 486
 487         if (NULL == msg) {
 488                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set exclusive command : Fail to make message");
 489                 return VC_ERROR_OPERATION_FAILED;
 490         } else {
 491                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set exclusive command : pid(%d)", pid);
 492         }
 493
 494         int temp = value;
 495
 496         dbus_message_append_args( msg,
 497                 DBUS_TYPE_INT32, &pid,
 498                 DBUS_TYPE_INT32, &temp,
 499                 DBUS_TYPE_INVALID);
 500
 501         DBusError err;
 502         dbus_error_init(&err);
 503
 504         DBusMessage* result_msg;
 505         int result = VC_ERROR_OPERATION_FAILED;
 506
 507         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 508         dbus_message_unref(msg);
 509
 510         if (dbus_error_is_set(&err)) {
 511                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 512                 dbus_error_free(&err);
 513         }
 514
 515         if (NULL != result_msg) {
 516                 dbus_message_get_args(result_msg, &err,
 517                         DBUS_TYPE_INT32, &result,
 518                         DBUS_TYPE_INVALID);
 519
 520                 if (dbus_error_is_set(&err)) {
 521                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 522                         dbus_error_free(&err);
 523                         result = VC_ERROR_OPERATION_FAILED;
 524                 }
 525                 dbus_message_unref(result_msg);
 526
 527                 if (0 == result) {
 528                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set exclusive command : result = %d", result);
 529                 } else {
 530                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set exclusive command : result = %d", result);
 531                 }
 532         } else {
 533                 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
 534                 vc_dbus_reconnect();
 535                 result = VC_ERROR_TIMED_OUT;
 536         }
 537
 538         return result;
 539 }
 540
 541 int vc_dbus_request_set_command(int pid, vc_cmd_type_e cmd_type)
 542 {
 543         DBusMessage* msg;
 544
 545         msg = dbus_message_new_method_call(
 546                 VC_SERVER_SERVICE_NAME,
 547                 VC_SERVER_SERVICE_OBJECT_PATH,
 548                 VC_SERVER_SERVICE_INTERFACE,
 549                 VC_METHOD_SET_COMMAND);
 550
 551         if (NULL == msg) {
 552                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set command : Fail to make message");
 553                 return VC_ERROR_OPERATION_FAILED;
 554         } else {
 555                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set command : pid(%d)", pid);
 556         }
 557
 558         dbus_message_append_args( msg,
 559                 DBUS_TYPE_INT32, &pid,
 560                 DBUS_TYPE_INT32, &cmd_type,
 561                 DBUS_TYPE_INVALID);
 562
 563         DBusError err;
 564         dbus_error_init(&err);
 565
 566         DBusMessage* result_msg;
 567         int result = VC_ERROR_OPERATION_FAILED;
 568
 569         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 570         dbus_message_unref(msg);
 571
 572         if (dbus_error_is_set(&err)) {
 573                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 574                 dbus_error_free(&err);
 575         }
 576
 577         if (NULL != result_msg) {
 578                 dbus_message_get_args(result_msg, &err,
 579                         DBUS_TYPE_INT32, &result,
 580                         DBUS_TYPE_INVALID);
 581
 582                 if (dbus_error_is_set(&err)) {
 583                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 584                         dbus_error_free(&err);
 585                         result = VC_ERROR_OPERATION_FAILED;
 586                 }
 587                 dbus_message_unref(result_msg);
 588
 589                 if (0 == result) {
 590                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set command : result = %d", result);
 591                 } else {
 592                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc set command : result = %d", result);
 593                 }
 594         } else {
 595                 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
 596                 vc_dbus_reconnect();
 597                 result = VC_ERROR_TIMED_OUT;
 598         }
 599
 600         return result;
 601 }
 602
 603 int vc_dbus_request_unset_command(int pid, vc_cmd_type_e cmd_type)
 604 {
 605         DBusMessage* msg;
 606
 607         msg = dbus_message_new_method_call(
 608                 VC_SERVER_SERVICE_NAME,
 609                 VC_SERVER_SERVICE_OBJECT_PATH,
 610                 VC_SERVER_SERVICE_INTERFACE,
 611                 VC_METHOD_UNSET_COMMAND);
 612
 613         if (NULL == msg) {
 614                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc unset command : Fail to make message");
 615                 return VC_ERROR_OPERATION_FAILED;
 616         } else {
 617                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc unset command : pid(%d), type(%d)", pid, cmd_type);
 618         }
 619
 620         dbus_message_append_args( msg,
 621                 DBUS_TYPE_INT32, &pid,
 622                 DBUS_TYPE_INT32, &cmd_type,
 623                 DBUS_TYPE_INVALID);
 624
 625         DBusError err;
 626         dbus_error_init(&err);
 627
 628         DBusMessage* result_msg;
 629         int result = VC_ERROR_OPERATION_FAILED;
 630
 631         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 632         dbus_message_unref(msg);
 633
 634         if (dbus_error_is_set(&err)) {
 635                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 636                 dbus_error_free(&err);
 637         }
 638
 639         if (NULL != result_msg) {
 640                 dbus_message_get_args(result_msg, &err,
 641                         DBUS_TYPE_INT32, &result,
 642                         DBUS_TYPE_INVALID);
 643
 644                 if (dbus_error_is_set(&err)) {
 645                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 646                         dbus_error_free(&err);
 647                         result = VC_ERROR_OPERATION_FAILED;
 648                 }
 649                 dbus_message_unref(result_msg);
 650
 651                 if (0 == result) {
 652                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc unset command : result = %d", result);
 653                 } else {
 654                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc unset command : result = %d", result);
 655                 }
 656         } else {
 657                 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
 658                 vc_dbus_reconnect();
 659                 result = VC_ERROR_TIMED_OUT;
 660         }
 661
 662         return result;
 663 }
 664
 665 #if 0
 666 int vc_dbus_request_start(int pid, int silence)
 667 {
 668         DBusMessage* msg;
 669
 670         /* create a signal & check for errors */
 671         msg = dbus_message_new_method_call(
 672                 VC_SERVER_SERVICE_NAME,
 673                 VC_SERVER_SERVICE_OBJECT_PATH,
 674                 VC_SERVER_SERVICE_INTERFACE,
 675                 VC_METHOD_REQUEST_START);
 676
 677         if (NULL == msg) {
 678                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc start : Fail to make message ");
 679                 return VC_ERROR_OPERATION_FAILED;
 680         } else {
 681                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc start : pid(%d), silence(%d)", pid, silence);
 682         }
 683
 684         DBusMessageIter args;
 685         dbus_message_iter_init_append(msg, &args);
 686
 687         /* Append result*/
 688         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid));
 689         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(silence));
 690
 691         DBusError err;
 692         dbus_error_init(&err);
 693
 694         DBusMessage* result_msg;
 695         int result = VC_ERROR_OPERATION_FAILED;
 696
 697         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 698         dbus_message_unref(msg);
 699
 700         if (dbus_error_is_set(&err)) {
 701                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 702                 dbus_error_free(&err);
 703         }
 704
 705         if (NULL != result_msg) {
 706                 dbus_message_get_args(result_msg, &err,
 707                         DBUS_TYPE_INT32, &result,
 708                         DBUS_TYPE_INVALID);
 709
 710                 if (dbus_error_is_set(&err)) {
 711                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 712                         dbus_error_free(&err);
 713                         result = VC_ERROR_OPERATION_FAILED;
 714                 }
 715                 dbus_message_unref(result_msg);
 716
 717                 if (0 == result) {
 718                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc start : result = %d", result);
 719                 } else {
 720                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc start : result = %d", result);
 721                 }
 722         } else {
 723                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
 724                 vc_dbus_reconnect();
 725                 result = VC_ERROR_TIMED_OUT;
 726         }
 727
 728         return result;
 729 }
 730
 731 int vc_dbus_request_stop(int pid)
 732 {
 733         DBusMessage* msg;
 734
 735         /* create a signal & check for errors */
 736         msg = dbus_message_new_method_call(
 737                 VC_SERVER_SERVICE_NAME,
 738                 VC_SERVER_SERVICE_OBJECT_PATH,
 739                 VC_SERVER_SERVICE_INTERFACE,
 740                 VC_METHOD_REQUEST_STOP);
 741
 742         if (NULL == msg) {
 743                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc stop : Fail to make message ");
 744                 return VC_ERROR_OPERATION_FAILED;
 745         } else {
 746                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc stop : pid(%d)", pid);
 747         }
 748
 749         dbus_message_append_args(msg,
 750                 DBUS_TYPE_INT32, &pid,
 751                 DBUS_TYPE_INVALID);
 752
 753         DBusError err;
 754         dbus_error_init(&err);
 755
 756         DBusMessage* result_msg;
 757         int result = VC_ERROR_OPERATION_FAILED;
 758
 759         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 760         dbus_message_unref(msg);
 761
 762         if (dbus_error_is_set(&err)) {
 763                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 764                 dbus_error_free(&err);
 765         }
 766
 767         if (NULL != result_msg) {
 768                 dbus_message_get_args(result_msg, &err,
 769                         DBUS_TYPE_INT32, &result,
 770                         DBUS_TYPE_INVALID);
 771
 772                 if (dbus_error_is_set(&err)) {
 773                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 774                         dbus_error_free(&err);
 775                         result = VC_ERROR_OPERATION_FAILED;
 776                 }
 777                 dbus_message_unref(result_msg);
 778
 779                 if (0 == result) {
 780                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc stop : result = %d", result);
 781                 } else {
 782                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc stop : result = %d", result);
 783                 }
 784         } else {
 785                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
 786                 vc_dbus_reconnect();
 787                 result = VC_ERROR_TIMED_OUT;
 788         }
 789
 790         return result;
 791 }
 792
 793 int vc_dbus_request_cancel(int pid)
 794 {
 795         DBusMessage* msg;
 796
 797         /* create a signal & check for errors */
 798         msg = dbus_message_new_method_call(
 799                 VC_SERVER_SERVICE_NAME,
 800                 VC_SERVER_SERVICE_OBJECT_PATH,  /* object name of the signal */
 801                 VC_SERVER_SERVICE_INTERFACE,    /* interface name of the signal */
 802                 VC_METHOD_REQUEST_CANCEL);      /* name of the signal */
 803
 804         if (NULL == msg) {
 805                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc cancel : Fail to make message ");
 806                 return VC_ERROR_OPERATION_FAILED;
 807         } else {
 808                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc cancel : pid(%d)", pid);
 809         }
 810
 811         dbus_message_append_args(msg,
 812                 DBUS_TYPE_INT32, &pid,
 813                 DBUS_TYPE_INVALID);
 814
 815         DBusError err;
 816         dbus_error_init(&err);
 817
 818         DBusMessage* result_msg;
 819         int result = VC_ERROR_OPERATION_FAILED;
 820
 821         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 822         dbus_message_unref(msg);
 823
 824         if (dbus_error_is_set(&err)) {
 825                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 826                 dbus_error_free(&err);
 827         }
 828
 829         if (NULL != result_msg) {
 830                 dbus_message_get_args(result_msg, &err,
 831                         DBUS_TYPE_INT32, &result,
 832                         DBUS_TYPE_INVALID);
 833
 834                 if (dbus_error_is_set(&err)) {
 835                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 836                         dbus_error_free(&err);
 837                         result = VC_ERROR_OPERATION_FAILED;
 838                 }
 839                 dbus_message_unref(result_msg);
 840
 841                 if (0 == result) {
 842                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc cancel : result = %d", result);
 843                 } else {
 844                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc cancel : result = %d", result);
 845                 }
 846         } else {
 847                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
 848                 vc_dbus_reconnect();
 849                 result = VC_ERROR_TIMED_OUT;
 850         }
 851
 852         return result;
 853 }
 854 #endif
 855
 856 /* Authority */
 857 int vc_dbus_request_auth_enable(int pid, int mgr_pid)
 858 {
 859         DBusMessage* msg;
 860
 861         char service_name[64] = {0,};
 862         char object_path[64] = {0,};
 863         char target_if_name[128] = {0,};
 864
 865         snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
 866         snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
 867         snprintf(target_if_name, 128, "%s", VC_MANAGER_SERVICE_INTERFACE);
 868
 869         /* create a signal & check for errors */
 870         msg = dbus_message_new_method_call(
 871                 service_name,
 872                 object_path,    /* object name of the signal */
 873                 target_if_name, /* interface name of the signal */
 874                 VC_METHOD_AUTH_ENABLE); /* name of the signal */
 875
 876         if (NULL == msg) {
 877                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth enable : Fail to make message ");
 878                 return VC_ERROR_OPERATION_FAILED;
 879         } else {
 880                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth enable : pid(%d)", pid);
 881         }
 882
 883         dbus_message_append_args(msg,
 884                 DBUS_TYPE_INT32, &pid,
 885                 DBUS_TYPE_INVALID);
 886
 887         DBusError err;
 888         dbus_error_init(&err);
 889
 890         DBusMessage* result_msg;
 891         int result = VC_ERROR_OPERATION_FAILED;
 892
 893         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 894         dbus_message_unref(msg);
 895
 896         if (dbus_error_is_set(&err)) {
 897                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 898                 dbus_error_free(&err);
 899         }
 900
 901         if (NULL != result_msg) {
 902                 dbus_message_get_args(result_msg, &err,
 903                         DBUS_TYPE_INT32, &result,
 904                         DBUS_TYPE_INVALID);
 905
 906                 if (dbus_error_is_set(&err)) {
 907                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 908                         dbus_error_free(&err);
 909                         result = VC_ERROR_OPERATION_FAILED;
 910                 }
 911                 dbus_message_unref(result_msg);
 912
 913                 if (0 == result) {
 914                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth enable : result = %d", result);
 915                 } else {
 916                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth enable : result = %d", result);
 917                 }
 918         } else {
 919                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
 920                 vc_dbus_reconnect();
 921                 result = VC_ERROR_TIMED_OUT;
 922         }
 923
 924         return result;
 925 }
 926
 927 int vc_dbus_request_auth_disable(int pid, int mgr_pid)
 928 {
 929         DBusMessage* msg;
 930
 931         char service_name[64] = {0,};
 932         char object_path[64] = {0,};
 933         char target_if_name[128] = {0,};
 934
 935         snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
 936         snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
 937         snprintf(target_if_name, 128, "%s", VC_MANAGER_SERVICE_INTERFACE);
 938
 939         /* create a signal & check for errors */
 940         msg = dbus_message_new_method_call(
 941                 service_name,
 942                 object_path,    /* object name of the signal */
 943                 target_if_name, /* interface name of the signal */
 944                 VC_METHOD_AUTH_DISABLE);        /* name of the signal */
 945
 946         if (NULL == msg) {
 947                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth disable : Fail to make message ");
 948                 return VC_ERROR_OPERATION_FAILED;
 949         } else {
 950                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth disable : pid(%d)", pid);
 951         }
 952
 953         dbus_message_append_args(msg,
 954                 DBUS_TYPE_INT32, &pid,
 955                 DBUS_TYPE_INVALID);
 956
 957         DBusError err;
 958         dbus_error_init(&err);
 959
 960         DBusMessage* result_msg;
 961         int result = VC_ERROR_OPERATION_FAILED;
 962
 963         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 964         dbus_message_unref(msg);
 965
 966         if (dbus_error_is_set(&err)) {
 967                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 968                 dbus_error_free(&err);
 969         }
 970
 971         if (NULL != result_msg) {
 972                 dbus_message_get_args(result_msg, &err,
 973                         DBUS_TYPE_INT32, &result,
 974                         DBUS_TYPE_INVALID);
 975
 976                 if (dbus_error_is_set(&err)) {
 977                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 978                         dbus_error_free(&err);
 979                         result = VC_ERROR_OPERATION_FAILED;
 980                 }
 981                 dbus_message_unref(result_msg);
 982
 983                 if (0 == result) {
 984                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth disable : result = %d", result);
 985                 } else {
 986                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth disable : result = %d", result);
 987                 }
 988         } else {
 989                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
 990                 vc_dbus_reconnect();
 991                 result = VC_ERROR_TIMED_OUT;
 992         }
 993
 994         return result;
 995 }
 996
 997 int vc_dbus_request_auth_start(int pid, int mgr_pid)
 998 {
 999         DBusMessage* msg;
1000
1001         char service_name[64] = {0,};
1002         char object_path[64] = {0,};
1003         char target_if_name[128] = {0,};
1004
1005         snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
1006         snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1007         snprintf(target_if_name, 128, "%s", VC_MANAGER_SERVICE_INTERFACE);
1008
1009         /* create a signal & check for errors */
1010         msg = dbus_message_new_method_call(
1011                 service_name,
1012                 object_path,
1013                 target_if_name,
1014                 VC_METHOD_AUTH_START);
1015
1016         if (NULL == msg) {
1017                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth start : Fail to make message ");
1018                 return VC_ERROR_OPERATION_FAILED;
1019         } else {
1020                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth start : pid(%d)", pid);
1021         }
1022
1023         DBusMessageIter args;
1024         dbus_message_iter_init_append(msg, &args);
1025
1026         /* Append result*/
1027         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid));
1028
1029         DBusError err;
1030         dbus_error_init(&err);
1031
1032         DBusMessage* result_msg;
1033         int result = VC_ERROR_OPERATION_FAILED;
1034
1035         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1036         dbus_message_unref(msg);
1037
1038         if (dbus_error_is_set(&err)) {
1039                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1040                 dbus_error_free(&err);
1041         }
1042
1043         if (NULL != result_msg) {
1044                 dbus_message_get_args(result_msg, &err,
1045                         DBUS_TYPE_INT32, &result,
1046                         DBUS_TYPE_INVALID);
1047
1048                 if (dbus_error_is_set(&err)) {
1049                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1050                         dbus_error_free(&err);
1051                         result = VC_ERROR_OPERATION_FAILED;
1052                 }
1053                 dbus_message_unref(result_msg);
1054
1055                 if (0 == result) {
1056                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth start : result = %d", result);
1057                 } else {
1058                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth start : result = %d", result);
1059                 }
1060         } else {
1061                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1062                 vc_dbus_reconnect();
1063                 result = VC_ERROR_TIMED_OUT;
1064         }
1065
1066         return result;
1067 }
1068
1069 int vc_dbus_request_auth_stop(int pid, int mgr_pid)
1070 {
1071         DBusMessage* msg;
1072
1073         char service_name[64] = {0,};
1074         char object_path[64] = {0,};
1075         char target_if_name[128] = {0,};
1076
1077         snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
1078         snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1079         snprintf(target_if_name, 128, "%s", VC_MANAGER_SERVICE_INTERFACE);
1080
1081         /* create a signal & check for errors */
1082         msg = dbus_message_new_method_call(
1083                 service_name,
1084                 object_path,
1085                 target_if_name,
1086                 VC_METHOD_AUTH_STOP);
1087
1088         if (NULL == msg) {
1089                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth stop : Fail to make message ");
1090                 return VC_ERROR_OPERATION_FAILED;
1091         } else {
1092                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth stop : pid(%d)", pid);
1093         }
1094
1095         dbus_message_append_args(msg,
1096                 DBUS_TYPE_INT32, &pid,
1097                 DBUS_TYPE_INVALID);
1098
1099         DBusError err;
1100         dbus_error_init(&err);
1101
1102         DBusMessage* result_msg;
1103         int result = VC_ERROR_OPERATION_FAILED;
1104
1105         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1106         dbus_message_unref(msg);
1107
1108         if (dbus_error_is_set(&err)) {
1109                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1110                 dbus_error_free(&err);
1111         }
1112
1113         if (NULL != result_msg) {
1114                 dbus_message_get_args(result_msg, &err,
1115                         DBUS_TYPE_INT32, &result,
1116                         DBUS_TYPE_INVALID);
1117
1118                 if (dbus_error_is_set(&err)) {
1119                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1120                         dbus_error_free(&err);
1121                         result = VC_ERROR_OPERATION_FAILED;
1122                 }
1123                 dbus_message_unref(result_msg);
1124
1125                 if (0 == result) {
1126                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth stop : result = %d", result);
1127                 } else {
1128                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth stop : result = %d", result);
1129                 }
1130         } else {
1131                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1132                 vc_dbus_reconnect();
1133                 result = VC_ERROR_TIMED_OUT;
1134         }
1135
1136         return result;
1137 }
1138
1139 int vc_dbus_request_auth_cancel(int pid, int mgr_pid)
1140 {
1141         DBusMessage* msg;
1142
1143         char service_name[64] = {0,};
1144         char object_path[64] = {0,};
1145         char target_if_name[128] = {0,};
1146
1147         snprintf(service_name, 64, "%s", VC_MANAGER_SERVICE_NAME);
1148         snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1149         snprintf(target_if_name, 128, "%s", VC_MANAGER_SERVICE_INTERFACE);
1150
1151         /* create a signal & check for errors */
1152         msg = dbus_message_new_method_call(
1153                 service_name,
1154                 object_path,    /* object name of the signal */
1155                 target_if_name, /* interface name of the signal */
1156                 VC_METHOD_AUTH_CANCEL); /* name of the signal */
1157
1158         if (NULL == msg) {
1159                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth cancel : Fail to make message ");
1160                 return VC_ERROR_OPERATION_FAILED;
1161         } else {
1162                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth cancel : pid(%d)", pid);
1163         }
1164
1165         dbus_message_append_args(msg,
1166                 DBUS_TYPE_INT32, &pid,
1167                 DBUS_TYPE_INVALID);
1168
1169         DBusError err;
1170         dbus_error_init(&err);
1171
1172         DBusMessage* result_msg;
1173         int result = VC_ERROR_OPERATION_FAILED;
1174
1175         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1176         dbus_message_unref(msg);
1177
1178         if (dbus_error_is_set(&err)) {
1179                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1180                 dbus_error_free(&err);
1181         }
1182
1183         if (NULL != result_msg) {
1184                 dbus_message_get_args(result_msg, &err,
1185                         DBUS_TYPE_INT32, &result,
1186                         DBUS_TYPE_INVALID);
1187
1188                 if (dbus_error_is_set(&err)) {
1189                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1190                         dbus_error_free(&err);
1191                         result = VC_ERROR_OPERATION_FAILED;
1192                 }
1193                 dbus_message_unref(result_msg);
1194
1195                 if (0 == result) {
1196                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth cancel : result = %d", result);
1197                 } else {
1198                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth cancel : result = %d", result);
1199                 }
1200         } else {
1201                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1202                 vc_dbus_reconnect();
1203                 result = VC_ERROR_TIMED_OUT;
1204         }
1205
1206         return result;
1207 }