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         dbus_message_set_no_reply(msg, TRUE);
 821
 822         if (1 != dbus_connection_send(g_conn_sender, msg, NULL)) {
 823                 SLOG(LOG_ERROR, TAG_VCC, "[Dbus ERROR] Fail to Send");
 824                 return VC_ERROR_OPERATION_FAILED;
 825         } else {
 826                 SLOG(LOG_DEBUG, TAG_VCC, "[Dbus DEBUG] Success to Send");
 827                 dbus_connection_flush(g_conn_sender);
 828         }
 829
 830         dbus_message_unref(msg);
 831
 832         return 0;
 833
 834 /*
 835         DBusError err;
 836         dbus_error_init(&err);
 837
 838         DBusMessage* result_msg;
 839         int result = VC_ERROR_OPERATION_FAILED;
 840
 841         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 842         dbus_message_unref(msg);
 843
 844         if (dbus_error_is_set(&err)) {
 845                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 846                 dbus_error_free(&err);
 847         }
 848
 849         if (NULL != result_msg) {
 850                 dbus_message_get_args(result_msg, &err,
 851                                         DBUS_TYPE_INT32, &result,
 852                                         DBUS_TYPE_INVALID);
 853
 854                 if (dbus_error_is_set(&err)) {
 855                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 856                         dbus_error_free(&err);
 857                         result = VC_ERROR_OPERATION_FAILED;
 858                 }
 859                 dbus_message_unref(result_msg);
 860
 861                 if (0 == result) {
 862                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc set command : result = %d", result);
 863                 } else {
 864                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc set command : result = %d", result);
 865                 }
 866         } else {
 867                 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
 868                 vc_dbus_reconnect();
 869                 result = VC_ERROR_TIMED_OUT;
 870         }
 871
 872         return result;
 873 */
 874 }
 875
 876 int vc_dbus_request_is_system_command_valid(int pid, bool* is_sys_cmd_valid)
 877 {
 878         if (NULL == g_conn_sender) {
 879                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] NULL connection");
 880                 if (0 != vc_dbus_reconnect()) {
 881                         SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Fail to reconnect");
 882                 }
 883         }
 884
 885         DBusMessage* msg;
 886
 887         msg = dbus_message_new_method_call(
 888                           VC_SERVER_SERVICE_NAME,
 889                           VC_SERVER_SERVICE_OBJECT_PATH,
 890                           VC_SERVER_SERVICE_INTERFACE,
 891                           VC_METHOD_IS_SYS_COMMAND_VALID);
 892
 893         if (NULL == msg) {
 894                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc is system command valid : Fail to make message");
 895                 return VC_ERROR_OPERATION_FAILED;
 896         } else {
 897                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc is system command valid : pid(%d)", pid);
 898         }
 899
 900         dbus_message_append_args(msg,
 901                                 DBUS_TYPE_INT32, &pid,
 902                                 DBUS_TYPE_INVALID);
 903
 904         DBusError err;
 905         dbus_error_init(&err);
 906         int tmp_sys_cmd = 0;
 907
 908         DBusMessage* result_msg;
 909         int result = VC_ERROR_OPERATION_FAILED;
 910
 911         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 912         dbus_message_unref(msg);
 913
 914         if (dbus_error_is_set(&err)) {
 915                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 916                 dbus_error_free(&err);
 917         }
 918
 919         if (NULL != result_msg) {
 920                 dbus_message_get_args(result_msg, &err,
 921                                         DBUS_TYPE_INT32, &result,
 922                                         DBUS_TYPE_INT32, &tmp_sys_cmd,
 923                                         DBUS_TYPE_INVALID);
 924
 925                 if (dbus_error_is_set(&err)) {
 926                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 927                         dbus_error_free(&err);
 928                         result = VC_ERROR_OPERATION_FAILED;
 929                 }
 930                 dbus_message_unref(result_msg);
 931
 932                 if (0 == result) {
 933                         *is_sys_cmd_valid = (bool)tmp_sys_cmd;
 934                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc is system command valid : result = %d, is_sys_cmd_valid = %d", result, *is_sys_cmd_valid);
 935                 } else {
 936                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc is system command valid : result = %d", result);
 937                 }
 938         } else {
 939                 SLOG(LOG_ERROR, TAG_VCC, "<<<< Result message is NULL");
 940                 vc_dbus_reconnect();
 941                 result = VC_ERROR_TIMED_OUT;
 942         }
 943
 944         return result;
 945 }
 946
 947
 948 #if 0
 949 int vc_dbus_request_start(int pid, int silence)
 950 {
 951         DBusMessage* msg;
 952
 953         /* create a signal & check for errors */
 954         msg = dbus_message_new_method_call(
 955                           VC_SERVER_SERVICE_NAME,
 956                           VC_SERVER_SERVICE_OBJECT_PATH,
 957                           VC_SERVER_SERVICE_INTERFACE,
 958                           VC_METHOD_REQUEST_START);
 959
 960         if (NULL == msg) {
 961                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc start : Fail to make message ");
 962                 return VC_ERROR_OPERATION_FAILED;
 963         } else {
 964                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc start : pid(%d), silence(%d)", pid, silence);
 965         }
 966
 967         DBusMessageIter args;
 968         dbus_message_iter_init_append(msg, &args);
 969
 970         /* Append result*/
 971         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid));
 972         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(silence));
 973
 974         DBusError err;
 975         dbus_error_init(&err);
 976
 977         DBusMessage* result_msg;
 978         int result = VC_ERROR_OPERATION_FAILED;
 979
 980         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 981         dbus_message_unref(msg);
 982
 983         if (dbus_error_is_set(&err)) {
 984                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
 985                 dbus_error_free(&err);
 986         }
 987
 988         if (NULL != result_msg) {
 989                 dbus_message_get_args(result_msg, &err,
 990                                                           DBUS_TYPE_INT32, &result,
 991                                                           DBUS_TYPE_INVALID);
 992
 993                 if (dbus_error_is_set(&err)) {
 994                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
 995                         dbus_error_free(&err);
 996                         result = VC_ERROR_OPERATION_FAILED;
 997                 }
 998                 dbus_message_unref(result_msg);
 999
1000                 if (0 == result) {
1001                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc start : result = %d", result);
1002                 } else {
1003                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc start : result = %d", result);
1004                 }
1005         } else {
1006                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1007                 vc_dbus_reconnect();
1008                 result = VC_ERROR_TIMED_OUT;
1009         }
1010
1011         return result;
1012 }
1013
1014 int vc_dbus_request_stop(int pid)
1015 {
1016         DBusMessage* msg;
1017
1018         /* create a signal & check for errors */
1019         msg = dbus_message_new_method_call(
1020                           VC_SERVER_SERVICE_NAME,
1021                           VC_SERVER_SERVICE_OBJECT_PATH,
1022                           VC_SERVER_SERVICE_INTERFACE,
1023                           VC_METHOD_REQUEST_STOP);
1024
1025         if (NULL == msg) {
1026                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc stop : Fail to make message ");
1027                 return VC_ERROR_OPERATION_FAILED;
1028         } else {
1029                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc stop : pid(%d)", pid);
1030         }
1031
1032         dbus_message_append_args(msg,
1033                                                          DBUS_TYPE_INT32, &pid,
1034                                                          DBUS_TYPE_INVALID);
1035
1036         DBusError err;
1037         dbus_error_init(&err);
1038
1039         DBusMessage* result_msg;
1040         int result = VC_ERROR_OPERATION_FAILED;
1041
1042         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1043         dbus_message_unref(msg);
1044
1045         if (dbus_error_is_set(&err)) {
1046                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1047                 dbus_error_free(&err);
1048         }
1049
1050         if (NULL != result_msg) {
1051                 dbus_message_get_args(result_msg, &err,
1052                                                           DBUS_TYPE_INT32, &result,
1053                                                           DBUS_TYPE_INVALID);
1054
1055                 if (dbus_error_is_set(&err)) {
1056                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1057                         dbus_error_free(&err);
1058                         result = VC_ERROR_OPERATION_FAILED;
1059                 }
1060                 dbus_message_unref(result_msg);
1061
1062                 if (0 == result) {
1063                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc stop : result = %d", result);
1064                 } else {
1065                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc stop : result = %d", result);
1066                 }
1067         } else {
1068                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1069                 vc_dbus_reconnect();
1070                 result = VC_ERROR_TIMED_OUT;
1071         }
1072
1073         return result;
1074 }
1075
1076 int vc_dbus_request_cancel(int pid)
1077 {
1078         DBusMessage* msg;
1079
1080         /* create a signal & check for errors */
1081         msg = dbus_message_new_method_call(
1082                           VC_SERVER_SERVICE_NAME,
1083                           VC_SERVER_SERVICE_OBJECT_PATH,        /* object name of the signal */
1084                           VC_SERVER_SERVICE_INTERFACE,  /* interface name of the signal */
1085                           VC_METHOD_REQUEST_CANCEL);    /* name of the signal */
1086
1087         if (NULL == msg) {
1088                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc cancel : Fail to make message ");
1089                 return VC_ERROR_OPERATION_FAILED;
1090         } else {
1091                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc cancel : pid(%d)", pid);
1092         }
1093
1094         dbus_message_append_args(msg,
1095                                                          DBUS_TYPE_INT32, &pid,
1096                                                          DBUS_TYPE_INVALID);
1097
1098         DBusError err;
1099         dbus_error_init(&err);
1100
1101         DBusMessage* result_msg;
1102         int result = VC_ERROR_OPERATION_FAILED;
1103
1104         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1105         dbus_message_unref(msg);
1106
1107         if (dbus_error_is_set(&err)) {
1108                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1109                 dbus_error_free(&err);
1110         }
1111
1112         if (NULL != result_msg) {
1113                 dbus_message_get_args(result_msg, &err,
1114                                                           DBUS_TYPE_INT32, &result,
1115                                                           DBUS_TYPE_INVALID);
1116
1117                 if (dbus_error_is_set(&err)) {
1118                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1119                         dbus_error_free(&err);
1120                         result = VC_ERROR_OPERATION_FAILED;
1121                 }
1122                 dbus_message_unref(result_msg);
1123
1124                 if (0 == result) {
1125                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc cancel : result = %d", result);
1126                 } else {
1127                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc cancel : result = %d", result);
1128                 }
1129         } else {
1130                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1131                 vc_dbus_reconnect();
1132                 result = VC_ERROR_TIMED_OUT;
1133         }
1134
1135         return result;
1136 }
1137 #endif
1138
1139 /* Authority */
1140 int vc_dbus_request_auth_enable(int pid, int mgr_pid)
1141 {
1142         if (0 != __dbus_check()) {
1143                 return VC_ERROR_OPERATION_FAILED;
1144         }
1145
1146         DBusMessage* msg;
1147
1148         char service_name[64] = {0,};
1149         char object_path[64] = {0,};
1150         char target_if_name[128] = {0,};
1151
1152         snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1153         snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1154         snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1155
1156         /* create a signal & check for errors */
1157         msg = dbus_message_new_method_call(
1158                           service_name,
1159                           object_path,  /* object name of the signal */
1160                           target_if_name,       /* interface name of the signal */
1161                           VC_METHOD_AUTH_ENABLE);       /* name of the signal */
1162
1163         if (NULL == msg) {
1164                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth enable : Fail to make message ");
1165                 return VC_ERROR_OPERATION_FAILED;
1166         } else {
1167                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth enable : pid(%d)", pid);
1168         }
1169
1170         dbus_message_append_args(msg,
1171                                                          DBUS_TYPE_INT32, &pid,
1172                                                          DBUS_TYPE_INVALID);
1173
1174         DBusError err;
1175         dbus_error_init(&err);
1176
1177         DBusMessage* result_msg;
1178         int result = VC_ERROR_OPERATION_FAILED;
1179
1180         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1181         dbus_message_unref(msg);
1182
1183         if (dbus_error_is_set(&err)) {
1184                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1185                 dbus_error_free(&err);
1186         }
1187
1188         if (NULL != result_msg) {
1189                 dbus_message_get_args(result_msg, &err,
1190                                                           DBUS_TYPE_INT32, &result,
1191                                                           DBUS_TYPE_INVALID);
1192
1193                 if (dbus_error_is_set(&err)) {
1194                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1195                         dbus_error_free(&err);
1196                         result = VC_ERROR_OPERATION_FAILED;
1197                 }
1198                 dbus_message_unref(result_msg);
1199
1200                 if (0 == result) {
1201                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth enable : result = %d", result);
1202                 } else {
1203                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth enable : result = %d", result);
1204                 }
1205         } else {
1206                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1207                 vc_dbus_reconnect();
1208                 result = VC_ERROR_TIMED_OUT;
1209         }
1210
1211         return result;
1212 }
1213
1214 int vc_dbus_request_auth_disable(int pid, int mgr_pid)
1215 {
1216         if (0 != __dbus_check()) {
1217                 return VC_ERROR_OPERATION_FAILED;
1218         }
1219
1220         DBusMessage* msg;
1221
1222         char service_name[64] = {0,};
1223         char object_path[64] = {0,};
1224         char target_if_name[128] = {0,};
1225
1226         snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1227         snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1228         snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1229
1230         /* create a signal & check for errors */
1231         msg = dbus_message_new_method_call(
1232                           service_name,
1233                           object_path,  /* object name of the signal */
1234                           target_if_name,       /* interface name of the signal */
1235                           VC_METHOD_AUTH_DISABLE);      /* name of the signal */
1236
1237         if (NULL == msg) {
1238                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth disable : Fail to make message ");
1239                 return VC_ERROR_OPERATION_FAILED;
1240         } else {
1241                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth disable : pid(%d)", pid);
1242         }
1243
1244         dbus_message_append_args(msg,
1245                                                          DBUS_TYPE_INT32, &pid,
1246                                                          DBUS_TYPE_INVALID);
1247
1248         DBusError err;
1249         dbus_error_init(&err);
1250
1251         DBusMessage* result_msg;
1252         int result = VC_ERROR_OPERATION_FAILED;
1253
1254         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1255         dbus_message_unref(msg);
1256
1257         if (dbus_error_is_set(&err)) {
1258                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1259                 dbus_error_free(&err);
1260         }
1261
1262         if (NULL != result_msg) {
1263                 dbus_message_get_args(result_msg, &err,
1264                                                           DBUS_TYPE_INT32, &result,
1265                                                           DBUS_TYPE_INVALID);
1266
1267                 if (dbus_error_is_set(&err)) {
1268                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1269                         dbus_error_free(&err);
1270                         result = VC_ERROR_OPERATION_FAILED;
1271                 }
1272                 dbus_message_unref(result_msg);
1273
1274                 if (0 == result) {
1275                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth disable : result = %d", result);
1276                 } else {
1277                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth disable : result = %d", result);
1278                 }
1279         } else {
1280                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1281                 vc_dbus_reconnect();
1282                 result = VC_ERROR_TIMED_OUT;
1283         }
1284
1285         return result;
1286 }
1287
1288 int vc_dbus_request_auth_start(int pid, int mgr_pid)
1289 {
1290         if (0 != __dbus_check()) {
1291                 return VC_ERROR_OPERATION_FAILED;
1292         }
1293
1294         DBusMessage* msg;
1295
1296         char service_name[64] = {0,};
1297         char object_path[64] = {0,};
1298         char target_if_name[128] = {0,};
1299
1300         snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1301         snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1302         snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1303
1304         /* create a signal & check for errors */
1305         msg = dbus_message_new_method_call(
1306                           service_name,
1307                           object_path,
1308                           target_if_name,
1309                           VC_METHOD_AUTH_START);
1310
1311         if (NULL == msg) {
1312                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth start : Fail to make message ");
1313                 return VC_ERROR_OPERATION_FAILED;
1314         } else {
1315                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth start : pid(%d)", pid);
1316         }
1317
1318         DBusMessageIter args;
1319         dbus_message_iter_init_append(msg, &args);
1320
1321         /* Append result*/
1322         dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(pid));
1323
1324         DBusError err;
1325         dbus_error_init(&err);
1326
1327         DBusMessage* result_msg;
1328         int result = VC_ERROR_OPERATION_FAILED;
1329
1330         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1331         dbus_message_unref(msg);
1332
1333         if (dbus_error_is_set(&err)) {
1334                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1335                 dbus_error_free(&err);
1336         }
1337
1338         if (NULL != result_msg) {
1339                 dbus_message_get_args(result_msg, &err,
1340                                                           DBUS_TYPE_INT32, &result,
1341                                                           DBUS_TYPE_INVALID);
1342
1343                 if (dbus_error_is_set(&err)) {
1344                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1345                         dbus_error_free(&err);
1346                         result = VC_ERROR_OPERATION_FAILED;
1347                 }
1348                 dbus_message_unref(result_msg);
1349
1350                 if (0 == result) {
1351                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth start : result = %d", result);
1352                 } else {
1353                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth start : result = %d", result);
1354                 }
1355         } else {
1356                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1357                 vc_dbus_reconnect();
1358                 result = VC_ERROR_TIMED_OUT;
1359         }
1360
1361         return result;
1362 }
1363
1364 int vc_dbus_request_auth_stop(int pid, int mgr_pid)
1365 {
1366         if (0 != __dbus_check()) {
1367                 return VC_ERROR_OPERATION_FAILED;
1368         }
1369
1370         DBusMessage* msg;
1371
1372         char service_name[64] = {0,};
1373         char object_path[64] = {0,};
1374         char target_if_name[128] = {0,};
1375
1376         snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1377         snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1378         snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1379
1380         /* create a signal & check for errors */
1381         msg = dbus_message_new_method_call(
1382                           service_name,
1383                           object_path,
1384                           target_if_name,
1385                           VC_METHOD_AUTH_STOP);
1386
1387         if (NULL == msg) {
1388                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth stop : Fail to make message ");
1389                 return VC_ERROR_OPERATION_FAILED;
1390         } else {
1391                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth stop : pid(%d)", pid);
1392         }
1393
1394         dbus_message_append_args(msg,
1395                                                          DBUS_TYPE_INT32, &pid,
1396                                                          DBUS_TYPE_INVALID);
1397
1398         DBusError err;
1399         dbus_error_init(&err);
1400
1401         DBusMessage* result_msg;
1402         int result = VC_ERROR_OPERATION_FAILED;
1403
1404         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1405         dbus_message_unref(msg);
1406
1407         if (dbus_error_is_set(&err)) {
1408                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1409                 dbus_error_free(&err);
1410         }
1411
1412         if (NULL != result_msg) {
1413                 dbus_message_get_args(result_msg, &err,
1414                                                           DBUS_TYPE_INT32, &result,
1415                                                           DBUS_TYPE_INVALID);
1416
1417                 if (dbus_error_is_set(&err)) {
1418                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1419                         dbus_error_free(&err);
1420                         result = VC_ERROR_OPERATION_FAILED;
1421                 }
1422                 dbus_message_unref(result_msg);
1423
1424                 if (0 == result) {
1425                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth stop : result = %d", result);
1426                 } else {
1427                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth stop : result = %d", result);
1428                 }
1429         } else {
1430                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1431                 vc_dbus_reconnect();
1432                 result = VC_ERROR_TIMED_OUT;
1433         }
1434
1435         return result;
1436 }
1437
1438 int vc_dbus_request_auth_cancel(int pid, int mgr_pid)
1439 {
1440         if (0 != __dbus_check()) {
1441                 return VC_ERROR_OPERATION_FAILED;
1442         }
1443
1444         DBusMessage* msg;
1445
1446         char service_name[64] = {0,};
1447         char object_path[64] = {0,};
1448         char target_if_name[128] = {0,};
1449
1450         snprintf(service_name, 64, "%s%d", VC_MANAGER_SERVICE_NAME, mgr_pid);
1451         snprintf(object_path, 64, "%s", VC_MANAGER_SERVICE_OBJECT_PATH);
1452         snprintf(target_if_name, 128, "%s%d", VC_MANAGER_SERVICE_INTERFACE, mgr_pid);
1453
1454         /* create a signal & check for errors */
1455         msg = dbus_message_new_method_call(
1456                           service_name,
1457                           object_path,  /* object name of the signal */
1458                           target_if_name,       /* interface name of the signal */
1459                           VC_METHOD_AUTH_CANCEL);       /* name of the signal */
1460
1461         if (NULL == msg) {
1462                 SLOG(LOG_ERROR, TAG_VCC, ">>>> vc auth cancel : Fail to make message ");
1463                 return VC_ERROR_OPERATION_FAILED;
1464         } else {
1465                 SLOG(LOG_DEBUG, TAG_VCC, ">>>> vc auth cancel : pid(%d)", pid);
1466         }
1467
1468         dbus_message_append_args(msg,
1469                                                          DBUS_TYPE_INT32, &pid,
1470                                                          DBUS_TYPE_INVALID);
1471
1472         DBusError err;
1473         dbus_error_init(&err);
1474
1475         DBusMessage* result_msg;
1476         int result = VC_ERROR_OPERATION_FAILED;
1477
1478         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1479         dbus_message_unref(msg);
1480
1481         if (dbus_error_is_set(&err)) {
1482                 SLOG(LOG_ERROR, TAG_VCC, "[ERROR] Dbus Error (%s)", err.message);
1483                 dbus_error_free(&err);
1484         }
1485
1486         if (NULL != result_msg) {
1487                 dbus_message_get_args(result_msg, &err,
1488                                                           DBUS_TYPE_INT32, &result,
1489                                                           DBUS_TYPE_INVALID);
1490
1491                 if (dbus_error_is_set(&err)) {
1492                         SLOG(LOG_ERROR, TAG_VCC, "<<<< Get arguments error (%s)", err.message);
1493                         dbus_error_free(&err);
1494                         result = VC_ERROR_OPERATION_FAILED;
1495                 }
1496                 dbus_message_unref(result_msg);
1497
1498                 if (0 == result) {
1499                         SLOG(LOG_DEBUG, TAG_VCC, "<<<< vc auth cancel : result = %d", result);
1500                 } else {
1501                         SLOG(LOG_ERROR, TAG_VCC, "<<<< vc auth cancel : result = %d", result);
1502                 }
1503         } else {
1504                 SLOG(LOG_DEBUG, TAG_VCC, "<<<< Result Message is NULL");
1505                 vc_dbus_reconnect();
1506                 result = VC_ERROR_TIMED_OUT;
1507         }
1508
1509         return result;
1510 }