hw.c

Go to the documentation of this file.

/**
 * @file hw.c
 * @brief This file implements the device signal handler functions.
 */
 
/*
 * This file is part of liberipc.
 *
 * liberipc is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * liberipc 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * 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>
 */

#include "internal.h"
#include "eripc.h"
#include <unistd.h>
#include <errno.h>
#include <assert.h>
#include <string.h>
    
static char *fix_name(const char* raw_name)
{
    char *name = strdup(raw_name);
    if (name == NULL) {
        ULOG_CRIT_F("fix_name failed: out of memory");
        return NULL;
    }
    
    // replace dashes (-) with underscores (_) as dbus chokes on dashes
    unsigned int i;
    for (i=0; i<strlen(name); i++)
    {
        if (name[i] == '-')
            name[i] = '_';
    }
    return name;
}    

static void _get_byte_array(DBusMessageIter *iter, eripc_arg_t *arg)
{
    arg->type = ERIPC_TYPE_DATA;
    dbus_message_iter_get_fixed_array(iter, &(arg->value.data),
                                      &(arg->data_len));
}

eripc_arg_t* _get_args(DBusMessageIter *iter)
{
    int type, idx = 0;
    eripc_arg_t *arg_array;

    arg_array = calloc(1, sizeof(eripc_arg_t) * (ERIPC_MAX_ARGS + 1));
    if (arg_array == NULL) {
            ULOG_ERR_F("calloc() failed: %s", strerror(errno));
            return NULL;
    }

    while ((type = dbus_message_iter_get_arg_type(iter))
           != DBUS_TYPE_INVALID) {

            int i;
            unsigned int u;
            double d;
            char c, *s;

            switch (type) {
                    case DBUS_TYPE_BOOLEAN:
                            arg_array[idx].type = ERIPC_TYPE_BOOL; 
                            dbus_message_iter_get_basic(iter, &i);
                            arg_array[idx].value.b = i ? 1 : 0;
                            ++idx;
                            break;
                    case DBUS_TYPE_INT32:
                            arg_array[idx].type = ERIPC_TYPE_INT; 
                            dbus_message_iter_get_basic(iter, &i);
                            arg_array[idx].value.i = i;
                            ++idx;
                            break;
                    case DBUS_TYPE_UINT32:
                            arg_array[idx].type = ERIPC_TYPE_UINT; 
                            dbus_message_iter_get_basic(iter, &u);
                            arg_array[idx].value.u = u;
                            ++idx;
                            break;
                    case DBUS_TYPE_DOUBLE:
                            arg_array[idx].type = ERIPC_TYPE_DOUBLE; 
                            dbus_message_iter_get_basic(iter, &d);
                            arg_array[idx].value.d = d;
                            ++idx;
                            break;
                    case DBUS_TYPE_BYTE:
                            arg_array[idx].type = ERIPC_TYPE_BYTE; 
                            dbus_message_iter_get_basic(iter, &c);
                            arg_array[idx].value.by = c;
                            ++idx;
                            break;
                    case DBUS_TYPE_STRING:
                            arg_array[idx].type = ERIPC_TYPE_STRING; 
                            dbus_message_iter_get_basic(iter, &s);
                            arg_array[idx].value.s = s;
                            ++idx;
                            break;
                    case DBUS_TYPE_ARRAY:
                            /* only byte arrays are supported */
                            if (dbus_message_iter_get_element_type(iter)
                                == DBUS_TYPE_BYTE) {
                                    _get_byte_array(iter,
                                                    &arg_array[idx]);
                                    ++idx;
                            } else {
                                    ULOG_ERR_F("arrays of type %d not"
                                               " supported",
                                    dbus_message_iter_get_element_type(iter));
                            }
                            break;
                    default:
                            ULOG_ERR_F("type %d not supported", type);
                            break;
            }

            dbus_message_iter_next(iter);
    }

    arg_array[idx].type = ERIPC_TYPE_INVALID;

    return arg_array;
}


static void generic_signal_handler(osso_context_t *osso,
                                   DBusMessage *msg,
                                   _osso_callback_data_t *data,
                                   eripc_bus_t dbus_type)
{
    eripc_event_info_t info;
    DBusMessageIter iter;
    eripc_handler_t *cb;
    char id_buf[MAX_MSGID_LEN + 1];

    ULOG_DEBUG_F("entered");
    assert(osso != NULL && data != NULL);

    memset(&info, 0, sizeof(info));

    info.service = dbus_message_get_sender(msg);
    info.path = dbus_message_get_path(msg);
    info.interface = dbus_message_get_interface(msg);
    info.name = dbus_message_get_member(msg);
    info.event_type = data->event_type;
    info.bus_type = dbus_type;

    /* create a dummy reply message for later use (workaround for
     * D-Bus library API) */
    if (osso->reply_dummy == NULL &&
        dbus_message_get_type(msg) == DBUS_MESSAGE_TYPE_METHOD_CALL) {
        DBusMessage *reply;
        reply = dbus_message_new_method_return(msg);
        if (reply == NULL) {
            ULOG_WARN_F("could not create reply_dummy");
        } else {
            osso->reply_dummy = reply;
        }
    }
    if (osso->error_dummy == NULL &&
        dbus_message_get_type(msg) == DBUS_MESSAGE_TYPE_METHOD_CALL) {
        DBusMessage *reply;
        reply = dbus_message_new_error(msg, "org.foo.dummy", NULL);
        if (reply == NULL) {
            ULOG_WARN_F("could not create error_dummy");
        } else { 
            osso->error_dummy = reply;
        }
    }

    if ((dbus_message_get_type(msg) == DBUS_MESSAGE_TYPE_METHOD_CALL
        && !dbus_message_get_no_reply(msg)) ||
        dbus_message_get_type(msg) == DBUS_MESSAGE_TYPE_METHOD_RETURN) {
            _make_id(dbus_type, dbus_message_get_sender(msg),
                           dbus_message_get_serial(msg), id_buf);
            info.message_id = id_buf;
    }

    if (dbus_message_get_type(msg) == DBUS_MESSAGE_TYPE_ERROR) {
            info.error = dbus_message_get_error_name(msg);
    }

    if (dbus_message_iter_init(msg, &iter)) {
            info.args = _get_args(&iter);
    }

    cb = data->user_cb;
    (*cb)((eripc_context_t*)osso, &info, data->user_data);

    if (info.args != NULL) {
            free((void*) info.args);
            info.args = NULL;
    }
}


inline static eripc_error_t _set_handler(eripc_context_t *context,
                                         const char *service,
                                         const char *object_path,
                                         const char *interface,
                                         const char *name,
                                         const char *match,
                                         const char *sys_match,
                                         _osso_handler_f *event_cb,
                                         eripc_event_t event_type,
                                         eripc_handler_t *user_handler,
                                         void *user_data,
                                         int handler_id,
                                         gboolean call_once_per_handler_id,
                                         eripc_bus_t bus_type)
{
        DBusError error;
        _osso_callback_data_t *cb_data;

        cb_data = calloc(1, sizeof(_osso_callback_data_t));
        if (cb_data == NULL) {
                ULOG_ERR_F("calloc failed");
                return ERIPC_ERROR_OOM;
        }

        cb_data->user_cb = user_handler;
        cb_data->user_data = user_data;
        cb_data->match_rule = match;
        cb_data->event_type = event_type;
        cb_data->bus_type = bus_type;
        cb_data->data = cb_data;

        if (service != NULL) {
                cb_data->service = strdup(service);
                if (cb_data->service == NULL) {
                        goto _set_handler_oom4;
                }
        }
        if (object_path != NULL) {
                cb_data->path = strdup(object_path);
                if (cb_data->path == NULL) {
                        goto _set_handler_oom3;
                }
        }
        if (interface != NULL) {
                cb_data->interface = strdup(interface);
                if (cb_data->interface == NULL) {
                        goto _set_handler_oom2;
                }
        }
        if (name != NULL) {
                cb_data->name = strdup(name);
                if (cb_data->name == NULL) {
                        goto _set_handler_oom1;
                }
        }

        dbus_error_init(&error);
        
        if (bus_type == ERIPC_BUS_SYSTEM || bus_type == ERIPC_BUS_BOTH) {
                if (!dbus_connection_get_is_connected(context->sys_conn)) {
                        ULOG_ERR_F("connection to system bus is not open");
                        goto _set_handler_failed_match;
                }

                dbus_bus_add_match(context->sys_conn, sys_match, &error);

                if (dbus_error_is_set(&error)) {
                        ULOG_ERR_F("dbus_bus_add_match failed: %s",
                                   error.message);
                        dbus_error_free(&error);
                        goto _set_handler_failed_match;
                }
        }

        if (bus_type == ERIPC_BUS_SESSION || bus_type == ERIPC_BUS_BOTH) {
                if (!dbus_connection_get_is_connected(context->conn)) {
                        ULOG_ERR_F("connection to session bus is not open");
                        goto _set_handler_failed_match;
                }

                dbus_bus_add_match(context->conn, match, &error);

                if (dbus_error_is_set(&error)) {
                        ULOG_ERR_F("dbus_bus_add_match failed: %s",
                                   error.message);
                        dbus_error_free(&error);

                        if (bus_type == ERIPC_BUS_BOTH) {
                                dbus_bus_remove_match(context->sys_conn,
                                                      match, NULL);
                        }

                        goto _set_handler_failed_match;
                }
        }

        if (_eripc_set_handler((_eripc_context_t*)context, event_cb,
                               cb_data, handler_id,
                               call_once_per_handler_id)) {
                return ERIPC_ERROR_SUCCESS;
        } else {
                return ERIPC_ERROR;
        }

_set_handler_oom1:
        free(cb_data->interface);
_set_handler_oom2:
        free(cb_data->path);
_set_handler_oom3:
        free(cb_data->service);
_set_handler_oom4:
        free(cb_data);
        return ERIPC_ERROR_OOM;

_set_handler_failed_match:
        free(cb_data->name);
        free(cb_data->interface);
        free(cb_data->path);
        free(cb_data->service);
        free(cb_data);
        return ERIPC_ERROR;
}

static eripc_error_t compose_match(const eripc_event_info_t *info,
                                   char **match)
{
        size_t free_space = ERIPC_MAX_MATCH_SIZE;
        char buf[ERIPC_MAX_MATCH_SIZE + 1];
        buf[0] = '\0';

        *match = malloc(ERIPC_MAX_MATCH_SIZE + 1);
        if (*match == NULL) {
                return ERIPC_ERROR_OOM;
        }
        (*match)[0] = '\0';

        if (info->service != NULL) {
                snprintf(buf, ERIPC_MAX_MATCH_SIZE, "sender='%s',",
                         info->service);
                strncat(*match, buf, free_space);
                free_space -= strlen(buf);
        }
        
        if (info->path != NULL) {
                snprintf(buf, ERIPC_MAX_MATCH_SIZE, "path='%s',", info->path);
                strncat(*match, buf, free_space);
                free_space -= strlen(buf);
        }
        if (info->interface != NULL) {
                snprintf(buf, ERIPC_MAX_MATCH_SIZE, "interface='%s',",
                         info->interface);
                strncat(*match, buf, free_space);
                free_space -= strlen(buf);
        }
        if (info->name != NULL) {
                snprintf(buf, ERIPC_MAX_MATCH_SIZE, "member='%s',",
                         info->name);
                strncat(*match, buf, free_space);
                free_space -= strlen(buf);
        }
        if (info->event_type != 0) {
                switch(info->event_type)
                {
                case ERIPC_EVENT_MESSAGE:
                    snprintf(buf, ERIPC_MAX_MATCH_SIZE, "type='method_call',");
                    break;
                case ERIPC_EVENT_SIGNAL:
                    snprintf(buf, ERIPC_MAX_MATCH_SIZE, "type='signal',");
                    break;
                case ERIPC_EVENT_REPLY:
                    snprintf(buf, ERIPC_MAX_MATCH_SIZE, "type='method_reply',");
                    break;
                case ERIPC_EVENT_ERROR:
                default:
                    snprintf(buf, ERIPC_MAX_MATCH_SIZE, "type='error',");
                    break;
                }
                strncat(*match, buf, free_space);
                free_space -= strlen(buf);
        }

        if (free_space < ERIPC_MAX_MATCH_SIZE) {
                /* remove the last comma */
                (*match)[strlen(*match) - 1] = '\0';
        } else {
                free(*match);
                *match = NULL;
        }
        
        return ERIPC_ERROR_SUCCESS;
}


eripc_error_t eripc_set_signal_handler(eripc_context_t *context,
                                       eripc_handler_t *handler,
                                       void *user_data,
                                       eripc_bus_t bus_type,
                                       const char *source,
                                       const char *name,
                                       int *handler_id)
{
    eripc_error_t error = ERIPC_ERROR_SUCCESS;
    eripc_event_info_t info;
    
    char *interface = fix_name(source);
    memset(&info, 0, sizeof(info));
    info.event_type = ERIPC_EVENT_SIGNAL;
    info.bus_type = bus_type;
    info.interface = interface;
    info.name = name;
    
    error = eripc_set_event_handler(context, &info, 
                                    handler, user_data, handler_id);
    
    free(interface);
    
    return error;
}


eripc_error_t eripc_set_message_handler(eripc_context_t *context,
                                       eripc_handler_t *handler,
                                       void *user_data,
                                       eripc_bus_t bus_type,
                                       const char *source,
                                       const char *name,
                                       int *handler_id)
{
    eripc_error_t error = ERIPC_ERROR_SUCCESS;
    eripc_event_info_t info;
    
    char *interface = fix_name(source);
    memset(&info, 0, sizeof(info));
    info.event_type = ERIPC_EVENT_MESSAGE;
    info.bus_type = bus_type;
    info.interface = interface;
    info.name = name;
    
    error = eripc_set_event_handler(context, &info, 
                                    handler, user_data, handler_id);
    
    free(interface);
    
    return error;
}


eripc_error_t eripc_set_event_handler(eripc_context_t *context,
                                      const eripc_event_info_t *info,
                                      eripc_handler_t *handler,
                                      void *user_data,
                                      int *handler_id)
{
        eripc_error_t error = ERIPC_ERROR_SUCCESS;
        _osso_handler_f *event_cb = NULL;
        char *tmp_match = NULL, *match = NULL, *sys_match = NULL;
        int new_handler_id;
        eripc_error_t ret;
        eripc_bus_t bus_type;

        ULOG_DEBUG_F("entered");

        if (context == NULL || handler == NULL) {
                ULOG_ERR_F("invalid arguments");
                return ERIPC_ERROR_INVALID;
        }

        if (info == NULL) {
                ULOG_ERR_F("info structure must be provided");
                return ERIPC_ERROR_INVALID;
        }

        if (info->bus_type == ERIPC_BUS_IRRELEVANT) {
                bus_type = ERIPC_BUS_BOTH;
        } else {
                bus_type = info->bus_type;
        }

        new_handler_id = context->next_handler_id++;

        event_cb = generic_signal_handler;

        ret = compose_match(info, &tmp_match);
        ULOG_DEBUG_F("match='%s'", tmp_match);
        
        if (ret == ERIPC_ERROR_SUCCESS) {
                if (bus_type == ERIPC_BUS_BOTH
                    || bus_type == ERIPC_BUS_SESSION) {
                        match = tmp_match;
                }
                if (bus_type == ERIPC_BUS_BOTH
                    || bus_type == ERIPC_BUS_SYSTEM) {
                        if (match == NULL) {
                                sys_match = tmp_match;
                        } else {
                                sys_match = strdup(tmp_match);
                                if (sys_match == NULL) {
                                        ULOG_ERR_F("strdup failed");
                                        free(tmp_match);
                                        error = ERIPC_ERROR_OOM;
                                        goto _oom_exit;
                                }
                        }
                }
                error = _set_handler(context,
                                     info->service,
                                     info->path,
                                     info->interface,
                                     info->name,
                                     match,
                                     sys_match,
                                     event_cb,
                                     info->event_type, // FIXME was 0, event_type ignored
                                     handler,
                                     user_data,
                                     new_handler_id,
                                     FALSE, bus_type);
        } else {
                error = ret;
        }

_oom_exit:
        if (handler_id != NULL) {
                if (error == ERIPC_ERROR_SUCCESS) {
                        *handler_id = new_handler_id;
                } else {
                        *handler_id = 0;
                }
        }
        return error;
}

eripc_error_t eripc_unset_handler(eripc_context_t *context,
                                  int handler_id)
{
        ULOG_DEBUG_F("entered");

        if (context == NULL || handler_id == 0) {
                ULOG_ERR_F("invalid arguments");
                return ERIPC_ERROR_INVALID;
        }

        if (_unset_handler((_eripc_context_t*)context, handler_id)) {
                return ERIPC_ERROR_SUCCESS;
        } else {
                /* id was not found */
                return ERIPC_ERROR_INVALID;
        }
}