server/cal_server_dbus.c

   1 /*
   2  * Calendar Service
   3  *
   4  * Copyright (c) 2012 - 2015 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <stdlib.h>
  21 #include <gio/gio.h>
  22
  23 #include "calendar.h"
  24 #include "cal_internal.h"
  25 #include "cal_typedef.h"
  26 #include "cal_handle.h"
  27 #include "cal_dbus_helper.h"
  28 #include "cal_dbus.h"
  29 #include "cal_db.h"
  30 #include "cal_db_util.h"
  31 #include "cal_server_dbus.h"
  32 #include "cal_utils.h"
  33 #include "cal_server_ondemand.h"
  34
  35 static calDbus *dbus_object = NULL;
  36 static GMutex cal_server_dbus_sender;
  37 static GList *cal_sender_list; /* global list to care resource handle for each sender bus */
  38
  39 typedef struct _cal_sender {
  40         gchar *name;
  41 } cal_sender_s;
  42
  43 calDbus* cal_dbus_get_object(void)
  44 {
  45         return dbus_object;
  46 }
  47
  48 static bool _has_sender(const char *name, GList **out_cursor)
  49 {
  50         bool has_sender = false;
  51
  52         GList *cursor = NULL;
  53         cursor = cal_sender_list;
  54         while (cursor) {
  55                 cal_sender_s *sender = (cal_sender_s *)cursor->data;
  56                 if (NULL == sender) {
  57                         WARN("sender is NULL");
  58                         cursor = g_list_next(cursor);
  59                         continue;
  60                 }
  61                 if (CAL_STRING_EQUAL == g_strcmp0(sender->name, name)) {
  62                         DBG("found sender[%s]", name);
  63                         has_sender = true;
  64                         if (out_cursor)
  65                                 *out_cursor = cursor;
  66                         break;
  67                 }
  68                 cursor = g_list_next(cursor);
  69         }
  70         return has_sender;
  71 }
  72
  73 static int _append_sender(const char *name)
  74 {
  75         RETV_IF(NULL == name, CALENDAR_ERROR_INVALID_PARAMETER);
  76
  77         cal_sender_s *sender = NULL;
  78         sender = calloc(1, sizeof(cal_sender_s));
  79         if (NULL == sender) {
  80                 /* LCOV_EXCL_START */
  81                 ERR("calloc() Fail");
  82                 return CALENDAR_ERROR_OUT_OF_MEMORY;
  83                 /* LCOV_EXCL_STOP */
  84         }
  85         sender->name = cal_strdup(name);
  86         DBG("[SENDER] Append sender[%s]", sender->name);
  87         cal_sender_list = g_list_append(cal_sender_list, sender);
  88         return CALENDAR_ERROR_NONE;
  89 }
  90
  91 static gboolean _handle_register_resource(calDbus *object,
  92                 GDBusMethodInvocation *invocation)
  93 {
  94         CAL_FN_CALL();
  95
  96         int ret = 0;
  97         const char *sender_name = NULL;
  98         sender_name = g_dbus_method_invocation_get_sender(invocation);
  99
 100         g_mutex_lock(&cal_server_dbus_sender);
 101         if (true == _has_sender(sender_name, NULL)) {
 102                 /* LCOV_EXCL_START */
 103                 ERR("Already has sender");
 104                 g_mutex_unlock(&cal_server_dbus_sender);
 105                 return TRUE;
 106                 /* LCOV_EXCL_STOP */
 107         }
 108         ret = _append_sender(sender_name);
 109         if (CALENDAR_ERROR_NONE != ret) {
 110                 /* LCOV_EXCL_START */
 111                 ERR("_append_sender() Fail");
 112                 g_mutex_unlock(&cal_server_dbus_sender);
 113                 return TRUE;
 114                 /* LCOV_EXCL_STOP */
 115         }
 116         DBG("append sender");
 117         g_mutex_unlock(&cal_server_dbus_sender);
 118
 119         cal_dbus_complete_register_resource(object, invocation, ret);
 120
 121         return TRUE;
 122 }
 123
 124 static gboolean _handle_unregister_resource(calDbus *object,
 125                 GDBusMethodInvocation *invocation)
 126 {
 127         CAL_FN_CALL();
 128
 129         int ret = 0;
 130         const char *sender_name = NULL;
 131         sender_name = g_dbus_method_invocation_get_sender(invocation);
 132
 133         GList *cursor = NULL;
 134         g_mutex_lock(&cal_server_dbus_sender);
 135         if (true == _has_sender(sender_name, &cursor)) {
 136                 DBG("[SENDER] delete sender[%s]", sender_name);
 137                 cal_sender_s *sender = (cal_sender_s *)cursor->data;
 138                 free(sender->name);
 139                 sender->name = NULL;
 140                 cal_sender_list = g_list_delete_link(cal_sender_list, cursor);
 141         }
 142
 143         if (0 == g_list_length(cal_sender_list)) {
 144                 DBG("sender list is 0");
 145                 g_list_free_full(cal_sender_list, free);
 146                 cal_sender_list = NULL;
 147         }
 148         g_mutex_unlock(&cal_server_dbus_sender);
 149
 150         cal_dbus_complete_unregister_resource(object, invocation, ret);
 151
 152         return TRUE;
 153 }
 154
 155 static gboolean _handle_insert_record(calDbus *object, GDBusMethodInvocation *invocation,
 156                 GVariant *arg_handle, GVariant *arg_record)
 157 {
 158         int ret = 0;
 159         calendar_record_h record = NULL;
 160         ret = cal_dbus_utils_gvariant_to_record(arg_record, &record);
 161
 162         int id = 0;
 163         ret = cal_db_insert_record(record, &id);
 164
 165         int version = 0;
 166         version = cal_db_util_get_transaction_ver();
 167         cal_dbus_complete_insert_record(object, invocation, id, version, ret);
 168         calendar_record_destroy(record, true);
 169
 170         cal_server_ondemand_start();
 171         return TRUE;
 172 }
 173
 174 static gboolean _handle_update_record(calDbus *object, GDBusMethodInvocation *invocation,
 175                 GVariant *arg_handle, GVariant *arg_record)
 176 {
 177         int ret = 0;
 178         calendar_record_h record = NULL;
 179         ret = cal_dbus_utils_gvariant_to_record(arg_record, &record);
 180
 181         ret = cal_db_update_record(record);
 182
 183         int version = 0;
 184         version = cal_db_util_get_transaction_ver();
 185         cal_dbus_complete_update_record(object, invocation, version, ret);
 186         calendar_record_destroy(record, true);
 187
 188         cal_server_ondemand_start();
 189         return TRUE;
 190 }
 191
 192 static gboolean _handle_delete_record(calDbus *object, GDBusMethodInvocation *invocation,
 193                 GVariant *arg_handle, char *view_uri, int id)
 194 {
 195         int ret = 0;
 196         ret = cal_db_delete_record(view_uri, id);
 197
 198         int version = 0;
 199         version = cal_db_util_get_transaction_ver();
 200         cal_dbus_complete_delete_record(object, invocation, version, ret);
 201
 202         cal_server_ondemand_start();
 203         return TRUE;
 204 }
 205
 206 static gboolean _handle_replace_record(calDbus *object, GDBusMethodInvocation *invocation,
 207                 GVariant *arg_handle, GVariant *arg_record, int id)
 208 {
 209         int ret = 0;
 210         calendar_record_h record = NULL;
 211         ret = cal_dbus_utils_gvariant_to_record(arg_record, &record);
 212
 213         ret = cal_db_replace_record(record, id);
 214
 215         int version = 0;
 216         version = cal_db_util_get_transaction_ver();
 217         cal_dbus_complete_replace_record(object, invocation, version, ret);
 218         calendar_record_destroy(record, true);
 219
 220         cal_server_ondemand_start();
 221         return TRUE;
 222 }
 223
 224 static gboolean _handle_insert_records(calDbus *object, GDBusMethodInvocation *invocation,
 225                 GVariant *arg_handle, GVariant *arg_list)
 226 {
 227         int ret = 0;
 228         calendar_list_h list = NULL;
 229         ret = cal_dbus_utils_gvariant_to_list(arg_list, &list);
 230
 231         int *ids = NULL;
 232         int count = 0;
 233         ret = cal_db_insert_records(list, &ids, &count);
 234         calendar_list_destroy(list, true);
 235
 236         int version = 0;
 237         version = cal_db_util_get_transaction_ver();
 238         GVariant *arg_ids = cal_dbus_utils_ids_to_gvariant(ids, count);
 239         cal_dbus_complete_insert_records(object, invocation, arg_ids, count, version, ret);
 240
 241         free(ids);
 242         g_variant_unref(arg_ids);
 243
 244         cal_server_ondemand_start();
 245         return TRUE;
 246 }
 247
 248 static gboolean _handle_update_records(calDbus *object, GDBusMethodInvocation *invocation,
 249                 GVariant *arg_handle, GVariant *arg_list)
 250 {
 251         int ret = 0;
 252         calendar_list_h list = NULL;
 253         ret = cal_dbus_utils_gvariant_to_list(arg_list, &list);
 254
 255         ret = cal_db_update_records(list);
 256         calendar_list_destroy(list, true);
 257
 258         int version = 0;
 259         version = cal_db_util_get_transaction_ver();
 260         cal_dbus_complete_update_records(object, invocation, version, ret);
 261
 262         cal_server_ondemand_start();
 263         return TRUE;
 264 }
 265
 266 static gboolean _handle_delete_records(calDbus *object, GDBusMethodInvocation *invocation,
 267                 GVariant *arg_handle, char *view_uri, GVariant *arg_ids, int count)
 268 {
 269         int ret = 0;
 270         int *ids = NULL;
 271         ret = cal_dbus_utils_gvariant_to_ids(arg_ids, count, &ids);
 272
 273         ret = cal_db_delete_records(view_uri, ids, count);
 274
 275         int version = 0;
 276         version = cal_db_util_get_transaction_ver();
 277         cal_dbus_complete_delete_records(object, invocation, version, ret);
 278         free(ids);
 279
 280         cal_server_ondemand_start();
 281         return TRUE;
 282 }
 283
 284 static gboolean _handle_replace_records(calDbus *object, GDBusMethodInvocation *invocation,
 285                 GVariant *arg_handle, GVariant *arg_list, GVariant *arg_ids, int count)
 286 {
 287         int ret = 0;
 288         calendar_list_h list = NULL;
 289         int *ids = NULL;
 290         ret = cal_dbus_utils_gvariant_to_list(arg_list, &list);
 291         ret = cal_dbus_utils_gvariant_to_ids(arg_ids, count, &ids);
 292
 293         ret = cal_db_replace_records(list, ids, count);
 294         free(ids);
 295         calendar_list_destroy(list, true);
 296
 297         int version = 0;
 298         version = cal_db_util_get_transaction_ver();
 299         cal_dbus_complete_replace_records(object, invocation, version, ret);
 300
 301         cal_server_ondemand_start();
 302         return TRUE;
 303 }
 304
 305 static gboolean _handle_get_record(calDbus *object, GDBusMethodInvocation *invocation,
 306                 GVariant *arg_handle, char *view_uri, int id)
 307 {
 308         int ret = 0;
 309         calendar_record_h record = NULL;
 310         ret = cal_db_get_record(view_uri, id, &record);
 311
 312         GVariant *arg_record = cal_dbus_utils_record_to_gvariant(record);
 313         cal_dbus_complete_get_record(object, invocation, arg_record, ret);
 314         g_variant_unref(arg_record);
 315         calendar_record_destroy(record, true);
 316
 317         cal_server_ondemand_start();
 318         return TRUE;
 319 }
 320
 321 static gboolean _handle_get_all_records(calDbus *object, GDBusMethodInvocation *invocation,
 322                 GVariant *arg_handle, char *view_uri, int offset, int limit)
 323 {
 324         CAL_FN_CALL();
 325
 326         int ret = 0;
 327         calendar_list_h list = NULL;
 328         ret = cal_db_get_all_records(view_uri, offset, limit, &list);
 329
 330         GVariant *arg_list = cal_dbus_utils_list_to_gvariant(list);
 331         cal_dbus_complete_get_all_records(object, invocation, arg_list, ret);
 332         calendar_list_destroy(list, true);
 333         g_variant_unref(arg_list);
 334
 335         cal_server_ondemand_start();
 336         return TRUE;
 337 }
 338
 339 static gboolean _handle_get_records_with_query(calDbus *object, GDBusMethodInvocation *invocation,
 340                 GVariant *arg_handle, GVariant *arg_query, int offset, int limit)
 341 {
 342         int ret = 0;
 343         calendar_query_h query = NULL;
 344         ret = cal_dbus_utils_gvariant_to_query(arg_query, &query);
 345
 346         calendar_list_h list = NULL;
 347         ret = cal_db_get_records_with_query(query, offset, limit, &list);
 348
 349         GVariant *arg_list = cal_dbus_utils_list_to_gvariant(list);
 350         cal_dbus_complete_get_records_with_query(object, invocation, arg_list, ret);
 351         g_variant_unref(arg_list);
 352         calendar_list_destroy(list, true);
 353
 354         cal_server_ondemand_start();
 355         return TRUE;
 356 }
 357
 358 static gboolean _handle_get_count(calDbus *object, GDBusMethodInvocation *invocation,
 359                 GVariant *arg_handle, char *view_uri)
 360 {
 361         int ret = 0;
 362         int count = 0;
 363         ret = cal_db_get_count(view_uri, &count);
 364
 365         cal_dbus_complete_get_count(object, invocation, count, ret);
 366
 367         cal_server_ondemand_start();
 368         return TRUE;
 369 }
 370
 371 static gboolean _handle_get_count_with_query(calDbus *object, GDBusMethodInvocation *invocation,
 372                 GVariant *arg_handle, GVariant *arg_query)
 373 {
 374         int ret = 0;
 375         calendar_query_h query = NULL;
 376         ret = cal_dbus_utils_gvariant_to_query(arg_query, &query);
 377
 378         int count = 0;
 379         ret = cal_db_get_count_with_query(query, &count);
 380         cal_dbus_complete_get_count_with_query(object, invocation, count, ret);
 381
 382         cal_server_ondemand_start();
 383         return TRUE;
 384 }
 385
 386 static gboolean _handle_get_current_version(calDbus *object, GDBusMethodInvocation *invocation,
 387                 GVariant *arg_handle)
 388 {
 389         int ret = 0;
 390         int version = 0;
 391         ret = cal_db_get_current_version(&version);
 392
 393         cal_dbus_complete_get_current_version(object, invocation, version, ret);
 394
 395         cal_server_ondemand_start();
 396         return TRUE;
 397 }
 398
 399 static gboolean _handle_check_permission_write(calDbus *object, GDBusMethodInvocation *invocation)
 400 {
 401         cal_dbus_complete_check_permission_write(object, invocation);
 402         cal_server_ondemand_start();
 403         return TRUE;
 404 }
 405
 406 static gboolean _handle_check_permission_read(calDbus *object, GDBusMethodInvocation *invocation)
 407 {
 408         cal_dbus_complete_check_permission_read(object, invocation);
 409         cal_server_ondemand_start();
 410         return TRUE;
 411 }
 412
 413 static gboolean _handle_get_changes_by_version(calDbus *object, GDBusMethodInvocation *invocation,
 414                 GVariant *arg_handle, char *view_uri, int book_id, int in_version)
 415 {
 416         int ret = 0;
 417         calendar_list_h list = NULL;
 418         int out_version = 0;
 419         ret = cal_db_get_changes_by_version(view_uri, book_id, in_version, &list, &out_version);
 420
 421         GVariant *arg_list = cal_dbus_utils_list_to_gvariant(list);
 422         cal_dbus_complete_get_changes_by_version(object, invocation, arg_list, out_version, ret);
 423         calendar_list_destroy(list, true);
 424         g_variant_unref(arg_list);
 425
 426         cal_server_ondemand_start();
 427         return TRUE;
 428 }
 429
 430 static gboolean _handle_get_changes_exception_by_version(calDbus *object,
 431                 GDBusMethodInvocation *invocation,
 432                 GVariant *arg_handle,
 433                 char *view_uri,
 434                 int original_id,
 435                 int version)
 436 {
 437         int ret = 0;
 438         calendar_list_h list = NULL;
 439         ret = cal_db_get_changes_exception_by_version(view_uri, original_id, version, &list);
 440
 441         GVariant *arg_list = cal_dbus_utils_list_to_gvariant(list);
 442         cal_dbus_complete_get_changes_exception_by_version(object, invocation, arg_list, ret);
 443         calendar_list_destroy(list, true);
 444         g_variant_unref(arg_list);
 445
 446         cal_server_ondemand_start();
 447         return TRUE;
 448 }
 449
 450 static gboolean _handle_clean_after_sync(calDbus *object, GDBusMethodInvocation *invocation,
 451                 GVariant *arg_handle, int book_id, int version)
 452 {
 453         int ret = 0;
 454         ret = cal_db_clean_after_sync(book_id, version);
 455
 456         cal_dbus_complete_clean_after_sync(object, invocation, ret);
 457
 458         cal_server_ondemand_start();
 459         return TRUE;
 460 }
 461
 462 static gboolean _handle_insert_vcalendars(calDbus *object, GDBusMethodInvocation *invocation,
 463                 GVariant *arg_handle, char *stream)
 464 {
 465         int ret = 0;
 466         int *ids = NULL;
 467         int count = 0;
 468         ret = cal_db_insert_vcalendars(stream, &ids, &count);
 469
 470         GVariant *arg_ids = cal_dbus_utils_ids_to_gvariant(ids, count);
 471
 472         int version = 0;
 473         version = cal_db_util_get_transaction_ver();
 474         cal_dbus_complete_insert_vcalendars(object, invocation, arg_ids, count, version, ret);
 475         free(ids);
 476         g_variant_unref(arg_ids);
 477
 478         cal_server_ondemand_start();
 479         return TRUE;
 480 }
 481
 482 static gboolean _handle_replace_vcalendars(calDbus *object, GDBusMethodInvocation *invocation,
 483                 GVariant *arg_handle, char *stream, GVariant *arg_ids, int count)
 484 {
 485         int ret = 0;
 486         int *ids = NULL;
 487         ret = cal_dbus_utils_gvariant_to_ids(arg_ids, count, &ids);
 488
 489         ret = cal_db_replace_vcalendars(stream, ids, count);
 490
 491         int version = 0;
 492         version = cal_db_util_get_transaction_ver();
 493         cal_dbus_complete_replace_vcalendars(object, invocation, ret, version);
 494         free(ids);
 495
 496         cal_server_ondemand_start();
 497         return TRUE;
 498 }
 499
 500 static int _cal_server_dbus_find_sender(const char *owner_name, cal_sender_s **out_sender)
 501 {
 502         GList *cursor = NULL;
 503
 504         RETV_IF(NULL == owner_name, CALENDAR_ERROR_INVALID_PARAMETER);
 505         RETV_IF(NULL == out_sender, CALENDAR_ERROR_INVALID_PARAMETER);
 506
 507         cursor = cal_sender_list;
 508         while (cursor) {
 509                 cal_sender_s *sender = (cal_sender_s *)cursor->data;
 510                 if (NULL == sender) {
 511                         /* LCOV_EXCL_START */
 512                         ERR("sender is NULL");
 513                         return CALENDAR_ERROR_NO_DATA;
 514                         /* LCOV_EXCL_STOP */
 515                 }
 516
 517                 if (CAL_STRING_EQUAL == g_strcmp0(sender->name, owner_name)) {
 518                         *out_sender = sender;
 519                         break;
 520                 }
 521                 cursor = g_list_next(cursor);
 522         }
 523
 524         return CALENDAR_ERROR_NONE;
 525 }
 526
 527 static void _delete_sender(cal_sender_s *sender)
 528 {
 529         RET_IF(NULL == sender);
 530
 531         GList *cursor = cal_sender_list;
 532         while (cursor) {
 533                 if (cursor->data == sender) {
 534                         DBG("[SENDER] Delete sender[%s]", sender->name);
 535                         free(sender->name);
 536                         sender->name = NULL;
 537                         cal_sender_list = g_list_delete_link(cal_sender_list, cursor);
 538                         break;
 539                 }
 540                 cursor = g_list_next(cursor);
 541         }
 542 }
 543
 544 static void _cal_server_dbus_name_owner_changed_cb(GDBusConnection *connection,
 545                 const gchar *sender_name,
 546                 const gchar *object_path,
 547                 const gchar *interface_name,
 548                 const gchar *signal_name,
 549                 GVariant *parameters,
 550                 gpointer user_data)
 551 {
 552         CAL_FN_CALL();
 553
 554         int ret = 0;
 555         gchar *name = NULL;
 556         gchar *old_owner = NULL;
 557         gchar *new_owner = NULL;
 558
 559         g_variant_get(parameters, "(&s&s&s)", &name, &old_owner, &new_owner);
 560         DBG("name[%s] old_owner[%s] new_owner[%s]", name, old_owner, new_owner);
 561
 562         if (0 != strlen(new_owner)) {
 563                 DBG("new_owner[%s]", new_owner);
 564                 return;
 565         }
 566         g_mutex_lock(&cal_server_dbus_sender);
 567         /* empty new_owner means server-kill */
 568         cal_sender_s *sender = NULL;
 569         ret = _cal_server_dbus_find_sender(old_owner, &sender);
 570         if (CALENDAR_ERROR_NONE != ret) {
 571                 /* LCOV_EXCL_START */
 572                 ERR("_cal_server_dbus_find_sender() Fail(%d)", ret);
 573                 g_mutex_unlock(&cal_server_dbus_sender);
 574                 return;
 575                 /* LCOV_EXCL_STOP */
 576         }
 577
 578         if (sender) { /* found bus name in our bus list */
 579                 DBG("owner[%s] stopped", old_owner);
 580                 _delete_sender(sender);
 581         }
 582         g_mutex_unlock(&cal_server_dbus_sender);
 583 }
 584
 585 static int _cal_server_dbus_subscribe_name_owner_changed(GDBusConnection *conn)
 586 {
 587         CAL_FN_CALL();
 588
 589         unsigned int id = 0;
 590         id = g_dbus_connection_signal_subscribe(conn,
 591                         "org.freedesktop.DBus", /* bus name */
 592                         "org.freedesktop.DBus", /* interface */
 593                         "NameOwnerChanged", /* member */
 594                         "/org/freedesktop/DBus", /* path */
 595                         NULL, /* arg0 */
 596                         G_DBUS_SIGNAL_FLAGS_NONE,
 597                         _cal_server_dbus_name_owner_changed_cb,
 598                         NULL,
 599                         NULL);
 600         if (0 == id) {
 601                 /* LCOV_EXCL_START */
 602                 ERR("g_dbus_connection_signal_subscribe() Fail");
 603                 return CALENDAR_ERROR_IPC;
 604                 /* LCOV_EXCL_STOP */
 605         }
 606         return CALENDAR_ERROR_NONE;
 607 }
 608
 609 static void _dbus_on_bus_acquired(GDBusConnection *conn, const gchar *name, gpointer user_data)
 610 {
 611         gboolean ret = 0;
 612         GError *error = NULL;
 613
 614         dbus_object = cal_dbus_skeleton_new();
 615         if (NULL == dbus_object) {
 616                 /* LCOV_EXCL_START */
 617                 ERR("cal_dbus_skeleton_new() Fail");
 618                 return;
 619                 /* LCOV_EXCL_STOP */
 620         }
 621
 622         g_signal_connect(dbus_object, "handle-register-resource",
 623                         G_CALLBACK(_handle_register_resource), NULL);
 624         g_signal_connect(dbus_object, "handle-unregister-resource",
 625                         G_CALLBACK(_handle_unregister_resource), NULL);
 626         g_signal_connect(dbus_object, "handle-insert-record",
 627                         G_CALLBACK(_handle_insert_record), NULL);
 628         g_signal_connect(dbus_object, "handle-update-record",
 629                         G_CALLBACK(_handle_update_record), NULL);
 630         g_signal_connect(dbus_object, "handle-delete-record",
 631                         G_CALLBACK(_handle_delete_record), NULL);
 632         g_signal_connect(dbus_object, "handle-replace-record",
 633                         G_CALLBACK(_handle_replace_record), NULL);
 634         g_signal_connect(dbus_object, "handle-insert-records",
 635                         G_CALLBACK(_handle_insert_records), NULL);
 636         g_signal_connect(dbus_object, "handle-update-records",
 637                         G_CALLBACK(_handle_update_records), NULL);
 638         g_signal_connect(dbus_object, "handle-delete-records",
 639                         G_CALLBACK(_handle_delete_records), NULL);
 640         g_signal_connect(dbus_object, "handle-replace-records",
 641                         G_CALLBACK(_handle_replace_records), NULL);
 642         g_signal_connect(dbus_object, "handle-get-record",
 643                         G_CALLBACK(_handle_get_record), NULL);
 644         g_signal_connect(dbus_object, "handle-get-all-records",
 645                         G_CALLBACK(_handle_get_all_records), NULL);
 646         g_signal_connect(dbus_object, "handle-get-records-with-query",
 647                         G_CALLBACK(_handle_get_records_with_query), NULL);
 648         g_signal_connect(dbus_object, "handle-get-count",
 649                         G_CALLBACK(_handle_get_count), NULL);
 650         g_signal_connect(dbus_object, "handle-get-count-with-query",
 651                         G_CALLBACK(_handle_get_count_with_query), NULL);
 652         g_signal_connect(dbus_object, "handle-get-current-version",
 653                         G_CALLBACK(_handle_get_current_version), NULL);
 654         g_signal_connect(dbus_object, "handle-check-permission-write",
 655                         G_CALLBACK(_handle_check_permission_write), NULL);
 656         g_signal_connect(dbus_object, "handle-check-permission-read",
 657                         G_CALLBACK(_handle_check_permission_read), NULL);
 658         g_signal_connect(dbus_object, "handle-get-changes-by-version",
 659                         G_CALLBACK(_handle_get_changes_by_version), NULL);
 660         g_signal_connect(dbus_object, "handle-get-changes-exception-by-version",
 661                         G_CALLBACK(_handle_get_changes_exception_by_version), NULL);
 662         g_signal_connect(dbus_object, "handle-clean-after-sync",
 663                         G_CALLBACK(_handle_clean_after_sync), NULL);
 664         g_signal_connect(dbus_object, "handle-insert-vcalendars",
 665                         G_CALLBACK(_handle_insert_vcalendars), NULL);
 666         g_signal_connect(dbus_object, "handle-replace-vcalendars",
 667                         G_CALLBACK(_handle_replace_vcalendars), NULL);
 668
 669         ret = g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(dbus_object),
 670                         conn, CAL_DBUS_OBJPATH, &error);
 671         if (FALSE == ret) {
 672                 /* LCOV_EXCL_START */
 673                 ERR("g_dbus_interface_skeleton_export() Fail(%s)", error->message);
 674                 g_error_free(error);
 675                 return;
 676                 /* LCOV_EXCL_STOP */
 677         }
 678
 679         ret = _cal_server_dbus_subscribe_name_owner_changed(conn);
 680         if (CALENDAR_ERROR_NONE != ret) {
 681                 /* LCOV_EXCL_START */
 682                 ERR("_cal_server_dbus_subscribe_name_owner_changed() Fail(%d)", ret);
 683                 return;
 684                 /* LCOV_EXCL_STOP */
 685         }
 686 }
 687
 688 static void _dbus_on_name_acquired(GDBusConnection *conn, const gchar *name, gpointer user_data)
 689 {
 690         DBG("Acquired the name %s", name);
 691 }
 692
 693 static void _dbus_on_name_lost(GDBusConnection *conn, const gchar *name, gpointer user_data)
 694 {
 695         DBG("Lost the name %s", name);
 696 }
 697
 698 unsigned int cal_server_dbus_init(void)
 699 {
 700         guint id = 0;
 701         id = g_bus_own_name(G_BUS_TYPE_SESSION,
 702                         CAL_DBUS_INTERFACE,
 703                         G_BUS_NAME_OWNER_FLAGS_REPLACE,
 704                         _dbus_on_bus_acquired,
 705                         _dbus_on_name_acquired,
 706                         _dbus_on_name_lost,
 707                         NULL,
 708                         NULL);
 709         if (0 == id) {
 710                 /* LCOV_EXCL_START */
 711                 ERR("g_bus_own_name() Fail");
 712                 return 0;
 713                 /* LCOV_EXCL_STOP */
 714         }
 715         return id;
 716 }
 717
 718 void cal_server_dbus_deinit(unsigned int id)
 719 {
 720         g_bus_unown_name(id);
 721 }
 722
 723 int cal_dbus_emit_signal(const char *dest, const char *signal_name, GVariant *value)
 724 {
 725         CAL_FN_CALL();
 726
 727         gboolean ret;
 728         GError *error = NULL;
 729
 730         DBG("signal_name[%s]", signal_name);
 731         DBG("data[%s]", g_variant_print(value, FALSE));
 732
 733         calDbusSkeleton *skeleton = NULL;
 734         skeleton = CAL_DBUS_SKELETON(cal_dbus_get_object());
 735         if (NULL == skeleton) {
 736                 /* LCOV_EXCL_START */
 737                 ERR("cal_dbus_get_object() Fail");
 738                 return CALENDAR_ERROR_IPC;
 739                 /* LCOV_EXCL_STOP */
 740         }
 741
 742         GDBusConnection *conn = NULL;
 743         conn = g_dbus_interface_skeleton_get_connection(G_DBUS_INTERFACE_SKELETON(skeleton));
 744         if (NULL == conn) {
 745                 /* LCOV_EXCL_START */
 746                 ERR("g_dbus_interface_skeleton_get_connection() Fail");
 747                 return CALENDAR_ERROR_IPC;
 748                 /* LCOV_EXCL_STOP */
 749         }
 750
 751         ret = g_dbus_connection_emit_signal(conn,
 752                         dest,
 753                         CAL_DBUS_OBJPATH,
 754                         CAL_DBUS_INTERFACE,
 755                         signal_name,
 756                         value,
 757                         &error);
 758
 759         if (FALSE == ret) {
 760                 /* LCOV_EXCL_START */
 761                 ERR("g_dbus_connection_emit_signal() Fail");
 762                 if (error) {
 763                         ERR("error[%s]", error->message);
 764                         g_error_free(error);
 765                 }
 766                 return CALENDAR_ERROR_IPC;
 767                 /* LCOV_EXCL_STOP */
 768         }
 769
 770         if (FALSE == g_dbus_connection_flush_sync(conn, NULL, &error)) {
 771                 /* LCOV_EXCL_START */
 772                 ERR("g_dbus_connection_flush_sync() Fail");
 773                 if (error) {
 774                         ERR("error[%s]", error->message);
 775                         g_error_free(error);
 776                 }
 777                 return CALENDAR_ERROR_IPC;
 778                 /* LCOV_EXCL_STOP */
 779         }
 780
 781         return CALENDAR_ERROR_NONE;
 782 }
 783
 784 int cal_dbus_publish_reminder(int stream_size, char *stream)
 785 {
 786         CAL_FN_CALL();
 787
 788         GVariant *value = NULL;
 789         value = cal_dbus_utils_stream_to_gvariant(stream_size, stream);
 790         cal_dbus_emit_signal(NULL, CAL_NOTI_REMINDER_CAHNGED, value);
 791
 792         return CALENDAR_ERROR_NONE;
 793 }