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