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 <openssl/md5.h>
  14 #include <fcntl.h>
  15
  16 #undef LOG_TAG
  17 #define LOG_TAG "eventsystem"
  18
  19 #define SYS_EVENT_NAME_PREFIX "tizen.system.event"
  20 #define EVENT_SYSTEM_PREFIX "eventsystem.id_"
  21 #define EVENT_SYSTEM_PREFIX_LEN 15
  22 #define EVENT_SYSTEM_MEMBER "eventsystem"
  23 #define VALID_COUNT_OF_EVENTNAME_TOKEN 3
  24 #define VALID_LAST_COUNT_FOR_EVENTNAME (VALID_COUNT_OF_EVENTNAME_TOKEN + 1)
  25 #define MAX_COUNT_FOR_EVENTNAME_CHECK (VALID_LAST_COUNT_FOR_EVENTNAME + 1)
  26
  27 #define _E(fmt, arg...) LOGE(fmt, ##arg)
  28 #define _D(fmt, arg...) LOGD(fmt, ##arg)
  29 #define _W(fmt, arg...) LOGW(fmt, ##arg)
  30 #define _I(fmt, arg...) LOGI(fmt, ##arg)
  31
  32 #define retvm_if(expr, val, fmt, arg...) do { \
  33         if (expr) { \
  34                 _E(fmt, ##arg); \
  35                 _E("(%s) -> %s() return", #expr, __func__); \
  36                 return val; \
  37         } \
  38 } while (0)
  39
  40 #define retv_if(expr, val) do { \
  41         if (expr) { \
  42                 _E("(%s) -> %s() return", #expr, __func__); \
  43                 return val; \
  44         } \
  45 } while (0)
  46
  47 #define tryvm_if(expr, val, fmt, arg...) do { \
  48          if (expr) { \
  49                 _E("(%s) "fmt, #expr, ##arg); \
  50                 val; \
  51                 goto catch; \
  52         } \
  53 } while (0)
  54
  55 pthread_mutex_t send_sync_lock = PTHREAD_MUTEX_INITIALIZER;
  56
  57 static GList *system_event_list;
  58 static int _initialized;
  59 static GHashTable *check_tbl;
  60
  61 typedef struct eventmap {
  62         char *event_name;
  63         char *interface_name;
  64         char *member_name;
  65         guint reg_id;
  66         GBusType bus_type;
  67         int event_type;
  68         union {
  69                 eventsystem_cb es_cb;
  70                 eventsystem_handler ep_cb;
  71         };
  72 } eventmap_s;
  73
  74 typedef struct eventinfo {
  75         char *event_name;
  76         char *destination_name;
  77         char *interface_name;
  78         char *object_path;
  79         char *member_name;
  80         bool is_user_event;
  81         gboolean is_trusted;
  82         bundle *event_data;
  83 } eventinfo_s;
  84
  85 typedef struct sysevent_info {
  86         guint owner_id;
  87         guint owner_id_session;
  88         char *own_name_system_bus;
  89         char *own_name_session_bus;
  90 } sysevent_info_s;
  91 static sysevent_info_s s_info;
  92
  93 static int __eventsystem_request_event_launch(const char *method_name,
  94                 const char *event_name, bundle *data);
  95 static int __eventsystem_check_user_send_validation(const char *event_name);
  96 static int __eventsystem_requet_destination_list(const char *event_name, GList **dest_list);
  97
  98 static int __event_compare_name_cb(gconstpointer a, gconstpointer b)
  99 {
 100         eventmap_s *key1 = (eventmap_s *)a;
 101         eventmap_s *key2 = (eventmap_s *)b;
 102         return strcmp(key1->interface_name, key2->interface_name) |
 103                         strcmp(key1->member_name, key2->member_name);
 104 }
 105
 106 static int __event_compare_reg_id_cb(gconstpointer a, gconstpointer b)
 107 {
 108         eventmap_s *key1 = (eventmap_s *)a;
 109         eventmap_s *key2 = (eventmap_s *)b;
 110         return !(key1->reg_id == key2->reg_id);
 111 }
 112
 113 static void __initialize(void)
 114 {
 115 #if (GLIB_MAJOR_VERSION <= 2 && GLIB_MINOR_VERSION < 36)
 116         g_type_init();
 117 #endif
 118
 119         _initialized = 1;
 120 }
 121
 122 static char *__get_object_path(char *interface_name)
 123 {
 124         int i;
 125         char *object_path = (char *)calloc(strlen(interface_name), sizeof(char)+2);
 126
 127         if (object_path == NULL) {
 128                 _E("failed to allocate memory");
 129                 return NULL;
 130         }
 131
 132         object_path[0] = '/';
 133
 134         for (i = 0 ; interface_name[i] ; i++) {
 135
 136                 if (interface_name[i] == '.') {
 137                         object_path[i+1] = '/';
 138                 } else {
 139                         object_path[i+1] = interface_name[i];
 140                 }
 141         }
 142
 143         return object_path;
 144 }
 145
 146 static char *__get_encoded_interface_name(char *interface_name)
 147 {
 148         unsigned char c[MD5_DIGEST_LENGTH] = {0, };
 149         char *md5_evtid = NULL;
 150         char *temp;
 151         int index = 0;
 152         MD5_CTX mdContext;
 153
 154         MD5_Init(&mdContext);
 155         MD5_Update(&mdContext, interface_name, strlen(interface_name));
 156         MD5_Final(c, &mdContext);
 157
 158         md5_evtid = (char *)calloc(EVENT_SYSTEM_PREFIX_LEN + (MD5_DIGEST_LENGTH * 2) + 1,
 159                 sizeof(char));
 160         if (md5_evtid == NULL) {
 161                 _D("Malloc failed!!");
 162                 return NULL;
 163         }
 164
 165         sprintf(md5_evtid, "%s", EVENT_SYSTEM_PREFIX);
 166
 167         temp = md5_evtid;
 168
 169         temp += EVENT_SYSTEM_PREFIX_LEN;
 170
 171         for (index = 0; index < MD5_DIGEST_LENGTH; index++) {
 172                 sprintf(temp, "%02x", c[index]);
 173                 temp += 2;
 174         }
 175
 176         return md5_evtid;
 177 }
 178
 179 static char *__get_member_name_from_eventname(char *event_name)
 180 {
 181         char *ptr = NULL;
 182         char *ptr_last = NULL;
 183         char *temp_name = NULL;
 184         char *member_name = NULL;
 185         int count = 0;
 186
 187         temp_name = strdup(event_name);
 188         if (temp_name == NULL) {
 189                 _E("out of memory");
 190                 return NULL;
 191         }
 192
 193         ptr = strtok(temp_name, ".");
 194         if (ptr == NULL) {
 195                 _E("invalid event_name(%s), count(%d)", event_name, count);
 196                 FREE_AND_NULL(temp_name);
 197                 return NULL;
 198         }
 199         count++;
 200
 201         while (count < MAX_COUNT_FOR_EVENTNAME_CHECK) {
 202                 ptr = strtok(NULL, ".");
 203                 if (ptr == NULL)
 204                         break;
 205                 /* _D("(%d)ptr(%s)(%d)", count, ptr, strlen(ptr)); */
 206                 ptr_last = ptr;
 207                 count++;
 208         }
 209         FREE_AND_NULL(temp_name);
 210
 211         if (count != VALID_LAST_COUNT_FOR_EVENTNAME) {
 212                 _E("invalid event_name(%s), count(%d)", event_name, count);
 213                 return NULL;
 214         }
 215
 216         if (ptr_last) {
 217                 /* _D("new member_name(%s)(%d)", ptr_last, strlen(ptr_last)); */
 218                 member_name = strdup(ptr_last);
 219                 if (!member_name) {
 220                         _E("out_of_memory");
 221                         return NULL;
 222                 }
 223         } else {
 224                 _E("ptr_last is NULL");
 225                 return NULL;
 226         }
 227
 228         _D("member_name(%s)", member_name);
 229
 230         return member_name;
 231 }
 232
 233 static int __check_validation_user_defined_name(const char *event_name)
 234 {
 235         char *event_id = NULL;
 236         char *key = NULL;
 237         int ret = 1;
 238
 239         if (check_tbl == NULL) {
 240                 check_tbl = g_hash_table_new(g_str_hash, g_str_equal);
 241         }
 242
 243         event_id = (char *)g_hash_table_lookup(check_tbl, event_name);
 244
 245         if (event_id == NULL) {
 246                 if (__eventsystem_check_user_send_validation(event_name) < 0) {
 247                         _E("invalid user-event name");
 248                         ret = 0;
 249                 } else {
 250                         key = strdup(event_name);
 251                         if (key == NULL) {
 252                                 _E("out_of_memory");
 253                                 ret = 0;
 254                         } else {
 255                                 g_hash_table_insert(check_tbl, key, key);
 256                         }
 257                 }
 258         }
 259
 260         return ret;
 261 }
 262
 263 static int __check_eventname_validation_user(char *event_name)
 264 {
 265         int ret = 1;
 266         int len = strlen(USER_EVENT_NAME_PREFIX);
 267
 268         if (strncmp(event_name, USER_EVENT_NAME_PREFIX, len) != 0) {
 269                 ret = 0;
 270         }
 271
 272         return ret;
 273 }
 274
 275 static int __check_eventname_validation_system(char *event_name)
 276 {
 277         int ret = 1;
 278         int len = strlen(SYS_EVENT_NAME_PREFIX);
 279
 280         if (strncmp(event_name, SYS_EVENT_NAME_PREFIX, len) != 0) {
 281                 ret = 0;
 282         }
 283
 284         return ret;
 285 }
 286
 287 static int __get_gdbus_shared_connection(GDBusConnection **connection, GBusType bus_type,
 288                 eventsystem_event_type event_type)
 289 {
 290         GError *error = NULL;
 291         guint owner_id = 0;
 292
 293         if (!_initialized) {
 294                 __initialize();
 295         }
 296
 297         *connection = g_bus_get_sync(bus_type, NULL, &error);
 298         if (*connection == NULL) {
 299                 if (error != NULL) {
 300                         _E("Failed to get dbus [%s], bus_type [%d]",
 301                                 error->message, bus_type);
 302                         g_error_free(error);
 303                 }
 304                 return ES_R_ERROR;
 305         }
 306
 307         if (((bus_type == G_BUS_TYPE_SYSTEM && !s_info.owner_id) ||
 308                 (bus_type == G_BUS_TYPE_SESSION && !s_info.owner_id_session))) {
 309                 gchar *guid = NULL;
 310                 char own_name[128] = {0, };
 311
 312                 guid = g_dbus_generate_guid();
 313                 if (guid == NULL) {
 314                         _E("failed to get guid");
 315                         return ES_R_ERROR;
 316                 }
 317                 snprintf(own_name, 128, "%s_%s_%s_%d", "event.busname",
 318                         (bus_type == G_BUS_TYPE_SESSION ? "session" : "system"),
 319                         guid, getpid());
 320                 g_free(guid);
 321
 322                 _D("bus_name is [%s]", own_name);
 323                 owner_id = g_bus_own_name_on_connection(*connection, own_name,
 324                         G_BUS_NAME_OWNER_FLAGS_NONE,
 325                         NULL, NULL, NULL, NULL);
 326                 if (!owner_id) {
 327                         _E("g_bus_own_name_on_connection, error");
 328                         return ES_R_ERROR;
 329                 }
 330
 331                 if (bus_type == G_BUS_TYPE_SESSION && event_type == ES_TYPE_USER) {
 332                         /* set same name on system-bus */
 333                         GDBusConnection *conn_system = NULL;
 334
 335                         error = NULL;
 336                         conn_system = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
 337                         if (conn_system == NULL) {
 338                                 _E("failed to get system connection");
 339                                 if (error != NULL) {
 340                                         _E("error(%s)", error->message);
 341                                         g_error_free(error);
 342                                 }
 343                                 return ES_R_ERROR;
 344                         } else {
 345                                 owner_id = g_bus_own_name_on_connection(conn_system,
 346                                         own_name, G_BUS_NAME_OWNER_FLAGS_NONE,
 347                                         NULL, NULL, NULL, NULL);
 348                                 if (!owner_id) {
 349                                         _E("g_bus_own_name_on_connection(for system), error");
 350                                         g_object_unref(conn_system);
 351                                         return ES_R_ERROR;
 352                                 }
 353
 354                                 g_object_unref(conn_system);
 355                         }
 356                 }
 357
 358                 if (bus_type == G_BUS_TYPE_SESSION) {
 359                         s_info.owner_id_session = owner_id;
 360                         s_info.own_name_session_bus = strdup(own_name);
 361                         if (s_info.own_name_session_bus == NULL) {
 362                                 _E("out of memory");
 363                                 return ES_R_ERROR;
 364                         }
 365                 } else {
 366                         s_info.owner_id = owner_id;
 367                         s_info.own_name_system_bus = strdup(own_name);
 368                         if (s_info.own_name_system_bus == NULL) {
 369                                 _E("out of memory");
 370                                 return ES_R_ERROR;
 371                         }
 372                 }
 373         }
 374
 375         return ES_R_OK;
 376 }
 377
 378 static void __eventsystem_event_handler(GDBusConnection *connection,
 379                 const gchar *sender_name, const gchar *object_path,
 380                 const gchar *interface_name, const gchar *signal_name,
 381                 GVariant *parameters, gpointer user_data)
 382 {
 383         int len;
 384         eventmap_s em;
 385         GList *cb_list = NULL;
 386         bundle *buf = NULL;
 387         bundle_raw *raw = NULL;
 388         gboolean is_trusted = FALSE;
 389
 390         em.interface_name = (char *)interface_name;
 391         em.member_name = (char *)signal_name;
 392
 393         _D("sender_name(%s), interface_name(%s), signal_name(%s)",
 394                 sender_name, interface_name, signal_name);
 395
 396         cb_list = g_list_find_custom(system_event_list, &em,
 397                 (GCompareFunc)__event_compare_name_cb);
 398         if (cb_list == NULL) {
 399                 return;
 400         }
 401
 402         g_variant_get(parameters, "(bus)", &is_trusted, &len, &raw);
 403
 404         buf = bundle_decode((bundle_raw *)raw, len);
 405
 406         em.event_name = ((eventmap_s *)cb_list->data)->event_name;
 407         em.ep_cb = ((eventmap_s *)cb_list->data)->ep_cb;
 408         if (em.ep_cb) {
 409                 em.ep_cb(em.event_name, buf, user_data);
 410         }
 411
 412         bundle_free_encoded_rawdata(&raw);
 413         bundle_free(buf);
 414 }
 415
 416 static void __eventsystem_application_event_handler(GDBusConnection *connection,
 417                 const gchar *sender_name, const gchar *object_path,
 418                 const gchar *interface_name, const gchar *signal_name,
 419                 GVariant *parameters, gpointer user_data)
 420 {
 421         GList *cb_list = NULL;
 422         eventmap_s em;
 423         bundle_raw *raw = NULL;
 424         int len;
 425
 426         em.interface_name = (char *)interface_name;
 427         em.member_name = (char *)signal_name;
 428
 429         _D("sender_name(%s), interface_name(%s), signal_name(%s)",
 430                 sender_name, interface_name, signal_name);
 431
 432         cb_list = g_list_find_custom(system_event_list, &em,
 433                 (GCompareFunc)__event_compare_name_cb);
 434
 435         if (cb_list == NULL) {
 436                 return;
 437         }
 438
 439         g_variant_get(parameters, "(bus)", NULL, &len, &raw);
 440
 441         em.event_name = ((eventmap_s *)cb_list->data)->event_name;
 442         em.es_cb = ((eventmap_s *)cb_list->data)->es_cb;
 443         if (em.es_cb) {
 444                 em.es_cb(em.event_name, raw, len, user_data);
 445         }
 446
 447         bundle_free_encoded_rawdata(&raw);
 448 }
 449
 450 /**
 451  * application-use filter for user-event
 452  */
 453 static void __eventsystem_filter_userevent_for_application(GDBusConnection *connection,
 454                 const gchar *sender_name, const gchar *object_path,
 455                 const gchar *interface_name, const gchar *signal_name,
 456                 GVariant *parameters, gpointer user_data)
 457 {
 458         gboolean is_trusted = FALSE;
 459
 460         _D("sender_name(%s), interface_name(%s)", sender_name, interface_name);
 461
 462         g_variant_get(parameters, "(bus)", &is_trusted, NULL, NULL);
 463
 464         __eventsystem_application_event_handler(connection, sender_name,
 465                 object_path, interface_name, signal_name, parameters, user_data);
 466 }
 467
 468 /**
 469  * application-use filter for system-event
 470  */
 471 static void __eventsystem_filter_sysevent_for_application(GDBusConnection *connection,
 472                 const gchar *sender_name, const gchar *object_path,
 473                 const gchar *interface_name, const gchar *signal_name,
 474                 GVariant *parameters, gpointer user_data)
 475 {
 476         _D("sender_name(%s), interface_name(%s)", sender_name, interface_name);
 477
 478         __eventsystem_application_event_handler(connection, sender_name,
 479                 object_path, interface_name, signal_name, parameters, user_data);
 480 }
 481
 482 /**
 483  * internal-use filter for user-event
 484  */
 485 static void __eventsystem_filter_userevent_for_internal(GDBusConnection *connection,
 486                 const gchar *sender_name, const gchar *object_path,
 487                 const gchar *interface_name, const gchar *signal_name,
 488                 GVariant *parameters, gpointer user_data)
 489 {
 490         _D("sender_name(%s), interface_name(%s), signal_name(%s)",
 491                 sender_name, interface_name, signal_name);
 492
 493         __eventsystem_event_handler(connection, sender_name,
 494                 object_path, interface_name, signal_name, parameters, user_data);
 495 }
 496
 497 /**
 498  * internal-use filter for system-event
 499  */
 500 static void __eventsystem_filter_sysevent_for_internal(GDBusConnection *connection,
 501                 const gchar *sender_name, const gchar *object_path,
 502                 const gchar *interface_name, const gchar *signal_name,
 503                 GVariant *parameters, gpointer user_data)
 504 {
 505         _D("sender_name(%s), interface_name(%s), signal_name(%s)",
 506                 sender_name, interface_name, signal_name);
 507
 508         __eventsystem_event_handler(connection, sender_name,
 509                 object_path, interface_name, signal_name, parameters, user_data);
 510 }
 511
 512 static int __eventsystem_register_event_internal(const char *event_name,
 513                 eventmap_s **em_s, void *user_data)
 514 {
 515         eventmap_s *em = NULL;
 516         char *interface_name = NULL;
 517         char *object_path = NULL;
 518         char *member_name = NULL;
 519         char *sender_name = NULL;
 520         GDBusSignalCallback filter;
 521         GBusType bus_type;
 522         guint subscription_id = 0;
 523         int ret = 0;
 524         int evt_type = ES_TYPE_UNKNOWN;
 525         GDBusConnection *conn = NULL;
 526
 527         if (__check_eventname_validation_system((char *)event_name)) {
 528                 evt_type = ES_TYPE_SYSTEM;
 529         } else if (__check_eventname_validation_user((char *)event_name)) {
 530                 evt_type = ES_TYPE_USER;
 531         } else {
 532                 evt_type = ES_TYPE_UNKNOWN;
 533                 _E("unknown type event(%s)", event_name);
 534                 return ES_R_EINVAL;
 535         }
 536
 537         if (evt_type == ES_TYPE_SYSTEM) {
 538                 interface_name = strdup(SYS_EVENT_NAME_PREFIX);
 539                 if (interface_name == NULL) {
 540                         _E("out of memory");
 541                         ret = ES_R_ENOMEM;
 542                         goto out_1;
 543                 }
 544
 545                 member_name = __get_member_name_from_eventname((char *)event_name);
 546                 if (member_name == NULL) {
 547                         _E("invalid member_name");
 548                         ret = ES_R_ERROR;
 549                         goto out_2;
 550                 }
 551
 552                 if (!g_dbus_is_member_name(member_name)) {
 553                         _E("invalid member name");
 554                         ret = ES_R_EINVAL;
 555                         goto out_3;
 556                 }
 557                 filter = __eventsystem_filter_sysevent_for_internal;
 558         } else {
 559                 interface_name = __get_encoded_interface_name((char *)event_name);
 560                 if (!interface_name) {
 561                         _E("interface_name is NULL");
 562                         ret = ES_R_ERROR;
 563                         goto out_1;
 564                 }
 565                 if (!g_dbus_is_interface_name(interface_name)) {
 566                         _E("invalid interface_name(%s)", interface_name);
 567                         ret = ES_R_EINVAL;
 568                         goto out_2;
 569                 }
 570                 member_name = strdup(EVENT_SYSTEM_MEMBER);
 571                 if (!member_name) {
 572                         _E("out_of_memory");
 573                         ret = ES_R_ERROR;
 574                         goto out_2;
 575                 }
 576                 filter = __eventsystem_filter_userevent_for_internal;
 577         }
 578
 579         object_path = __get_object_path(interface_name);
 580         if (!object_path) {
 581                 _E("object_path is NULL");
 582                 ret = ES_R_ERROR;
 583                 goto out_3;
 584         }
 585         sender_name = NULL;
 586
 587         bus_type = G_BUS_TYPE_SYSTEM;
 588
 589         if (__get_gdbus_shared_connection(&conn, bus_type, evt_type) < 0) {
 590                 _E("getting gdbus-connetion error");
 591                 goto out_4;
 592         }
 593
 594         subscription_id = g_dbus_connection_signal_subscribe(conn,
 595                 sender_name, /* sender */
 596                 interface_name,
 597                 member_name, /* member */
 598                 object_path, /* object_path */
 599                 NULL, /* arg0 */
 600                 G_DBUS_SIGNAL_FLAGS_NONE,
 601                 filter,
 602                 user_data,
 603                 NULL); /* user_data_free_func */
 604
 605         _D("event_name(%s), interface_name(%s)", event_name, interface_name);
 606         _D("member_name(%s), subscription_id(%d), bus_type(%d)",
 607                 member_name, subscription_id, bus_type);
 608
 609         if (subscription_id != 0) {
 610                 em = calloc(1, sizeof(eventmap_s));
 611                 if (!em) {
 612                         _E("memory alloc failed");
 613                         ret = ES_R_ENOMEM;
 614                 } else {
 615                         em->interface_name = strdup(interface_name);
 616                         em->member_name = strdup(member_name);
 617                         em->event_name = strdup(event_name);
 618                         em->bus_type = bus_type;
 619                         em->reg_id = subscription_id;
 620                         em->event_type = evt_type;
 621
 622                         if (!em->interface_name || !em->member_name || !em->event_name) {
 623                                 _E("out_of_memory");
 624                                 FREE_AND_NULL(em->interface_name);
 625                                 FREE_AND_NULL(em->member_name);
 626                                 FREE_AND_NULL(em->event_name);
 627                                 FREE_AND_NULL(em);
 628                                 ret = ES_R_ENOMEM;
 629                                 goto out_4;
 630                         }
 631
 632                         *em_s = em;
 633                         ret = ES_R_OK;
 634                 }
 635         } else {
 636                 _D("dbus subscribe: error(%d), event(%s)", subscription_id, event_name);
 637                 ret = ES_R_ERROR;
 638         }
 639
 640 out_4:
 641         FREE_AND_NULL(object_path);
 642 out_3:
 643         FREE_AND_NULL(member_name);
 644 out_2:
 645         FREE_AND_NULL(interface_name);
 646 out_1:
 647         if (conn) {
 648                 g_object_unref(conn);
 649         }
 650
 651         return ret;
 652 }
 653
 654 /**
 655  * function : register the event
 656  */
 657 int eventsystem_register_event(const char *event_name, unsigned int *reg_id,
 658                 eventsystem_handler callback, void *user_data)
 659 {
 660         eventmap_s *em = NULL;
 661         int ret = ES_R_ERROR;
 662
 663         retvm_if(!g_dbus_is_interface_name(event_name), ES_R_EINVAL,
 664                 "Invalid argument : event_name(%s)", event_name);
 665         retvm_if(!reg_id, ES_R_EINVAL, "Invalid argument : reg_id");
 666         retvm_if(!callback, ES_R_EINVAL, "Invalid argument : callback");
 667
 668         if (!_initialized) {
 669                 __initialize();
 670         }
 671
 672         ret = __eventsystem_register_event_internal(event_name, &em, user_data);
 673
 674         if (ret == ES_R_OK && em) {
 675                 em->ep_cb = callback;
 676                 system_event_list = g_list_append(system_event_list, em);
 677                 *reg_id = em->reg_id;
 678                 ret = ES_R_OK;
 679         } else {
 680                 _E("error, ret(%d), em(%s)", ret, em);
 681         }
 682
 683         return ret;
 684 }
 685
 686 /**
 687  * function : unregister the event
 688  */
 689 int eventsystem_unregister_event(unsigned int reg_id)
 690 {
 691         eventmap_s em;
 692         eventmap_s *em_data = NULL;
 693         GBusType bus_type;
 694         GList *cb_list = NULL;
 695         GDBusConnection *conn = NULL;
 696         eventsystem_event_type evt_type;
 697
 698         retvm_if(reg_id == 0, ES_R_EINVAL, "Invalid argument : reg_id");
 699
 700         if (!_initialized) {
 701                 __initialize();
 702         }
 703
 704         em.reg_id = reg_id;
 705         cb_list = g_list_find_custom(system_event_list, &em,
 706                 (GCompareFunc)__event_compare_reg_id_cb);
 707         if (cb_list) {
 708                 em_data = (eventmap_s *)cb_list->data;
 709
 710                 bus_type = em_data->bus_type;
 711                 evt_type = em_data->event_type;
 712
 713                 _D("unsubscribe: reg_id(%d), bus_type(%d)", reg_id, bus_type);
 714
 715                 if (__get_gdbus_shared_connection(&conn, bus_type, evt_type) < 0) {
 716                         _E("getting gdbus-connetion error");
 717                         return ES_R_ERROR;
 718                 }
 719                 g_dbus_connection_signal_unsubscribe(conn, reg_id);
 720
 721                 system_event_list = g_list_remove(system_event_list, cb_list->data);
 722
 723                 FREE_AND_NULL(em_data->interface_name);
 724                 FREE_AND_NULL(em_data->member_name);
 725                 FREE_AND_NULL(em_data->event_name);
 726                 FREE_AND_NULL(em_data);
 727                 g_object_unref(conn);
 728         }
 729
 730         return ES_R_OK;
 731 }
 732
 733 static int eventsystem_send_event(GDBusConnection *conn, eventinfo_s *evti, bundle *data)
 734 {
 735         GError *error = NULL;
 736         GVariant *param = NULL;
 737         gboolean ret;
 738
 739         bundle_raw *raw = NULL;
 740         bundle *buf = data;
 741         int len;
 742
 743         bundle_encode(buf, &raw, &len);
 744
 745         if (!evti->is_user_event)
 746                 evti->is_trusted = FALSE;
 747
 748         param = g_variant_new("(bus)", evti->is_trusted, len, raw);
 749         ret = g_dbus_connection_emit_signal(conn,
 750                 evti->destination_name,
 751                 evti->object_path,
 752                 evti->interface_name,
 753                 evti->member_name,
 754                 param,
 755                 &error);
 756
 757         _D("interface_name(%s)", evti->interface_name);
 758         _D("object_path(%s)", evti->object_path);
 759         _D("member_name(%s)", evti->member_name);
 760
 761         bundle_free_encoded_rawdata(&raw);
 762
 763         if (ret == FALSE) {
 764                 _E("Unable to connect to dbus: %s", error->message);
 765                 g_error_free(error);
 766                 return ES_R_ERROR;
 767         }
 768
 769         return ES_R_OK;
 770 }
 771
 772 static void __eventsystem_free_trusted_list(gpointer data)
 773 {
 774         char *name = (char *)data;
 775
 776         FREE_AND_NULL(name);
 777 }
 778
 779 static int __eventsystem_send_trusted_event(GDBusConnection *conn, eventinfo_s *evti,
 780                 bundle *data, GList *dest_list)
 781 {
 782         GList *tmp_list = NULL;
 783         int ret = 0;
 784         int real_sent = 0;
 785
 786         if (dest_list) {
 787                 tmp_list = g_list_first(dest_list);
 788
 789                 while (tmp_list != NULL) {
 790                         char *dest_name = (char *)tmp_list->data;
 791                         if (dest_name && dest_name[0] != '\0') {
 792                                 _D("dest_name(%s)", dest_name);
 793                                 evti->destination_name = dest_name;
 794                                 ret = eventsystem_send_event(conn, evti, data);
 795                                 if (ret != ES_R_OK) {
 796                                         _E("send error");
 797                                         ret = ES_R_ERROR;
 798                                         break;
 799                                 }
 800                                 real_sent = 1;
 801                         }
 802                         tmp_list = g_list_next(tmp_list);
 803                 }
 804                 g_list_free_full(dest_list, __eventsystem_free_trusted_list);
 805
 806                 if (real_sent) {
 807                         __eventsystem_request_event_launch("RequestTrustedEventLaunch",
 808                                 evti->event_name, data);
 809                 }
 810         } else {
 811                 _E("dest_list is null");
 812         }
 813
 814         return ES_R_OK;
 815 }
 816
 817 /**
 818  * function : send the user-event
 819  */
 820 int eventsystem_send_user_event(const char *event_name, bundle *data, bool is_trusted)
 821 {
 822         int ret = 0;
 823
 824         /* check validation */
 825         retvm_if(!event_name, ES_R_EINVAL, "Invalid argument : event_name is NULL");
 826         retvm_if(!data, ES_R_EINVAL, "Invalid argument : data is NULL");
 827         retvm_if(!__check_eventname_validation_user((char *)event_name), ES_R_EINVAL,
 828                 "Invalid argument : event_name(%s)", event_name);
 829
 830         if (!__check_validation_user_defined_name(event_name)) {
 831                 _E("Invalid event name(%s)", event_name);
 832                 return ES_R_EINVAL;
 833         }
 834
 835         eventinfo_s *evti = NULL;
 836         evti = calloc(1, sizeof(eventinfo_s));
 837         if (!evti) {
 838                 _E("memory alloc failed");
 839                 return ES_R_ENOMEM;
 840         }
 841         evti->event_name = strdup(event_name);
 842         if (!evti->event_name) {
 843                 _E("memory alloc failed");
 844                 ret = ES_R_ENOMEM;
 845                 goto out_1;
 846         }
 847
 848         evti->interface_name = __get_encoded_interface_name(evti->event_name);
 849         if (!evti->interface_name) {
 850                 _E("interface_name is NULL");
 851                 ret = ES_R_ERROR;
 852                 goto out_2;
 853         }
 854         evti->member_name = strdup(EVENT_SYSTEM_MEMBER);
 855         if (!evti->member_name) {
 856                 _E("memory alloc failed");
 857                 ret = ES_R_ENOMEM;
 858                 goto out_3;
 859         }
 860
 861         evti->object_path = __get_object_path(evti->interface_name);
 862         if (!evti->object_path) {
 863                 _E("object_path is NULL");
 864                 ret = ES_R_ERROR;
 865                 goto out_4;
 866         }
 867
 868         evti->destination_name = NULL;
 869         evti->is_user_event = true;
 870         evti->is_trusted = (gboolean)is_trusted;
 871
 872         GDBusConnection *conn = NULL;
 873         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SESSION, ES_TYPE_USER) == ES_R_OK) {
 874                 if (evti->is_trusted) {
 875                         GList *dest_list = NULL;
 876                         ret = __eventsystem_requet_destination_list(evti->event_name, &dest_list);
 877                         if (ret < 0) {
 878                                 _E("failed to get dest list");
 879                                 ret = ES_R_ERROR;
 880                         } else {
 881                                 ret = __eventsystem_send_trusted_event(conn, evti,
 882                                         data, dest_list);
 883                         }
 884                 } else {
 885                         ret = eventsystem_send_event(conn, evti, data);
 886                         if (ret == ES_R_OK) {
 887                                 __eventsystem_request_event_launch("RequestEventLaunch",
 888                                         evti->event_name, data);
 889                         }
 890                 }
 891         } else {
 892                 _E("getting gdbus-connetion error");
 893                 ret = ES_R_ERROR;
 894         }
 895
 896         if (conn) {
 897                 g_object_unref(conn);
 898         }
 899         FREE_AND_NULL(evti->object_path);
 900 out_4:
 901         FREE_AND_NULL(evti->member_name);
 902 out_3:
 903         FREE_AND_NULL(evti->interface_name);
 904 out_2:
 905         FREE_AND_NULL(evti->event_name);
 906 out_1:
 907         FREE_AND_NULL(evti);
 908
 909         return ret;
 910 }
 911
 912 /**
 913  * function : send the system-event
 914  */
 915 int eventsystem_send_system_event(const char *event_name, bundle *data)
 916 {
 917         int ret = 0;
 918
 919         pthread_mutex_lock(&send_sync_lock);
 920
 921         /* check validation */
 922         tryvm_if(!event_name, ret = ES_R_EINVAL, "Invalid argument : event_name is NULL");
 923         tryvm_if(!data, ret = ES_R_EINVAL, "Invalid argument : data is NULL");
 924         tryvm_if(!__check_eventname_validation_system((char *)event_name), ret = ES_R_EINVAL,
 925                 "Invalid argument : event_name(%s)", event_name);
 926         tryvm_if(!g_dbus_is_interface_name(event_name), ret = ES_R_EINVAL,
 927                 "Invalid argument : event_name(%s)", event_name);
 928
 929         _D("event_name(%s)", event_name);
 930
 931         eventinfo_s *evti = NULL;
 932         evti = calloc(1, sizeof(eventinfo_s));
 933         if (!evti) {
 934                 _E("memory alloc failed");
 935                 pthread_mutex_unlock(&send_sync_lock);
 936                 return ES_R_ENOMEM;
 937         }
 938         evti->event_name = strdup(event_name);
 939         if (!evti->event_name) {
 940                 _E("out_of_memory");
 941                 ret = ES_R_ENOMEM;
 942                 goto out_1;
 943         }
 944         evti->interface_name = strdup(SYS_EVENT_NAME_PREFIX);
 945         if (!evti->interface_name) {
 946                 _E("out of memory");
 947                 ret = ES_R_ENOMEM;
 948                 goto out_2;
 949         }
 950         evti->member_name = __get_member_name_from_eventname(evti->event_name);
 951         if (!evti->member_name) {
 952                 _E("member_name is NULL");
 953                 ret = ES_R_ERROR;
 954                 goto out_3;
 955         }
 956         if (!g_dbus_is_member_name(evti->member_name)) {
 957                 _E("Invalid member_name(%s)", evti->member_name);
 958                 ret = ES_R_EINVAL;
 959                 goto out_4;
 960         }
 961         evti->object_path = __get_object_path(evti->interface_name);
 962         if (!evti->object_path) {
 963                 _E("object_path is NULL");
 964                 ret = ES_R_ERROR;
 965                 goto out_4;
 966         }
 967         evti->destination_name = NULL;
 968         evti->is_user_event = false;
 969         evti->is_trusted = FALSE;
 970
 971         GDBusConnection *conn = NULL;
 972         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SYSTEM, ES_TYPE_SYSTEM) == ES_R_OK) {
 973                 ret = eventsystem_send_event(conn, evti, data);
 974         } else {
 975                 _E("getting gdbus-connection error");
 976                 ret = ES_R_ERROR;
 977         }
 978
 979         if (conn) {
 980                 g_object_unref(conn);
 981         }
 982         FREE_AND_NULL(evti->object_path);
 983 out_4:
 984         FREE_AND_NULL(evti->member_name);
 985 out_3:
 986         FREE_AND_NULL(evti->interface_name);
 987 out_2:
 988         FREE_AND_NULL(evti->event_name);
 989 out_1:
 990         FREE_AND_NULL(evti);
 991
 992 catch:
 993         pthread_mutex_unlock(&send_sync_lock);
 994
 995         return ret;
 996 }
 997
 998 /**
 999  * function : request sending the event
1000  */
1001 int eventsystem_request_sending_system_event(const char *event_name, bundle *data)
1002 {
1003         int ret = 0;
1004         GDBusConnection *conn = NULL;
1005         GError *error = NULL;
1006         GDBusProxy *proxy = NULL;
1007         GVariant *param = NULL;
1008         GVariant *value = NULL;
1009         gint result = 0;
1010         bundle_raw *raw = NULL;
1011         int len = 0;
1012
1013         _D("event_name(%s)", event_name);
1014
1015         if (!_initialized) {
1016                 __initialize();
1017         }
1018
1019         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SYSTEM, ES_TYPE_SYSTEM) < 0) {
1020                 _E("getting gdbus-connetion error");
1021                 ret = ES_R_ERROR;
1022                 goto out_1;
1023         }
1024
1025         proxy = g_dbus_proxy_new_sync(conn,
1026                 G_DBUS_PROXY_FLAGS_NONE, NULL,
1027                 ESD_BUS_NAME, ESD_OBJECT_PATH, ESD_INTERFACE_NAME,
1028                 NULL, &error);
1029         if (proxy == NULL) {
1030                 _E("failed to create new proxy, error(%s)", error->message);
1031                 g_error_free(error);
1032                 ret = ES_R_ERROR;
1033                 goto out_1;
1034         }
1035
1036         bundle_encode(data, &raw, &len);
1037
1038         param = g_variant_new("(ssi)", event_name, raw, len);
1039         value = g_dbus_proxy_call_sync(proxy, "RequestSendingEvent", param,
1040                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1041         if (error != NULL) {
1042                 _E("proxy call sync error(%s)", error->message);
1043                 g_error_free(error);
1044                 ret = ES_R_ERROR;
1045                 goto out_2;
1046         }
1047
1048         g_variant_get(value, "(i)", &result);
1049
1050         _D("result(%d)", result);
1051
1052         ret = ES_R_OK;
1053
1054 out_2:
1055         g_variant_unref(value);
1056 out_1:
1057         if (conn) {
1058                 g_object_unref(conn);
1059         }
1060
1061         return ret;
1062 }
1063
1064 static int __eventsystem_request_event_launch(const char *method_name,
1065                 const char *event_name, bundle *data)
1066 {
1067         int ret = 0;
1068         GDBusConnection *conn = NULL;
1069         GError *error = NULL;
1070         GDBusProxy *proxy = NULL;
1071         GVariant *param = NULL;
1072         GVariant *value = NULL;
1073         gint result = 0;
1074         bundle_raw *raw = NULL;
1075         int len = 0;
1076
1077         _D("event_name(%s)", event_name);
1078
1079         if (!_initialized) {
1080                 __initialize();
1081         }
1082
1083         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SYSTEM, ES_TYPE_SYSTEM) < 0) {
1084                 _E("getting gdbus-connetion error");
1085                 ret = ES_R_ERROR;
1086                 goto out_1;
1087         }
1088
1089         proxy = g_dbus_proxy_new_sync(conn,
1090                 G_DBUS_PROXY_FLAGS_NONE, NULL,
1091                 ESD_BUS_NAME, ESD_OBJECT_PATH, ESD_INTERFACE_NAME,
1092                 NULL, &error);
1093         if (proxy == NULL) {
1094                 _E("failed to create new proxy, error(%s)", error->message);
1095                 g_error_free(error);
1096                 ret = ES_R_ERROR;
1097                 goto out_1;
1098         }
1099
1100         bundle_encode(data, &raw, &len);
1101
1102         param = g_variant_new("(ssi)", event_name, raw, len);
1103         value = g_dbus_proxy_call_sync(proxy, method_name, param,
1104                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1105         if (error != NULL) {
1106                 _E("proxy call sync error(%s)", error->message);
1107                 g_error_free(error);
1108                 ret = ES_R_ERROR;
1109                 goto out_2;
1110         }
1111
1112         g_variant_get(value, "(i)", &result);
1113
1114         _D("result(%d)", result);
1115
1116         ret = ES_R_OK;
1117
1118 out_2:
1119         g_variant_unref(value);
1120 out_1:
1121         if (conn) {
1122                 g_object_unref(conn);
1123         }
1124
1125         return ret;
1126 }
1127
1128 static int __eventsystem_check_user_send_validation(const char *event_name)
1129 {
1130         int ret = ES_R_EINVAL;
1131         GDBusConnection *conn = NULL;
1132         GError *error = NULL;
1133         GDBusProxy *proxy = NULL;
1134         GVariant *param = NULL;
1135         GVariant *value = NULL;
1136         gint result = 0;
1137
1138         if (!_initialized) {
1139                 __initialize();
1140         }
1141
1142         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SYSTEM, ES_TYPE_SYSTEM) < 0) {
1143                 _E("getting gdbus-connetion error");
1144                 ret = ES_R_ERROR;
1145                 goto out_1;
1146         }
1147
1148         proxy = g_dbus_proxy_new_sync(conn,
1149                 G_DBUS_PROXY_FLAGS_NONE, NULL,
1150                 ESD_BUS_NAME, ESD_OBJECT_PATH, ESD_INTERFACE_NAME,
1151                 NULL, &error);
1152         if (proxy == NULL) {
1153                 _E("failed to create new proxy, error(%s)", error->message);
1154                 g_error_free(error);
1155                 ret = ES_R_ERROR;
1156                 goto out_1;
1157         }
1158
1159         param = g_variant_new("(s)", event_name);
1160         value = g_dbus_proxy_call_sync(proxy, "CheckUserSendValidation", param,
1161                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1162         if (error != NULL) {
1163                 _E("proxy call sync error(%s)", error->message);
1164                 g_error_free(error);
1165                 ret = ES_R_ERROR;
1166                 goto out_2;
1167         }
1168
1169         g_variant_get(value, "(i)", &result);
1170
1171         _D("result(%d)", result);
1172
1173         if (result == 1) {
1174                 ret = ES_R_OK;
1175         }
1176 out_2:
1177         g_variant_unref(value);
1178 out_1:
1179         if (conn) {
1180                 g_object_unref(conn);
1181         }
1182
1183         return ret;
1184 }
1185
1186 static int __eventsystem_check_privilege_validation(const char *event_name)
1187 {
1188         int ret = ES_R_ENOTPERMITTED;
1189         GDBusConnection *conn = NULL;
1190         GError *error = NULL;
1191         GDBusProxy *proxy = NULL;
1192         GVariant *param = NULL;
1193         GVariant *value = NULL;
1194         gint result = 0;
1195
1196         if (!_initialized) {
1197                 __initialize();
1198         }
1199
1200         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SYSTEM, ES_TYPE_SYSTEM) < 0) {
1201                 _E("getting gdbus-connetion error");
1202                 ret = ES_R_ERROR;
1203                 goto out_1;
1204         }
1205
1206         proxy = g_dbus_proxy_new_sync(conn,
1207                 G_DBUS_PROXY_FLAGS_NONE, NULL,
1208                 ESD_BUS_NAME, ESD_OBJECT_PATH, ESD_INTERFACE_NAME,
1209                 NULL, &error);
1210         if (proxy == NULL) {
1211                 _E("failed to create new proxy, error(%s)", error->message);
1212                 g_error_free(error);
1213                 ret = ES_R_ERROR;
1214                 goto out_1;
1215         }
1216
1217         param = g_variant_new("(s)", event_name);
1218         value = g_dbus_proxy_call_sync(proxy, "CheckPrivilegeValidation", param,
1219                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1220         if (error != NULL) {
1221                 _E("proxy call sync error(%s)", error->message);
1222                 g_error_free(error);
1223                 ret = ES_R_ERROR;
1224                 goto out_2;
1225         }
1226
1227         g_variant_get(value, "(i)", &result);
1228
1229         _D("result(%d)", result);
1230
1231         if (result == 1) {
1232                 ret = ES_R_OK;
1233         }
1234 out_2:
1235         g_variant_unref(value);
1236 out_1:
1237         if (conn) {
1238                 g_object_unref(conn);
1239         }
1240
1241         return ret;
1242 }
1243
1244 static int __eventsystem_setup_trusted_peer(const char *event_name, const char *dest_bus_name)
1245 {
1246         int ret = ES_R_ERROR;
1247         GDBusConnection *conn = NULL;
1248         GError *error = NULL;
1249         GDBusProxy *proxy = NULL;
1250         GVariant *param = NULL;
1251         GVariant *value = NULL;
1252         gint result = 0;
1253
1254         if (!_initialized) {
1255                 __initialize();
1256         }
1257
1258         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SYSTEM, ES_TYPE_SYSTEM) < 0) {
1259                 _E("getting gdbus-connetion error");
1260                 ret = ES_R_ERROR;
1261                 goto out_1;
1262         }
1263
1264         proxy = g_dbus_proxy_new_sync(conn,
1265                 G_DBUS_PROXY_FLAGS_NONE, NULL,
1266                 ESD_BUS_NAME, ESD_OBJECT_PATH, ESD_INTERFACE_NAME,
1267                 NULL, &error);
1268         if (proxy == NULL) {
1269                 _E("failed to create new proxy, error(%s)", error->message);
1270                 g_error_free(error);
1271                 ret = ES_R_ERROR;
1272                 goto out_1;
1273         }
1274
1275         param = g_variant_new("(ss)", event_name, dest_bus_name);
1276
1277         value = g_dbus_proxy_call_sync(proxy, "SetupTrustedPeer", param,
1278                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1279         if (error != NULL) {
1280                 _E("proxy call sync error(%s)", error->message);
1281                 g_error_free(error);
1282                 ret = ES_R_ERROR;
1283                 goto out_2;
1284         }
1285
1286         g_variant_get(value, "(i)", &result);
1287
1288         _D("result(%d)", result);
1289
1290         if (result == 1) {
1291                 ret = ES_R_OK;
1292         }
1293 out_2:
1294         g_variant_unref(value);
1295 out_1:
1296         if (conn) {
1297                 g_object_unref(conn);
1298         }
1299
1300         return ret;
1301 }
1302
1303 static int __eventsystem_requet_destination_list(const char *event_name, GList **dest_list)
1304 {
1305         int ret = ES_R_ERROR;
1306         GDBusConnection *conn = NULL;
1307         GError *error = NULL;
1308         GDBusProxy *proxy = NULL;
1309         GVariant *param = NULL;
1310         GVariant *value = NULL;
1311         GVariantIter *iter;
1312         gchar *str;
1313         char *dest_name = NULL;
1314         gint result = 0;
1315
1316         if (!_initialized) {
1317                 __initialize();
1318         }
1319
1320         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SYSTEM, ES_TYPE_SYSTEM) < 0) {
1321                 _E("getting gdbus-connetion error");
1322                 ret = ES_R_ERROR;
1323                 goto out_1;
1324         }
1325
1326         proxy = g_dbus_proxy_new_sync(conn,
1327                 G_DBUS_PROXY_FLAGS_NONE, NULL,
1328                 ESD_BUS_NAME, ESD_OBJECT_PATH, ESD_INTERFACE_NAME,
1329                 NULL, &error);
1330         if (proxy == NULL) {
1331                 _E("failed to create new proxy, error(%s)", error->message);
1332                 g_error_free(error);
1333                 ret = ES_R_ERROR;
1334                 goto out_1;
1335         }
1336
1337         param = g_variant_new("(s)", event_name);
1338
1339         value = g_dbus_proxy_call_sync(proxy, "GetTrustedPeerList", param,
1340                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1341         if (error != NULL) {
1342                 _E("proxy call sync error(%s)", error->message);
1343                 g_error_free(error);
1344                 ret = ES_R_ERROR;
1345                 goto out_2;
1346         }
1347
1348         g_variant_get(value, "(ias)", &result, &iter);
1349
1350         _D("result(%d)", result);
1351
1352         if (result == 1) {
1353                 ret = ES_R_OK;
1354                 while (g_variant_iter_loop(iter, "s", &str)) {
1355                         dest_name = strdup((char *)str);
1356                         if (dest_name) {
1357                                 _D("dest name(%s)", str);
1358                                 *dest_list = g_list_append(*dest_list, dest_name);
1359                         } else {
1360                                 _E("out of memory");
1361                                 ret = ES_R_ENOMEM;
1362                                 break;
1363                         }
1364                 }
1365         }
1366         g_variant_iter_free(iter);
1367
1368 out_2:
1369         g_variant_unref(value);
1370 out_1:
1371         if (conn) {
1372                 g_object_unref(conn);
1373         }
1374
1375         return ret;
1376 }
1377
1378 #ifdef APPFW_EVENT_SYSTEM_EARLIER_FEATURE
1379 static int __eventsystem_request_earlier_data(const char *event_name,
1380                 eventsystem_cb callback, void *user_data)
1381 {
1382         int ret = 0;
1383         GDBusConnection *conn = NULL;
1384         GError *error = NULL;
1385         GDBusProxy *proxy = NULL;
1386         GVariant *param = NULL;
1387         gint result = 0;
1388         bundle_raw *raw = NULL;
1389         int len = 0;
1390
1391         if (!_initialized) {
1392                 __initialize();
1393         }
1394
1395         if (__get_gdbus_shared_connection(&conn, G_BUS_TYPE_SYSTEM, ES_TYPE_SYSTEM) < 0) {
1396                 _E("getting gdbus-connetion error");
1397                 ret = ES_R_ERROR;
1398                 goto out_1;
1399         }
1400
1401         proxy = g_dbus_proxy_new_sync(conn,
1402                 G_DBUS_PROXY_FLAGS_NONE, NULL,
1403                 ESD_BUS_NAME, ESD_OBJECT_PATH, ESD_INTERFACE_NAME,
1404                 NULL, &error);
1405
1406         if (proxy == NULL) {
1407                 _E("failed to create new proxy, error(%s)", error->message);
1408                 g_error_free(error);
1409                 ret = ES_R_ERROR;
1410                 goto out_1;
1411         }
1412
1413         param = g_variant_new("(s)", event_name);
1414         GVariant *value = g_dbus_proxy_call_sync(proxy, "GetEarlierData", param,
1415                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1416         if (error != NULL) {
1417                 _E("proxy call sync error(%s)", error->message);
1418                 g_error_free(error);
1419                 ret = ES_R_ERROR;
1420                 goto out_2;
1421         }
1422
1423         g_variant_get(value, "(iis)", &result, &len, &raw);
1424         g_variant_unref(value);
1425
1426         _D("result(%d), len(%d)", result, len);
1427
1428         if (!result && raw && len > 0) {
1429                 callback(event_name, raw, len, user_data);
1430                 bundle_free_encoded_rawdata(&raw);
1431         }
1432
1433         ret = ES_R_OK;
1434
1435 out_2:
1436         g_variant_unref(value);
1437 out_1:
1438         if (conn) {
1439                 g_object_unref(conn);
1440         }
1441
1442         return ret;
1443 }
1444 #endif
1445
1446 int eventsystem_register_application_event(const char *event_name, unsigned int *reg_id,
1447                 int *event_type, eventsystem_cb callback, void *user_data)
1448 {
1449         eventmap_s *em;
1450         char *interface_name = NULL;
1451         char *object_path = NULL;
1452         char *member_name = NULL;
1453         char *sender_name = NULL;
1454         GDBusSignalCallback filter;
1455         GBusType bus_type;
1456         guint  subscription_id  = 0;
1457         int ret = 0;
1458         GDBusConnection *conn = NULL;
1459
1460         if (!_initialized) {
1461                 __initialize();
1462         }
1463
1464         if (__check_eventname_validation_system((char *)event_name)) {
1465                 if (__eventsystem_check_privilege_validation(event_name) != ES_R_OK) {
1466                         _E("invalid privilege(%s)", event_name);
1467                         return ES_R_ENOTPERMITTED;
1468                 }
1469                 *event_type = ES_TYPE_SYSTEM;
1470         } else if (__check_eventname_validation_user((char *)event_name)) {
1471                 *event_type = ES_TYPE_USER;
1472         } else {
1473                 *event_type = ES_TYPE_UNKNOWN;
1474                 _E("unknown type event(%s)", event_name);
1475                 return ES_R_EINVAL;
1476         }
1477
1478         if (*event_type == ES_TYPE_SYSTEM) {
1479                 interface_name = strdup(SYS_EVENT_NAME_PREFIX);
1480                 if (interface_name == NULL) {
1481                         _E("out of memory");
1482                         return ES_R_ENOMEM;
1483                 }
1484                 if (!g_dbus_is_interface_name(interface_name)) {
1485                         _E("invalid interface_name(%s)", interface_name);
1486                         FREE_AND_NULL(interface_name);
1487                         return ES_R_EINVAL;
1488                 }
1489                 member_name = __get_member_name_from_eventname((char *)event_name);
1490                 if (member_name == NULL) {
1491                         _E("member_name is NULL(%s)", event_name);
1492                         FREE_AND_NULL(interface_name);
1493                         return ES_R_ERROR;
1494                 }
1495                 if (!g_dbus_is_member_name(member_name)) {
1496                         _E("Invalid member_name(%s)", member_name);
1497                         FREE_AND_NULL(interface_name);
1498                         FREE_AND_NULL(member_name);
1499                         return ES_R_ERROR;
1500                 }
1501                 filter = __eventsystem_filter_sysevent_for_application;
1502                 bus_type = G_BUS_TYPE_SYSTEM;
1503         } else {
1504                 interface_name = __get_encoded_interface_name((char *)event_name);
1505                 if (!interface_name) {
1506                         _E("interface_name is NULL");
1507                         return ES_R_ERROR;
1508                 }
1509                 if (!g_dbus_is_interface_name(interface_name)) {
1510                         _E("invalid interface_name(%s)", interface_name);
1511                         FREE_AND_NULL(interface_name);
1512                         return ES_R_EINVAL;
1513                 }
1514                 member_name = strdup(EVENT_SYSTEM_MEMBER);
1515                 if (!member_name) {
1516                         _E("out_of_memory");
1517                         FREE_AND_NULL(interface_name);
1518                         return ES_R_ERROR;
1519                 }
1520                 filter = __eventsystem_filter_userevent_for_application;
1521                 bus_type = G_BUS_TYPE_SESSION;
1522         }
1523
1524         object_path = __get_object_path(interface_name);
1525         if (!object_path) {
1526                 _E("failed get object_path");
1527                 FREE_AND_NULL(interface_name);
1528                 FREE_AND_NULL(member_name);
1529                 return ES_R_ERROR;
1530         }
1531         sender_name = NULL;
1532
1533         _D("interface_name(%s), object_path(%s)", interface_name, object_path);
1534         _D(" member_name(%s), sender_name(%s), type(%d), bus_type(%d)",
1535                 member_name, sender_name, *event_type, bus_type);
1536
1537         if (__get_gdbus_shared_connection(&conn, bus_type, *event_type) < 0) {
1538                 _E("getting gdbus-connetion error");
1539                 FREE_AND_NULL(interface_name);
1540                 FREE_AND_NULL(object_path);
1541                 FREE_AND_NULL(member_name);
1542                 return ES_R_ERROR;
1543         }
1544
1545 #ifdef APPFW_EVENT_SYSTEM_EARLIER_FEATURE
1546         __eventsystem_request_earlier_data(event_name, callback, user_data);
1547 #endif
1548
1549         subscription_id = g_dbus_connection_signal_subscribe(conn,
1550                 sender_name, /* sender */
1551                 interface_name,
1552                 member_name, /* member */
1553                 object_path, /* object_path */
1554                 NULL, /* arg0 */
1555                 G_DBUS_SIGNAL_FLAGS_NONE,
1556                 filter,
1557                 user_data,
1558                 NULL); /* user_data_free_func */
1559
1560         _D("event_name(%s), subscription_id(%d)", event_name, subscription_id);
1561
1562         if (subscription_id != 0) {
1563                 em = calloc(1, sizeof(eventmap_s));
1564                 if (!em) {
1565                         _E("memory alloc failed");
1566                         ret = ES_R_ENOMEM;
1567                 } else {
1568                         em->interface_name = strdup(interface_name);
1569                         em->member_name = strdup(member_name);
1570                         em->event_name = strdup(event_name);
1571                         em->es_cb = callback;
1572                         em->bus_type = bus_type;
1573                         em->reg_id = subscription_id;
1574                         em->event_type = *event_type;
1575
1576                         if (!em->interface_name || !em->member_name ||
1577                                 !em->event_name) {
1578                                 _E("out_of_memory");
1579                                 FREE_AND_NULL(em->interface_name);
1580                                 FREE_AND_NULL(em->member_name);
1581                                 FREE_AND_NULL(em->event_name);
1582                                 FREE_AND_NULL(em);
1583                                 ret = ES_R_ENOMEM;
1584                         } else {
1585                                 system_event_list =
1586                                         g_list_append(system_event_list, em);
1587                                 *reg_id = subscription_id;
1588
1589                                 ret = ES_R_OK;
1590
1591                                 if (em->bus_type == G_BUS_TYPE_SESSION &&
1592                                          em->event_type == ES_TYPE_USER) {
1593                                         if (s_info.own_name_session_bus == NULL) {
1594                                                 _E("session bus is not ready");
1595                                                 ret = ES_R_ERROR;
1596                                         } else {
1597                                                 if (__eventsystem_setup_trusted_peer(event_name,
1598                                                         s_info.own_name_session_bus) < 0) {
1599                                                         _E("failed to setup trusted peer");
1600                                                         ret = ES_R_ERROR;
1601                                                 }
1602                                         }
1603                                 }
1604                         }
1605                 }
1606         } else {
1607                 _E("dbus subscribe: error(%d)", subscription_id);
1608                 ret = ES_R_ERROR;
1609         }
1610
1611         FREE_AND_NULL(interface_name);
1612         FREE_AND_NULL(object_path);
1613         FREE_AND_NULL(member_name);
1614         if (conn) {
1615                 g_object_unref(conn);
1616         }
1617
1618         return ret;
1619 }
1620
1621 int eventsystem_unregister_application_event(unsigned int reg_id)
1622 {
1623         eventmap_s em;
1624         eventmap_s *em_data = NULL;
1625         GBusType bus_type;
1626         GList *cb_list = NULL;
1627         GDBusConnection *conn = NULL;
1628         eventsystem_event_type evt_type;
1629
1630         retvm_if(reg_id == 0, ES_R_EINVAL, "Invalid argument : reg_id");
1631
1632         if (!_initialized) {
1633                 __initialize();
1634         }
1635
1636         em.reg_id = reg_id;
1637         cb_list = g_list_find_custom(system_event_list, &em,
1638                 (GCompareFunc)__event_compare_reg_id_cb);
1639         if (cb_list) {
1640                 em_data = (eventmap_s *)cb_list->data;
1641
1642                 bus_type = em_data->bus_type;
1643                 evt_type = em_data->event_type;
1644
1645                 _D("unsubscribe: reg_id(%d), bus_type(%d)", reg_id, bus_type);
1646
1647                 if (__get_gdbus_shared_connection(&conn, bus_type, evt_type) < 0) {
1648                         _E("getting gdbus-connetion error");
1649                         return ES_R_ERROR;
1650                 }
1651                 g_dbus_connection_signal_unsubscribe(conn, reg_id);
1652
1653                 system_event_list = g_list_remove(system_event_list, cb_list->data);
1654
1655                 FREE_AND_NULL(em_data->interface_name);
1656                 FREE_AND_NULL(em_data->member_name);
1657                 FREE_AND_NULL(em_data->event_name);
1658                 FREE_AND_NULL(em_data);
1659                 g_object_unref(conn);
1660         } else {
1661                 _E("not found matched item");
1662                 return ES_R_ERROR;
1663         }
1664
1665         return ES_R_OK;
1666 }
1667
1668 int eventsystem_application_finalize(void)
1669 {
1670         gpointer key, value;
1671
1672         _D("release all resouces");
1673
1674         if (system_event_list) {
1675                 g_list_free(system_event_list);
1676         }
1677
1678         if (check_tbl) {
1679                 GHashTableIter iter;
1680
1681                 g_hash_table_iter_init(&iter, check_tbl);
1682
1683                 while (g_hash_table_iter_next(&iter, &key, &value)) {
1684                         char *val_item = (char *)value;
1685                         if (val_item) {
1686                                 free(val_item);
1687                         } else {
1688                                 _E("check_tbl, val_item is NULL");
1689                         }
1690                         g_hash_table_iter_remove(&iter);
1691                 }
1692                 g_hash_table_unref(check_tbl);
1693         }
1694
1695         FREE_AND_NULL(s_info.own_name_system_bus);
1696         FREE_AND_NULL(s_info.own_name_session_bus);
1697
1698         return 0;
1699 }