init.c File Reference

This file implements all initialisation and shutdown of the library. More...

#include "stdio.h"
#include "internal.h"
#include "init.h"
#include <assert.h>
#include "eripc.h"

Include dependency graph for init.c:

Go to the source code of this file.

Defines
#define	UNUSED(x)   (void)(x)
Functions
static DBusHandlerResult	_filter_session (DBusConnection *conn, DBusMessage *msg, void *data)
static DBusHandlerResult	_filter_system (DBusConnection *conn, DBusMessage *msg, void *data)
static DBusHandlerResult	_filter (DBusConnection *conn, DBusMessage *msg, void *data, eripc_bus_t dbus_type)
static void	compose_opm_hash_key (const char *object_path, const char *member, char *key)
gboolean	__attribute__ ((visibility("hidden")))
eripc_context_t *	eripc_init (const char *program_name, const char *program_version, GMainContext *context)
static gboolean	_validate (const gchar *application, const gchar *version)
static void	free_handler (gpointer data, gpointer user_data)
static void	free_uniq_hash_value (gpointer data)
static void	free_if_hash_value (gpointer data)
static osso_context_t *	_init (const char *application, const char *version)
static void	_deinit (osso_context_t *osso)
static DBusConnection *	_dbus_setup (osso_context_t *osso, DBusBusType bus_type, GMainContext *context)
int	eripc_convert_msgtype (int t)
static int	types_match (int a, int b)
static int	str_match (const char *a, const char *b)
static void	opm_match_helper (const char *object_path, const char *member, char *key)
static GSList *	opm_match (osso_context_t *ipc, const char *path, const char *member)
static gboolean	add_to_opm_hash (osso_context_t *osso, const _osso_handler_t *handler, const char *opm_key)
static void	remove_from_opm_hash (_eripc_context_t *context, int handler_id, const char *opm_key)
Variables
static const char *	opm_match_all_key

---

Detailed Description

This file implements all initialisation and shutdown of the library.

Definition in file init.c.

---

Define Documentation

#define UNUSED

(

x

)

(void)(x)

Copyright (C) 2008 iRex Technologies B.V. All rights reserved.

Based on code found in libosso library by Kimmo Hämäläinen <kimmo.hamalainen@nokia.com>

Definition at line 36 of file init.c.

---

Function Documentation

gboolean __attribute__

(

(visibility("hidden"))

)

Definition at line 866 of file init.c.

References _osso_callback_data_t::bus_type, compose_opm_hash_key(), _osso_handler_t::data, ERIPC_BUS_BOTH, ERIPC_BUS_SESSION, ERIPC_BUS_SYSTEM, ERIPC_MEMBER_MATCH_ALL, ERIPC_PATH_MATCH_ALL, _osso_hash_value_t::handlers, _osso_callback_data_t::interface, _osso_callback_data_t::match_rule, MAX_OPM_HASH_KEY_LEN, _osso_callback_data_t::name, _osso_callback_data_t::path, remove_from_opm_hash(), _osso_callback_data_t::service, ULOG_DEBUG_F, ULOG_ERR_F, and ULOG_WARN_F.

{
    _osso_hash_value_t *elem;
    GSList *list;

    ULOG_DEBUG_F("context=%p", context);
    elem = g_hash_table_lookup(context->id_hash, GINT_TO_POINTER(handler_id));
    if (elem == NULL) {
        ULOG_ERR_F("couldn't find handler_id %d from id_hash", handler_id);
        return FALSE;
    }

    /* remove handlers from the interface hash */
    list = elem->handlers;
    while (list != NULL) {
        char opm_key[MAX_OPM_HASH_KEY_LEN + 1];
        DBusError err;
        _osso_handler_t *h = list->data;

        compose_opm_hash_key(h->data->path, h->data->name, opm_key);
        remove_from_opm_hash(context, handler_id, opm_key);

        dbus_error_init(&err);

        if (h->data->match_rule && (h->data->bus_type == ERIPC_BUS_SYSTEM
            || h->data->bus_type == ERIPC_BUS_BOTH)) {
            dbus_bus_remove_match(context->sys_conn, h->data->match_rule,
                                  &err);
            if (dbus_error_is_set(&err)) {
                ULOG_WARN_F("dbus_bus_remove_match failed for %s: %s",
                            h->data->match_rule, err.message);
                dbus_error_free(&err);
                dbus_error_init(&err);
            }
        }

        if (h->data->match_rule && (h->data->bus_type == ERIPC_BUS_SESSION
            || h->data->bus_type == ERIPC_BUS_BOTH)) {
            dbus_bus_remove_match(context->conn, h->data->match_rule,
                                  &err);
            if (dbus_error_is_set(&err)) {
                ULOG_WARN_F("dbus_bus_remove_match failed for %s: %s",
                            h->data->match_rule, err.message);
                dbus_error_free(&err);
            }
        }

        free(h->data->service); h->data->service = NULL;
        if (h->data->path != NULL
            && strcmp(ERIPC_PATH_MATCH_ALL, h->data->path) != 0) {
            free(h->data->path); h->data->path = NULL;
        }
        free(h->data->interface); h->data->interface = NULL;
        if (h->data->name != NULL
            && strcmp(ERIPC_MEMBER_MATCH_ALL, h->data->name) != 0) {
            free(h->data->name); h->data->name = NULL;
        }
        free(h->data); h->data = NULL;

        list = g_slist_next(list);
    }

    if (!g_hash_table_remove(context->id_hash, GINT_TO_POINTER(handler_id))) {
        ULOG_ERR_F("couldn't find handler_id %d from id_hash", handler_id);
        assert(0); /* this is a bug */
    }

    return TRUE;
}

Here is the call graph for this function:

static DBusConnection* _dbus_setup	(	osso_context_t *	osso,
		DBusBusType	bus_type,
		GMainContext *	context
	)			[static]

Definition at line 322 of file init.c.

References _filter_session(), _filter_system(), dprint, osso_af_context_t::service, and ULOG_ERR_F.

Referenced by eripc_init().

{
    DBusConnection *conn;
    DBusError err;
    int ret;
    
    dbus_error_init(&err);

    /* TODO: add dbus_connection_unref calls when the fixed D-Bus
     * is available */
    conn = dbus_bus_get(bus_type, &err);
    if (conn == NULL) {
        ULOG_ERR_F("Unable to connect to the D-Bus %s bus: %s",
                   bus_type == DBUS_BUS_SESSION ? "session" : "system",
                   err.message);
        dbus_error_free(&err);
        return NULL;
    }
    dbus_connection_setup_with_g_main(conn, context);

    ret = dbus_bus_request_name(conn, osso->service,
                                DBUS_NAME_FLAG_ALLOW_REPLACEMENT, &err);
    if (ret == -1) {
        ULOG_ERR_F("dbus_bus_request_name failed: %s", err.message);
   dbus_error_free(&err);
   return NULL;
    }

    dbus_connection_set_exit_on_disconnect(conn, FALSE);

    if (bus_type == DBUS_BUS_SESSION) {
        if (!dbus_connection_add_filter(conn, _filter_session,
                                        osso, NULL)) {
            ULOG_ERR_F("dbus_connection_add_filter failed");
       return NULL;
        }
    } else {
        if (!dbus_connection_add_filter(conn, _filter_system,
                                        osso, NULL)) {
            ULOG_ERR_F("dbus_connection_add_filter failed");
       return NULL;
        }
    }

    dprint("My base service is '%s'", dbus_bus_get_unique_name(conn));

    return conn;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void _deinit

(

osso_context_t *

osso

)

[static]

Definition at line 294 of file init.c.

References osso_af_context_t::cp_plugins, osso_af_context_t::id_hash, osso_af_context_t::if_hash, osso_af_context_t::opm_hash, and osso_af_context_t::uniq_hash.

Referenced by eripc_init().

{
    if (osso == NULL) {
   return;
    }
    if (osso->uniq_hash != NULL) {
        g_hash_table_destroy(osso->uniq_hash);
    }
    if (osso->if_hash != NULL) {
        g_hash_table_destroy(osso->if_hash);
    }
    if (osso->opm_hash != NULL) {
        g_hash_table_destroy(osso->opm_hash);
    }
    if (osso->id_hash != NULL) {
        g_hash_table_destroy(osso->id_hash);
    }
    if (osso->cp_plugins != NULL) {
        g_hash_table_destroy(osso->cp_plugins);
    }
    
    memset(osso, 0, sizeof(osso_context_t));
    free(osso);
    osso = NULL;
}

Here is the caller graph for this function:

static DBusHandlerResult _filter	(	DBusConnection *	conn,
		DBusMessage *	msg,
		void *	data,
		eripc_bus_t	dbus_type
	)			[inline, static]

Definition at line 569 of file init.c.

References _osso_callback_data_t::bus_type, _osso_handler_t::call_once_per_handler_id, osso_af_context_t::cur_conn, _osso_handler_t::data, ERIPC_BUS_BOTH, eripc_convert_msgtype(), ERIPC_EVENT_NONE, ERIPC_EVENT_SIGNAL, _osso_callback_data_t::event_type, _osso_handler_t::handler, handler_id, _osso_handler_t::handler_id, _osso_hash_value_t::handlers, _osso_callback_data_t::interface, _osso_callback_data_t::message_id, opm_match(), _osso_callback_data_t::service, str_match(), types_match(), and ULOG_DEBUG_F.

Referenced by _filter_session(), and _filter_system().

{
    osso_context_t *ipc;
    GSList *elem_list, *elem_list_p, *rm_list = NULL, *rm_list_p;
    int msgtype;
    unsigned int reply_to;
    gboolean found = FALSE;
    
    ipc = data;

    assert(ipc != NULL);
    ipc->cur_conn = conn;

    msgtype = eripc_convert_msgtype(dbus_message_get_type(msg));
    if (msgtype == ERIPC_EVENT_NONE) {
        ULOG_DEBUG_F("_filter: ERIPC_EVENT_NONE");
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
    }
    reply_to = dbus_message_get_reply_serial(msg);

    elem_list = opm_match(ipc, dbus_message_get_path(msg),
                          dbus_message_get_member(msg));

    elem_list_p = elem_list;
    while (elem_list_p != NULL) {
        _osso_hash_value_t *elem;

        elem = elem_list_p->data;

        if (elem != NULL) {
            GSList *list;
            int last_id = 0;

            list = elem->handlers;
            while (list != NULL) {
                _osso_handler_t *handler;
                _osso_callback_data_t *cb_data;
                gboolean match_sender = TRUE;

                handler = list->data;

/*
                if (handler) {
                        ULOG_DEBUG_F("found handler");
                        if (handler->data != NULL) {
                                ULOG_DEBUG_F("s/p/n t/i: %s/%s/%s %d/%s",
                                    handler->data->service,
                                    handler->data->path,
                                    handler->data->name,
                                    handler->data->event_type,
                                    handler->data->interface);

                                ULOG_DEBUG_F("s/p/n t/i: %s/%s/%s %d/%s",
                                    dbus_message_get_sender(msg),
                                    dbus_message_get_path(msg),
                                    dbus_message_get_member(msg),
                                    msgtype,
                                    dbus_message_get_interface(msg));

                                ULOG_DEBUG_F("types: %d %d",
                                    handler->data->event_type, msgtype);
                        }
                }
*/

                /* Note: this relies on the fact that the handlers with the
                 * same id are adjacent in the list */
                if (handler->call_once_per_handler_id
                    && handler->handler_id == last_id) {
                        /* do not call the callback this time, workaround for
                         * ERIPC_EVENT_MESSAGE_OR_SIGNAL etc. implementation */
                        ULOG_DEBUG_F("handler already called, skip");
                        list = g_slist_next(list);
                        continue;
                }

                cb_data = handler->data;
                
                if (cb_data != NULL && cb_data->message_id != 0
                    && cb_data->message_id == reply_to) {
                        /* this (one-shot) handler was created for this
                         * (reply) message */
                        ULOG_DEBUG_F("calling one-shot handler at %p,"
                                     " data=%p", handler->handler, cb_data);
                        (*handler->handler)(ipc, msg, cb_data, dbus_type);
                        ULOG_DEBUG_F("after calling handler at %p",
                                     handler->handler);
                        found = TRUE;
                        /* The handler is one-shot (because the serial is
                         * supposed to be unique). Add it to list to remove
                         * it later safely outside this loop. */
                        rm_list = g_slist_prepend(rm_list,
                                      GINT_TO_POINTER(handler->handler_id));

                        list = g_slist_next(list);
                        continue;
                }

                if (cb_data != NULL && cb_data->bus_type != ERIPC_BUS_BOTH
                    && cb_data->bus_type != dbus_type) {
                        /* handler is not for this bus type */
                        ULOG_DEBUG_F("handler is not for this bus type, skip");
                        list = g_slist_next(list);
                        continue;
                }

                if (msgtype == ERIPC_EVENT_SIGNAL) {
                        /* does not make sense to match sender in case
                         * of a D-Bus signal, because D-Bus uses the
                         * (practically random) unique bus name as the
                         * sender */
                        match_sender = FALSE;
                }

                if (cb_data != NULL &&
                    types_match(cb_data->event_type, msgtype) &&
                    (!match_sender || str_match(cb_data->service,
                                          dbus_message_get_sender(msg))) &&
                    str_match(cb_data->interface,
                              dbus_message_get_interface(msg))) {
                    /* object path and member have matched already */

                    ULOG_DEBUG_F("before calling the handler at %p, data=%p",
                                 handler->handler, cb_data);
                    (*handler->handler)(ipc, msg, cb_data, dbus_type);
                    ULOG_DEBUG_F("after calling handler at %p",
                                 handler->handler);
                    found = TRUE;
                }

                last_id = handler->handler_id;
                list = g_slist_next(list);
            }
        }

        elem_list_p = g_slist_next(elem_list_p);
    }
    
    if (elem_list != NULL) {
        g_slist_free(elem_list);
    }

    if (rm_list != NULL) {
        rm_list_p = rm_list;
        do {
            gboolean ret;
            int handler_id = GPOINTER_TO_INT(rm_list_p->data);

            assert(handler_id != 0);
            ret = _unset_handler(ipc, handler_id);
            assert(ret);

            rm_list_p = g_slist_next(rm_list_p);
        } while (rm_list_p != NULL);
        g_slist_free(rm_list);
    }

    if (!found) {
        ULOG_DEBUG_F("suitable handler not found for '%s/%s'",
                     dbus_message_get_path(msg),
                     dbus_message_get_member(msg));
    }
    else {
        return DBUS_HANDLER_RESULT_HANDLED;
    }
    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static DBusHandlerResult _filter_session	(	DBusConnection *	conn,
		DBusMessage *	msg,
		void *	data
	)			[static]

Definition at line 510 of file init.c.

References _filter(), and ERIPC_BUS_SESSION.

Referenced by _dbus_setup().

{
    return _filter(conn, msg, data, ERIPC_BUS_SESSION);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static DBusHandlerResult _filter_system	(	DBusConnection *	conn,
		DBusMessage *	msg,
		void *	data
	)			[static]

Definition at line 516 of file init.c.

References _filter(), and ERIPC_BUS_SYSTEM.

Referenced by _dbus_setup().

{
    return _filter(conn, msg, data, ERIPC_BUS_SYSTEM);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static osso_context_t* _init	(	const char *	application,
		const char *	version
	)			[static]

Definition at line 255 of file init.c.

References _validate(), osso_af_context_t::application, osso_af_context_t::cp_plugins, free_if_hash_value(), free_uniq_hash_value(), osso_af_context_t::id_hash, osso_af_context_t::interface, MAX_APP_NAME_LEN, MAX_VERSION_LEN, osso_af_context_t::next_handler_id, osso_af_context_t::object_path, osso_af_context_t::opm_hash, osso_af_context_t::service, osso_af_context_t::timeout_ms, ULOG_ERR_F, and osso_af_context_t::version.

Referenced by eripc_init().

{
    osso_context_t *osso;
    
    if (!_validate(application, version)) {
   ULOG_ERR_F("invalid arguments");
   return NULL;
    }

    osso = calloc(1, sizeof(osso_context_t));
    if (osso == NULL) {
   ULOG_ERR_F("calloc failed");
   return NULL;
    } 

    g_snprintf(osso->application, MAX_APP_NAME_LEN, "%s", application);
    g_snprintf(osso->version, MAX_VERSION_LEN, "%s", version);
    make_default_interface((const char*)application, osso->interface);
    make_default_service((const char*)application, osso->service);
    make_default_object_path((const char*)application, osso->object_path);

    osso->opm_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
                                          free, free_if_hash_value);
    osso->id_hash = g_hash_table_new_full(g_direct_hash, g_direct_equal,
                                          NULL, free_uniq_hash_value);
    if (osso->id_hash == NULL || osso->opm_hash == NULL) {
        ULOG_ERR_F("g_hash_table_new_full failed");
        free(osso);
        return NULL;
    }
    osso->cp_plugins = g_hash_table_new(g_str_hash, g_str_equal);
    osso->timeout_ms = 500; /* ms */
    osso->next_handler_id = 1;
    return osso;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean _validate	(	const gchar *	application,
		const gchar *	version
	)			[static]

Definition at line 130 of file init.c.

References ULOG_ERR_F, and validate_appname().

Referenced by _init().

{
    if (application == NULL || version == NULL) {
   return FALSE;
    }
    if (!validate_appname(application)) {
   return FALSE;
    }
    if (strchr(version, '/') != NULL) {
        ULOG_ERR_F("invalid version string '%s'", version);
   return FALSE;
    }
    return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean add_to_opm_hash	(	osso_context_t *	osso,
		const _osso_handler_t *	handler,
		const char *	opm_key
	)			[static]

Definition at line 740 of file init.c.

References _osso_hash_value_t::handlers, osso_af_context_t::opm_hash, and ULOG_ERR_F.

{
    _osso_hash_value_t *old;

    old = g_hash_table_lookup(osso->opm_hash, opm_key);
    if (old != NULL) {
        old->handlers = g_slist_append(old->handlers,
                                       (_osso_handler_t*)handler);
    } else {
        _osso_hash_value_t *new_elem;
        char *new_key;

        /* we need to allocate a new hash table element */
        new_elem = calloc(1, sizeof(_osso_hash_value_t));
        if (new_elem == NULL) {
            ULOG_ERR_F("calloc() failed");
            return FALSE;
        }

        new_key = strdup(opm_key);
        if (new_key == NULL) {
            ULOG_ERR_F("calloc() failed");
            free(new_elem);
            return FALSE;
        }

        new_elem->handlers = g_slist_append(NULL, (_osso_handler_t*)handler);

        g_hash_table_insert(osso->opm_hash, new_key, new_elem);
    }
    return TRUE;
}

static void compose_opm_hash_key	(	const char *	object_path,
		const char *	member,
		char *	key
	)			[inline, static]

Definition at line 52 of file init.c.

References ERIPC_MEMBER_MATCH_ALL, ERIPC_PATH_MATCH_ALL, MAX_MEMBER_LEN, MAX_OP_LEN, and opm_match_all_key.

Referenced by __attribute__().

{
    key[0] = '\0';
    if (object_path == NULL && member == NULL) {
        strncat(key, opm_match_all_key, MAX_OP_LEN + MAX_MEMBER_LEN);
    } else if (object_path == NULL) {
        strncat(key, ERIPC_PATH_MATCH_ALL, MAX_OP_LEN);
        strncat(key, member, MAX_MEMBER_LEN);
    } else if (member == NULL) {
        strncat(key, object_path, MAX_OP_LEN);
        strncat(key, ERIPC_MEMBER_MATCH_ALL, MAX_MEMBER_LEN);
    } else {
        strncat(key, object_path, MAX_OP_LEN);
        strncat(key, member, MAX_MEMBER_LEN);
    }
}

Here is the caller graph for this function:

int eripc_convert_msgtype

(

int

t

)

Definition at line 460 of file init.c.

References ERIPC_EVENT_ERROR, ERIPC_EVENT_MESSAGE, ERIPC_EVENT_NONE, ERIPC_EVENT_REPLY, ERIPC_EVENT_SIGNAL, and ULOG_ERR_F.

Referenced by _filter(), and eripc_reply_handler().

{
    switch (t) {
            case DBUS_MESSAGE_TYPE_METHOD_CALL:
                    return ERIPC_EVENT_MESSAGE;
            case DBUS_MESSAGE_TYPE_SIGNAL:
                    return ERIPC_EVENT_SIGNAL;
            case DBUS_MESSAGE_TYPE_ERROR:
                    return ERIPC_EVENT_ERROR;
            case DBUS_MESSAGE_TYPE_METHOD_RETURN:
                    return ERIPC_EVENT_REPLY;
            default:
                    ULOG_ERR_F("unknown message type %d", t);
                    return ERIPC_EVENT_NONE;
    }
}

Here is the caller graph for this function:

static void free_handler	(	gpointer	data,
		gpointer	user_data
	)			[static]

Definition at line 214 of file init.c.

References _osso_handler_t::can_free_data, _osso_handler_t::data, and UNUSED.

Referenced by free_uniq_hash_value().

{
    UNUSED(user_data);
    _osso_handler_t *h = data;

    if (h != NULL) {
        if (h->can_free_data) {
            free(h->data);
            h->data = NULL;
        }
        free(h);
    }
}

Here is the caller graph for this function:

static void free_if_hash_value

(

gpointer

data

)

[static]

Definition at line 242 of file init.c.

References _osso_hash_value_t::handlers.

Referenced by _init().

{
    _osso_hash_value_t *elem = data;

    if (elem != NULL) {
        if (elem->handlers != NULL) {
            g_slist_free(elem->handlers);
            elem->handlers = NULL;
        }
        free(elem);
    }
}

Here is the caller graph for this function:

static void free_uniq_hash_value

(

gpointer

data

)

[static]

Definition at line 228 of file init.c.

References free_handler(), and _osso_hash_value_t::handlers.

Referenced by _init().

{
    _osso_hash_value_t *elem = data;

    if (elem != NULL) {
        if (elem->handlers != NULL) {
            g_slist_foreach(elem->handlers, free_handler, NULL);
            g_slist_free(elem->handlers);
            elem->handlers = NULL;
        }
        free(elem);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static GSList* opm_match	(	osso_context_t *	ipc,
		const char *	path,
		const char *	member
	)			[inline, static]

Definition at line 531 of file init.c.

References ERIPC_MEMBER_MATCH_ALL, ERIPC_PATH_MATCH_ALL, MAX_OPM_HASH_KEY_LEN, osso_af_context_t::opm_hash, opm_match_all_key, and opm_match_helper().

Referenced by _filter().

{
    GSList *list = NULL;
    _osso_hash_value_t *elem;
    char opm_key[MAX_OPM_HASH_KEY_LEN + 1];

    if (path != NULL && member != NULL) {
        /* direct match? */
        opm_match_helper(path, member, opm_key);
        elem = g_hash_table_lookup(ipc->opm_hash, opm_key);
        if (elem != NULL) list = g_slist_prepend(list, elem);
    }

    /* return list of match-'em-all handlers */
    elem = g_hash_table_lookup(ipc->opm_hash, opm_match_all_key);
    if (elem != NULL) list = g_slist_prepend(list, elem);

    if (member != NULL) {
        /* any path + member? */
        opm_match_helper(ERIPC_PATH_MATCH_ALL, member, opm_key);
        elem = g_hash_table_lookup(ipc->opm_hash, opm_key);
        if (elem != NULL) list = g_slist_prepend(list, elem);
    }

    if (path != NULL) {
        /* path + any member? */
        opm_match_helper(path, ERIPC_MEMBER_MATCH_ALL, opm_key);
        elem = g_hash_table_lookup(ipc->opm_hash, opm_key);
        if (elem != NULL) list = g_slist_prepend(list, elem);
    }

    return list;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void opm_match_helper	(	const char *	object_path,
		const char *	member,
		char *	key
	)			[inline, static]

Definition at line 521 of file init.c.

References MAX_MEMBER_LEN, and MAX_OP_LEN.

Referenced by opm_match().

{
    key[0] = '\0';
    strncat(key, object_path, MAX_OP_LEN);
    strncat(key, member, MAX_MEMBER_LEN);
}

Here is the caller graph for this function:

static void remove_from_opm_hash	(	_eripc_context_t *	context,
		int	handler_id,
		const char *	opm_key
	)			[static]

Definition at line 832 of file init.c.

References _osso_handler_t::handler_id, _osso_hash_value_t::handlers, _eripc_context_t::opm_hash, and ULOG_DEBUG_F.

Referenced by __attribute__().

{
    _osso_hash_value_t *elem;

    elem = g_hash_table_lookup(context->opm_hash, opm_key);
    if (elem != NULL) {
        GSList *list;

        list = elem->handlers;
        while (list != NULL) {
            _osso_handler_t *h = list->data;
            GSList *next_elem;

            next_elem = g_slist_next(list);

            if (h->handler_id == handler_id) {
                ULOG_DEBUG_F("found handler_id %d from if_hash", handler_id);
                elem->handlers = g_slist_remove_link(elem->handlers, list);
                g_slist_free_1(list); /* free the removed link */

                /* if this was the last element in the list, free the
                 * list and the hash element */
                if (g_slist_length(elem->handlers) == 0) {
                    g_hash_table_remove(context->opm_hash, opm_key);
                    return;
                }
            }
            list = next_elem;
        }
    }
}

Here is the caller graph for this function:

static int str_match	(	const char *	a,
		const char *	b
	)			[inline, static]

Definition at line 500 of file init.c.

Referenced by _filter().

{
    if (a == NULL || b == NULL) return 1;

    if (strcmp(a, b) == 0) return 1;

    return 0;
}

Here is the caller graph for this function:

static int types_match	(	int	a,
		int	b
	)			[inline, static]

Definition at line 477 of file init.c.

References ERIPC_EVENT_ERROR, ERIPC_EVENT_MESSAGE, ERIPC_EVENT_MESSAGE_OR_SIGNAL, ERIPC_EVENT_REPLY, ERIPC_EVENT_REPLY_OR_ERROR, and ERIPC_EVENT_SIGNAL.

Referenced by _filter().

{
    if (a == b) return 1;

    if (a == ERIPC_EVENT_MESSAGE_OR_SIGNAL &&
        (b == ERIPC_EVENT_MESSAGE || b == ERIPC_EVENT_SIGNAL))
            return 1;

    if (a == ERIPC_EVENT_REPLY_OR_ERROR &&
        (b == ERIPC_EVENT_REPLY || b == ERIPC_EVENT_ERROR))
            return 1;

    if (b == ERIPC_EVENT_MESSAGE_OR_SIGNAL &&
        (a == ERIPC_EVENT_MESSAGE || a == ERIPC_EVENT_SIGNAL))
            return 1;

    if (b == ERIPC_EVENT_REPLY_OR_ERROR &&
        (a == ERIPC_EVENT_REPLY || a == ERIPC_EVENT_ERROR))
            return 1;

    return 0;
}

Here is the caller graph for this function:

---

Variable Documentation

const char* opm_match_all_key [static]

Initial value:

 ERIPC_PATH_MATCH_ALL
                                       ERIPC_MEMBER_MATCH_ALL

Definition at line 48 of file init.c.

Referenced by compose_opm_hash_key(), and opm_match().