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 reason, int daemon_pid, char* msg);
  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_signal(msg, if_name, VCD_METHOD_ERROR)) {
 124                         SLOG(LOG_DEBUG, TAG_VCC, "===== Get Error");
 125                         int reason;
 126                         int daemon_pid;
 127                         char* err_msg;
 128
 129                         dbus_message_get_args(msg, &err,
 130                                 DBUS_TYPE_INT32, &reason,
 131                                 DBUS_TYPE_INT32, &daemon_pid,
 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 : reason(%d), daemon_pid(%d), msg(%s)", reason, daemon_pid, err_msg);
 140                                 __vc_cb_error(reason, daemon_pid, err_msg);
 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_WARN, 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 static int __dbus_check()
 311 {
 312         if (NULL == g_conn_sender) {
 313                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection");
 314                 return vc_dbus_reconnect();
 315         }
 316         return 0;
 317 }
 318
 319 int vc_dbus_request_hello()
 320 {
 321         if (0 != __dbus_check()) {
 322                 return VC_ERROR_OPERATION_FAILED;
 323         }
 324
 325         DBusMessage* msg;
 326
 327         msg = dbus_message_new_method_call(
 328                           VC_SERVER_SERVICE_NAME,
 329                           VC_SERVER_SERVICE_OBJECT_PATH,
 330                           VC_SERVER_SERVICE_INTERFACE,
 331                           VC_METHOD_HELLO);
 332
 333         if (NULL == msg) {
 334                 SLOG(LOG_ERROR, TAG_VCC, ">>>> Request vc hello : Fail to make message");
 335                 return VC_ERROR_OPERATION_FAILED;
 336         }
 337
 338         DBusError err;
 339         dbus_error_init(&err);
 340
 341         DBusMessage* result_msg = NULL;
 342         int result = 0;
 343
 344         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, 500, &err);
 345
 346         if (dbus_error_is_set(&err)) {
 347                 dbus_error_free(&err);
 348         }
 349
 350         dbus_message_unref(msg);
 351
 352         if (NULL != result_msg) {
 353                 dbus_message_unref(result_msg);
 354                 result = 0;
 355         } else {
 356                 result = VC_ERROR_TIMED_OUT;
 357         }
 358
 359         return result;
 360 }
 361
 362
 363 int vc_dbus_request_initialize(int pid, int* mgr_pid, int* service_state, int* daemon_pid)
 364 {
 365         if (0 != __dbus_check()) {
 366                 return VC_ERROR_OPERATION_FAILED;
 367         }
 368
 369         DBusMessage* msg;
 370
 371         msg = dbus_message_new_method_call(
 372                           VC_SERVER_SERVICE_NAME,
 373                           VC_SERVER_SERVICE_OBJECT_PATH,
 374                           VC_SERVER_SERVICE_INTERFACE,
 375                           VC_METHOD_INITIALIZE);
 376
 377         if (NULL == msg) {
 378                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc initialize : Fail to make message ");
 379                 return VC_ERROR_OPERATION_FAILED;
 380         } else {
 381                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc initialize : pid(%d)", pid);
 382         }
 383
 384         dbus_message_append_args(msg,
 385                         DBUS_TYPE_INT32, &pid,
 386                         DBUS_TYPE_INVALID);
 387
 388         DBusError err;
 389         dbus_error_init(&err);
 390
 391         DBusMessage* result_msg;
 392         int result = VC_ERROR_OPERATION_FAILED;
 393
 394         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 395         dbus_message_unref(msg);
 396
 397         if (dbus_error_is_set(&err)) {
 398                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 399                 dbus_error_free(&err);
 400         }
 401
 402         if (NULL != result_msg) {
 403                 int tmp = -1;
 404                 int tmp_service_state = 0;
 405                 int tmp_daemon_pid = 0;
 406                 dbus_message_get_args(result_msg, &err,
 407                         DBUS_TYPE_INT32, &result,
 408                         DBUS_TYPE_INT32, &tmp,
 409                         DBUS_TYPE_INT32, &tmp_service_state,
 410                         DBUS_TYPE_INT32, &tmp_daemon_pid,
 411                         DBUS_TYPE_INVALID);
 412
 413                 if (dbus_error_is_set(&err)) {
 414                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 415                         dbus_error_free(&err);
 416                         result = VC_ERROR_OPERATION_FAILED;
 417                 }
 418
 419                 dbus_message_unref(result_msg);
 420
 421                 if (0 == result) {
 422                         *mgr_pid = tmp;
 423                         *service_state = tmp_service_state;
 424                         *daemon_pid = tmp_daemon_pid;
 425                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc initialize : result = %d mgr = %d service = %d daemon_pid = %d", result, *mgr_pid, *service_state, *daemon_pid);
 426                 } else {
 427                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc initialize : result = %d", result);
 428                 }
 429         } else {
 430                 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL ");
 431                 vc_dbus_reconnect();
 432                 result = VC_ERROR_TIMED_OUT;
 433         }
 434
 435         return result;
 436 }
 437
 438 int vc_dbus_request_finalize(int pid)
 439 {
 440         if (0 != __dbus_check()) {
 441                 return VC_ERROR_OPERATION_FAILED;
 442         }
 443
 444         DBusMessage* msg;
 445
 446         msg = dbus_message_new_method_call(
 447                           VC_SERVER_SERVICE_NAME,
 448                           VC_SERVER_SERVICE_OBJECT_PATH,
 449                           VC_SERVER_SERVICE_INTERFACE,
 450                           VC_METHOD_FINALIZE);
 451
 452         if (NULL == msg) {
 453                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc finalize : Fail to make message ");
 454                 return VC_ERROR_OPERATION_FAILED;
 455         } else {
 456                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc finalize : pid(%d)", pid);
 457         }
 458
 459         dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID);
 460
 461         DBusError err;
 462         dbus_error_init(&err);
 463
 464         DBusMessage* result_msg;
 465         int result = VC_ERROR_OPERATION_FAILED;
 466
 467         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 468         dbus_message_unref(msg);
 469
 470         if (dbus_error_is_set(&err)) {
 471                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 472                 dbus_error_free(&err);
 473         }
 474
 475         if (NULL != result_msg) {
 476                 dbus_message_get_args(result_msg, &err,
 477                                                           DBUS_TYPE_INT32, &result,
 478                                                           DBUS_TYPE_INVALID);
 479
 480                 if (dbus_error_is_set(&err)) {
 481                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 482                         dbus_error_free(&err);
 483                         result = VC_ERROR_OPERATION_FAILED;
 484                 }
 485
 486                 dbus_message_unref(result_msg);
 487
 488                 if (0 == result) {
 489                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc finalize : result = %d", result);
 490                 } else {
 491                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc finalize : result = %d", result);
 492                 }
 493         } else {
 494                 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL ");
 495                 vc_dbus_reconnect();
 496                 result = VC_ERROR_TIMED_OUT;
 497         }
 498
 499         return result;
 500 }
 501
 502 int vc_dbus_request_set_exclusive_command(int pid, bool value)
 503 {
 504         if (0 != __dbus_check()) {
 505                 return VC_ERROR_OPERATION_FAILED;
 506         }
 507
 508         DBusMessage* msg;
 509
 510         msg = dbus_message_new_method_call(
 511                           VC_SERVER_SERVICE_NAME,
 512                           VC_SERVER_SERVICE_OBJECT_PATH,
 513                           VC_SERVER_SERVICE_INTERFACE,
 514                           VC_METHOD_SET_EXCLUSIVE_CMD);
 515
 516         if (NULL == msg) {
 517                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set exclusive command : Fail to make message");
 518                 return VC_ERROR_OPERATION_FAILED;
 519         } else {
 520                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set exclusive command : pid(%d)", pid);
 521         }
 522
 523         int temp = value;
 524
 525         dbus_message_append_args(msg,
 526                                                          DBUS_TYPE_INT32, &pid,
 527                                                          DBUS_TYPE_INT32, &temp,
 528                                                          DBUS_TYPE_INVALID);
 529
 530         DBusError err;
 531         dbus_error_init(&err);
 532
 533         DBusMessage* result_msg;
 534         int result = VC_ERROR_OPERATION_FAILED;
 535
 536         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 537         dbus_message_unref(msg);
 538
 539         if (dbus_error_is_set(&err)) {
 540                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 541                 dbus_error_free(&err);
 542         }
 543
 544         if (NULL != result_msg) {
 545                 dbus_message_get_args(result_msg, &err,
 546                                                           DBUS_TYPE_INT32, &result,
 547                                                           DBUS_TYPE_INVALID);
 548
 549                 if (dbus_error_is_set(&err)) {
 550                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 551                         dbus_error_free(&err);
 552                         result = VC_ERROR_OPERATION_FAILED;
 553                 }
 554                 dbus_message_unref(result_msg);
 555
 556                 if (0 == result) {
 557                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set exclusive command : result = %d", result);
 558                 } else {
 559                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set exclusive command : result = %d", result);
 560                 }
 561         } else {
 562                 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
 563                 vc_dbus_reconnect();
 564                 result = VC_ERROR_TIMED_OUT;
 565         }
 566
 567         return result;
 568 }
 569
 570 int vc_dbus_request_set_command(int pid, vc_cmd_type_e cmd_type)
 571 {
 572         if (0 != __dbus_check()) {
 573                 return VC_ERROR_OPERATION_FAILED;
 574         }
 575
 576         DBusMessage* msg;
 577
 578         msg = dbus_message_new_method_call(
 579                           VC_SERVER_SERVICE_NAME,
 580                           VC_SERVER_SERVICE_OBJECT_PATH,
 581                           VC_SERVER_SERVICE_INTERFACE,
 582                           VC_METHOD_SET_COMMAND);
 583
 584         if (NULL == msg) {
 585                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set command : Fail to make message");
 586                 return VC_ERROR_OPERATION_FAILED;
 587         } else {
 588                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set command : pid(%d)", pid);
 589         }
 590
 591         dbus_message_append_args(msg,
 592                                                          DBUS_TYPE_INT32, &pid,
 593                                                          DBUS_TYPE_INT32, &cmd_type,
 594                                                          DBUS_TYPE_INVALID);
 595
 596         DBusError err;
 597         dbus_error_init(&err);
 598
 599         DBusMessage* result_msg;
 600         int result = VC_ERROR_OPERATION_FAILED;
 601
 602         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 603         dbus_message_unref(msg);
 604
 605         if (dbus_error_is_set(&err)) {
 606                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 607                 dbus_error_free(&err);
 608         }
 609
 610         if (NULL != result_msg) {
 611                 dbus_message_get_args(result_msg, &err,
 612                                                           DBUS_TYPE_INT32, &result,
 613                                                           DBUS_TYPE_INVALID);
 614
 615                 if (dbus_error_is_set(&err)) {
 616                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 617                         dbus_error_free(&err);
 618                         result = VC_ERROR_OPERATION_FAILED;
 619                 }
 620                 dbus_message_unref(result_msg);
 621
 622                 if (0 == result) {
 623                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set command : result = %d", result);
 624                 } else {
 625                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc set command : result = %d", result);
 626                 }
 627         } else {
 628                 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
 629                 vc_dbus_reconnect();
 630                 result = VC_ERROR_TIMED_OUT;
 631         }
 632
 633         return result;
 634 }
 635
 636 int vc_dbus_request_unset_command(int pid, vc_cmd_type_e cmd_type)
 637 {
 638         if (0 != __dbus_check()) {
 639                 return VC_ERROR_OPERATION_FAILED;
 640         }
 641
 642         DBusMessage* msg;
 643
 644         msg = dbus_message_new_method_call(
 645                           VC_SERVER_SERVICE_NAME,
 646                           VC_SERVER_SERVICE_OBJECT_PATH,
 647                           VC_SERVER_SERVICE_INTERFACE,
 648                           VC_METHOD_UNSET_COMMAND);
 649
 650         if (NULL == msg) {
 651                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc unset command : Fail to make message");
 652                 return VC_ERROR_OPERATION_FAILED;
 653         } else {
 654                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc unset command : pid(%d), type(%d)", pid, cmd_type);
 655         }
 656
 657         dbus_message_append_args(msg,
 658                                                          DBUS_TYPE_INT32, &pid,
 659                                                          DBUS_TYPE_INT32, &cmd_type,
 660                                                          DBUS_TYPE_INVALID);
 661
 662         DBusError err;
 663         dbus_error_init(&err);
 664
 665         DBusMessage* result_msg;
 666         int result = VC_ERROR_OPERATION_FAILED;
 667
 668         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 669         dbus_message_unref(msg);
 670
 671         if (dbus_error_is_set(&err)) {
 672                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 673                 dbus_error_free(&err);
 674         }
 675
 676         if (NULL != result_msg) {
 677                 dbus_message_get_args(result_msg, &err,
 678                                                           DBUS_TYPE_INT32, &result,
 679                                                           DBUS_TYPE_INVALID);
 680
 681                 if (dbus_error_is_set(&err)) {
 682                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 683                         dbus_error_free(&err);
 684                         result = VC_ERROR_OPERATION_FAILED;
 685                 }
 686                 dbus_message_unref(result_msg);
 687
 688                 if (0 == result) {
 689                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc unset command : result = %d", result);
 690                 } else {
 691                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc unset command : result = %d", result);
 692                 }
 693         } else {
 694                 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
 695                 vc_dbus_reconnect();
 696                 result = VC_ERROR_TIMED_OUT;
 697         }
 698
 699         return result;
 700 }
 701
 702 int vc_dbus_set_foreground(int pid, bool value)
 703 {
 704         if (0 != __dbus_check()) {
 705                 return VC_ERROR_OPERATION_FAILED;
 706         }
 707
 708         DBusMessage* msg = NULL;
 709         int tmp_value = 0;
 710
 711         tmp_value = (int)value;
 712
 713         msg = dbus_message_new_signal(
 714                 VC_MANAGER_SERVICE_OBJECT_PATH,
 715                 VC_MANAGER_SERVICE_INTERFACE,
 716                 VCC_MANAGER_METHOD_SET_FOREGROUND);
 717
 718         if (NULL == msg) {
 719                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set foreground to manager : Fail to make message");
 720                 return VC_ERROR_OPERATION_FAILED;
 721         } else {
 722                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set foreground to manager : client pid(%d), value(%s)", pid, tmp_value ? "true" : "false");
 723         }
 724
 725         dbus_message_append_args(msg,
 726                 DBUS_TYPE_INT32, &pid,
 727                 DBUS_TYPE_INT32, &tmp_value,
 728                 DBUS_TYPE_INVALID);
 729
 730         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 731                 SLOG(LOG_ERROR, TAG_VCC, "[Dbus ERROR] Fail to Send");
 732                 return VC_ERROR_OPERATION_FAILED;
 733         }
 734
 735         dbus_message_unref(msg);
 736
 737         msg = NULL;
 738         msg = dbus_message_new_method_call(
 739                 VC_SERVER_SERVICE_NAME,
 740                 VC_SERVER_SERVICE_OBJECT_PATH,
 741                 VC_SERVER_SERVICE_INTERFACE,
 742                 VC_METHOD_SET_FOREGROUND);
 743
 744         if (NULL == msg) {
 745                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc set foreground to daemon : Fail to make message");
 746                 return VC_ERROR_OPERATION_FAILED;
 747         } else {
 748                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc set foreground to daemon : client pid(%d), value(%s)", pid, tmp_value ? "true" : "false");
 749         }
 750
 751         dbus_message_append_args(msg,
 752                 DBUS_TYPE_INT32, &pid,
 753                 DBUS_TYPE_INT32, &tmp_value,
 754                 DBUS_TYPE_INVALID);
 755
 756         dbus_message_set_no_reply(msg, TRUE);
 757
 758         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 759                 SLOG(LOG_ERROR, TAG_VCC, "[Dbus ERROR] Fail to Send");
 760                 return VC_ERROR_OPERATION_FAILED;
 761         }
 762
 763         dbus_connection_flush(g_conn_sender);
 764
 765         dbus_message_unref(msg);
 766
 767         return 0;
 768 }
 769
 770 int vc_dbus_request_dialog(int pid, const char* disp_text, const char* utt_text, bool continuous)
 771 {
 772         if (NULL == g_conn_sender) {
 773                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection");
 774                 if (0 != vc_dbus_reconnect()) {
 775                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to reconnect");
 776                 }
 777         }
 778
 779         DBusMessage* msg;
 780         int tmp_continue = 0;
 781
 782         tmp_continue = (int)continuous;
 783
 784         msg = dbus_message_new_method_call(
 785                 VC_SERVER_SERVICE_NAME,
 786                 VC_SERVER_SERVICE_OBJECT_PATH,
 787                 VC_SERVER_SERVICE_INTERFACE,
 788                 VC_METHOD_DIALOG);
 789
 790         if (NULL == msg) {
 791                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc request dialog to manager : Fail to make message");
 792                 return VC_ERROR_OPERATION_FAILED;
 793         } else {
 794                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc request dialog to manager : client pid(%d), disp_text(%s), utt_text(%s), continuous(%d)", getpid(), disp_text, utt_text, continuous);
 795         }
 796
 797         dbus_message_append_args(msg,
 798                                 DBUS_TYPE_INT32, &pid,
 799                                 DBUS_TYPE_STRING, &disp_text,
 800                                 DBUS_TYPE_STRING, &utt_text,
 801                                 DBUS_TYPE_INT32, &tmp_continue,
 802                                 DBUS_TYPE_INVALID);
 803
 804         DBusError err;
 805         dbus_error_init(&err);
 806
 807         DBusMessage* result_msg;
 808         int result = VC_ERROR_OPERATION_FAILED;
 809
 810         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 811         dbus_message_unref(msg);
 812
 813         if (dbus_error_is_set(&err)) {
 814                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 815                 dbus_error_free(&err);
 816         }
 817
 818         if (NULL != result_msg) {
 819                 dbus_message_get_args(result_msg, &err,
 820                                         DBUS_TYPE_INT32, &result,
 821                                         DBUS_TYPE_INVALID);
 822
 823                 if (dbus_error_is_set(&err)) {
 824                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 825                         dbus_error_free(&err);
 826                         result = VC_ERROR_OPERATION_FAILED;
 827                 }
 828                 dbus_message_unref(result_msg);
 829
 830                 if (0 == result) {
 831                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set command : result = %d", result);
 832                 } else {
 833                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc set command : result = %d", result);
 834                 }
 835         } else {
 836                 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
 837                 vc_dbus_reconnect();
 838                 result = VC_ERROR_TIMED_OUT;
 839         }
 840
 841         return result;
 842 }
 843
 844 int vc_dbus_request_is_system_command_valid(int pid, bool* is_sys_cmd_valid)
 845 {
 846         if (NULL == g_conn_sender) {
 847                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection");
 848                 if (0 != vc_dbus_reconnect()) {
 849                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to reconnect");
 850                 }
 851         }
 852
 853         DBusMessage* msg;
 854
 855         msg = dbus_message_new_method_call(
 856                           VC_SERVER_SERVICE_NAME,
 857                           VC_SERVER_SERVICE_OBJECT_PATH,
 858                           VC_SERVER_SERVICE_INTERFACE,
 859                           VC_METHOD_IS_SYS_COMMAND_VALID);
 860
 861         if (NULL == msg) {
 862                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc is system command valid : Fail to make message");
 863                 return VC_ERROR_OPERATION_FAILED;
 864         } else {
 865                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc is system command valid : pid(%d)", pid);
 866         }
 867
 868         dbus_message_append_args(msg,
 869                                 DBUS_TYPE_INT32, &pid,
 870                                 DBUS_TYPE_INVALID);
 871
 872         DBusError err;
 873         dbus_error_init(&err);
 874         int tmp_sys_cmd = 0;
 875
 876         DBusMessage* result_msg;
 877         int result = VC_ERROR_OPERATION_FAILED;
 878
 879         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 880         dbus_message_unref(msg);
 881
 882         if (dbus_error_is_set(&err)) {
 883                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 884                 dbus_error_free(&err);
 885         }
 886
 887         if (NULL != result_msg) {
 888                 dbus_message_get_args(result_msg, &err,
 889                                         DBUS_TYPE_INT32, &result,
 890                                         DBUS_TYPE_INT32, &tmp_sys_cmd,
 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                         *is_sys_cmd_valid = (bool)tmp_sys_cmd;
 902                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc is system command valid : result = %d, is_sys_cmd_valid = %d", result, *is_sys_cmd_valid);
 903                 } else {
 904                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc is system command valid : result = %d", result);
 905                 }
 906         } else {
 907                 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
 908                 vc_dbus_reconnect();
 909                 result = VC_ERROR_TIMED_OUT;
 910         }
 911
 912         return result;
 913 }
 914
 915
 916 #if 0
 917 int vc_dbus_request_start(int pid, int silence)
 918 {
 919         DBusMessage* msg;
 920
 921         /* create a signal & check for errors */
 922         msg = dbus_message_new_method_call(
 923                           VC_SERVER_SERVICE_NAME,
 924                           VC_SERVER_SERVICE_OBJECT_PATH,
 925                           VC_SERVER_SERVICE_INTERFACE,
 926                           VC_METHOD_REQUEST_START);
 927
 928         if (NULL == msg) {
 929                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc start : Fail to make message ");
 930                 return VC_ERROR_OPERATION_FAILED;
 931         } else {
 932                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc start : pid(%d), silence(%d)", pid, silence);
 933         }
 934
 935         DBusMessageIter args;
 936         dbus_message_iter_init_append(msg, &args);
 937
 938         /* Append result*/
 939         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid));
 940         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(silence));
 941
 942         DBusError err;
 943         dbus_error_init(&err);
 944
 945         DBusMessage* result_msg;
 946         int result = VC_ERROR_OPERATION_FAILED;
 947
 948         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 949         dbus_message_unref(msg);
 950
 951         if (dbus_error_is_set(&err)) {
 952                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 953                 dbus_error_free(&err);
 954         }
 955
 956         if (NULL != result_msg) {
 957                 dbus_message_get_args(result_msg, &err,
 958                                                           DBUS_TYPE_INT32, &result,
 959                                                           DBUS_TYPE_INVALID);
 960
 961                 if (dbus_error_is_set(&err)) {
 962                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 963                         dbus_error_free(&err);
 964                         result = VC_ERROR_OPERATION_FAILED;
 965                 }
 966                 dbus_message_unref(result_msg);
 967
 968                 if (0 == result) {
 969                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc start : result = %d", result);
 970                 } else {
 971                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc start : result = %d", result);
 972                 }
 973         } else {
 974                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
 975                 vc_dbus_reconnect();
 976                 result = VC_ERROR_TIMED_OUT;
 977         }
 978
 979         return result;
 980 }
 981
 982 int vc_dbus_request_stop(int pid)
 983 {
 984         DBusMessage* msg;
 985
 986         /* create a signal & check for errors */
 987         msg = dbus_message_new_method_call(
 988                           VC_SERVER_SERVICE_NAME,
 989                           VC_SERVER_SERVICE_OBJECT_PATH,
 990                           VC_SERVER_SERVICE_INTERFACE,
 991                           VC_METHOD_REQUEST_STOP);
 992
 993         if (NULL == msg) {
 994                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc stop : Fail to make message ");
 995                 return VC_ERROR_OPERATION_FAILED;
 996         } else {
 997                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc stop : pid(%d)", pid);
 998         }
 999
1000         dbus_message_append_args(msg,
1001                                                          DBUS_TYPE_INT32, &pid,
1002                                                          DBUS_TYPE_INVALID);
1003
1004         DBusError err;
1005         dbus_error_init(&err);
1006
1007         DBusMessage* result_msg;
1008         int result = VC_ERROR_OPERATION_FAILED;
1009
1010         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1011         dbus_message_unref(msg);
1012
1013         if (dbus_error_is_set(&err)) {
1014                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1015                 dbus_error_free(&err);
1016         }
1017
1018         if (NULL != result_msg) {
1019                 dbus_message_get_args(result_msg, &err,
1020                                                           DBUS_TYPE_INT32, &result,
1021                                                           DBUS_TYPE_INVALID);
1022
1023                 if (dbus_error_is_set(&err)) {
1024                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1025                         dbus_error_free(&err);
1026                         result = VC_ERROR_OPERATION_FAILED;
1027                 }
1028                 dbus_message_unref(result_msg);
1029
1030                 if (0 == result) {
1031                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc stop : result = %d", result);
1032                 } else {
1033                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc stop : result = %d", result);
1034                 }
1035         } else {
1036                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1037                 vc_dbus_reconnect();
1038                 result = VC_ERROR_TIMED_OUT;
1039         }
1040
1041         return result;
1042 }
1043
1044 int vc_dbus_request_cancel(int pid)
1045 {
1046         DBusMessage* msg;
1047
1048         /* create a signal & check for errors */
1049         msg = dbus_message_new_method_call(
1050                           VC_SERVER_SERVICE_NAME,
1051                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
1052                           VC_SERVER_SERVICE_INTERFACE,  /* interface name of the signal */
1053                           VC_METHOD_REQUEST_CANCEL);    /* name of the signal */
1054
1055         if (NULL == msg) {
1056                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc cancel : Fail to make message ");
1057                 return VC_ERROR_OPERATION_FAILED;
1058         } else {
1059                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc cancel : pid(%d)", pid);
1060         }
1061
1062         dbus_message_append_args(msg,
1063                                                          DBUS_TYPE_INT32, &pid,
1064                                                          DBUS_TYPE_INVALID);
1065
1066         DBusError err;
1067         dbus_error_init(&err);
1068
1069         DBusMessage* result_msg;
1070         int result = VC_ERROR_OPERATION_FAILED;
1071
1072         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1073         dbus_message_unref(msg);
1074
1075         if (dbus_error_is_set(&err)) {
1076                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1077                 dbus_error_free(&err);
1078         }
1079
1080         if (NULL != result_msg) {
1081                 dbus_message_get_args(result_msg, &err,
1082                                                           DBUS_TYPE_INT32, &result,
1083                                                           DBUS_TYPE_INVALID);
1084
1085                 if (dbus_error_is_set(&err)) {
1086                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1087                         dbus_error_free(&err);
1088                         result = VC_ERROR_OPERATION_FAILED;
1089                 }
1090                 dbus_message_unref(result_msg);
1091
1092                 if (0 == result) {
1093                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc cancel : result = %d", result);
1094                 } else {
1095                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc cancel : result = %d", result);
1096                 }
1097         } else {
1098                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1099                 vc_dbus_reconnect();
1100                 result = VC_ERROR_TIMED_OUT;
1101         }
1102
1103         return result;
1104 }
1105 #endif
1106
1107 /* Authority */
1108 int vc_dbus_request_auth_enable(int pid, int mgr_pid)
1109 {
1110         if (0 != __dbus_check()) {
1111                 return VC_ERROR_OPERATION_FAILED;
1112         }
1113
1114         DBusMessage* msg;
1115
1116         char service_name[64] = {0,};
1117         char object_path[64] = {0,};
1118         char target_if_name[128] = {0,};
1119
1120         snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1121         snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1122         snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1123
1124         /* create a signal & check for errors */
1125         msg = dbus_message_new_method_call(
1126                           service_name,
1127                           object_path,  /* object name of the signal */
1128                           target_if_name,       /* interface name of the signal */
1129                           VC_METHOD_AUTH_ENABLE);       /* name of the signal */
1130
1131         if (NULL == msg) {
1132                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth enable : Fail to make message ");
1133                 return VC_ERROR_OPERATION_FAILED;
1134         } else {
1135                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth enable : pid(%d)", pid);
1136         }
1137
1138         dbus_message_append_args(msg,
1139                                                          DBUS_TYPE_INT32, &pid,
1140                                                          DBUS_TYPE_INVALID);
1141
1142         DBusError err;
1143         dbus_error_init(&err);
1144
1145         DBusMessage* result_msg;
1146         int result = VC_ERROR_OPERATION_FAILED;
1147
1148         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1149         dbus_message_unref(msg);
1150
1151         if (dbus_error_is_set(&err)) {
1152                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1153                 dbus_error_free(&err);
1154         }
1155
1156         if (NULL != result_msg) {
1157                 dbus_message_get_args(result_msg, &err,
1158                                                           DBUS_TYPE_INT32, &result,
1159                                                           DBUS_TYPE_INVALID);
1160
1161                 if (dbus_error_is_set(&err)) {
1162                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1163                         dbus_error_free(&err);
1164                         result = VC_ERROR_OPERATION_FAILED;
1165                 }
1166                 dbus_message_unref(result_msg);
1167
1168                 if (0 == result) {
1169                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth enable : result = %d", result);
1170                 } else {
1171                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth enable : result = %d", result);
1172                 }
1173         } else {
1174                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1175                 vc_dbus_reconnect();
1176                 result = VC_ERROR_TIMED_OUT;
1177         }
1178
1179         return result;
1180 }
1181
1182 int vc_dbus_request_auth_disable(int pid, int mgr_pid)
1183 {
1184         if (0 != __dbus_check()) {
1185                 return VC_ERROR_OPERATION_FAILED;
1186         }
1187
1188         DBusMessage* msg;
1189
1190         char service_name[64] = {0,};
1191         char object_path[64] = {0,};
1192         char target_if_name[128] = {0,};
1193
1194         snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1195         snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1196         snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1197
1198         /* create a signal & check for errors */
1199         msg = dbus_message_new_method_call(
1200                           service_name,
1201                           object_path,  /* object name of the signal */
1202                           target_if_name,       /* interface name of the signal */
1203                           VC_METHOD_AUTH_DISABLE);      /* name of the signal */
1204
1205         if (NULL == msg) {
1206                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth disable : Fail to make message ");
1207                 return VC_ERROR_OPERATION_FAILED;
1208         } else {
1209                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth disable : pid(%d)", pid);
1210         }
1211
1212         dbus_message_append_args(msg,
1213                                                          DBUS_TYPE_INT32, &pid,
1214                                                          DBUS_TYPE_INVALID);
1215
1216         DBusError err;
1217         dbus_error_init(&err);
1218
1219         DBusMessage* result_msg;
1220         int result = VC_ERROR_OPERATION_FAILED;
1221
1222         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1223         dbus_message_unref(msg);
1224
1225         if (dbus_error_is_set(&err)) {
1226                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1227                 dbus_error_free(&err);
1228         }
1229
1230         if (NULL != result_msg) {
1231                 dbus_message_get_args(result_msg, &err,
1232                                                           DBUS_TYPE_INT32, &result,
1233                                                           DBUS_TYPE_INVALID);
1234
1235                 if (dbus_error_is_set(&err)) {
1236                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1237                         dbus_error_free(&err);
1238                         result = VC_ERROR_OPERATION_FAILED;
1239                 }
1240                 dbus_message_unref(result_msg);
1241
1242                 if (0 == result) {
1243                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth disable : result = %d", result);
1244                 } else {
1245                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth disable : result = %d", result);
1246                 }
1247         } else {
1248                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1249                 vc_dbus_reconnect();
1250                 result = VC_ERROR_TIMED_OUT;
1251         }
1252
1253         return result;
1254 }
1255
1256 int vc_dbus_request_auth_start(int pid, int mgr_pid)
1257 {
1258         if (0 != __dbus_check()) {
1259                 return VC_ERROR_OPERATION_FAILED;
1260         }
1261
1262         DBusMessage* msg;
1263
1264         char service_name[64] = {0,};
1265         char object_path[64] = {0,};
1266         char target_if_name[128] = {0,};
1267
1268         snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1269         snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1270         snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1271
1272         /* create a signal & check for errors */
1273         msg = dbus_message_new_method_call(
1274                           service_name,
1275                           object_path,
1276                           target_if_name,
1277                           VC_METHOD_AUTH_START);
1278
1279         if (NULL == msg) {
1280                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth start : Fail to make message ");
1281                 return VC_ERROR_OPERATION_FAILED;
1282         } else {
1283                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth start : pid(%d)", pid);
1284         }
1285
1286         DBusMessageIter args;
1287         dbus_message_iter_init_append(msg, &args);
1288
1289         /* Append result*/
1290         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid));
1291
1292         DBusError err;
1293         dbus_error_init(&err);
1294
1295         DBusMessage* result_msg;
1296         int result = VC_ERROR_OPERATION_FAILED;
1297
1298         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1299         dbus_message_unref(msg);
1300
1301         if (dbus_error_is_set(&err)) {
1302                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1303                 dbus_error_free(&err);
1304         }
1305
1306         if (NULL != result_msg) {
1307                 dbus_message_get_args(result_msg, &err,
1308                                                           DBUS_TYPE_INT32, &result,
1309                                                           DBUS_TYPE_INVALID);
1310
1311                 if (dbus_error_is_set(&err)) {
1312                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1313                         dbus_error_free(&err);
1314                         result = VC_ERROR_OPERATION_FAILED;
1315                 }
1316                 dbus_message_unref(result_msg);
1317
1318                 if (0 == result) {
1319                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth start : result = %d", result);
1320                 } else {
1321                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth start : result = %d", result);
1322                 }
1323         } else {
1324                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1325                 vc_dbus_reconnect();
1326                 result = VC_ERROR_TIMED_OUT;
1327         }
1328
1329         return result;
1330 }
1331
1332 int vc_dbus_request_auth_stop(int pid, int mgr_pid)
1333 {
1334         if (0 != __dbus_check()) {
1335                 return VC_ERROR_OPERATION_FAILED;
1336         }
1337
1338         DBusMessage* msg;
1339
1340         char service_name[64] = {0,};
1341         char object_path[64] = {0,};
1342         char target_if_name[128] = {0,};
1343
1344         snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1345         snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1346         snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1347
1348         /* create a signal & check for errors */
1349         msg = dbus_message_new_method_call(
1350                           service_name,
1351                           object_path,
1352                           target_if_name,
1353                           VC_METHOD_AUTH_STOP);
1354
1355         if (NULL == msg) {
1356                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth stop : Fail to make message ");
1357                 return VC_ERROR_OPERATION_FAILED;
1358         } else {
1359                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth stop : pid(%d)", pid);
1360         }
1361
1362         dbus_message_append_args(msg,
1363                                                          DBUS_TYPE_INT32, &pid,
1364                                                          DBUS_TYPE_INVALID);
1365
1366         DBusError err;
1367         dbus_error_init(&err);
1368
1369         DBusMessage* result_msg;
1370         int result = VC_ERROR_OPERATION_FAILED;
1371
1372         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1373         dbus_message_unref(msg);
1374
1375         if (dbus_error_is_set(&err)) {
1376                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1377                 dbus_error_free(&err);
1378         }
1379
1380         if (NULL != result_msg) {
1381                 dbus_message_get_args(result_msg, &err,
1382                                                           DBUS_TYPE_INT32, &result,
1383                                                           DBUS_TYPE_INVALID);
1384
1385                 if (dbus_error_is_set(&err)) {
1386                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1387                         dbus_error_free(&err);
1388                         result = VC_ERROR_OPERATION_FAILED;
1389                 }
1390                 dbus_message_unref(result_msg);
1391
1392                 if (0 == result) {
1393                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth stop : result = %d", result);
1394                 } else {
1395                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth stop : result = %d", result);
1396                 }
1397         } else {
1398                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1399                 vc_dbus_reconnect();
1400                 result = VC_ERROR_TIMED_OUT;
1401         }
1402
1403         return result;
1404 }
1405
1406 int vc_dbus_request_auth_cancel(int pid, int mgr_pid)
1407 {
1408         if (0 != __dbus_check()) {
1409                 return VC_ERROR_OPERATION_FAILED;
1410         }
1411
1412         DBusMessage* msg;
1413
1414         char service_name[64] = {0,};
1415         char object_path[64] = {0,};
1416         char target_if_name[128] = {0,};
1417
1418         snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1419         snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1420         snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1421
1422         /* create a signal & check for errors */
1423         msg = dbus_message_new_method_call(
1424                           service_name,
1425                           object_path,  /* object name of the signal */
1426                           target_if_name,       /* interface name of the signal */
1427                           VC_METHOD_AUTH_CANCEL);       /* name of the signal */
1428
1429         if (NULL == msg) {
1430                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth cancel : Fail to make message ");
1431                 return VC_ERROR_OPERATION_FAILED;
1432         } else {
1433                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth cancel : pid(%d)", pid);
1434         }
1435
1436         dbus_message_append_args(msg,
1437                                                          DBUS_TYPE_INT32, &pid,
1438                                                          DBUS_TYPE_INVALID);
1439
1440         DBusError err;
1441         dbus_error_init(&err);
1442
1443         DBusMessage* result_msg;
1444         int result = VC_ERROR_OPERATION_FAILED;
1445
1446         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1447         dbus_message_unref(msg);
1448
1449         if (dbus_error_is_set(&err)) {
1450                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1451                 dbus_error_free(&err);
1452         }
1453
1454         if (NULL != result_msg) {
1455                 dbus_message_get_args(result_msg, &err,
1456                                                           DBUS_TYPE_INT32, &result,
1457                                                           DBUS_TYPE_INVALID);
1458
1459                 if (dbus_error_is_set(&err)) {
1460                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1461                         dbus_error_free(&err);
1462                         result = VC_ERROR_OPERATION_FAILED;
1463                 }
1464                 dbus_message_unref(result_msg);
1465
1466                 if (0 == result) {
1467                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth cancel : result = %d", result);
1468                 } else {
1469                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth cancel : result = %d", result);
1470                 }
1471         } else {
1472                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1473                 vc_dbus_reconnect();
1474                 result = VC_ERROR_TIMED_OUT;
1475         }
1476
1477         return result;
1478 }