src/eventsystem.c

   1 /**
   2  * event system low-level API
   3  */
   4 #include <stdio.h>
   5 #include <string.h>
   6 #include <stdlib.h>
   7 #include <dlog.h>
   8 #include <bundle.h>
   9 #include <bundle_internal.h>
  10 #include <glib.h>
  11 #include <gio/gio.h>
  12 #include <eventsystem.h>
  13 #include <fcntl.h>
  14
  15 #undef LOG_TAG
  16 #define LOG_TAG "eventsystem"
  17
  18 #define SYS_EVENT_NAME_PREFIX "tizen.system.event"
  19 #define EVENT_SYSTEM_PREFIX "eventsystem.id_"
  20 #define EVENT_SYSTEM_PREFIX_LEN 15
  21 #define EVENT_SYSTEM_MEMBER "eventsystem"
  22 #define VALID_COUNT_OF_EVENTNAME_TOKEN 3
  23 #define VALID_LAST_COUNT_FOR_EVENTNAME (VALID_COUNT_OF_EVENTNAME_TOKEN + 1)
  24 #define MAX_COUNT_FOR_EVENTNAME_CHECK (VALID_LAST_COUNT_FOR_EVENTNAME + 1)
  25
  26 #define FREE_AND_NULL(ptr) do { \
  27         if (ptr) { \
  28                 free((void *)ptr); \
  29                 ptr = NULL; \
  30         } \
  31 } while (0)
  32
  33 #define _E(fmt, arg...) LOGE(fmt, ##arg)
  34 #define _D(fmt, arg...) LOGD(fmt, ##arg)
  35 #define _W(fmt, arg...) LOGW(fmt, ##arg)
  36 #define _I(fmt, arg...) LOGI(fmt, ##arg)
  37
  38 #define retvm_if(expr, val, fmt, arg...) do { \
  39         if (expr) { \
  40                 _E(fmt, ##arg); \
  41                 _E("(%s) -> %s() return", #expr, __func__); \
  42                 return val; \
  43         } \
  44 } while (0)
  45
  46 #define retv_if(expr, val) do { \
  47         if (expr) { \
  48                 _E("(%s) -> %s() return", #expr, __func__); \
  49                 return val; \
  50         } \
  51 } while (0)
  52
  53 #define tryvm_if(expr, val, fmt, arg...) do { \
  54          if (expr) { \
  55                 _E("(%s) "fmt, #expr, ##arg); \
  56                 val; \
  57                 goto catch; \
  58         } \
  59 } while (0)
  60
  61 pthread_mutex_t send_sync_lock = PTHREAD_MUTEX_INITIALIZER;
  62
  63 static GList *system_event_list;
  64 static int _initialized;
  65 static GHashTable *check_tbl;
  66 static GHashTable *filter_tbl;
  67 static GHashTable *last_data_tbl;
  68
  69 struct last_data_item {
  70         char *event_name;
  71         GVariant *param;
  72         GVariant *trusted_param;
  73 };
  74
  75 typedef struct eventmap {
  76         char *event_name;
  77         char *interface_name;
  78         char *member_name;
  79         guint reg_id;
  80         GBusType bus_type;
  81         int event_type;
  82         union {
  83                 eventsystem_cb es_cb;
  84                 eventsystem_handler ep_cb;
  85         };
  86         void *user_data;
  87 } eventmap_s;
  88
  89 typedef struct eventinfo {
  90         char *event_name;
  91         char *destination_name;
  92         char *interface_name;
  93         char *object_path;
  94         char *member_name;
  95         bool is_user_event;
  96         bool is_trusted;
  97         bundle *event_data;
  98 } eventinfo_s;
  99
 100 typedef struct sysevent_info {
 101         guint owner_id;
 102         guint owner_id_session;
 103         char *own_name_system_bus;
 104         char *own_name_session_bus;
 105 } sysevent_info_s;
 106 static sysevent_info_s s_info;
 107
 108 static int __eventsystem_check_user_send_validation(const char *event_name);
 109 static int __eventsystem_request_destination_list(const char *event_name, GList **dest_list);
 110 static int __eventsystem_check_sender_validation(int sender_pid,
 111                 const char *event_name, char **sender);
 112 static eventmap_s *__create_eventmap(const char *interface_name,
 113                 const char *member_name, const char *event_name,
 114                 int event_type, eventsystem_cb callback, void *user_data);
 115 static void __destroy_eventmap(gpointer data);
 116 static int __eventsystem_launch_on_event_for_userevent(const char *event_name,
 117                 bundle *data, gboolean trusted);
 118
 119 static int __event_compare_reg_id_cb(gconstpointer a, gconstpointer b)
 120 {
 121         eventmap_s *key1 = (eventmap_s *)a;
 122         eventmap_s *key2 = (eventmap_s *)b;
 123         return !(key1->reg_id == key2->reg_id);
 124 }
 125
 126 static void __initialize(void)
 127 {
 128 #if (GLIB_MAJOR_VERSION <= 2 && GLIB_MINOR_VERSION < 36)
 129         g_type_init();
 130 #endif
 131
 132         _initialized = 1;
 133 }
 134
 135 static int __eventsystem_get_sender_pid(GDBusConnection *conn, const char *sender_name)
 136 {
 137         GDBusMessage *msg = NULL;
 138         GDBusMessage *reply = NULL;
 139         GError *err = NULL;
 140         GVariant *body;
 141         int pid = 0;
 142
 143         msg = g_dbus_message_new_method_call("org.freedesktop.DBus", "/org/freedesktop/DBus",
 144                 "org.freedesktop.DBus", "GetConnectionUnixProcessID");
 145         if (!msg) {
 146                 _E("Can't allocate new method call");
 147                 goto out;
 148         }
 149
 150         g_dbus_message_set_body(msg, g_variant_new("(s)", sender_name));
 151         reply = g_dbus_connection_send_message_with_reply_sync(conn, msg,
 152                 G_DBUS_SEND_MESSAGE_FLAGS_NONE, -1, NULL, NULL, &err);
 153
 154         if (!reply) {
 155                 if (err != NULL) {
 156                         _E("Failed to get pid [%s]", err->message);
 157                         g_error_free(err);
 158                 }
 159                 goto out;
 160         }
 161
 162         body = g_dbus_message_get_body(reply);
 163         g_variant_get(body, "(u)", &pid);
 164
 165 out:
 166         if (msg)
 167                 g_object_unref(msg);
 168         if (reply)
 169                 g_object_unref(reply);
 170
 171         return pid;
 172 }
 173
 174 static char *__get_object_path(char *interface_name)
 175 {
 176         int i;
 177         char *object_path = (char *)calloc(strlen(interface_name), sizeof(char) + 2);
 178
 179         if (object_path == NULL) {
 180                 _E("failed to allocate memory");
 181                 return NULL;
 182         }
 183
 184         object_path[0] = '/';
 185
 186         for (i = 0; interface_name[i]; i++) {
 187                 if (interface_name[i] == '.')
 188                         object_path[i + 1] = '/';
 189                 else
 190                         object_path[i + 1] = interface_name[i];
 191         }
 192
 193         return object_path;
 194 }
 195
 196 static char *__get_encoded_interface_name(char *interface_name)
 197 {
 198         char *evtid = NULL;
 199         int evtid_len = 0;
 200         gchar *encoded_value;
 201
 202         encoded_value = g_compute_checksum_for_string(G_CHECKSUM_MD5,
 203                 interface_name, strlen(interface_name));
 204
 205         evtid_len = EVENT_SYSTEM_PREFIX_LEN + strlen(encoded_value) + 1;
 206
 207         evtid = (char *)calloc(evtid_len, sizeof(char));
 208         if (evtid == NULL) {
 209                 _D("memory alloc failed");
 210                 g_free(encoded_value);
 211                 return NULL;
 212         }
 213
 214         snprintf(evtid, evtid_len, "%s%s", EVENT_SYSTEM_PREFIX, (char *)encoded_value);
 215
 216         g_free(encoded_value);
 217
 218         return evtid;
 219 }
 220
 221 static char *__get_member_name_from_eventname(char *event_name)
 222 {
 223         char *ptr = NULL;
 224         char *ptr_last = NULL;
 225         char *temp_name = NULL;
 226         char *member_name = NULL;
 227         char *save_ptr = NULL;
 228         int count = 0;
 229
 230         temp_name = strdup(event_name);
 231         if (temp_name == NULL) {
 232                 _E("out of memory");
 233                 return NULL;
 234         }
 235
 236         ptr = strtok_r(temp_name, ".", &save_ptr);
 237         if (ptr == NULL) {
 238                 _E("invalid event_name(%s), count(%d)", event_name, count);
 239                 FREE_AND_NULL(temp_name);
 240                 return NULL;
 241         }
 242         count++;
 243
 244         while (count < MAX_COUNT_FOR_EVENTNAME_CHECK) {
 245                 ptr = strtok_r(NULL, ".", &save_ptr);
 246                 if (ptr == NULL)
 247                         break;
 248                 /* _D("(%d)ptr(%s)(%d)", count, ptr, strlen(ptr)); */
 249                 ptr_last = ptr;
 250                 count++;
 251         }
 252
 253         if (count != VALID_LAST_COUNT_FOR_EVENTNAME) {
 254                 _E("invalid event_name(%s), count(%d)", event_name, count);
 255                 FREE_AND_NULL(temp_name);
 256                 return NULL;
 257         }
 258
 259         if (ptr_last) {
 260                 /* _D("new member_name(%s)(%d)", ptr_last, strlen(ptr_last)); */
 261                 member_name = strdup(ptr_last);
 262                 if (!member_name) {
 263                         _E("out_of_memory");
 264                         FREE_AND_NULL(temp_name);
 265                         return NULL;
 266                 }
 267         } else {
 268                 _E("ptr_last is NULL");
 269                 FREE_AND_NULL(temp_name);
 270                 return NULL;
 271         }
 272
 273         _D("member_name(%s)", member_name);
 274
 275         FREE_AND_NULL(temp_name);
 276         return member_name;
 277 }
 278
 279 static int __check_validation_usrevent_sender(int sender_pid,
 280                 const char *interface_name, const char *event_name)
 281 {
 282         char *sender_id = NULL;
 283         char *key = NULL;
 284         char *val = NULL;
 285
 286         if (__eventsystem_check_sender_validation(sender_pid,
 287                 event_name, &sender_id) < 0) {
 288                 _E("invalid user-event sender");
 289                 return ES_R_EINVAL;
 290         }
 291
 292         if (sender_id == NULL) {
 293                 _E("sender_id is null");
 294                 return ES_R_EINVAL;
 295         }
 296
 297         key = strdup(interface_name);
 298         if (key == NULL) {
 299                 _E("out of memory");
 300                 g_free(sender_id);
 301                 return ES_R_ENOMEM;
 302         }
 303
 304         val = strdup(sender_id);
 305         if (val == NULL) {
 306                 _E("out of memory");
 307                 free(key);
 308                 g_free(sender_id);
 309                 return ES_R_ENOMEM;
 310         }
 311
 312         g_hash_table_insert(filter_tbl, key, val);
 313         g_free(sender_id);
 314
 315         return ES_R_OK;
 316 }
 317
 318 static int __check_validation_user_defined_name(const char *event_name)
 319 {
 320         char *event_id = NULL;
 321         char *key = NULL;
 322         int ret = 1;
 323
 324         if (check_tbl == NULL)
 325                 check_tbl = g_hash_table_new(g_str_hash, g_str_equal);
 326
 327         event_id = (char *)g_hash_table_lookup(check_tbl, event_name);
 328         if (event_id == NULL) {
 329                 if (__eventsystem_check_user_send_validation(event_name) < 0) {
 330                         _E("invalid user-event name");
 331                         ret = 0;
 332                 } else {
 333                         key = strdup(event_name);
 334                         if (key == NULL) {
 335                                 _E("out_of_memory");
 336                                 ret = 0;
 337                         } else {
 338                                 g_hash_table_insert(check_tbl, key, key);
 339                         }
 340                 }
 341         }
 342
 343         return ret;
 344 }
 345
 346 static int __check_interface_validation_user(char *interface_name)
 347 {
 348         int len = strlen(EVENT_SYSTEM_PREFIX);
 349
 350         if (strncmp(interface_name, EVENT_SYSTEM_PREFIX, len) != 0)
 351                 return 0;
 352
 353         return 1;
 354 }
 355
 356 static int __check_eventname_validation_user(char *event_name)
 357 {
 358         int len = strlen(USER_EVENT_NAME_PREFIX);
 359
 360         if (strncmp(event_name, USER_EVENT_NAME_PREFIX, len) != 0)
 361                 return 0;
 362
 363         return 1;
 364 }
 365
 366 static int __check_eventname_validation_system(char *event_name)
 367 {
 368         int len = strlen(SYS_EVENT_NAME_PREFIX);
 369
 370         if (strncmp(event_name, SYS_EVENT_NAME_PREFIX, len) != 0)
 371                 return 0;
 372
 373         return 1;
 374 }
 375
 376 static int __get_gdbus_shared_connection(GDBusConnection **connection, GBusType bus_type,
 377                 eventsystem_event_type event_type)
 378 {
 379         GError *error = NULL;
 380         guint owner_id = 0;
 381         gchar *guid = NULL;
 382         char own_name[128] = {0, };
 383         GDBusConnection *conn_system = NULL;
 384
 385         if (!_initialized)
 386                 __initialize();
 387
 388         *connection = g_bus_get_sync(bus_type, NULL, &error);
 389         if (*connection == NULL) {
 390                 if (error != NULL) {
 391                         _E("Failed to get dbus [%s], bus_type [%d]",
 392                                 error->message, bus_type);
 393                         g_error_free(error);
 394                 }
 395                 return ES_R_ERROR;
 396         }
 397
 398         if (((bus_type == G_BUS_TYPE_SYSTEM && !s_info.owner_id) ||
 399                 (bus_type == G_BUS_TYPE_SESSION && !s_info.owner_id_session))) {
 400                 guid = g_dbus_generate_guid();
 401                 if (guid == NULL) {
 402                         _E("failed to get guid");
 403                         return ES_R_ERROR;
 404                 }
 405                 snprintf(own_name, 128, "%s.%s.id%s_%d_%d", "event.busname",
 406                         (bus_type == G_BUS_TYPE_SESSION ? "session" : "system"),
 407                         guid, getuid(), getpid());
 408                 g_free(guid);
 409
 410                 _D("bus_name is [%s]", own_name);
 411                 owner_id = g_bus_own_name_on_connection(*connection, own_name,
 412                         G_BUS_NAME_OWNER_FLAGS_NONE,
 413                         NULL, NULL, NULL, NULL);
 414                 if (!owner_id) {
 415                         _E("g_bus_own_name_on_connection, error");
 416                         return ES_R_ERROR;
 417                 }
 418
 419                 if (bus_type == G_BUS_TYPE_SESSION && event_type == ES_TYPE_USER) {
 420                         /* set same name on system-bus */
 421                         error = NULL;
 422                         conn_system = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
 423                         if (conn_system == NULL) {
 424                                 _E("failed to get system connection");
 425                                 if (error != NULL) {
 426                                         _E("error(%s)", error->message);
 427                                         g_error_free(error);
 428                                 }
 429                                 return ES_R_ERROR;
 430                         } else {
 431                                 owner_id = g_bus_own_name_on_connection(conn_system,
 432                                         own_name, G_BUS_NAME_OWNER_FLAGS_NONE,
 433                                         NULL, NULL, NULL, NULL);
 434                                 if (!owner_id) {
 435                                         _E("g_bus_own_name_on_connection(for system), error");
 436                                         g_object_unref(conn_system);
 437                                         return ES_R_ERROR;
 438                                 }
 439
 440                                 g_object_unref(conn_system);
 441                         }
 442                 }
 443
 444                 if (bus_type == G_BUS_TYPE_SESSION) {
 445                         s_info.owner_id_session = owner_id;
 446                         s_info.own_name_session_bus = strdup(own_name);
 447                         if (s_info.own_name_session_bus == NULL) {
 448                                 _E("out of memory");
 449                                 return ES_R_ERROR;
 450                         }
 451                 } else {
 452                         s_info.owner_id = owner_id;
 453                         s_info.own_name_system_bus = strdup(own_name);
 454                         if (s_info.own_name_system_bus == NULL) {
 455                                 _E("out of memory");
 456                                 return ES_R_ERROR;
 457                         }
 458                 }
 459         }
 460
 461         return ES_R_OK;
 462 }
 463
 464 static void __eventsystem_event_handler(GDBusConnection *connection,
 465                 const gchar *sender_name, const gchar *object_path,
 466                 const gchar *interface_name, const gchar *signal_name,
 467                 GVariant *parameters, gpointer user_data)
 468 {
 469         int len;
 470         eventmap_s *em = (eventmap_s *)user_data;
 471         GList *cb_list = NULL;
 472         bundle *buf = NULL;
 473         bundle_raw *raw = NULL;
 474
 475         if (!em) {
 476                 _E("Critical error!");
 477                 return;
 478         }
 479
 480         _D("sender_name(%s), interface_name(%s), signal_name(%s)",
 481                 sender_name, interface_name, signal_name);
 482
 483         cb_list = g_list_find(system_event_list, em);
 484         if (cb_list == NULL)
 485                 return;
 486
 487         g_variant_get(parameters, "(us)", &len, &raw);
 488
 489         buf = bundle_decode((bundle_raw *)raw, len);
 490
 491         if (em->ep_cb)
 492                 em->ep_cb(em->event_name, buf, em->user_data);
 493
 494         bundle_free_encoded_rawdata(&raw);
 495         bundle_free(buf);
 496 }
 497
 498 static void __eventsystem_application_event_handler(int sender_pid,
 499                 const gchar *interface_name, const gchar *signal_name,
 500                 GVariant *parameters, gpointer user_data)
 501 {
 502         GList *cb_list;
 503         eventmap_s *em = (eventmap_s *)user_data;
 504         bundle_raw *raw = NULL;
 505         int len;
 506
 507         if (!em) {
 508                 _E("Critical error!");
 509                 return;
 510         }
 511
 512         cb_list = g_list_find(system_event_list, em);
 513         if (cb_list == NULL) {
 514                 _E("not interested event");
 515                 return;
 516         }
 517
 518         if (sender_pid > 0 && __check_interface_validation_user((char *)interface_name)) {
 519                 if (__check_validation_usrevent_sender(sender_pid,
 520                         (const char *)interface_name, em->event_name) < 0) {
 521                         _E("invalid sender");
 522                         return;
 523                 }
 524         }
 525
 526         g_variant_get(parameters, "(us)", &len, &raw);
 527         if (em->es_cb)
 528                 em->es_cb(em->event_name, raw, len, em->user_data);
 529
 530         bundle_free_encoded_rawdata(&raw);
 531 }
 532
 533 /**
 534  * application-use filter for user-event
 535  */
 536 static void __eventsystem_filter_userevent_for_application(GDBusConnection *connection,
 537                 const gchar *sender_name, const gchar *object_path,
 538                 const gchar *interface_name, const gchar *signal_name,
 539                 GVariant *parameters, gpointer user_data)
 540 {
 541         char *sender_id = NULL;
 542         int sender_pid = -1;
 543
 544         _D("sender_name(%s), interface_name(%s)", sender_name, interface_name);
 545
 546         if (filter_tbl == NULL)
 547                 filter_tbl = g_hash_table_new(g_str_hash, g_str_equal);
 548
 549         sender_id = (char *)g_hash_table_lookup(filter_tbl, interface_name);
 550         if (sender_id == NULL) {
 551                 sender_pid = __eventsystem_get_sender_pid(connection, sender_name);
 552                 if (sender_pid <= 0) {
 553                         _E("failed to get pid of sender(%s)", sender_name);
 554                         return;
 555                 }
 556                 _D("sender_pid(%d)", sender_pid);
 557         }
 558
 559         __eventsystem_application_event_handler(sender_pid, interface_name,
 560                 signal_name, parameters, user_data);
 561 }
 562
 563 /**
 564  * application-use filter for system-event
 565  */
 566 static void __eventsystem_filter_sysevent_for_application(GDBusConnection *connection,
 567                 const gchar *sender_name, const gchar *object_path,
 568                 const gchar *interface_name, const gchar *signal_name,
 569                 GVariant *parameters, gpointer user_data)
 570 {
 571         _D("sender_name(%s), interface_name(%s)", sender_name, interface_name);
 572
 573         __eventsystem_application_event_handler(-1, interface_name,
 574                 signal_name, parameters, user_data);
 575 }
 576
 577 /**
 578  * internal-use filter for user-event
 579  */
 580 static void __eventsystem_filter_userevent_for_internal(GDBusConnection *connection,
 581                 const gchar *sender_name, const gchar *object_path,
 582                 const gchar *interface_name, const gchar *signal_name,
 583                 GVariant *parameters, gpointer user_data)
 584 {
 585         _D("sender_name(%s), interface_name(%s), signal_name(%s)",
 586                 sender_name, interface_name, signal_name);
 587
 588         __eventsystem_event_handler(connection, sender_name,
 589                 object_path, interface_name, signal_name, parameters, user_data);
 590 }
 591
 592 /**
 593  * internal-use filter for system-event
 594  */
 595 static void __eventsystem_filter_sysevent_for_internal(GDBusConnection *connection,
 596                 const gchar *sender_name, const gchar *object_path,
 597                 const gchar *interface_name, const gchar *signal_name,
 598                 GVariant *parameters, gpointer user_data)
 599 {
 600         _D("sender_name(%s), interface_name(%s), signal_name(%s)",
 601                 sender_name, interface_name, signal_name);
 602
 603         __eventsystem_event_handler(connection, sender_name,
 604                 object_path, interface_name, signal_name, parameters, user_data);
 605 }
 606
 607 static int __eventsystem_register_event_internal(const char *event_name,
 608                 eventmap_s **em_s, void *user_data)
 609 {
 610         eventmap_s *em;
 611         char *interface_name;
 612         char *object_path;
 613         char *member_name;
 614         GDBusSignalCallback filter;
 615         GBusType bus_type;
 616         guint subscription_id = 0;
 617         int ret = 0;
 618         int evt_type = ES_TYPE_UNKNOWN;
 619         GDBusConnection *conn = NULL;
 620
 621         if (__check_eventname_validation_system((char *)event_name)) {
 622                 evt_type = ES_TYPE_SYSTEM;
 623         } else if (__check_eventname_validation_user((char *)event_name)) {
 624                 evt_type = ES_TYPE_USER;
 625         } else {
 626                 evt_type = ES_TYPE_UNKNOWN;
 627                 _E("unknown type event(%s)", event_name);
 628                 return ES_R_EINVAL;
 629         }
 630
 631         if (evt_type == ES_TYPE_SYSTEM) {
 632                 interface_name = strdup(SYS_EVENT_NAME_PREFIX);
 633                 if (interface_name == NULL) {
 634                         _E("out of memory");
 635                         ret = ES_R_ENOMEM;
 636                         goto out_1;
 637                 }
 638
 639                 member_name = __get_member_name_from_eventname((char *)event_name);
 640                 if (member_name == NULL) {
 641                         _E("invalid member_name");
 642                         ret = ES_R_ERROR;
 643                         goto out_2;
 644                 }
 645
 646                 if (!g_dbus_is_member_name(member_name)) {
 647                         _E("invalid member name");
 648                         ret = ES_R_EINVAL;
 649                         goto out_3;
 650                 }
 651                 filter = __eventsystem_filter_sysevent_for_internal;
 652         } else {
 653                 interface_name = __get_encoded_interface_name((char *)event_name);
 654                 if (!interface_name) {
 655                         _E("interface_name is NULL");
 656                         ret = ES_R_ERROR;
 657                         goto out_1;
 658                 }
 659                 if (!g_dbus_is_interface_name(interface_name)) {
 660                         _E("invalid interface_name(%s)", interface_name);
 661                         ret = ES_R_EINVAL;
 662                         goto out_2;
 663                 }
 664                 member_name = strdup(EVENT_SYSTEM_MEMBER);
 665                 if (!member_name) {
 666                         _E("out_of_memory");
 667                         ret = ES_R_ERROR;
 668                         goto out_2;
 669                 }
 670                 filter = __eventsystem_filter_userevent_for_internal;
 671         }
 672
 673         object_path = __get_object_path(interface_name);
 674         if (!object_path) {
 675                 _E("object_path is NULL");
 676                 ret = ES_R_ERROR;
 677                 goto out_3;
 678         }
 679
 680         bus_type = G_BUS_TYPE_SYSTEM;
 681
 682         if (__get_gdbus_shared_connection(&conn, bus_type, evt_type) < 0) {
 683                 _E("getting gdbus-connetion error");
 684                 goto out_4;
 685         }
 686
 687         em = __create_eventmap(interface_name, member_name, event_name,
 688                         evt_type, NULL, user_data);
 689         if (!em) {
 690                 ret = ES_R_ENOMEM;
 691                 goto out_4;
 692         }
 693
 694         subscription_id = g_dbus_connection_signal_subscribe(conn,
 695                 NULL, /* sender */
 696                 interface_name,
 697                 member_name, /* member */
 698                 object_path, /* object_path */
 699                 NULL, /* arg0 */
 700                 G_DBUS_SIGNAL_FLAGS_NONE,
 701                 filter,
 702                 em,
 703                 NULL); /* user_data_free_func */
 704
 705         _D("event_name(%s), interface_name(%s)", event_name, interface_name);
 706         _D("member_name(%s), subscription_id(%d), bus_type(%d)",
 707                 member_name, subscription_id, bus_type);
 708
 709         if (subscription_id != 0) {
 710                 em->bus_type = bus_type;
 711                 em->reg_id = subscription_id;
 712
 713                 *em_s = em;
 714                 ret = ES_R_OK;
 715         } else {
 716                 _D("dbus subscribe: error(%d), event(%s)", subscription_id, event_name);
 717                 __destroy_eventmap(em);
 718                 ret = ES_R_ERROR;
 719         }
 720
 721 out_4:
 722         FREE_AND_NULL(object_path);
 723 out_3:
 724         FREE_AND_NULL(member_name);
 725 out_2:
 726         FREE_AND_NULL(interface_name);
 727 out_1:
 728         if (conn)
 729                 g_object_unref(conn);
 730
 731         return ret;
 732 }
 733
 734 /**
 735  * function : register the event
 736  */
 737 int eventsystem_register_event(const char *event_name, unsigned int *reg_id,
 738                 eventsystem_handler callback, void *user_data)
 739 {
 740         eventmap_s *em = NULL;
 741         int ret = ES_R_ERROR;
 742
 743         retvm_if(!g_dbus_is_interface_name(event_name), ES_R_EINVAL,
 744                 "Invalid argument : event_name(%s)", event_name);
 745         retvm_if(!reg_id, ES_R_EINVAL, "Invalid argument : reg_id");
 746         retvm_if(!callback, ES_R_EINVAL, "Invalid argument : callback");
 747
 748         if (!_initialized)
 749                 __initialize();
 750
 751         ret = __eventsystem_register_event_internal(event_name, &em, user_data);
 752         if (ret == ES_R_OK && em) {
 753                 em->ep_cb = callback;
 754                 system_event_list = g_list_append(system_event_list, em);
 755                 *reg_id = em->reg_id;
 756                 ret = ES_R_OK;
 757         } else {
 758                 _E("error, ret(%d), event_name(%s)", ret, event_name);
 759         }
 760
 761         return ret;
 762 }
 763
 764 /**
 765  * function : unregister the event
 766  */
 767 int eventsystem_unregister_event(unsigned int reg_id)
 768 {
 769         eventmap_s em;
 770         eventmap_s *em_data = NULL;
 771         GBusType bus_type;
 772         GList *cb_list = NULL;
 773         GDBusConnection *conn = NULL;
 774         eventsystem_event_type evt_type;
 775
 776         retvm_if(reg_id == 0, ES_R_EINVAL, "Invalid argument : reg_id");
 777
 778         if (!_initialized)
 779                 __initialize();
 780
 781         em.reg_id = reg_id;
 782         cb_list = g_list_find_custom(system_event_list, &em,
 783                 (GCompareFunc)__event_compare_reg_id_cb);
 784         if (cb_list) {
 785                 em_data = (eventmap_s *)cb_list->data;
 786
 787                 bus_type = em_data->bus_type;
 788                 evt_type = em_data->event_type;
 789
 790                 _D("unsubscribe: reg_id(%d), bus_type(%d)", reg_id, bus_type);
 791
 792                 if (__get_gdbus_shared_connection(&conn, bus_type, evt_type) < 0) {
 793                         _E("getting gdbus-connetion error");
 794                         return ES_R_ERROR;
 795                 }
 796                 g_dbus_connection_signal_unsubscribe(conn, reg_id);
 797
 798                 system_event_list = g_list_remove(system_event_list, cb_list->data);
 799
 800                 __destroy_eventmap(em_data);
 801                 g_object_unref(conn);
 802         }
 803
 804         return ES_R_OK;
 805 }
 806
 807 static int __eventsystem_send_event(GDBusConnection *conn, eventinfo_s *evti, bundle *data)
 808 {
 809         GError *error = NULL;
 810         GVariant *param = NULL;
 811         gboolean ret;
 812
 813         bundle_raw *raw = NULL;
 814         bundle *buf = data;
 815         int len;
 816
 817         bundle_encode(buf, &raw, &len);
 818
 819         param = g_variant_new("(us)", len, raw);
 820         ret = g_dbus_connection_emit_signal(conn,
 821                 evti->destination_name,
 822                 evti->object_path,
 823                 evti->interface_name,
 824                 evti->member_name,
 825                 param,
 826                 &error);
 827
 828         _D("interface_name(%s)", evti->interface_name);
 829         _D("object_path(%s)", evti->object_path);
 830         _D("member_name(%s)", evti->member_name);
 831
 832         bundle_free_encoded_rawdata(&raw);
 833
 834         if (ret == FALSE) {
 835                 _E("Unable to connect to dbus: %s", error->message);
 836                 g_error_free(error);
 837                 return ES_R_ERROR;
 838         }
 839
 840         return ES_R_OK;
 841 }
 842
 843 static void __eventsystem_free_trusted_list(gpointer data)
 844 {
 845         char *name = (char *)data;
 846
 847         FREE_AND_NULL(name);
 848 }
 849
 850 static int __eventsystem_send_trusted_event(GDBusConnection *conn, eventinfo_s *evti,
 851                 bundle *data, GList *dest_list)
 852 {
 853         GList *tmp_list = NULL;
 854         int ret = 0;
 855         char *dest_name;
 856
 857         if (dest_list) {
 858                 tmp_list = g_list_first(dest_list);
 859
 860                 while (tmp_list != NULL) {
 861                         dest_name = (char *)tmp_list->data;
 862                         if (dest_name && dest_name[0] != '\0') {
 863                                 _D("dest_name(%s)", dest_name);
 864                                 evti->destination_name = dest_name;
 865                                 ret = __eventsystem_send_event(conn, evti, data);
 866                                 if (ret != ES_R_OK) {
 867                                         _E("send error");
 868                                         ret = ES_R_ERROR;
 869                                         break;
 870                                 }
 871                         }
 872                         tmp_list = g_list_next(tmp_list);
 873                 }
 874         } else {
 875                 _E("dest_list is null");
 876         }
 877
 878         return ES_R_OK;
 879 }
 880
 881 /**
 882  * function : send the user-event
 883  */
 884 int eventsystem_send_user_event(const char *event_name, bundle *data, bool is_trusted)
 885 {
 886         int ret = ES_R_OK;
 887         eventinfo_s *evti = NULL;
 888         struct last_data_item *item;
 889         bundle_raw *raw = NULL;
 890         int len;
 891         GDBusConnection *conn = NULL;
 892         GList *trusted_dest_list = NULL;
 893
 894         /* check validation */
 895         retvm_if(!event_name, ES_R_EINVAL, "Invalid argument : event_name is NULL");
 896         retvm_if(!data, ES_R_EINVAL, "Invalid argument : data is NULL");
 897         retvm_if(!__check_eventname_validation_user((char *)event_name), ES_R_EINVAL,
 898                 "Invalid argument : event_name(%s)", event_name);
 899
 900         if (!__check_validation_user_defined_name(event_name)) {
 901                 _E("Invalid event name(%s)", event_name);
 902                 return ES_R_EINVAL;
 903         }
 904
 905         evti = calloc(1, sizeof(eventinfo_s));
 906         if (!evti) {
 907                 _E("memory alloc failed");
 908                 return ES_R_ENOMEM;
 909         }
 910         evti->event_name = strdup(event_name);
 911         if (!evti->event_name) {
 912                 _E("memory alloc failed");
 913                 ret = ES_R_ENOMEM;
 914                 goto out;
 915         }
 916
 917         evti->interface_name = __get_encoded_interface_name(evti->event_name);
 918         if (!evti->interface_name) {
 919                 _E("interface_name is NULL");
 920                 ret = ES_R_ERROR;
 921                 goto out;
 922         }
 923         evti->member_name = strdup(EVENT_SYSTEM_MEMBER);
 924         if (!evti->member_name) {
 925                 _E("memory alloc failed");
 926                 ret = ES_R_ENOMEM;
 927                 goto out;
 928         }
 929
 930         evti->object_path = __get_object_path(evti->interface_name);
 931         if (!evti->object_path) {
 932                 _E("object_path is NULL");
 933                 ret = ES_R_ERROR;
 934                 goto out;
 935         }
 936
 937         evti->destination_name = NULL;
 938         evti->is_user_event = true;
 939         evti->is_trusted = is_trusted;
 940
 941         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SESSION, ES_TYPE_USER) == ES_R_OK) {
 942                 if (bundle_encode(data, &raw, &len)) {
 943                         _E("Unable to encode bundle");
 944                         ret = ES_R_ERROR;
 945                         goto out;
 946                 }
 947
 948                 item = (struct last_data_item *)g_hash_table_lookup(last_data_tbl,
 949                                 evti->event_name);
 950                 if (item) {
 951                         if (!evti->is_trusted) {
 952                                 if (item->param)
 953                                         g_variant_unref(item->param);
 954                                 item->param = g_variant_new("(us)", len, raw);
 955                         }
 956                         if (item->trusted_param)
 957                                 g_variant_unref(item->trusted_param);
 958                         item->trusted_param = g_variant_new("(us)", len, raw);
 959                 }
 960
 961                 bundle_free_encoded_rawdata(&raw);
 962
 963                 if (is_trusted) {
 964                         if (__eventsystem_request_destination_list(evti->event_name, &trusted_dest_list) < 0) {
 965                                 _E("failed to get dest list");
 966                                 ret = ES_R_ERROR;
 967                                 goto out;
 968                         }
 969                         if (__eventsystem_send_trusted_event(conn, evti, data, trusted_dest_list) < 0) {
 970                                 _E("failed to send trusted event");
 971                                 ret = ES_R_ERROR;
 972                                 goto out;
 973                         }
 974
 975                         if (__eventsystem_launch_on_event_for_userevent(evti->event_name, data, TRUE) < 0)
 976                                 _E("Failed to launch on event for userevent");
 977                 } else {
 978                         if (__eventsystem_send_event(conn, evti, data) < 0) {
 979                                 _E("failed to send event");
 980                                 ret = ES_R_ERROR;
 981                                 goto out;
 982                         }
 983
 984                         if (__eventsystem_launch_on_event_for_userevent(evti->event_name, data, FALSE) < 0)
 985                                 _E("Failed to launch on event for userevent");
 986                 }
 987         } else {
 988                 _E("getting gdbus-connetion error");
 989                 ret = ES_R_ERROR;
 990         }
 991
 992 out:
 993         if (conn)
 994                 g_object_unref(conn);
 995         if (trusted_dest_list)
 996         g_list_free_full(trusted_dest_list, __eventsystem_free_trusted_list);
 997         FREE_AND_NULL(evti->object_path);
 998         FREE_AND_NULL(evti->member_name);
 999         FREE_AND_NULL(evti->interface_name);
1000         FREE_AND_NULL(evti->event_name);
1001         FREE_AND_NULL(evti);
1002
1003         return ret;
1004 }
1005
1006 /**
1007  * function : send the system-event
1008  */
1009 int eventsystem_send_system_event(const char *event_name, bundle *data)
1010 {
1011         int ret = 0;
1012         eventinfo_s *evti = NULL;
1013         GDBusConnection *conn = NULL;
1014
1015         pthread_mutex_lock(&send_sync_lock);
1016
1017         /* check validation */
1018         tryvm_if(!event_name, ret = ES_R_EINVAL, "Invalid argument : event_name is NULL");
1019         tryvm_if(!data, ret = ES_R_EINVAL, "Invalid argument : data is NULL");
1020         tryvm_if(!__check_eventname_validation_system((char *)event_name), ret = ES_R_EINVAL,
1021                 "Invalid argument : event_name(%s)", event_name);
1022         tryvm_if(!g_dbus_is_interface_name(event_name), ret = ES_R_EINVAL,
1023                 "Invalid argument : event_name(%s)", event_name);
1024
1025         _D("event_name(%s)", event_name);
1026
1027         evti = calloc(1, sizeof(eventinfo_s));
1028         if (!evti) {
1029                 _E("memory alloc failed");
1030                 pthread_mutex_unlock(&send_sync_lock);
1031                 return ES_R_ENOMEM;
1032         }
1033         evti->event_name = strdup(event_name);
1034         if (!evti->event_name) {
1035                 _E("out_of_memory");
1036                 ret = ES_R_ENOMEM;
1037                 goto out_1;
1038         }
1039         evti->interface_name = strdup(SYS_EVENT_NAME_PREFIX);
1040         if (!evti->interface_name) {
1041                 _E("out of memory");
1042                 ret = ES_R_ENOMEM;
1043                 goto out_2;
1044         }
1045         evti->member_name = __get_member_name_from_eventname(evti->event_name);
1046         if (!evti->member_name) {
1047                 _E("member_name is NULL");
1048                 ret = ES_R_ERROR;
1049                 goto out_3;
1050         }
1051         if (!g_dbus_is_member_name(evti->member_name)) {
1052                 _E("Invalid member_name(%s)", evti->member_name);
1053                 ret = ES_R_EINVAL;
1054                 goto out_4;
1055         }
1056         evti->object_path = __get_object_path(evti->interface_name);
1057         if (!evti->object_path) {
1058                 _E("object_path is NULL");
1059                 ret = ES_R_ERROR;
1060                 goto out_4;
1061         }
1062         evti->destination_name = NULL;
1063         evti->is_user_event = false;
1064
1065         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SYSTEM, ES_TYPE_SYSTEM) == ES_R_OK) {
1066                 ret = __eventsystem_send_event(conn, evti, data);
1067         } else {
1068                 _E("getting gdbus-connection error");
1069                 ret = ES_R_ERROR;
1070         }
1071
1072         if (conn)
1073                 g_object_unref(conn);
1074
1075         FREE_AND_NULL(evti->object_path);
1076 out_4:
1077         FREE_AND_NULL(evti->member_name);
1078 out_3:
1079         FREE_AND_NULL(evti->interface_name);
1080 out_2:
1081         FREE_AND_NULL(evti->event_name);
1082 out_1:
1083         FREE_AND_NULL(evti);
1084
1085 catch:
1086         pthread_mutex_unlock(&send_sync_lock);
1087
1088         return ret;
1089 }
1090
1091 /**
1092  * function : request sending the event
1093  */
1094 int eventsystem_request_sending_system_event(const char *event_name, bundle *data)
1095 {
1096         int ret = 0;
1097         GDBusConnection *conn = NULL;
1098         GError *error = NULL;
1099         GDBusProxy *proxy = NULL;
1100         GVariant *param = NULL;
1101         GVariant *value = NULL;
1102         gint result = 0;
1103         bundle_raw *raw = NULL;
1104         int len = 0;
1105
1106         _D("event_name(%s)", event_name);
1107
1108         if (!_initialized)
1109                 __initialize();
1110
1111         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SYSTEM, ES_TYPE_SYSTEM) < 0) {
1112                 _E("getting gdbus-connetion error");
1113                 ret = ES_R_ERROR;
1114                 goto out_1;
1115         }
1116
1117         proxy = g_dbus_proxy_new_sync(conn,
1118                 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, NULL,
1119                 ESD_BUS_NAME, ESD_OBJECT_PATH, ESD_INTERFACE_NAME,
1120                 NULL, &error);
1121         if (proxy == NULL) {
1122                 _E("failed to create new proxy, error(%s)", error->message);
1123                 g_error_free(error);
1124                 ret = ES_R_ERROR;
1125                 goto out_1;
1126         }
1127
1128         bundle_encode(data, &raw, &len);
1129
1130         param = g_variant_new("(ssi)", event_name, raw, len);
1131         value = g_dbus_proxy_call_sync(proxy, "RequestSendingEvent", param,
1132                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1133         if (error != NULL) {
1134                 _E("proxy call sync error(%s)", error->message);
1135                 g_error_free(error);
1136                 ret = ES_R_ERROR;
1137                 goto out_2;
1138         }
1139
1140         g_variant_get(value, "(i)", &result);
1141
1142         _D("result(%d)", result);
1143
1144         ret = ES_R_OK;
1145
1146 out_2:
1147         g_object_unref(proxy);
1148         g_variant_unref(value);
1149 out_1:
1150         if (conn)
1151                 g_object_unref(conn);
1152
1153         return ret;
1154 }
1155
1156 static int __eventsystem_check_sender_validation(int sender_pid, const char *event_name,
1157                 char **sender_id)
1158 {
1159         int ret = ES_R_EINVAL;
1160         GDBusConnection *conn = NULL;
1161         GError *error = NULL;
1162         GDBusProxy *proxy = NULL;
1163         GVariant *param = NULL;
1164         GVariant *value = NULL;
1165         gint result = 0;
1166
1167         if (!_initialized)
1168                 __initialize();
1169
1170         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SYSTEM, ES_TYPE_SYSTEM) < 0) {
1171                 _E("getting gdbus-connetion error");
1172                 ret = ES_R_ERROR;
1173                 goto out_1;
1174         }
1175
1176         proxy = g_dbus_proxy_new_sync(conn,
1177                 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, NULL,
1178                 ESD_BUS_NAME, ESD_OBJECT_PATH, ESD_INTERFACE_NAME,
1179                 NULL, &error);
1180         if (proxy == NULL) {
1181                 _E("failed to create new proxy, error(%s)", error->message);
1182                 g_error_free(error);
1183                 ret = ES_R_ERROR;
1184                 goto out_1;
1185         }
1186
1187         param = g_variant_new("(is)", sender_pid, event_name);
1188         value = g_dbus_proxy_call_sync(proxy, "CheckSenderValidation", param,
1189                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1190         if (error != NULL) {
1191                 _E("proxy call sync error(%s)", error->message);
1192                 g_error_free(error);
1193                 ret = ES_R_ERROR;
1194                 goto out_2;
1195         }
1196
1197         g_variant_get(value, "(is)", &result, sender_id);
1198
1199         _D("result(%d)", result);
1200
1201         if (result == 1)
1202                 ret = ES_R_OK;
1203 out_2:
1204         g_object_unref(proxy);
1205         g_variant_unref(value);
1206 out_1:
1207         if (conn)
1208                 g_object_unref(conn);
1209
1210         return ret;
1211 }
1212
1213 static int __eventsystem_check_user_send_validation(const char *event_name)
1214 {
1215         int ret = ES_R_EINVAL;
1216         GDBusConnection *conn = NULL;
1217         GError *error = NULL;
1218         GDBusProxy *proxy = NULL;
1219         GVariant *param = NULL;
1220         GVariant *value = NULL;
1221         gint result = 0;
1222
1223         if (!_initialized)
1224                 __initialize();
1225
1226         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SYSTEM, ES_TYPE_SYSTEM) < 0) {
1227                 _E("getting gdbus-connetion error");
1228                 ret = ES_R_ERROR;
1229                 goto out_1;
1230         }
1231
1232         proxy = g_dbus_proxy_new_sync(conn,
1233                 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, NULL,
1234                 ESD_BUS_NAME, ESD_OBJECT_PATH, ESD_INTERFACE_NAME,
1235                 NULL, &error);
1236         if (proxy == NULL) {
1237                 _E("failed to create new proxy, error(%s)", error->message);
1238                 g_error_free(error);
1239                 ret = ES_R_ERROR;
1240                 goto out_1;
1241         }
1242
1243         param = g_variant_new("(s)", event_name);
1244         value = g_dbus_proxy_call_sync(proxy, "CheckUserSendValidation", param,
1245                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1246         if (error != NULL) {
1247                 _E("proxy call sync error(%s)", error->message);
1248                 g_error_free(error);
1249                 ret = ES_R_ERROR;
1250                 goto out_2;
1251         }
1252
1253         g_variant_get(value, "(i)", &result);
1254
1255         _D("result(%d)", result);
1256
1257         if (result == 1)
1258                 ret = ES_R_OK;
1259 out_2:
1260         g_object_unref(proxy);
1261         g_variant_unref(value);
1262 out_1:
1263         if (conn)
1264                 g_object_unref(conn);
1265
1266         return ret;
1267 }
1268
1269 static int __eventsystem_check_privilege_validation(const char *event_name)
1270 {
1271         int ret = ES_R_ENOTPERMITTED;
1272         GDBusConnection *conn = NULL;
1273         GError *error = NULL;
1274         GDBusProxy *proxy = NULL;
1275         GVariant *param = NULL;
1276         GVariant *value = NULL;
1277         gint result = 0;
1278
1279         if (!_initialized)
1280                 __initialize();
1281
1282         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SYSTEM, ES_TYPE_SYSTEM) < 0) {
1283                 _E("getting gdbus-connetion error");
1284                 ret = ES_R_ERROR;
1285                 goto out_1;
1286         }
1287
1288         proxy = g_dbus_proxy_new_sync(conn,
1289                 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, NULL,
1290                 ESD_BUS_NAME, ESD_OBJECT_PATH, ESD_INTERFACE_NAME,
1291                 NULL, &error);
1292         if (proxy == NULL) {
1293                 _E("failed to create new proxy, error(%s)", error->message);
1294                 g_error_free(error);
1295                 ret = ES_R_ERROR;
1296                 goto out_1;
1297         }
1298
1299         param = g_variant_new("(s)", event_name);
1300         value = g_dbus_proxy_call_sync(proxy, "CheckPrivilegeValidation", param,
1301                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1302         if (error != NULL) {
1303                 _E("proxy call sync error(%s)", error->message);
1304                 g_error_free(error);
1305                 ret = ES_R_ERROR;
1306                 goto out_2;
1307         }
1308
1309         g_variant_get(value, "(i)", &result);
1310
1311         _D("result(%d)", result);
1312
1313         if (result == 1)
1314                 ret = ES_R_OK;
1315 out_2:
1316         g_object_unref(proxy);
1317         g_variant_unref(value);
1318 out_1:
1319         if (conn)
1320                 g_object_unref(conn);
1321
1322         return ret;
1323 }
1324
1325 static int __eventsystem_setup_trusted_peer(const char *event_name, const char *dest_bus_name)
1326 {
1327         int ret = ES_R_ERROR;
1328         GDBusConnection *conn = NULL;
1329         GError *error = NULL;
1330         GDBusProxy *proxy = NULL;
1331         GVariant *param = NULL;
1332         GVariant *value = NULL;
1333         gint result = 0;
1334
1335         if (!_initialized)
1336                 __initialize();
1337
1338         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SYSTEM, ES_TYPE_SYSTEM) < 0) {
1339                 _E("getting gdbus-connetion error");
1340                 ret = ES_R_ERROR;
1341                 goto out_1;
1342         }
1343
1344         proxy = g_dbus_proxy_new_sync(conn,
1345                 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, NULL,
1346                 ESD_BUS_NAME, ESD_OBJECT_PATH, ESD_INTERFACE_NAME,
1347                 NULL, &error);
1348         if (proxy == NULL) {
1349                 _E("failed to create new proxy, error(%s)", error->message);
1350                 g_error_free(error);
1351                 ret = ES_R_ERROR;
1352                 goto out_1;
1353         }
1354
1355         param = g_variant_new("(ss)", event_name, dest_bus_name);
1356         value = g_dbus_proxy_call_sync(proxy, "SetupTrustedPeer", param,
1357                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1358         if (error != NULL) {
1359                 _E("proxy call sync error(%s)", error->message);
1360                 g_error_free(error);
1361                 ret = ES_R_ERROR;
1362                 goto out_2;
1363         }
1364
1365         g_variant_get(value, "(i)", &result);
1366
1367         _D("result(%d)", result);
1368
1369         if (result == 1)
1370                 ret = ES_R_OK;
1371 out_2:
1372         g_object_unref(proxy);
1373         g_variant_unref(value);
1374 out_1:
1375         if (conn)
1376                 g_object_unref(conn);
1377
1378         return ret;
1379 }
1380
1381 static int __eventsystem_request_destination_list(const char *event_name, GList **dest_list)
1382 {
1383         int ret = ES_R_ERROR;
1384         GDBusConnection *conn = NULL;
1385         GError *error = NULL;
1386         GDBusProxy *proxy = NULL;
1387         GVariant *param = NULL;
1388         GVariant *value = NULL;
1389         GVariantIter *iter;
1390         gchar *str;
1391         char *dest_name = NULL;
1392         gint result = 0;
1393
1394         if (!_initialized)
1395                 __initialize();
1396
1397         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SYSTEM, ES_TYPE_SYSTEM) < 0) {
1398                 _E("getting gdbus-connetion error");
1399                 ret = ES_R_ERROR;
1400                 goto out_1;
1401         }
1402
1403         proxy = g_dbus_proxy_new_sync(conn,
1404                 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, NULL,
1405                 ESD_BUS_NAME, ESD_OBJECT_PATH, ESD_INTERFACE_NAME,
1406                 NULL, &error);
1407         if (proxy == NULL) {
1408                 _E("failed to create new proxy, error(%s)", error->message);
1409                 g_error_free(error);
1410                 ret = ES_R_ERROR;
1411                 goto out_1;
1412         }
1413
1414         param = g_variant_new("(s)", event_name);
1415         value = g_dbus_proxy_call_sync(proxy, "GetTrustedPeerList", param,
1416                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1417         if (error != NULL) {
1418                 _E("proxy call sync error(%s)", error->message);
1419                 g_error_free(error);
1420                 ret = ES_R_ERROR;
1421                 goto out_2;
1422         }
1423
1424         g_variant_get(value, "(ias)", &result, &iter);
1425
1426         _D("result(%d)", result);
1427
1428         if (result == 1) {
1429                 ret = ES_R_OK;
1430                 while (g_variant_iter_loop(iter, "s", &str)) {
1431                         dest_name = strdup((char *)str);
1432                         if (dest_name) {
1433                                 _D("dest name(%s)", str);
1434                                 *dest_list = g_list_append(*dest_list, dest_name);
1435                         } else {
1436                                 _E("out of memory");
1437                                 ret = ES_R_ENOMEM;
1438                                 break;
1439                         }
1440                 }
1441         }
1442         g_variant_iter_free(iter);
1443
1444 out_2:
1445         g_object_unref(proxy);
1446         g_variant_unref(value);
1447 out_1:
1448         if (conn)
1449                 g_object_unref(conn);
1450
1451         return ret;
1452 }
1453
1454 #ifdef APPFW_EVENT_SYSTEM_EARLIER_FEATURE
1455 static int __eventsystem_request_earlier_data(const char *event_name,
1456                 eventsystem_cb callback, void *user_data)
1457 {
1458         int ret = 0;
1459         GDBusConnection *conn = NULL;
1460         GError *error = NULL;
1461         GDBusProxy *proxy = NULL;
1462         GVariant *param = NULL;
1463         GVariant *value = NULL;
1464         gint result = 0;
1465         bundle_raw *raw = NULL;
1466         int len = 0;
1467
1468         if (!_initialized)
1469                 __initialize();
1470
1471         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SYSTEM, ES_TYPE_SYSTEM) < 0) {
1472                 _E("getting gdbus-connetion error");
1473                 ret = ES_R_ERROR;
1474                 goto out_1;
1475         }
1476
1477         proxy = g_dbus_proxy_new_sync(conn,
1478                 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, NULL,
1479                 ESD_BUS_NAME, ESD_OBJECT_PATH, ESD_INTERFACE_NAME,
1480                 NULL, &error);
1481
1482         if (proxy == NULL) {
1483                 _E("failed to create new proxy, error(%s)", error->message);
1484                 g_error_free(error);
1485                 ret = ES_R_ERROR;
1486                 goto out_1;
1487         }
1488
1489         param = g_variant_new("(s)", event_name);
1490         value = g_dbus_proxy_call_sync(proxy, "GetEarlierData", param,
1491                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1492         if (error != NULL) {
1493                 _E("proxy call sync error(%s)", error->message);
1494                 g_error_free(error);
1495                 ret = ES_R_ERROR;
1496                 goto out_2;
1497         }
1498
1499         g_variant_get(value, "(ii&s)", &result, &len, &raw);
1500
1501         _D("result(%d), len(%d)", result, len);
1502
1503         if (!result && raw && len > 0) {
1504                 callback(event_name, raw, len, user_data);
1505                 ret = ES_R_OK;
1506         } else {
1507                 ret = ES_R_ERROR;
1508         }
1509
1510 out_2:
1511         g_object_unref(proxy);
1512         g_variant_unref(value);
1513 out_1:
1514         if (conn)
1515                 g_object_unref(conn);
1516
1517         return ret;
1518 }
1519 #endif
1520
1521 static int __request_esd_for_last_data(const char *event_name, bool check)
1522 {
1523         int ret = 0;
1524         GDBusConnection *conn = NULL;
1525         GError *error = NULL;
1526         GDBusProxy *proxy = NULL;
1527         GVariant *param = NULL;
1528         GVariant *value = NULL;
1529         gint result = 0;
1530
1531         if (!_initialized)
1532                 __initialize();
1533
1534         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SYSTEM,
1535                                 ES_TYPE_SYSTEM) < 0) {
1536                 _E("getting gdbus-connetion error");
1537                 ret = ES_R_ERROR;
1538                 goto out_1;
1539         }
1540
1541         proxy = g_dbus_proxy_new_sync(conn,
1542                 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, NULL,
1543                 ESD_BUS_NAME, ESD_OBJECT_PATH, ESD_INTERFACE_NAME,
1544                 NULL, &error);
1545
1546         if (proxy == NULL) {
1547                 _E("failed to create new proxy, error(%s)", error->message);
1548                 g_error_free(error);
1549                 ret = ES_R_ERROR;
1550                 goto out_1;
1551         }
1552
1553         param = g_variant_new("(ss)", event_name,
1554                         check ? s_info.own_name_session_bus :
1555                         s_info.own_name_system_bus);
1556         value = g_dbus_proxy_call_sync(proxy,
1557                         check ? "CheckLastData" : "KeepLastData", param,
1558                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1559
1560         if (error != NULL) {
1561                 _E("proxy call sync error(%s)", error->message);
1562                 g_error_free(error);
1563                 ret = ES_R_ERROR;
1564                 goto out_2;
1565         }
1566
1567         g_variant_get(value, "(i)", &result);
1568
1569         _D("result(%d)", result);
1570
1571         ret = result;
1572
1573 out_2:
1574         g_object_unref(proxy);
1575         g_variant_unref(value);
1576 out_1:
1577         if (conn)
1578                 g_object_unref(conn);
1579
1580         return ret;
1581 }
1582
1583 static int __eventsystem_launch_on_event_for_userevent(const char *event_name,
1584                 bundle *data, gboolean trusted)
1585 {
1586         int ret = ES_R_EINVAL;
1587         GDBusConnection *conn = NULL;
1588         GError *error = NULL;
1589         GDBusProxy *proxy = NULL;
1590         GVariant *param = NULL;
1591         GVariant *value = NULL;
1592         gint result = 0;
1593         bundle_raw *raw = NULL;
1594         bundle *buf = data;
1595         int len;
1596
1597         if (!_initialized)
1598                 __initialize();
1599
1600         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SYSTEM, ES_TYPE_SYSTEM) < 0) {
1601                 _E("getting gdbus-connetion error");
1602                 ret = ES_R_ERROR;
1603                 goto out_1;
1604         }
1605
1606         proxy = g_dbus_proxy_new_sync(conn,
1607                 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, NULL,
1608                 ESD_BUS_NAME, ESD_OBJECT_PATH, ESD_INTERFACE_NAME,
1609                 NULL, &error);
1610         if (proxy == NULL) {
1611                 _E("failed to create new proxy, error(%s)", error->message);
1612                 g_error_free(error);
1613                 ret = ES_R_ERROR;
1614                 goto out_1;
1615         }
1616
1617         bundle_encode(buf, &raw, &len);
1618
1619         param = g_variant_new("(ssib)", event_name, raw, len, trusted);
1620         value = g_dbus_proxy_call_sync(proxy, "LaunchOnEventFromUserEvent", param,
1621                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1622         if (error != NULL) {
1623                 _E("proxy call sync error(%s)", error->message);
1624                 g_error_free(error);
1625                 ret = ES_R_ERROR;
1626                 goto out_2;
1627         }
1628
1629         _D("Launch on event from user event (%s)", event_name);
1630
1631         g_variant_get(value, "(i)", &result);
1632
1633         _D("result(%d)", result);
1634
1635         ret = result;
1636
1637 out_2:
1638         bundle_free_encoded_rawdata(&raw);
1639         g_object_unref(proxy);
1640         g_variant_unref(value);
1641 out_1:
1642         if (conn)
1643                 g_object_unref(conn);
1644
1645         return ret;
1646 }
1647
1648
1649 static void _send_last_user_event(const char *event_name,
1650                 bundle *data, void *user_data)
1651 {
1652         GDBusConnection *conn = NULL;
1653         GError *error = NULL;
1654         eventinfo_s *evti = NULL;
1655         int ret;
1656         struct last_data_item *item;
1657         const char *is_trusted;
1658
1659         _D("send last data");
1660
1661         if (g_strcmp0(event_name, SYS_EVENT_REQUEST_LAST_DATA) != 0)
1662                 return;
1663
1664         evti = calloc(1, sizeof(eventinfo_s));
1665         if (!evti) {
1666                 _E("memory alloc failed");
1667                 return;
1668         }
1669
1670         evti->event_name = (char *)bundle_get_val(data,
1671                         EVT_KEY_KEPT_EVENT_NAME);
1672         if (!evti->event_name) {
1673                 _E("memory alloc failed");
1674                 goto out_1;
1675         }
1676
1677         item = (struct last_data_item *)g_hash_table_lookup(last_data_tbl,
1678                         evti->event_name);
1679         if (!item)
1680                 goto out_1;
1681
1682         evti->interface_name = __get_encoded_interface_name(evti->event_name);
1683         if (!evti->interface_name) {
1684                 _E("interface_name is NULL");
1685                 goto out_1;
1686         }
1687
1688         evti->member_name = strdup(EVENT_SYSTEM_MEMBER);
1689         if (!evti->member_name) {
1690                 _E("memory alloc failed");
1691                 goto out_2;
1692         }
1693
1694         evti->object_path = __get_object_path(evti->interface_name);
1695         if (!evti->object_path) {
1696                 _E("object_path is NULL");
1697                 goto out_3;
1698         }
1699
1700         evti->destination_name = (char *)bundle_get_val(data,
1701                         EVT_KEY_KEPT_OWN_NAME);
1702         if (!evti->destination_name) {
1703                 _E("object_path is NULL");
1704                 goto out_4;
1705         }
1706
1707         is_trusted = bundle_get_val(data, EVT_KEY_KEPT_IS_TRUSTED);
1708         if (!is_trusted) {
1709                 _E("object_path is NULL");
1710                 goto out_4;
1711         }
1712
1713         if (strncmp("true", is_trusted, sizeof("true")) != 0) {
1714                         if (!item->trusted_param)
1715                                 goto out_4;
1716                         evti->is_trusted = true;
1717         } else {
1718                         if (!item->param)
1719                                 goto out_4;
1720                         evti->is_trusted = false;
1721         }
1722
1723         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SESSION,
1724                                 ES_TYPE_USER) == ES_R_OK) {
1725                 ret = g_dbus_connection_emit_signal(conn,
1726                                 evti->destination_name,
1727                                 evti->object_path,
1728                                 evti->interface_name,
1729                                 evti->member_name,
1730                                 evti->is_trusted ? item->trusted_param : item->param,
1731                                 &error);
1732                 if (ret == FALSE) {
1733                         _E("Unable to connect to dbus: %s", error->message);
1734                         g_error_free(error);
1735                 }
1736         }
1737
1738         if (conn)
1739                 g_object_unref(conn);
1740
1741 out_4:
1742         FREE_AND_NULL(evti->object_path);
1743 out_3:
1744         FREE_AND_NULL(evti->member_name);
1745 out_2:
1746         FREE_AND_NULL(evti->interface_name);
1747 out_1:
1748         FREE_AND_NULL(evti);
1749 }
1750
1751 int eventsystem_keep_last_event_data(const char *event_name)
1752 {
1753         int ret = 0;
1754         unsigned int reg_id;
1755         struct last_data_item *item;
1756
1757         if (last_data_tbl == NULL)
1758                 last_data_tbl = g_hash_table_new(g_str_hash, g_str_equal);
1759
1760         ret = __request_esd_for_last_data(event_name, false);
1761         if (ret != ES_R_OK)
1762                 return ret;
1763
1764         item = calloc(1, sizeof(*item));
1765         if (!item)
1766                 return ES_R_ENOMEM;
1767
1768         item->event_name = strdup(event_name);
1769         item->param = NULL;
1770         item->trusted_param = NULL;
1771
1772         g_hash_table_insert(last_data_tbl, item->event_name, item);
1773
1774         ret = eventsystem_register_event(SYS_EVENT_REQUEST_LAST_DATA,
1775                         &reg_id, _send_last_user_event, NULL);
1776
1777         return ret;
1778 }
1779
1780 static void __destroy_eventmap(gpointer data)
1781 {
1782         eventmap_s *em = (eventmap_s *)data;
1783
1784         if (!em)
1785                 return;
1786
1787         if (em->interface_name)
1788                 free(em->interface_name);
1789         if (em->member_name)
1790                 free(em->member_name);
1791         if (em->event_name)
1792                 free(em->event_name);
1793         free(em);
1794 }
1795
1796 static eventmap_s *__create_eventmap(const char *interface_name,
1797                 const char *member_name, const char *event_name,
1798                 int event_type, eventsystem_cb callback, void *user_data)
1799 {
1800         eventmap_s *em;
1801
1802         em = calloc(1, sizeof(eventmap_s));
1803         if (!em) {
1804                 _E("Out of memory");
1805                 return NULL;
1806         }
1807
1808         em->interface_name = strdup(interface_name);
1809         if (!em->interface_name) {
1810                 _E("Failed to duplicate interface name");
1811                 __destroy_eventmap(em);
1812                 return NULL;
1813         }
1814
1815         em->member_name = strdup(member_name);
1816         if (!em->member_name) {
1817                 _E("Failed to duplicate member name");
1818                 __destroy_eventmap(em);
1819                 return NULL;
1820         }
1821
1822         em->event_name = strdup(event_name);
1823         if (!em->event_name) {
1824                 _E("Failed to duplicate event name");
1825                 __destroy_eventmap(em);
1826                 return NULL;
1827         }
1828
1829         em->event_type = event_type;
1830         em->es_cb = callback;
1831         em->user_data = user_data;
1832
1833         return em;
1834 }
1835
1836 int eventsystem_register_application_event(const char *event_name, unsigned int *reg_id,
1837                 int *event_type, eventsystem_cb callback, void *user_data)
1838 {
1839         eventmap_s *em;
1840         char *interface_name;
1841         char *object_path;
1842         char *member_name;
1843         GDBusSignalCallback filter;
1844         GBusType bus_type;
1845         guint subscription_id = 0;
1846         int ret = 0;
1847         GDBusConnection *conn = NULL;
1848
1849         if (!_initialized)
1850                 __initialize();
1851
1852         if (__check_eventname_validation_system((char *)event_name)) {
1853                 if (__eventsystem_check_privilege_validation(event_name) != ES_R_OK) {
1854                         _E("invalid privilege(%s)", event_name);
1855                         return ES_R_ENOTPERMITTED;
1856                 }
1857                 *event_type = ES_TYPE_SYSTEM;
1858         } else if (__check_eventname_validation_user((char *)event_name)) {
1859                 *event_type = ES_TYPE_USER;
1860         } else {
1861                 *event_type = ES_TYPE_UNKNOWN;
1862                 _E("unknown type event(%s)", event_name);
1863                 return ES_R_EINVAL;
1864         }
1865
1866         if (*event_type == ES_TYPE_SYSTEM) {
1867                 interface_name = strdup(SYS_EVENT_NAME_PREFIX);
1868                 if (interface_name == NULL) {
1869                         _E("out of memory");
1870                         return ES_R_ENOMEM;
1871                 }
1872                 if (!g_dbus_is_interface_name(interface_name)) {
1873                         _E("invalid interface_name(%s)", interface_name);
1874                         FREE_AND_NULL(interface_name);
1875                         return ES_R_EINVAL;
1876                 }
1877                 member_name = __get_member_name_from_eventname((char *)event_name);
1878                 if (member_name == NULL) {
1879                         _E("member_name is NULL(%s)", event_name);
1880                         FREE_AND_NULL(interface_name);
1881                         return ES_R_ERROR;
1882                 }
1883                 if (!g_dbus_is_member_name(member_name)) {
1884                         _E("Invalid member_name(%s)", member_name);
1885                         FREE_AND_NULL(interface_name);
1886                         FREE_AND_NULL(member_name);
1887                         return ES_R_ERROR;
1888                 }
1889                 filter = __eventsystem_filter_sysevent_for_application;
1890                 bus_type = G_BUS_TYPE_SYSTEM;
1891         } else {
1892                 interface_name = __get_encoded_interface_name((char *)event_name);
1893                 if (!interface_name) {
1894                         _E("interface_name is NULL");
1895                         return ES_R_ERROR;
1896                 }
1897                 if (!g_dbus_is_interface_name(interface_name)) {
1898                         _E("invalid interface_name(%s)", interface_name);
1899                         FREE_AND_NULL(interface_name);
1900                         return ES_R_EINVAL;
1901                 }
1902                 member_name = strdup(EVENT_SYSTEM_MEMBER);
1903                 if (!member_name) {
1904                         _E("out_of_memory");
1905                         FREE_AND_NULL(interface_name);
1906                         return ES_R_ERROR;
1907                 }
1908                 filter = __eventsystem_filter_userevent_for_application;
1909                 bus_type = G_BUS_TYPE_SESSION;
1910         }
1911
1912         object_path = __get_object_path(interface_name);
1913         if (!object_path) {
1914                 _E("failed get object_path");
1915                 ret = ES_R_ERROR;
1916                 goto end;
1917         }
1918
1919         _D("interface_name(%s), object_path(%s)", interface_name, object_path);
1920         _D(" member_name(%s), type(%d), bus_type(%d)",
1921                 member_name, *event_type, bus_type);
1922
1923         if (__get_gdbus_shared_connection(&conn, bus_type, *event_type) < 0) {
1924                 _E("getting gdbus-connetion error");
1925                 ret = ES_R_ERROR;
1926                 goto end;
1927         }
1928
1929 #ifdef APPFW_EVENT_SYSTEM_EARLIER_FEATURE
1930         __eventsystem_request_earlier_data(event_name, callback, user_data);
1931 #endif
1932
1933         em = __create_eventmap(interface_name, member_name, event_name,
1934                         *event_type, callback, user_data);
1935         if (!em) {
1936                 ret = ES_R_ENOMEM;
1937                 goto end;
1938         }
1939
1940         subscription_id = g_dbus_connection_signal_subscribe(conn,
1941                 NULL, /* sender */
1942                 interface_name,
1943                 member_name, /* member */
1944                 object_path, /* object_path */
1945                 NULL, /* arg0 */
1946                 G_DBUS_SIGNAL_FLAGS_NONE,
1947                 filter,
1948                 em,
1949                 NULL); /* user_data_free_func */
1950
1951         _D("event_name(%s), subscription_id(%d)", event_name, subscription_id);
1952
1953         if (subscription_id != 0) {
1954                 em->bus_type = bus_type;
1955                 em->reg_id = subscription_id;
1956
1957                 system_event_list = g_list_append(system_event_list, em);
1958                 *reg_id = subscription_id;
1959
1960                 ret = ES_R_OK;
1961
1962                 if (em->bus_type == G_BUS_TYPE_SESSION &&
1963                                 em->event_type == ES_TYPE_USER) {
1964                         if (s_info.own_name_session_bus == NULL) {
1965                                 _E("session bus is not ready");
1966                                 ret = ES_R_ERROR;
1967                                 g_dbus_connection_signal_unsubscribe(conn, subscription_id);
1968                                 __destroy_eventmap(em);
1969                         } else {
1970                                 if (__eventsystem_setup_trusted_peer(event_name,
1971                                                         s_info.own_name_session_bus) < 0) {
1972                                         _E("failed to setup trusted peer");
1973                                         ret = ES_R_ERROR;
1974                                         g_dbus_connection_signal_unsubscribe(conn, subscription_id);
1975                                         __destroy_eventmap(em);
1976                                 }
1977                         }
1978                 }
1979         } else {
1980                 _E("dbus subscribe: error(%d)", subscription_id);
1981                 __destroy_eventmap(em);
1982                 ret = ES_R_ERROR;
1983         }
1984
1985         if (*event_type == ES_TYPE_USER)
1986                 __request_esd_for_last_data(event_name, true);
1987 end:
1988         FREE_AND_NULL(interface_name);
1989         FREE_AND_NULL(object_path);
1990         FREE_AND_NULL(member_name);
1991         if (conn)
1992                 g_object_unref(conn);
1993
1994         return ret;
1995 }
1996
1997 int eventsystem_unregister_application_event(unsigned int reg_id)
1998 {
1999         eventmap_s em;
2000         eventmap_s *em_data;
2001         GBusType bus_type;
2002         GList *cb_list;
2003         GDBusConnection *conn = NULL;
2004         eventsystem_event_type evt_type;
2005
2006         retvm_if(reg_id == 0, ES_R_EINVAL, "Invalid argument : reg_id");
2007
2008         if (!_initialized)
2009                 __initialize();
2010
2011         em.reg_id = reg_id;
2012         cb_list = g_list_find_custom(system_event_list, &em,
2013                         (GCompareFunc)__event_compare_reg_id_cb);
2014         if (!cb_list) {
2015                 _E("not found matched item");
2016                 return ES_R_ERROR;
2017         }
2018
2019         em_data = (eventmap_s *)cb_list->data;
2020
2021         bus_type = em_data->bus_type;
2022         evt_type = em_data->event_type;
2023
2024         _D("unsubscribe: reg_id(%d), bus_type(%d)", reg_id, bus_type);
2025
2026         if (__get_gdbus_shared_connection(&conn, bus_type, evt_type) < 0) {
2027                 _E("getting gdbus-connetion error");
2028                 return ES_R_ERROR;
2029         }
2030         g_dbus_connection_signal_unsubscribe(conn, reg_id);
2031
2032         system_event_list = g_list_remove(system_event_list, cb_list->data);
2033
2034         __destroy_eventmap(em_data);
2035         g_object_unref(conn);
2036
2037         return ES_R_OK;
2038 }
2039
2040 int eventsystem_application_finalize(void)
2041 {
2042         gpointer key;
2043         gpointer value;
2044         GHashTableIter iter;
2045         char *key_item;
2046         char *val_item;
2047         struct last_data_item *last_item;
2048
2049         _D("release all resouces");
2050
2051         if (system_event_list)
2052                 g_list_free(system_event_list);
2053
2054         if (check_tbl) {
2055                 g_hash_table_iter_init(&iter, check_tbl);
2056
2057                 while (g_hash_table_iter_next(&iter, &key, &value)) {
2058                         val_item = (char *)value;
2059                         if (val_item)
2060                                 free(val_item);
2061                         else
2062                                 _E("check_tbl, val_item is NULL");
2063                         g_hash_table_iter_remove(&iter);
2064                 }
2065                 g_hash_table_unref(check_tbl);
2066         }
2067
2068         if (filter_tbl) {
2069                 g_hash_table_iter_init(&iter, filter_tbl);
2070
2071                 while (g_hash_table_iter_next(&iter, &key, &value)) {
2072                         key_item = (char *)key;
2073                         if (key_item)
2074                                 free(key_item);
2075                         else
2076                                 _E("filter_tbl, key_item is NULL");
2077
2078                         val_item = (char *)value;
2079                         if (val_item)
2080                                 free(val_item);
2081                         else
2082                                 _E("filter_tbl, val_item is NULL");
2083
2084                         g_hash_table_iter_remove(&iter);
2085                 }
2086                 g_hash_table_unref(filter_tbl);
2087         }
2088
2089         if (last_data_tbl) {
2090                 g_hash_table_iter_init(&iter, last_data_tbl);
2091
2092                 while (g_hash_table_iter_next(&iter, &key, &value)) {
2093                         last_item = (struct last_data_item *)value;
2094                         if (last_item) {
2095                                 if (last_item->event_name)
2096                                         free(last_item->event_name);
2097                                 if (last_item->param)
2098                                         g_variant_unref(last_item->param);
2099                                 if (last_item->trusted_param)
2100                                         g_variant_unref(last_item->trusted_param);
2101                                 free(last_item);
2102                         } else {
2103                                 _E("last_data_tbl, val_item is NULL");
2104                         }
2105                         g_hash_table_iter_remove(&iter);
2106                 }
2107                 g_hash_table_unref(last_data_tbl);
2108         }
2109
2110         FREE_AND_NULL(s_info.own_name_system_bus);
2111         FREE_AND_NULL(s_info.own_name_session_bus);
2112
2113         return 0;
2114 }