client/vc_dbus.c

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