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