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