dbus-manager-glue.c \
dubs-service-glue.h \
dbus-service-glue.c \
+ dbus-error.h \
+ dbus-error.c \
$(NULL)
libmessageport_dbus_glue_la_CPPFLAGS = \
--- /dev/null
+#include "dbus-error.h"
+
+#include <gio/gio.h>
+
+#define MSGPORT_ERROR_DOMAIN "messagport"
+#define _PREFIX "org.tizen.MessagePort.Error"
+
+GDBusErrorEntry __msgport_errors [] = {
+ {MSGPORT_ERROR_IO_ERROR, _PREFIX".IOError"},
+ {MSGPORT_ERROR_INVALID_PARAMS, _PREFIX".InvalidParams"},
+ {MSGPORT_ERROR_OUT_OF_MEMORY, _PREFIX".OutOfMemory"},
+ {MSGPORT_ERROR_NOT_FOUND, _PREFIX".NotFound"},
+ {MSGPORT_ERROR_ALREADY_EXISTING, _PREFIX".AlreadyExisting"},
+ {MSGPORT_ERROR_CERTIFICATE_MISMATCH, _PREFIX".CertificateMismatch"},
+ {MSGPORT_ERROR_UNKNOWN, _PREFIX ".Unknown"}
+};
+
+GQuark
+msgport_error_quark (void)
+{
+ static volatile gsize quark_volatile = 0;
+
+ if (!quark_volatile) {
+ g_dbus_error_register_error_domain (MSGPORT_ERROR_DOMAIN,
+ &quark_volatile,
+ __msgport_errors,
+ G_N_ELEMENTS (__msgport_errors));
+ }
+
+ return quark_volatile;
+}
--- /dev/null
+#ifndef __MSGPORT_ERROR_H
+#define __MSGPORT_ERROR_H
+
+#include <glib.h>
+
+#define MSGPORT_ERROR_QUARK (msgport_error_quark())
+
+G_BEGIN_DECLS
+
+typedef enum _MsgPortError
+{
+ MSGPORT_ERROR_IO_ERROR = 100,
+ MSGPORT_ERROR_OUT_OF_MEMORY,
+ MSGPORT_ERROR_INVALID_PARAMS,
+ MSGPORT_ERROR_NOT_FOUND,
+ MSGPORT_ERROR_ALREADY_EXISTING,
+ MSGPORT_ERROR_CERTIFICATE_MISMATCH,
+ MSGPORT_ERROR_UNKNOWN
+
+} MsgPortError;
+
+GQuark
+msgport_error_quark ();
+
+#define msgport_error_new(id, msg, args...) \
+ g_error_new (MSGPORT_ERROR_QUARK, id, msg, ##args)
+
+#define msgport_error_port_existing_new(app_id, port_name) \
+ msgport_error_new (MSGPORT_ERROR_ALREADY_EXISTING, \
+ "port already existing with name '%s' on application '%s'", port_name, app_id)
+
+#define msgport_error_no_memory_new() \
+ msgport_error_new (MSGPORT_ERROR_OUT_OF_MEMORY, "no memomry")
+
+#define msgport_error_port_not_found(app_id, port_name) \
+ msgport_error_new (MSGPORT_ERROR_NOT_FOUND, "port not found with name '%s' on application '%s'", port_name, app_id)
+
+#define msgport_error_port_id_not_found_new(service_id) \
+ msgport_error_new (MSGPORT_ERROR_NOT_FOUND, "no port found with id '%d'", service_id);
+
+#define msgport_error_unknown_new() \
+ msgport_error_new (MSGPORT_ERROR_UNKNOWN, "unknown");
+
+G_END_DECLS
+
+#endif /* __MSGPORT_ERROR_H */
AC_SUBST(GIOUNIX_CFLAGS)
AC_SUBST(GIOUINX_LIBS)
+#PKG_CHECK_MODULES([AUL], [aul])
+AC_SUBST(AUL_CFLAGS)
+AC_SUBST(AUL_LIBS)
+
PKG_CHECK_MODULES([BUNDLE], [bundle])
AC_SUBST(BUNDLE_CFLAGS)
AC_SUBST(BUNDLE_LIBS)
dbus-manager.c \
dbus-server.h \
dbus-server.c \
- service.h \
- service.c \
manager.h \
manager.c \
main.c \
messageportd_CPPFLAGS = \
-I$(top_builddir) \
- $(GLIB_CLFAGS) $(GIO_CFLAGS) \
+ $(GLIB_CLFAGS) $(GIO_CFLAGS) $(AUL_CFLAGS) \
$(NULL)
messageportd_LDADD = \
../common/libmessageport-dbus-glue.la \
- $(GLIB_LIBS) $(GIO_LIBS) \
+ $(GLIB_LIBS) $(GIO_LIBS) $(AUL_LIBS) \
$(NULL)
CLEANFILES =
#include "dbus-manager.h"
#include "common/dbus-manager-glue.h"
#include "common/dbus-service-glue.h"
+#include "common/dbus-error.h"
#include "common/log.h"
#include "dbus-service.h"
#include "dbus-server.h"
#include "manager.h"
+#include "utils.h"
G_DEFINE_TYPE (MsgPortDbusManager, msgport_dbus_manager, G_TYPE_OBJECT)
g_clear_object (&dbus_mgr->priv->connection);
/* unregister all services owned by this connection */
- msgport_manager_unregister_services (dbus_mgr->priv->manager, dbus_mgr);
+ msgport_manager_unregister_services (dbus_mgr->priv->manager, dbus_mgr, NULL);
g_clear_object (&dbus_mgr->priv->manager);
{
GError *error = NULL;
MsgPortDbusService *dbus_service = NULL;
- g_return_val_if_fail (dbus_mgr && MSGPORT_IS_DBUS_MANAGER (dbus_mgr), FALSE);
+ msgport_return_val_if_fail (dbus_mgr && MSGPORT_IS_DBUS_MANAGER (dbus_mgr), FALSE);
DBG ("register service request from %p for port %s", dbus_mgr, port_name);
dbus_mgr->priv->manager, dbus_mgr,
port_name, is_trusted, &error);
- if (error) {
- g_dbus_method_invocation_take_error (invocation, error);
- }
- else {
+ if (dbus_service) {
msgport_dbus_glue_manager_complete_register_service (
dbus_mgr->priv->dbus_skeleton, invocation,
msgport_dbus_service_get_object_path(dbus_service));
+ return TRUE;
}
+ if (!error) error = msgport_error_unknown_new ();
+ g_dbus_method_invocation_take_error (invocation, error);
+
return TRUE;
}
MsgPortDbusService *dbus_service = NULL;
MsgPortDbusManager *remote_dbus_manager = NULL;
- g_return_val_if_fail (dbus_mgr && MSGPORT_IS_DBUS_MANAGER (dbus_mgr), FALSE);
+ msgport_return_val_if_fail (dbus_mgr && MSGPORT_IS_DBUS_MANAGER (dbus_mgr), FALSE);
DBG ("check remote service request from %p for %s %s", dbus_mgr, remote_app_id, remote_port_name);
remote_dbus_manager = msgport_dbus_server_get_dbus_manager_by_app_id (
dbus_mgr->priv->server, remote_app_id);
- dbus_service = msgport_manager_get_service (dbus_mgr->priv->manager,
- remote_dbus_manager, remote_port_name, is_trusted);
-
- if (error) {
- g_dbus_method_invocation_take_error (invocation, error);
- }
- else {
- DBG ("Found service id : %d", msgport_dbus_service_get_id (dbus_service));
- msgport_dbus_glue_manager_complete_check_for_remote_service (
+ if (remote_dbus_manager) {
+ dbus_service = msgport_manager_get_service (dbus_mgr->priv->manager,
+ remote_dbus_manager, remote_port_name, is_trusted, &error);
+ if (dbus_service) {
+ DBG ("Found service id : %d", msgport_dbus_service_get_id (dbus_service));
+ msgport_dbus_glue_manager_complete_check_for_remote_service (
dbus_mgr->priv->dbus_skeleton, invocation,
msgport_dbus_service_get_id (dbus_service));
+ return TRUE;
+ }
}
+ if (!error) error = msgport_error_port_not_found (remote_app_id, remote_port_name);
+ g_dbus_method_invocation_take_error (invocation, error);
+
return TRUE;
}
GError *error = NULL;
MsgPortDbusService *dbus_service = 0;
- g_return_val_if_fail (dbus_mgr && MSGPORT_IS_DBUS_MANAGER (dbus_mgr), FALSE);
+ msgport_return_val_if_fail (dbus_mgr && MSGPORT_IS_DBUS_MANAGER (dbus_mgr), FALSE);
DBG ("send_message from %p : %d ", dbus_mgr, service_id);
dbus_service = msgport_manager_get_service_by_id (
- dbus_mgr->priv->manager, service_id);
+ dbus_mgr->priv->manager, service_id, &error);
if (dbus_service){
- msgport_dbus_service_send_message (dbus_service, data, "", "", FALSE);
- msgport_dbus_glue_manager_complete_send_message (
+ if (msgport_dbus_service_send_message (dbus_service, data, "", "", FALSE, &error)) {
+ msgport_dbus_glue_manager_complete_send_message (
dbus_mgr->priv->dbus_skeleton, invocation);
+ return TRUE;
+ }
}
- else {
- /* FIXME : fill error */
- g_dbus_method_invocation_take_error (invocation, error);
- }
+
+ if (!error) error = msgport_error_unknown_new ();
+ g_dbus_method_invocation_take_error (invocation, error);
return TRUE;
}
static void
+msgport_dbus_manager_class_init (MsgPortDbusManagerClass *klass)
+{
+ GObjectClass *gklass = G_OBJECT_CLASS(klass);
+
+ g_type_class_add_private (klass, sizeof(MsgPortDbusManagerPrivate));
+
+ gklass->finalize = _dbus_manager_finalize;
+ gklass->dispose = _dbus_manager_dispose;
+}
+
+static void
msgport_dbus_manager_init (MsgPortDbusManager *self)
{
MsgPortDbusManagerPrivate *priv = MSGPORT_DBUS_MANAGER_GET_PRIV (self);
self->priv = priv;
}
-
-static void
-msgport_dbus_manager_class_init (MsgPortDbusManagerClass *klass)
-{
- GObjectClass *gklass = G_OBJECT_CLASS(klass);
-
- g_type_class_add_private (klass, sizeof(MsgPortDbusManagerPrivate));
-
- gklass->finalize = _dbus_manager_finalize;
- gklass->dispose = _dbus_manager_dispose;
-}
-
static gchar *
_get_app_id_from_connection (GDBusConnection *connection)
{
- gchar *str_cred = NULL;
+ pid_t peer_pid;
+ GError *error = NULL;
GCredentials *cred = g_dbus_connection_get_peer_credentials (connection);
- g_return_val_if_fail (cred != NULL, NULL);
+ msgport_return_val_if_fail (cred != NULL, NULL);
- str_cred = g_credentials_to_string (cred);
+#ifdef ENABLE_DEBUG
+ gchar *str_cred = g_credentials_to_string (cred);
DBG ("Client Credentials : %s", str_cred);
g_free (str_cred);
+#endif
- return g_strdup_printf ("%d", g_credentials_get_unix_pid(cred, NULL));
+ peer_pid = g_credentials_get_unix_pid (cred, &error);
+ if (error) {
+ WARN ("Faild to get peer pid on conneciton %p : %s", connection, error->message);
+ g_error_free (error);
+ return NULL;
+ }
+
+#if 0
+ char buffer[255];
+ if ((res = aul_app_get_appid_bypid (peer_pid, &buffer, sizeof(buffer))) != AUL_R_OK) {
+ WARN ("Fail to get appid of peer pid '%d', error : %d", peer_pid, res);
+ return NULL;
+ }
+ else g_strdup (buffer);
+#else
+ return g_strdup_printf ("%d", peer_pid);
+#endif
}
MsgPortDbusManager *
msgport_dbus_manager_new (
GDBusConnection *connection,
MsgPortDbusServer *server,
- MsgPortManager *manager)
+ GError **error)
{
MsgPortDbusManager *dbus_mgr = NULL;
- GError *error = NULL;
dbus_mgr = MSGPORT_DBUS_MANAGER (g_object_new (MSGPORT_TYPE_DBUS_MANAGER, NULL));
- if (!dbus_mgr) return NULL;
+ if (!dbus_mgr) {
+ if (error) *error = msgport_error_new (MSGPORT_ERROR_OUT_OF_MEMORY, "Out of memory");
+ return NULL;
+ }
if (!g_dbus_interface_skeleton_export (
G_DBUS_INTERFACE_SKELETON (dbus_mgr->priv->dbus_skeleton),
connection,
"/",
- &error)) {
- g_print ("Failed to export dbus object on connection %p : %s",
- connection, error->message);
- g_error_free (error);
+ error)) {
+ WARN ("Failed to export dbus object on connection %p : %s",
+ connection, error ? (*error)->message : "");
g_object_unref (dbus_mgr);
return NULL;
}
dbus_mgr->priv->connection = g_object_ref (connection);
- dbus_mgr->priv->manager = g_object_ref (manager);
dbus_mgr->priv->server = server;
dbus_mgr->priv->app_id = _get_app_id_from_connection (connection);
MsgPortManager *
msgport_dbus_manager_get_manager (MsgPortDbusManager *dbus_manager)
{
- g_return_val_if_fail (dbus_manager && MSGPORT_IS_DBUS_MANAGER (dbus_manager), NULL);
+ msgport_return_val_if_fail (dbus_manager && MSGPORT_IS_DBUS_MANAGER (dbus_manager), NULL);
return dbus_manager->priv->manager;
}
GDBusConnection *
msgport_dbus_manager_get_connection (MsgPortDbusManager *dbus_manager)
{
- g_return_val_if_fail (dbus_manager && MSGPORT_IS_DBUS_MANAGER (dbus_manager), NULL);
+ msgport_return_val_if_fail (dbus_manager && MSGPORT_IS_DBUS_MANAGER (dbus_manager), NULL);
return dbus_manager->priv->connection;
}
const gchar *
msgport_dbus_manager_get_app_id (MsgPortDbusManager *dbus_manager)
{
- g_return_val_if_fail (dbus_manager && MSGPORT_IS_DBUS_MANAGER (dbus_manager), NULL);
+ msgport_return_val_if_fail (dbus_manager && MSGPORT_IS_DBUS_MANAGER (dbus_manager), NULL);
return (const gchar *)dbus_manager->priv->app_id;
}
GType msgport_dbus_manager_get_type (void);
MsgPortDbusManager *
-msgport_dbus_manager_new (GDBusConnection *connection, MsgPortDbusServer *server, MsgPortManager *manager);
+msgport_dbus_manager_new (
+ GDBusConnection *connection,
+ MsgPortDbusServer *server,
+ GError **error);
MsgPortManager *
msgport_dbus_manager_get_manager (MsgPortDbusManager *dbus_manager);
#include "common/log.h"
#include "dbus-server.h"
#include "dbus-manager.h"
-#include "manager.h"
G_DEFINE_TYPE (MsgPortDbusServer, msgport_dbus_server, G_TYPE_OBJECT)
{
GDBusServer *bus_server;
gchar *address;
- MsgPortManager *manager;
GHashTable *dbus_managers; /* {GDBusConnection,MsgPortDbusManager} */
};
self->priv->bus_server = NULL;
self->priv->address = NULL;
- self->priv->manager = msgport_manager_new ();
self->priv->dbus_managers = g_hash_table_new_full (
g_direct_hash, g_direct_equal, NULL, g_object_unref);
}
GDBusConnection *connection)
{
MsgPortDbusManager *dbus_manager = NULL;
+ GError *error = NULL;
DBG("Starting dbus manager on connection %p", connection);
dbus_manager = msgport_dbus_manager_new (
- connection, server, server->priv->manager);
+ connection, server, &error);
+ if (!dbus_manager) {
+ WARN ("Could not create dbus manager on conneciton %p: %s", connection, error->message);
+ g_error_free (error);
+ return;
+ }
g_hash_table_insert (server->priv->dbus_managers, connection, dbus_manager);
_on_client_request (GDBusServer *dbus_server, GDBusConnection *connection, gpointer userdata)
{
MsgPortDbusServer *server = MSGPORT_DBUS_SERVER(userdata);
-
- if (!server) {
- ERR ("memory corruption");
- return TRUE;
- }
+
+ g_return_val_if_fail (server && MSGPORT_IS_DBUS_SERVER (server), FALSE);
msgport_dbus_server_start_dbus_manager_for_connection (server, connection);
return server ;
}
-MsgPortManager *
-msgport_dbus_server_get_manager (MsgPortDbusServer *server)
-{
- g_return_val_if_fail (server && MSGPORT_IS_DBUS_SERVER (server), NULL);
-
- return server->priv->manager;
-}
-
static gboolean
_find_dbus_manager_by_app_id (
GDBusConnection *key,
#include "dbus-service.h"
#include "common/dbus-service-glue.h"
+#include "common/dbus-error.h"
#include "common/log.h"
#include "manager.h"
+#include "utils.h"
G_DEFINE_TYPE (MsgPortDbusService, msgport_dbus_service, G_TYPE_OBJECT)
G_TYPE_INSTANCE_GET_PRIVATE ((obj), MSGPORT_TYPE_DBUS_SERVICE, MsgPortDbusServicePrivate)
struct _MsgPortDbusServicePrivate {
- MsgPortDbusManager *owner;
+ guint id;
MsgPortDbusGlueService *dbus_skeleton;
- MsgPortService *service;
- gchar *object_path;
- guint id;
+ MsgPortDbusManager *owner;
+ gchar *port_name;
+ gboolean is_trusted;
};
{
MsgPortDbusService *dbus_service = MSGPORT_DBUS_SERVICE (self);
- if (dbus_service->priv->object_path) {
- g_free (dbus_service->priv->object_path);
- dbus_service->priv->object_path = NULL;
- }
-
G_OBJECT_CLASS (msgport_dbus_service_parent_class)->finalize (self);
}
_dbus_service_dispose (GObject *self)
{
MsgPortDbusService *dbus_service = MSGPORT_DBUS_SERVICE (self);
- DBG ("Unregistering service '%s'",
- msgport_service_get_port_name (dbus_service->priv->service));
+ DBG ("Unregistering service '%s'", dbus_service->priv->port_name);
if (dbus_service->priv->dbus_skeleton) {
g_dbus_interface_skeleton_unexport (
G_DBUS_INTERFACE_SKELETON (dbus_service->priv->dbus_skeleton));
g_clear_object (&dbus_service->priv->dbus_skeleton);
}
- g_clear_object (&dbus_service->priv->service);
-
-// g_clear_object (&dbus_service->priv->owner);
-
G_OBJECT_CLASS (msgport_dbus_service_parent_class)->dispose (self);
}
MsgPortDbusService *peer_dbus_service = NULL;
MsgPortManager *manager = NULL;
GError *error;
- g_return_val_if_fail (dbus_service && MSGPORT_IS_DBUS_SERVICE (dbus_service), FALSE);
+
+ msgport_return_val_if_fail_with_error (dbus_service && MSGPORT_IS_DBUS_SERVICE (dbus_service), FALSE, &error);
DBG ("Send Message rquest on service %p to remote service id : %d", dbus_service, remote_service_id);
manager = msgport_dbus_manager_get_manager (dbus_service->priv->owner);
- peer_dbus_service = msgport_manager_get_service_by_id (manager, remote_service_id);
- if (!peer_dbus_service) {
- /* FIXME: return ENOTFOUND error */
- g_dbus_method_invocation_take_error (invocation, error);
- }
- else {
- msgport_dbus_service_send_message (peer_dbus_service, data,
+ peer_dbus_service = msgport_manager_get_service_by_id (manager, remote_service_id, &error);
+
+ if (peer_dbus_service) {
+ if (msgport_dbus_service_send_message (peer_dbus_service, data,
msgport_dbus_service_get_app_id (dbus_service),
- msgport_dbus_service_get_port_name (dbus_service),
- msgport_dbus_service_get_is_trusted (dbus_service));
- msgport_dbus_glue_service_complete_send_message (
- dbus_service->priv->dbus_skeleton, invocation);
+ dbus_service->priv->port_name,
+ dbus_service->priv->is_trusted, &error)) {
+ msgport_dbus_glue_service_complete_send_message (
+ dbus_service->priv->dbus_skeleton, invocation);
+
+ return TRUE;
+ }
}
+
+ if (!error) error = msgport_error_unknown_new ();
+ g_dbus_method_invocation_take_error (invocation, error);
return TRUE;
}
GDBusMethodInvocation *invocation,
gpointer userdata)
{
- g_return_val_if_fail (dbus_service && MSGPORT_IS_DBUS_SERVICE (dbus_service), FALSE);
+ GError *error = NULL;
+ msgport_return_val_if_fail_with_error (dbus_service && MSGPORT_IS_DBUS_SERVICE (dbus_service), FALSE, &error);
/* FIXME unregister */
return TRUE;
}
+static GVariant *
+_msgport_service_to_variant (MsgPortDbusService *service)
+{
+ GVariantBuilder v_builder;
+ g_return_val_if_fail (service && MSGPORT_IS_DBUS_SERVICE (service), NULL);
+
+ g_variant_builder_init (&v_builder, G_VARIANT_TYPE_VARDICT);
+
+ g_variant_builder_add (&v_builder, "{sv}", "Id",
+ g_variant_new_int32 (service->priv->id));
+ g_variant_builder_add (&v_builder, "{sv}", "AappId",
+ g_variant_new_string (msgport_dbus_manager_get_app_id
+ (service->priv->owner)));
+ g_variant_builder_add (&v_builder, "{sv}", "PortName",
+ g_variant_new_string (service->priv->port_name));
+ g_variant_builder_add (&v_builder, "{sv}", "IsTrusted",
+ g_variant_new_boolean (service->priv->is_trusted));
+
+ return g_variant_builder_end (&v_builder);
+}
+
static gboolean
_dbus_service_handle_get_properties (
MsgPortDbusService *dbus_service,
msgport_dbus_glue_service_complete_get_properties (
dbus_service->priv->dbus_skeleton,
invocation,
- msgport_service_to_variant (dbus_service->priv->service));
+ _msgport_service_to_variant (dbus_service));
return TRUE;
}
MsgPortDbusServicePrivate *priv = MSGPORT_DBUS_SERVICE_GET_PRIV (self);
priv->dbus_skeleton = msgport_dbus_glue_service_skeleton_new ();
- priv->service = NULL;
priv->owner = NULL;
+ priv->id = 0;
+ priv->port_name = NULL;
g_signal_connect_swapped (priv->dbus_skeleton, "handle-send-message",
G_CALLBACK (_dbus_service_handle_send_message), (gpointer)self);
}
MsgPortDbusService *
-msgport_dbus_service_new (MsgPortDbusManager *owner, const gchar *name, gboolean is_trusted)
+msgport_dbus_service_new (MsgPortDbusManager *owner, const gchar *name, gboolean is_trusted, GError **error)
{
static guint object_conter = 0;
MsgPortDbusService *dbus_service = NULL;
GDBusConnection *connection = NULL;
gchar *object_path = 0;
- GError *error = NULL;
+
+ msgport_return_val_if_fail_with_error (owner && MSGPORT_IS_DBUS_MANAGER (owner), NULL, error);
+ msgport_return_val_if_fail_with_error (name && name[0], NULL, error);
connection = msgport_dbus_manager_get_connection (owner),
dbus_service = MSGPORT_DBUS_SERVICE (g_object_new (MSGPORT_TYPE_DBUS_SERVICE, NULL));
- if (!dbus_service) return NULL;
+ if (!dbus_service) {
+ if (error) *error = msgport_error_no_memory_new ();
+ return NULL;
+ }
+ dbus_service->priv->owner = owner;
+ dbus_service->priv->id = object_conter + 1;
+ dbus_service->priv->port_name = g_strdup (name);
+ dbus_service->priv->is_trusted = is_trusted;
/* FIXME: better way of path creation */
- object_path = g_strdup_printf ("/%u", ++object_conter);
+ object_path = g_strdup_printf ("/%u", dbus_service->priv->id);
if (!g_dbus_interface_skeleton_export (
G_DBUS_INTERFACE_SKELETON (dbus_service->priv->dbus_skeleton),
connection,
object_path,
- &error)) {
+ error)) {
g_print ("Failed to export dbus object on connection %p : %s",
- connection, error->message);
- g_error_free (error);
+ connection, error ? (*error)->message : "");
g_object_unref (dbus_service);
g_free (object_path);
+ object_conter--;
+
return NULL;
}
- dbus_service->priv->id = object_conter;
- dbus_service->priv->owner = /*g_object_ref*/ (owner);
- dbus_service->priv->object_path = object_path;
- dbus_service->priv->service = msgport_service_new (
- msgport_dbus_manager_get_app_id (owner), name, is_trusted);
-
- g_assert (dbus_service->priv->service);
- g_assert (MSGPORT_IS_SERVICE (dbus_service->priv->service));
+ g_free (object_path);
+ ++object_conter;
+
return dbus_service;
}
{
g_return_val_if_fail (dbus_service && MSGPORT_IS_DBUS_SERVICE (dbus_service), NULL);
- return (const gchar *)dbus_service->priv->object_path ;
+ return g_dbus_interface_skeleton_get_object_path (
+ G_DBUS_INTERFACE_SKELETON (dbus_service->priv->dbus_skeleton)) ;
}
GDBusConnection *
return msgport_dbus_manager_get_connection (dbus_service->priv->owner);
}
-MsgPortService *
-msgport_dbus_service_get_service (MsgPortDbusService *dbus_service)
-{
- g_return_val_if_fail (dbus_service && MSGPORT_IS_DBUS_SERVICE (dbus_service), NULL);
-
- return dbus_service->priv->service;
-}
-
MsgPortDbusManager *
msgport_dbus_service_get_owner (MsgPortDbusService *dbus_service)
{
{
g_return_val_if_fail (dbus_service && MSGPORT_IS_DBUS_SERVICE (dbus_service), NULL);
- return msgport_service_get_port_name (dbus_service->priv->service);
+ return (const gchar *)dbus_service->priv->port_name;
}
const gchar *
{
g_return_val_if_fail (dbus_service && MSGPORT_IS_DBUS_SERVICE (dbus_service), FALSE);
- return msgport_service_get_is_trusted (dbus_service->priv->service);
+ return dbus_service->priv->is_trusted;
}
gboolean
-msgport_dbus_service_send_message (MsgPortDbusService *dbus_service, GVariant *data, const gchar *r_app_id, const gchar *r_port, gboolean r_is_trusted)
+msgport_dbus_service_send_message (
+ MsgPortDbusService *dbus_service,
+ GVariant *data,
+ const gchar *r_app_id,
+ const gchar *r_port,
+ gboolean r_is_trusted,
+ GError **error)
{
- g_return_val_if_fail (dbus_service && MSGPORT_IS_DBUS_SERVICE (dbus_service), FALSE);
+ msgport_return_val_if_fail_with_error (dbus_service && MSGPORT_IS_DBUS_SERVICE (dbus_service), FALSE, error);
DBG ("Sending message to %p from '%s:%s'", dbus_service, r_app_id, r_port);
msgport_dbus_glue_service_emit_on_message (dbus_service->priv->dbus_skeleton, data, r_app_id, r_port, r_is_trusted);
-
+
return TRUE;
}
#include <glib.h>
#include <gio/gio.h>
#include <glib-object.h>
-#include "service.h"
#include "dbus-manager.h"
G_BEGIN_DECLS
GType msgport_dbus_service_get_type (void);
MsgPortDbusService *
-msgport_dbus_service_new (MsgPortDbusManager *owner, const gchar *name, gboolean is_trusted);
+msgport_dbus_service_new (MsgPortDbusManager *owner, const gchar *name, gboolean is_trusted, GError **error_out);
const gchar *
msgport_dbus_service_get_object_path (MsgPortDbusService *dbus_service);
GDBusConnection *
msgport_dbus_service_get_connection (MsgPortDbusService *dbus_service);
-MsgPortService *
-msgport_dbus_service_get_service (MsgPortDbusService *dbus_service);
-
guint
msgport_dbus_service_get_id (MsgPortDbusService *dbus_service);
GVariant *data,
const gchar *remote_app_id,
const gchar *remote_port_name,
- gboolean remote_is_trusted);
+ gboolean remote_is_trusted,
+ GError **error_out);
G_END_DECLS
*/
#include "manager.h"
+#include "common/dbus-error.h"
#include "common/log.h"
#include "dbus-manager.h"
#include "dbus-service.h"
+#include "utils.h"
G_DEFINE_TYPE (MsgPortManager, msgport_manager, G_TYPE_OBJECT)
GError **error)
{
GList *service_list = NULL; /* services list owned by a client */
- gboolean was_empty = TRUE;
+ gboolean list_was_empty = TRUE;
MsgPortDbusService *dbus_service = NULL;
- g_return_val_if_fail (manager && MSGPORT_IS_MANAGER (manager), NULL);
- g_return_val_if_fail (owner && MSGPORT_IS_DBUS_MANAGER (owner), NULL);
+ msgport_return_val_if_fail_with_error (manager && MSGPORT_IS_MANAGER (manager), NULL, error);
+ msgport_return_val_if_fail_with_error (owner && MSGPORT_IS_DBUS_MANAGER (owner), NULL, error);
+ msgport_return_val_if_fail_with_error (port_name && port_name[0], NULL, error);
if ((service_list = (GList *)g_hash_table_lookup (manager->priv->owner_service_map, owner)) != NULL) {
GList *list = NULL;
for (list = service_list; list != NULL; list = list->next) {
MsgPortDbusService *dbus_service = (MsgPortDbusService *)list->data;
- if ( !g_strcmp0 (port_name, msgport_dbus_service_get_port_name (dbus_service))) {
- /* FIXME: return EALREADY error */
+ if ( !g_strcmp0 (port_name, msgport_dbus_service_get_port_name (dbus_service)) &&
+ msgport_dbus_service_get_is_trusted (dbus_service) == is_trusted ) {
+ if (error) {
+ const gchar *app_id = msgport_dbus_service_get_app_id (dbus_service);
+ *error = msgport_error_port_existing_new (app_id, port_name);
+ }
return NULL;
}
}
}
- was_empty = (service_list == NULL);
-
- dbus_service = msgport_dbus_service_new (owner, port_name, is_trusted);
+ dbus_service = msgport_dbus_service_new (owner, port_name, is_trusted, error);
if (!dbus_service) {
- /* FIXME : return NOMEMERY error */
return NULL;
}
/* cache newly created service */
GINT_TO_POINTER (msgport_dbus_service_get_id (dbus_service)),
(gpointer)dbus_service);
+ list_was_empty = (service_list == NULL);
+
/* append to list of services */
service_list = g_list_append (service_list, dbus_service);
- if (was_empty) {
+ if (list_was_empty) {
g_hash_table_insert (manager->priv->owner_service_map, owner, service_list);
}
MsgPortManager *manager,
MsgPortDbusManager *owner,
const gchar *remote_port_name,
- gboolean is_trusted)
+ gboolean is_trusted,
+ GError **error)
{
GList *service_list = NULL;
- g_return_val_if_fail (manager && MSGPORT_IS_MANAGER (manager), NULL);
+
+ msgport_return_val_if_fail_with_error (manager && MSGPORT_IS_MANAGER (manager), NULL, error);
+ msgport_return_val_if_fail_with_error (owner && MSGPORT_IS_DBUS_MANAGER (owner), NULL, error);
+ msgport_return_val_if_fail_with_error (remote_port_name && remote_port_name[0], NULL, error);
service_list = g_hash_table_lookup (manager->priv->owner_service_map, owner);
while (service_list != NULL) {
service_list = service_list->next;
}
- /* FIXME: return ENOTFOUND */
+ if (error) *error = msgport_error_port_not_found (msgport_dbus_manager_get_app_id (owner), remote_port_name);
+
return NULL;
}
MsgPortDbusService *
msgport_manager_get_service_by_id (
MsgPortManager *manager,
- guint service_id)
+ guint service_id,
+ GError **error)
{
MsgPortDbusService *dbus_service = NULL;
- g_return_val_if_fail (manager && MSGPORT_IS_MANAGER (manager), NULL);
+
+ msgport_return_val_if_fail_with_error (manager && MSGPORT_IS_MANAGER (manager), NULL, error);
+ msgport_return_val_if_fail_with_error (service_id != 0, NULL, error);
dbus_service = MSGPORT_DBUS_SERVICE (g_hash_table_lookup (
manager->priv->service_cache, GINT_TO_POINTER(service_id)));
}
/*
- * unregister all the services owned by a client
- */
-gboolean
-msgport_manager_unregister_services (
- MsgPortManager *manager,
- MsgPortDbusManager *owner)
-{
-DBG("{");
- GList *service_list = NULL;
- g_return_val_if_fail (manager && MSGPORT_IS_MANAGER (manager), FALSE);
-
- /* fetch sevice list owned by the client */
- service_list = g_hash_table_lookup (manager->priv->owner_service_map, owner);
- if (!service_list) {
- DBG(" No service found");
- return FALSE;
- }
-
- /* remove all the service from the list */
- g_list_foreach (service_list, _unref_dbus_manager_cb, manager);
- g_hash_table_remove (manager->priv->owner_service_map, owner);
-DBG("}");
- return TRUE;
-}
-
-/*
* unregister a signle service for given service id
*/
gboolean
msgport_manager_unregister_service (
MsgPortManager *manager,
- gint service_id)
+ gint service_id,
+ GError **error)
{
MsgPortDbusService *service = NULL;
MsgPortDbusManager *owner = NULL;
GList *service_list = NULL, *new_service_list = NULL;
- g_return_val_if_fail (manager && MSGPORT_IS_MANAGER (manager), FALSE);
+
+ msgport_return_val_if_fail_with_error (manager && MSGPORT_IS_MANAGER (manager), FALSE, error);
service = g_hash_table_lookup (manager->priv->service_cache, GINT_TO_POINTER (service_id));
- if (!service) return FALSE;
+ if (!service) {
+ if (error) *error = msgport_error_port_id_not_found_new (service_id);
+ return FALSE;
+ }
owner = msgport_dbus_service_get_owner (service);
return TRUE;
}
+/*
+ * unregister all the services owned by a client
+ */
+gboolean
+msgport_manager_unregister_services (
+ MsgPortManager *manager,
+ MsgPortDbusManager *owner,
+ GError **error)
+{
+
+ GList *service_list = NULL;
+
+ msgport_return_val_if_fail_with_error (manager && MSGPORT_IS_MANAGER (manager), FALSE, error);
+
+ /* fetch sevice list owned by the client */
+ service_list = g_hash_table_lookup (manager->priv->owner_service_map, owner);
+ if (!service_list) {
+ DBG("no services found on client '%p'", owner);
+ return TRUE;
+ }
+
+ /* remove all the service from the list */
+ g_list_foreach (service_list, _unref_dbus_manager_cb, manager);
+ g_hash_table_remove (manager->priv->owner_service_map, owner);
+
+ return TRUE;
+}
+
+
MsgPortManager *manager,
MsgPortDbusManager *owner,
const gchar *remote_port_name,
- gboolean is_trusted);
+ gboolean is_trusted,
+ GError **error_out);
MsgPortDbusService *
msgport_manager_get_service_by_id (
MsgPortManager *manager,
- guint service_id);
+ guint service_id,
+ GError **error_out);
gboolean
msgport_manager_unregister_services (
MsgPortManager *manager,
- MsgPortDbusManager *owned_by);
+ MsgPortDbusManager *owned_by,
+ GError **error_out);
G_END_DECLS
+++ /dev/null
-/* vi: set et sw=4 ts=4 cino=t0,(0: */
-/* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * Copyright (C) 2013 Intel Corporation.
- *
- * Contact: Amarnath Valluri <amarnath.valluri@linux.intel.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- */
-
-#include "service.h"
-#include "common/log.h"
-
-G_DEFINE_TYPE (MsgPortService, msgport_service, G_TYPE_OBJECT)
-
-#define MSGPORT_SERVICE_GET_PRIV(obj) \
- G_TYPE_INSTANCE_GET_PRIVATE ((obj), MSGPORT_TYPE_SERVICE, MsgPortServicePrivate)
-
-struct _MsgPortServicePrivate {
- gchar *app_id;
- gchar *port_name;
- gboolean is_trusted;
-};
-
-static void
-_service_finalize (GObject *self)
-{
- MsgPortService *service = MSGPORT_SERVICE (self);
-
- g_free (service->priv->app_id);
- g_free (service->priv->port_name);
-
- G_OBJECT_CLASS (msgport_service_parent_class)->finalize (self);
-}
-
-static void
-_service_dispose (GObject *self)
-{
- //MsgPortService *service = MSGPORT_SERVICE (self);
-
- G_OBJECT_CLASS (msgport_service_parent_class)->dispose (self);
-}
-
-static void
-msgport_service_init (MsgPortService *self)
-{
- MsgPortServicePrivate *priv = MSGPORT_SERVICE_GET_PRIV (self);
-
- priv->app_id = NULL;
- priv->port_name = NULL;
- priv->is_trusted = FALSE;
-
- self->priv = priv;
-}
-
-static void
-msgport_service_class_init (MsgPortServiceClass *klass)
-{
- GObjectClass *gklass = G_OBJECT_CLASS(klass);
-
- g_type_class_add_private (klass, sizeof(MsgPortServicePrivate));
-
- gklass->finalize = _service_finalize;
- gklass->dispose = _service_dispose;
-}
-
-MsgPortService *
-msgport_service_new (const gchar *app_id,
- const gchar *port,
- gboolean is_trusted)
-{
- MsgPortService *service = NULL;
-
- service= MSGPORT_SERVICE (g_object_new (MSGPORT_TYPE_SERVICE, NULL));
- if (!service) return NULL;
-
- service->priv->app_id = g_strdup (app_id);
- service->priv->port_name = g_strdup (port);
- service->priv->is_trusted = is_trusted;
-
- return service;
-}
-
-const gchar *
-msgport_service_get_app_id (MsgPortService *service)
-{
- g_return_val_if_fail (service && MSGPORT_IS_SERVICE (service), NULL);
-
- return (const gchar *)service->priv->app_id;
-}
-
-const gchar *
-msgport_service_get_port_name (MsgPortService *service)
-{
- g_return_val_if_fail (service && MSGPORT_IS_SERVICE (service), NULL);
-
- return (const gchar *)service->priv->port_name;
-}
-
-gboolean
-msgport_service_get_is_trusted (MsgPortService *service)
-{
- g_return_val_if_fail (service && MSGPORT_IS_SERVICE (service), FALSE);
-
- return service->priv->is_trusted;
-}
-
-GVariant *
-msgport_service_to_variant (MsgPortService *service)
-{
- GVariantBuilder v_builder;
- g_return_val_if_fail (service && MSGPORT_IS_SERVICE (service), NULL);
-
- g_variant_builder_init (&v_builder, G_VARIANT_TYPE_VARDICT);
-
- g_variant_builder_add (&v_builder, "{sv}", "AappId",
- g_variant_new_string (service->priv->app_id));
- g_variant_builder_add (&v_builder, "{sv}", "PortName",
- g_variant_new_string (service->priv->port_name));
- g_variant_builder_add (&v_builder, "{sv}", "IsTrusted",
- g_variant_new_boolean (service->priv->is_trusted));
-
- return g_variant_builder_end (&v_builder);
-}
-
+++ /dev/null
-/* vi: set et sw=4 ts=4 cino=t0,(0: */
-/* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * Copyright (C) 2013 Intel Corporation.
- *
- * Contact: Amarnath Valluri <amarnath.valluri@linux.intel.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- */
-
-#ifndef _MSGPORT_SERVICE_H
-#define _MSGPORT_SERVICE_H
-
-#include <glib-object.h>
-
-G_BEGIN_DECLS
-
-#define MSGPORT_TYPE_SERVICE (msgport_service_get_type())
-#define MSGPORT_SERVICE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), MSGPORT_TYPE_SERVICE, MsgPortService))
-#define MSGPORT_SERVICE_CLASS(obj) (G_TYPE_CHECK_CLASS_CAST((kls), MSGPORT_TYPE_SERVICE, MsgPortServiceClass))
-#define MSGPORT_IS_SERVICE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), MSGPORT_TYPE_SERVICE))
-#define MSGPORT_IS_SERVICE_CLASS(kls) (G_TYPE_CHECK_CLASS_TYPE((kls), MSGPORT_TYPE_SERVICE))
-
-typedef struct _MsgPortService MsgPortService;
-typedef struct _MsgPortServiceClass MsgPortServiceClass;
-typedef struct _MsgPortServicePrivate MsgPortServicePrivate;
-
-struct _MsgPortService
-{
- GObject parent;
-
- /* private */
- MsgPortServicePrivate *priv;
-};
-
-struct _MsgPortServiceClass
-{
- GObjectClass parenet_class;
-};
-
-GType msgport_service_get_type (void);
-
-MsgPortService *
-msgport_service_new (const gchar *app_id,
- const gchar *port,
- gboolean is_trusted);
-
-const gchar *
-msgport_service_get_app_id (MsgPortService *service);
-
-const gchar *
-msgport_service_get_port_name (MsgPortService *service);
-
-gboolean
-msgport_service_get_is_trusted (MsgPortService *service);
-
-GVariant *
-msgport_service_to_variant (MsgPortService *service);
-
-G_END_DECLS
-
-#endif /* _MSGPORT_SERVICE_H */
-
--- /dev/null
+#ifndef __MSGPORT_UTILS_H
+#define __MSGPORT_UTILS_H
+
+#include <glib.h>
+#include "utils.h"
+
+#define msgport_return_if_fail(expr) g_return_if_fail (expr)
+#define msgport_return_if_fail_with_error(expr, err) \
+do {\
+ if (G_LIKELY (expr)) { }\
+ else \
+ g_return_if_fail_warning (G_LOG_DOMAIN,__PRETTY_FUNCTION__, ##expr);\
+ if (err) *err = msgport_error_new (MSGPORT_ERROR_INVALID_PARAMS, "assert("#expr")"); \
+ return; \
+ }\
+} while(0);
+
+#define msgport_return_val_if_fail(expr, ret) g_return_val_if_fail (expr, ret)
+#define msgport_return_val_if_fail_with_error(expr, ret, err) \
+do {\
+ if (G_LIKELY(expr)) { } \
+ else {\
+ g_return_if_fail_warning (G_LOG_DOMAIN,__PRETTY_FUNCTION__, #expr);\
+ if (err) *err = msgport_error_new (MSGPORT_ERROR_INVALID_PARAMS, "assert("#expr")"); \
+ return ret; \
+ }\
+} while (0);
+
+#endif /* __MSGPORT_UTILS_H */
projects / profile / ivi / message-port.git / commitdiff