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