* @file message-port.cpp
* @brief This is the implementation file for the MessagePort.
*/
+#define _GNU_SOURCE
#include <sys/socket.h>
#include <stdlib.h>
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 {
int send_sock_fd;
int watcher_id;
bool exist;
+ GIOChannel *gio_read;
+ 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;
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)
{
pli->exist = false;
pli->watcher_id = 0;
- _LOGI("name vanished socket : %d", pli->send_sock_fd);
- if (pli->send_sock_fd > 0) {
- close(pli->send_sock_fd);
- pli->send_sock_fd = 0;
- }
}
static int __get_local_port_info(int id, message_port_local_port_info_s **info)
return remote_app_info;
}
+static void __clear_disconnect_socket(port_list_info_s *port_info)
+{
+ GError *error = NULL;
+
+ if (port_info == NULL)
+ return;
+ _LOGI("__clear_disconnect_socket : fd [%d]", port_info->send_sock_fd);
+
+ if (port_info->gio_read != NULL) {
+ g_io_channel_shutdown(port_info->gio_read, TRUE, &error);
+ if (error) {
+ _LOGE("g_io_channel_shutdown error : %s", error->message);
+ g_error_free(error);
+ }
+ g_io_channel_unref(port_info->gio_read);
+ port_info->gio_read = NULL;
+ }
+
+ if (port_info->g_src_id != 0) {
+ g_source_remove(port_info->g_src_id);
+ port_info->g_src_id = 0;
+ }
+ port_info->send_sock_fd = 0;
+}
+
+static gboolean __socket_disconnect_handler(GIOChannel *gio,
+ GIOCondition cond,
+ gpointer data)
+{
+ /* It's sender socket's gio channel so, only EOF can be received */
+ port_list_info_s *port_info = (port_list_info_s *)data;
+ _LOGI("__socket_disconnect_handler %d", cond);
+ __clear_disconnect_socket(port_info);
+ return FALSE;
+}
+
static void __watch_remote_port_info(port_list_info_s *port_info)
{
if (port_info == NULL)
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;
if (returned_fds == NULL) {
_LOGE("fail to get fds");
__callback_info_free(callback_info);
- return -1;
+ return false;
}
fd = returned_fds[0];
if (!callback_info->gio_read) {
_LOGE("Error is %s\n", strerror_r(errno, buf, sizeof(buf)));
__callback_info_free(callback_info);
- return -1;
+ return false;
}
callback_info->g_src_id = g_io_add_watch(callback_info->gio_read, G_IO_IN | G_IO_HUP,
if (callback_info->g_src_id == 0) {
_LOGE("fail to add watch on socket");
__callback_info_free(callback_info);
- return -1;
+ return false;
}
callback_info_list = g_hash_table_lookup(__callback_info_hash, GUINT_TO_POINTER(mi->local_id));
if (head_callback_info == NULL) {
_LOGE("fail to alloc head_callback_info");
__callback_info_free(callback_info);
- return -1;
+ return false;
}
head_callback_info->local_id = 0;
head_callback_info->remote_app_id = NULL;
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 {
if (__write_string_to_socket(sockfd, local_port, local_port_len) != MESSAGEPORT_ERROR_NONE) {
_LOGE("write local_port fail");
- return MESSAGEPORT_ERROR_IO_ERROR;
+ ret = MESSAGEPORT_ERROR_IO_ERROR;
+ goto out;
}
if (__write_socket(sockfd, (char *)&is_bidirection, sizeof(is_bidirection), &nb) != MESSAGEPORT_ERROR_NONE) {
_LOGE("write is_bidirection fail");
- return MESSAGEPORT_ERROR_IO_ERROR;
+ ret = MESSAGEPORT_ERROR_IO_ERROR;
+ goto out;
}
if (__write_socket(sockfd, (char *)&local_trusted, sizeof(local_trusted), &nb) != MESSAGEPORT_ERROR_NONE) {
_LOGE("write local_trusted fail");
- return MESSAGEPORT_ERROR_IO_ERROR;
+ ret = MESSAGEPORT_ERROR_IO_ERROR;
+ goto out;
}
if (__write_string_to_socket(sockfd, (void *)kb_data, data_len) != MESSAGEPORT_ERROR_NONE) {
_LOGE("write kb_data fail");
ret = MESSAGEPORT_ERROR_IO_ERROR;
+ goto out;
}
out:
if (kb_data)
GError *err = NULL;
GVariant *body = NULL;
int sock_pair[2] = {0,};
+ char buf[1024];
ret = __get_remote_port_info(remote_appid, remote_port, trusted_message, &remote_app_info, &port_info);
if (ret != MESSAGEPORT_ERROR_NONE)
goto out;
}
}
- __watch_remote_port_info(port_info);
if (port_info->send_sock_fd > 0) {
ret = __message_port_send_async(port_info->send_sock_fd, message,
_LOGE("g_unix_fd_list_append [%s]", err->message);
ret = MESSAGEPORT_ERROR_IO_ERROR;
g_error_free(err);
- close(sock_pair[SOCK_PAIR_SENDER]);
- close(sock_pair[SOCK_PAIR_RECEIVER]);
goto out;
}
+
port_info->send_sock_fd = sock_pair[SOCK_PAIR_SENDER];
close(sock_pair[SOCK_PAIR_RECEIVER]);
+ sock_pair[SOCK_PAIR_RECEIVER] = 0;
+
+ port_info->gio_read = g_io_channel_unix_new(port_info->send_sock_fd);
+ if (!port_info->gio_read) {
+ _LOGE("Error is %s\n", strerror_r(errno, buf, sizeof(buf)));
+ ret = MESSAGEPORT_ERROR_IO_ERROR;
+ goto out;
+ }
+
+ port_info->g_src_id = g_io_add_watch(port_info->gio_read, G_IO_IN | G_IO_HUP,
+ __socket_disconnect_handler, (gpointer)port_info);
+ if (port_info->g_src_id == 0) {
+ _LOGE("fail to add watch on socket");
+ ret = MESSAGEPORT_ERROR_IO_ERROR;
+ goto out;
+ }
+
}
}
ret = MESSAGEPORT_ERROR_IO_ERROR;
goto out;
}
-
+ __watch_remote_port_info(port_info);
}
if (fd_list)
g_object_unref(fd_list);
+ if (ret != MESSAGEPORT_ERROR_NONE) {
+ __clear_disconnect_socket(port_info);
+ if (sock_pair[SOCK_PAIR_SENDER])
+ close(sock_pair[SOCK_PAIR_SENDER]);
+ if (sock_pair[SOCK_PAIR_RECEIVER])
+ close(sock_pair[SOCK_PAIR_RECEIVER]);
+ }
return ret;
}
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)
{
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;
+}
projects / platform / core / appfw / message-port.git / blobdiff