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