} message_port_local_port_info_s;
typedef struct message_port_remote_port_info {
- char *sender_id;
char *remote_app_id;
int certificate_info;
GList *port_list;
} message_port_remote_app_info_s;
typedef struct port_list_info {
+ message_port_remote_app_info_s *remote_app_info;
char *port_name;
char *encoded_bus_name;
bool is_trusted;
int send_sock_fd;
- int watcher_id;
bool exist;
GIOChannel *gio_read;
int g_src_id;
return MESSAGEPORT_ERROR_NONE;
}
-static void on_name_appeared(GDBusConnection *connection,
- const gchar *name,
- const gchar *name_owner,
- gpointer user_data)
-{
- _LOGD("name appeared : %s %s", __app_id, name);
-}
-
-static void on_name_vanished(GDBusConnection *connection,
- const gchar *name,
- gpointer user_data)
-{
- _LOGI("name vanished : %s", name);
- port_list_info_s *pli = (port_list_info_s *)user_data;
- if (pli == NULL) {
- LOGE("NULL port info");
- return;
- }
-
- _LOGD("watcher_id :%d", pli->watcher_id);
- if (pli->watcher_id > 0)
- g_bus_unwatch_name(pli->watcher_id);
- else
- _LOGE("Invalid watcher_id %d", pli->watcher_id);
- pli->exist = false;
- pli->watcher_id = 0;
-
-}
-
static int __get_local_port_info(int id, message_port_local_port_info_s **info)
{
message_port_local_port_info_s *mi = (message_port_local_port_info_s *)g_hash_table_lookup(__local_port_info, GINT_TO_POINTER(id));
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);
port_info->send_sock_fd = 0;
}
-static gboolean __socket_disconnect_handler(GIOChannel *gio,
- GIOCondition cond,
- gpointer data)
+/* LCOV_EXCL_START */
+void __free_port_info(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;
-}
+ message_port_remote_app_info_s *remote_app_info;
-static void __watch_remote_port_info(port_list_info_s *port_info)
-{
if (port_info == NULL)
return;
- if (port_info->watcher_id < 1) {
- port_info->watcher_id = g_bus_watch_name_on_connection(
- __gdbus_conn,
- port_info->encoded_bus_name,
- G_BUS_NAME_WATCHER_FLAGS_NONE,
- on_name_appeared,
- on_name_vanished,
- port_info,
- NULL);
- } else {
- LOGD("Already watched port info");
- return;
+ remote_app_info = port_info->remote_app_info;
+
+ _LOGI("__free_port_info : remote_app_id : %s port_name : %s",
+ remote_app_info->remote_app_id,
+ port_info->port_name);
+
+ remote_app_info->port_list = g_list_remove(remote_app_info->port_list,
+ port_info);
+
+ __clear_disconnect_socket(port_info);
+
+ if (port_info->encoded_bus_name)
+ free(port_info->encoded_bus_name);
+ if (port_info->port_name)
+ free(port_info->port_name);
+
+ free(port_info);
+
+ if (g_list_length(remote_app_info->port_list) == 0) {
+ g_hash_table_remove(__remote_app_info,
+ remote_app_info->remote_app_id);
}
}
+/* LCOV_EXCL_STOP */
+
+static gboolean __socket_disconnect_handler(GIOChannel *gio,
+ GIOCondition cond,
+ gpointer data)
+{
+ _LOGI("__socket_disconnect_handler %d", cond);
+ __free_port_info(data);
+
+ return FALSE;
+}
static int __get_remote_port_info(const char *remote_app_id, const char *remote_port, bool is_trusted,
message_port_remote_app_info_s **mri, port_list_info_s **pli)
*mri = remote_app_info;
port_info.port_name = strdup(remote_port);
+ if (port_info.port_name == NULL) {
+ ret_val = MESSAGEPORT_ERROR_OUT_OF_MEMORY;
+ goto out;
+ }
port_info.is_trusted = is_trusted;
cb_list = g_list_find_custom(remote_app_info->port_list, &port_info,
(GCompareFunc)__remote_port_compare_cb);
goto out;
}
remote_app_info->port_list = g_list_append(remote_app_info->port_list, tmp);
+ tmp->remote_app_info = remote_app_info;
*pli = tmp;
} else {
*pli = (port_list_info_s *)cb_list->data;
bundle_raw *raw = NULL;
message_port_local_port_info_s *mi;
int local_reg_id = 0;
- message_port_callback_info_s *callback_info;
+ message_port_callback_info_s *callback_info = NULL;
message_port_callback_info_s *head_callback_info;
GList *callback_info_list = NULL;
int fd_len;
int *returned_fds = NULL;
int fd;
+ bool ret = false;
g_variant_get(parameters, "(&s&sbb&s&sbu&s)", &local_appid, &local_port, &local_trusted, &bi_dir,
&remote_appid, &remote_port, &remote_trusted, &len, &raw);
callback_info->local_id = mi->local_id;
callback_info->remote_app_id = strdup(local_appid);
+ if (callback_info->remote_app_id == NULL) {
+ _LOGE("out of memory");
+ goto out;
+ }
callback_info->callback = mi->callback;
msg = g_dbus_method_invocation_get_message(invocation);
returned_fds = g_unix_fd_list_steal_fds(fd_list, &fd_len);
if (returned_fds == NULL) {
_LOGE("fail to get fds");
- __callback_info_free(callback_info);
- return false;
+ goto out;
}
fd = returned_fds[0];
callback_info->gio_read = g_io_channel_unix_new(fd);
if (!callback_info->gio_read) {
_LOGE("Error is %s\n", strerror_r(errno, buf, sizeof(buf)));
- __callback_info_free(callback_info);
- return false;
+ goto out;
}
callback_info->g_src_id = g_io_add_watch(callback_info->gio_read, G_IO_IN | G_IO_HUP,
__socket_request_handler, (gpointer)callback_info);
if (callback_info->g_src_id == 0) {
_LOGE("fail to add watch on socket");
- __callback_info_free(callback_info);
- return false;
+ goto out;
}
callback_info_list = g_hash_table_lookup(__callback_info_hash, GUINT_TO_POINTER(mi->local_id));
head_callback_info = (message_port_callback_info_s *)calloc(1, sizeof(message_port_callback_info_s));
if (head_callback_info == NULL) {
_LOGE("fail to alloc head_callback_info");
- __callback_info_free(callback_info);
- return false;
+ goto out;
}
head_callback_info->local_id = 0;
head_callback_info->remote_app_id = NULL;
else
mi->callback(mi->local_id, local_appid, NULL, false, data, NULL);
bundle_free(data);
+
+ ret = true;
out:
+ if (ret == false)
+ __callback_info_free(callback_info);
+
if (returned_fds)
free(returned_fds);
- return true;
+ return ret;
}
static int __check_remote_port(const char *remote_app_id, const char *remote_port, bool is_trusted, bool *exist)
port_info->exist = true;
*exist = true;
ret_val = MESSAGEPORT_ERROR_NONE;
- __watch_remote_port_info(port_info);
}
}
out:
if (result)
g_variant_unref(result);
+ if (ret_val != MESSAGEPORT_ERROR_NONE || !name_exist)
+ __free_port_info((gpointer)port_info);
+
return ret_val;
}
char *local_appid = NULL;
int pid = __get_sender_pid(conn, sender);
int *watcher_id = (int *)calloc(1, sizeof(int));
+ char *_sender;
+ retvm_if(!watcher_id, false, "Malloc failed");
ret = aul_app_get_appid_bypid(pid, buffer, sizeof(buffer));
if (ret != AUL_R_OK) {
if (strncmp(buffer, local_appid, MAX_PACKAGE_STR_SIZE) == 0) {
_LOGD("insert sender !!!!! %s", sender);
- g_hash_table_insert(__sender_appid_hash, (gpointer)strdup(sender), GINT_TO_POINTER(pid));
+ _sender = strdup(sender);
+ if (_sender == NULL) {
+ _LOGE("out of memory");
+ free(watcher_id);
+ return false;
+ }
+ g_hash_table_insert(__sender_appid_hash, (gpointer)_sender, GINT_TO_POINTER(pid));
*watcher_id = g_bus_watch_name_on_connection(
__gdbus_conn,
sender,
}
/* LCOV_EXCL_START */
-void __list_free_port_list(gpointer data)
-{
- port_list_info_s *n = (port_list_info_s *)data;
-
- FREE_AND_NULL(n->encoded_bus_name);
- FREE_AND_NULL(n->port_name);
- FREE_AND_NULL(n);
-}
-/* LCOV_EXCL_STOP */
-
-/* LCOV_EXCL_START */
static void __hash_destory_local_value(gpointer data)
{
message_port_local_port_info_s *mli = (message_port_local_port_info_s *)data;
{
message_port_remote_app_info_s *mri = (message_port_remote_app_info_s *)data;
if (mri) {
- FREE_AND_NULL(mri->sender_id);
FREE_AND_NULL(mri->remote_app_id);
if (mri->port_list)
- g_list_free_full(mri->port_list, __list_free_port_list);
+ g_list_free_full(mri->port_list, __free_port_info);
free(mri);
}
pthread_mutex_unlock(&mutex);
return G_SOURCE_CONTINUE;
} else if (ret == MESSAGEPORT_ERROR_IO_ERROR) {
- __clear_disconnect_socket(port_info);
+ __free_port_info((gpointer)port_info);
pthread_mutex_unlock(&mutex);
return G_SOURCE_REMOVE;
}
bool exist = false;
_LOGD("port exist check !!");
ret = __check_remote_port(remote_appid, remote_port, trusted_message, &exist);
- if (ret != MESSAGEPORT_ERROR_NONE) {
- goto out;
- } else if (!exist) {
- ret = MESSAGEPORT_ERROR_MESSAGEPORT_NOT_FOUND;
- goto out;
- }
+ if (ret != MESSAGEPORT_ERROR_NONE)
+ return ret;
+ else if (!exist)
+ return MESSAGEPORT_ERROR_MESSAGEPORT_NOT_FOUND;
}
if (port_info->send_sock_fd > 0) {
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);
+ 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;
ret = MESSAGEPORT_ERROR_IO_ERROR;
goto out;
}
- __watch_remote_port_info(port_info);
-
}
out:
g_object_unref(fd_list);
if (ret != MESSAGEPORT_ERROR_NONE) {
- __clear_disconnect_socket(port_info);
+ __free_port_info((gpointer)port_info);
if (sock_pair[SOCK_PAIR_SENDER])
close(sock_pair[SOCK_PAIR_SENDER]);
if (sock_pair[SOCK_PAIR_RECEIVER])
__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));
+ retvm_if(!registered_cb_info, MESSAGEPORT_ERROR_OUT_OF_MEMORY, "Malloc failed");
+
registered_cb_info->registered_cb = registered_cb;
registered_cb_info->unregistered_cb = unregistered_cb;
registered_cb_info->user_data = user_data;