Add new apis to watch that remote port is registered and unregistered

[platform/core/appfw/message-port.git] / src / message-port.c

diff --git a/src/message-port.c b/src/message-port.c
index 52f87d7..6868a5e 100755 (executable)
--- a/src/message-port.c
+++ b/src/message-port.c
@@ -86,6 +86,7 @@ static GHashTable *__remote_app_info;
 static GHashTable *__sender_appid_hash;
 static GHashTable *__trusted_app_list_hash;
 static GHashTable *__callback_info_hash;
+static GHashTable *__registered_callback_info_hash;
 static const int MAX_MESSAGE_SIZE = 16 * 1024;
 
 enum __certificate_info_type {
@@ -136,6 +137,16 @@ typedef struct port_list_info {
        int g_src_id;
 } port_list_info_s;
 
+typedef struct registered_callback_info {
+       char *remote_app_id;
+       char *remote_port;
+       bool is_trusted;
+       int watcher_id;
+       void *user_data;
+       messageport_registration_event_cb registered_cb;
+       messageport_registration_event_cb unregistered_cb;
+} registered_callback_info_s;
+
 static void __callback_info_free(gpointer data)
 {
        message_port_callback_info_s *callback_info = (message_port_callback_info_s *)data;
@@ -181,6 +192,22 @@ static void __callback_info_free_by_info(message_port_callback_info_s *callback_
        g_list_free(find_list);
 }
 
+static void __registered_callback_info_free(gpointer data)
+{
+       registered_callback_info_s *callback_info = (registered_callback_info_s *)data;
+       if (callback_info == NULL)
+               return;
+
+       if (callback_info->remote_app_id)
+               free(callback_info->remote_app_id);
+
+       if (callback_info->remote_port)
+               free(callback_info->remote_port);
+
+       free(callback_info);
+}
+
+
 static void __hash_destroy_callback_info(gpointer data)
 {
 
@@ -715,6 +742,8 @@ message_port_pkt_s *__message_port_recv_raw(int fd)
 
        if (__read_string_from_socket(fd, (char **)&pkt->data, &pkt->data_len) != MESSAGEPORT_ERROR_NONE) {
                LOGE("read socket fail: data");
+               if (pkt->data)
+                       free(pkt->data);
                free(pkt->remote_port_name);
                free(pkt);
                return NULL;
@@ -999,7 +1028,7 @@ static int __check_remote_port(const char *remote_app_id, const char *remote_por
                g_variant_get(result, "(b)", &name_exist);
 
                if (!name_exist) {
-                       LOGE("Name not exist %s", bus_name);
+                       _LOGI("Name not exist %s", bus_name);
                        *exist = false;
                        ret_val = MESSAGEPORT_ERROR_NONE;
                } else {
@@ -1594,6 +1623,92 @@ int __message_send_bidirectional_message(int id, const char *remote_app_id, cons
                        local_info->port_name, trusted_message, local_info->is_trusted, true, message);
 }
 
+static void __name_registered(GDBusConnection *connection,
+               const gchar *name,
+               const gchar *name_owner,
+               gpointer user_data)
+{
+
+       registered_callback_info_s *info = (registered_callback_info_s *)user_data;
+       if (info == NULL) {
+               LOGE("NULL registered_callback_info");
+               return;
+       }
+
+       _LOGI("watcher_id : %d, appeared name : %s , name_owner : %s\n", info->watcher_id, name, name_owner);
+       if (info->registered_cb)
+               info->registered_cb(info->remote_app_id, info->remote_port, info->is_trusted, info->user_data);
+}
+
+static void __name_unregistered(GDBusConnection *connection,
+               const gchar *name,
+               gpointer user_data)
+{
+
+       registered_callback_info_s *info = (registered_callback_info_s *)user_data;
+       if (info == NULL) {
+               LOGE("NULL registered_callback_info");
+               return;
+       }
+
+       _LOGI("watcher_id : %d, vanished name : %s\n", info->watcher_id, name);
+       if (info->unregistered_cb)
+               info->unregistered_cb(info->remote_app_id, info->remote_port, info->is_trusted, info->user_data);
+}
+
+int __messageport_watch_remote_port(int *watcher_id, const char *remote_app_id, const char *remote_port, bool trusted_remote_port, messageport_registration_event_cb registered_cb, messageport_registration_event_cb unregistered_cb, void *user_data)
+{
+       int ret_val = MESSAGEPORT_ERROR_NONE;
+       message_port_remote_app_info_s *remote_app_info = NULL;
+       port_list_info_s *port_info = NULL;
+
+       _LOGI("remote_app_id, app_id :[%s : %s] ", remote_app_id, __app_id);
+
+       ret_val = __get_remote_port_info(remote_app_id, remote_port, trusted_remote_port, &remote_app_info, &port_info);
+       if (ret_val != MESSAGEPORT_ERROR_NONE)
+               return ret_val;
+
+       if (__registered_callback_info_hash == NULL)
+               __registered_callback_info_hash = g_hash_table_new_full(g_direct_hash,  g_direct_equal, NULL, __registered_callback_info_free);
+
+       registered_callback_info_s *registered_cb_info = (registered_callback_info_s *)calloc(1, sizeof(registered_callback_info_s));
+       registered_cb_info->registered_cb = registered_cb;
+       registered_cb_info->unregistered_cb = unregistered_cb;
+       registered_cb_info->user_data = user_data;
+       registered_cb_info->remote_app_id = strdup(remote_app_info->remote_app_id);
+       if (registered_cb_info->remote_app_id == NULL) {
+               free(registered_cb_info);
+               return MESSAGEPORT_ERROR_OUT_OF_MEMORY;
+       }
+       registered_cb_info->remote_port = strdup(port_info->port_name);
+       if (registered_cb_info->remote_port == NULL) {
+               free(registered_cb_info->remote_app_id);
+               free(registered_cb_info);
+               return MESSAGEPORT_ERROR_OUT_OF_MEMORY;
+       }
+
+       registered_cb_info->watcher_id = g_bus_watch_name_on_connection(
+                       __gdbus_conn,
+                       port_info->encoded_bus_name,
+                       G_BUS_NAME_WATCHER_FLAGS_NONE,
+                       __name_registered,
+                       __name_unregistered,
+                       registered_cb_info,
+                       NULL);
+       if (registered_cb_info->watcher_id == 0) {
+               free(registered_cb_info->remote_app_id);
+               free(registered_cb_info->remote_port);
+               free(registered_cb_info);
+               return MESSAGEPORT_ERROR_IO_ERROR;
+       }
+
+       g_hash_table_insert(__registered_callback_info_hash,
+                       GINT_TO_POINTER(registered_cb_info->watcher_id), registered_cb_info);
+
+       *watcher_id = registered_cb_info->watcher_id;
+       return MESSAGEPORT_ERROR_NONE;
+}
+
 int messageport_unregister_local_port(int local_port_id, bool trusted_port)
 {
 
@@ -1758,3 +1873,42 @@ int messageport_send_bidirectional_trusted_message(int id, const char *remote_ap
        return __message_send_bidirectional_message(id, remote_app_id, remote_port, true, message);
 }
 
+int messageport_add_registered_cb(const char *remote_app_id, const char *remote_port, bool is_trusted, messageport_registration_event_cb registered_cb, void *user_data, int *watcher_id)
+{
+       if (!_initialized) {
+               if (!__initialize())
+                       return MESSAGEPORT_ERROR_IO_ERROR;
+       }
+       return __messageport_watch_remote_port(watcher_id, remote_app_id, remote_port, is_trusted, registered_cb, NULL, user_data);
+}
+
+int messageport_add_unregistered_cb(const char *remote_app_id, const char *remote_port, bool is_trusted, messageport_registration_event_cb unregistered_cb, void *user_data, int *watcher_id)
+{
+       if (!_initialized) {
+               if (!__initialize())
+                       return MESSAGEPORT_ERROR_IO_ERROR;
+       }
+       return __messageport_watch_remote_port(watcher_id, remote_app_id, remote_port, is_trusted, NULL, unregistered_cb, user_data);
+}
+
+
+int messageport_remove_registration_event_cb(int watcher_id)
+{
+       registered_callback_info_s *registered_cb_info = NULL;
+       gboolean remove_result = FALSE;
+
+       if (watcher_id < 1)
+               return MESSAGEPORT_ERROR_INVALID_PARAMETER;
+
+       registered_cb_info = g_hash_table_lookup(__registered_callback_info_hash, GINT_TO_POINTER(watcher_id));
+       if (registered_cb_info == NULL)
+               return MESSAGEPORT_ERROR_INVALID_PARAMETER;
+
+       remove_result = g_hash_table_remove(__registered_callback_info_hash, GINT_TO_POINTER(watcher_id));
+       if (!remove_result)
+               return MESSAGEPORT_ERROR_IO_ERROR;
+
+       g_bus_unwatch_name(watcher_id);
+
+       return MESSAGEPORT_ERROR_NONE;
+}