rpc.c

Go to the documentation of this file.

/**
 * @file rpc.c
 * @brief This file implements rpc calls from one application to another.
 */
 
/*
 * 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 <assert.h>
#include <stdlib.h>

#define UNUSED(x) (void)(x)

void
_parse_id(const char *id, eripc_bus_t *bus, char *sender,
                int *serial)
{
    int i;
    char buf[20], *p;

    /* get bus type */
    for (i = 0, p = (char*) id; *p != ','; ++p, ++i) {
        assert(*p != '\0');
        assert(i < 20);
        buf[i] = *p;
    }
    buf[i] = '\0';
    *bus = atoi(buf);
    /* get sender */
    ++p;
    for (i = 0; *p != ','; ++p, ++i) {
        assert(*p != '\0');
        assert(i <= MAX_SVC_LEN);
        sender[i] = *p;
    }
    sender[i] = '\0';
    /* get serial */
    ++p;
    for (i = 0; *p != '\0'; ++p, ++i) {
        assert(i < 20);
        buf[i] = *p;
    }
    buf[i] = '\0';
    *serial = atoi(buf);
}

void
_make_id(eripc_bus_t bus, const char *sender, int serial, char *id)
{
    snprintf(id, MAX_MSGID_LEN, "%d,%s,%d", bus, sender, serial);
}

static eripc_error_t _append_args(DBusMessage *msg, int type,
                                        va_list var_args)
{
    eripc_error_t rc = ERIPC_ERROR_SUCCESS;

    while (type != ERIPC_TYPE_INVALID && rc == ERIPC_ERROR_SUCCESS) {
        dbus_bool_t ret;
        char *s;
        const char *empty_str = "";
        int i;
        unsigned int u;
        double d;

        switch (type) {
        case ERIPC_TYPE_BOOL:
            i = va_arg(var_args, int);
            ret = dbus_message_append_args(msg, DBUS_TYPE_BOOLEAN,
                                     &i, DBUS_TYPE_INVALID);
            if (!ret) rc = ERIPC_ERROR;
            break;
        case ERIPC_TYPE_BYTE:
            i = va_arg(var_args, int);
            ret = dbus_message_append_args(msg, DBUS_TYPE_BYTE,
                                     &i, DBUS_TYPE_INVALID);
            if (!ret) rc = ERIPC_ERROR;
            break;
        case ERIPC_TYPE_INT:
            i = va_arg(var_args, int);
            ret = dbus_message_append_args(msg, DBUS_TYPE_INT32,
                                     &i, DBUS_TYPE_INVALID);
            if (!ret) rc = ERIPC_ERROR;
            break;
        case ERIPC_TYPE_UINT:
            u = va_arg(var_args, unsigned int);
            ret = dbus_message_append_args(msg, DBUS_TYPE_UINT32,
                                     &u, DBUS_TYPE_INVALID);
            if (!ret) rc = ERIPC_ERROR;
            break;
        case ERIPC_TYPE_DOUBLE:
            d = va_arg(var_args, double);
            ret = dbus_message_append_args(msg, DBUS_TYPE_DOUBLE,
                                     &d, DBUS_TYPE_INVALID);
            if (!ret) rc = ERIPC_ERROR;
            break;
        case ERIPC_TYPE_STRING:
            s = va_arg(var_args, char *);
            if (s == NULL) {
                ret = dbus_message_append_args(msg,
                    DBUS_TYPE_STRING, &empty_str,
                    DBUS_TYPE_INVALID);
            } else {
                ret = dbus_message_append_args(msg,
                    DBUS_TYPE_STRING, &s, DBUS_TYPE_INVALID);
            }
            if (!ret) rc = ERIPC_ERROR;
            break;
        case ERIPC_TYPE_DATA:
            i = va_arg(var_args, int); /* length of the data */
            s = va_arg(var_args, char *);
            ret = dbus_message_append_args(msg,
                      DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
                      &s, i, DBUS_TYPE_INVALID);
            if (!ret) rc = ERIPC_ERROR;
            break;
        default:
            ULOG_ERR_F("unknown type %d", type);
            rc = ERIPC_ERROR_INVALID;
            break;       
        }
        type = va_arg(var_args, int);
    }
    return rc;
}


eripc_error_t eripc_get_timeout (eripc_context_t *context, int *timeout)
{
    if(context == NULL) return ERIPC_ERROR_INVALID;
    *timeout = context->timeout_ms;
    return ERIPC_ERROR_SUCCESS;
}


void *eripc_get_system_connection (eripc_context_t *context)
{
    return (void *) context->sys_conn;
}

void *eripc_get_session_connection (eripc_context_t *context)
{
    return (void *) context->conn;
}


eripc_error_t eripc_set_timeout(eripc_context_t *context, int timeout)
{
    if(context == NULL) return ERIPC_ERROR_INVALID;
    context->timeout_ms = timeout;
    return ERIPC_ERROR_SUCCESS;
}



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

    assert(cb_data->message_id == dbus_message_get_reply_serial(msg));
    assert(cb_data->bus_type == dbus_type);
    assert(cb_data->data == osso);

    /* create a dummy reply message for later use (workaround for
     * D-Bus library API) */
    if (osso->reply_dummy == NULL) {
        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) {
        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;
        }
    }

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

    msgtype = dbus_message_get_type(msg);
    info.service = dbus_message_get_sender(msg);
    info.path = dbus_message_get_path(msg);
    info.interface = dbus_message_get_interface(msg);
    if (msgtype == DBUS_MESSAGE_TYPE_ERROR) {
        info.name = dbus_message_get_error_name(msg);
    } else {
        info.name = dbus_message_get_member(msg);
    }
    info.bus_type = dbus_type;
    _make_id(dbus_type, dbus_message_get_sender(msg),
                   dbus_message_get_serial(msg), id_buf);
    info.message_id = id_buf;

    info.event_type = eripc_convert_msgtype(msgtype);

    if (dbus_message_iter_init(msg, &iter)) {
        info.args = _get_args(&iter);
        if (info.args != NULL && msgtype == DBUS_MESSAGE_TYPE_ERROR
            && info.args[0].type == ERIPC_TYPE_STRING) {
                info.error = info.args[0].value.s;
        }
    }

    cb = cb_data->user_cb;
    assert(cb != NULL);

    (*cb)((eripc_context_t*)osso, &info, cb_data->user_data);

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


static eripc_error_t _send_signal_helper(eripc_context_t *context,
                                         eripc_bus_t bus_type,
                                         const char *signal_path,
                                         const char *signal_interface,
                                         const char *signal_name,
                                         eripc_data_t arg_type, va_list va_args)
{
    DBusConnection *conn;
    DBusMessage *msg;

    if (context == NULL || signal_name == NULL) {
        return ERIPC_ERROR_INVALID;
    }
    
    if (bus_type != ERIPC_BUS_SESSION && bus_type != ERIPC_BUS_SYSTEM) {
        ULOG_ERR_F("bus_type must be either ERIPC_BUS_SESSION "
                   "or ERIPC_BUS_SYSTEM");
        return ERIPC_ERROR_INVALID;
    }

    if (bus_type == ERIPC_BUS_SESSION) {
        conn = context->conn;
    } else {
        conn = context->sys_conn;
    }

    if (!dbus_connection_get_is_connected(conn)) {
        ULOG_ERR_F("connection %p is not open", conn);
        return ERIPC_ERROR_INVALID;
    }

    msg = dbus_message_new_signal(signal_path, signal_interface, signal_name);
    if (msg == NULL) {
        ULOG_ERR_F("dbus_message_new_signal failed");
        return ERIPC_ERROR_OOM;
    }

    if (arg_type != ERIPC_TYPE_INVALID) {
        eripc_error_t rc;
        rc = _append_args(msg, arg_type, va_args);
        if (rc != ERIPC_ERROR_SUCCESS) {
            ULOG_ERR_F("dbus_message_append_args failed");
            dbus_message_unref(msg);
            return ERIPC_ERROR;
        }
    }
    
    if (!dbus_connection_send(conn, msg, NULL)) {
        ULOG_ERR_F("dbus_connection_send failed");
        dbus_message_unref(msg);
        return ERIPC_ERROR_OOM;
    }
    dbus_message_unref(msg);

    return ERIPC_ERROR_SUCCESS;
}


eripc_error_t eripc_send_signal_varargs(eripc_context_t *context,
                                        eripc_bus_t bus_type,
                                        const char *signal_path,
                                        const char *signal_interface,
                                        const char *signal_name,
                                        eripc_data_t arg_type, ...)
{
    va_list va_args;
    eripc_error_t rc;

    va_start(va_args, arg_type);
    rc = _send_signal_helper(context, bus_type,
                             signal_path, signal_interface, signal_name,
                             arg_type, va_args);
    va_end(va_args);
    return rc;
}


eripc_error_t eripc_send_signal(eripc_context_t *context,
                                eripc_bus_t bus_type,
                                const char *signal_name,
                                const char *argument)
{
    eripc_error_t rc;
    
    if (argument == NULL)
    {        
        rc = eripc_send_signal_varargs(context, bus_type, 
                                      context->object_path, context->interface, signal_name,
                                      ERIPC_TYPE_INVALID);
    }
    else 
    {
        rc = eripc_send_signal_varargs(context, bus_type, 
                                      context->object_path, context->interface, signal_name,
                                      ERIPC_TYPE_STRING, argument,
                                      ERIPC_TYPE_INVALID);
    }
    return rc;
}

static eripc_error_t _send_helper(eripc_context_t *context,
                                  eripc_handler_t *reply_handler,
                                  const void *user_data,
                                  eripc_bus_t bus_type,
                                  const char *destination,
                                  const char *message_name,
                                  eripc_data_t arg_type, va_list va_args)
{
    char service[MAX_SVC_LEN + 1], path[MAX_OP_LEN + 1],
         interface[MAX_IF_LEN + 1];
    _osso_callback_data_t *cb_data;
    DBusMessage *msg;
    DBusConnection *conn;
    unsigned int msg_serial = 0;
    int handler_id;

    if (context == NULL) {
        ULOG_ERR_F("context error");
        return ERIPC_ERROR_INVALID;
    }

    if (destination == NULL || message_name == NULL || destination[0] == '\0') {
        ULOG_ERR_F("destination and message_name must be provided");
        return ERIPC_ERROR_INVALID;
    }

    if (bus_type != ERIPC_BUS_SESSION && bus_type != ERIPC_BUS_SYSTEM) {
        ULOG_ERR_F("bus_type must be either ERIPC_BUS_SESSION "
                   "or ERIPC_BUS_SYSTEM");
        return ERIPC_ERROR_INVALID;
    }

    if (reply_handler == NULL && user_data != NULL) {
        ULOG_ERR_F("reply_handler == NULL: ignoring user_data "
                    "argument");
        fprintf(stderr, "Warning: reply_handler is NULL: ignoring"
                " user_data argument");
    }

    if (bus_type == ERIPC_BUS_SESSION) {
        conn = context->conn;
    } else {
        conn = context->sys_conn;
    }

    if (!dbus_connection_get_is_connected(conn)) {
        ULOG_ERR_F("connection %p is not open", conn);
        return ERIPC_ERROR_INVALID;
    }

    make_default_service(destination, service);
    make_default_object_path(destination, path);
    make_default_interface(destination, interface);

    msg = dbus_message_new_method_call(service, path, interface,
                                       message_name);
    if (msg == NULL) {
        ULOG_ERR_F("dbus_message_new_method_call failed");
        goto _send_oom;
    }

    if (arg_type != ERIPC_TYPE_INVALID) {
        eripc_error_t rc;
        rc = _append_args(msg, arg_type, va_args);
        if (rc != ERIPC_ERROR_SUCCESS) {
            ULOG_ERR_F("invalid type");
            dbus_message_unref(msg);
            return rc;
        }
    }

    if (reply_handler == NULL) {
        dbus_message_set_no_reply(msg, TRUE);
    }

    if (!dbus_connection_send(conn, msg, &msg_serial)) {
        ULOG_ERR_F("dbus_connection_send failed");
        dbus_message_unref(msg);
        goto _send_oom;
    }
    dbus_message_unref(msg);

    if (reply_handler == NULL) {
        /* the caller does not want to handle the reply, so
         * let's not put any handler for it */
        return ERIPC_ERROR_SUCCESS;
    }

    cb_data = calloc(1, sizeof(_osso_callback_data_t));
    if (cb_data == NULL) {
        ULOG_ERR_F("calloc failed");
        goto _send_oom;
    }
    /* this is used to recognise the reply for this message */
    cb_data->message_id = (long)msg_serial;

    cb_data->user_cb = reply_handler;
    cb_data->user_data = (void*) user_data;
    cb_data->match_rule = NULL;
    cb_data->event_type = 0;
    cb_data->bus_type = bus_type;
    cb_data->data = context;

    cb_data->service = NULL;
    cb_data->path = ERIPC_PATH_MATCH_ALL;
    cb_data->interface = NULL;
    cb_data->name = ERIPC_MEMBER_MATCH_ALL;

    /* (eripc_filter removes the handler, otherwise this would need
     * to be saved somewhere) */
    handler_id = context->next_handler_id++;

    if (_eripc_set_handler((_eripc_context_t*)context,
                           eripc_reply_handler, cb_data, handler_id,
                           FALSE)) {
        return ERIPC_ERROR_SUCCESS;
    } else {
        ULOG_ERR_F("_set_handler failed");
        free(cb_data);
        return ERIPC_ERROR;
    }

_send_oom:

    return ERIPC_ERROR_OOM;
}


static
eripc_error_t _send_sync_helper(eripc_context_t *context,
                                eripc_event_info_t **reply,
                                eripc_bus_t bus_type,
                                const char *destination,
                                const char *message_name,
                                eripc_data_t arg_type, va_list va_args)
{
    char service[MAX_SVC_LEN + 1], path[MAX_OP_LEN + 1],
         interface[MAX_IF_LEN + 1];
    DBusMessage *msg;
    DBusMessage *reply_msg;
    DBusConnection *conn;
    DBusMessageIter iter;
    DBusError error;
    
    char id_buf[MAX_MSGID_LEN + 1];

    if (reply != NULL && *reply != NULL) {
         *reply = NULL;
   }

    if (context == NULL) {
        ULOG_ERR_F("context error");
        return ERIPC_ERROR_INVALID;
    }

    if (destination == NULL || message_name == NULL || destination[0] == '\0') {
        ULOG_ERR_F("destination and message_name must be provided");
        return ERIPC_ERROR_INVALID;
    }

    if (bus_type != ERIPC_BUS_SESSION && bus_type != ERIPC_BUS_SYSTEM) {
        ULOG_ERR_F("bus_type must be either ERIPC_BUS_SESSION "
                   "or ERIPC_BUS_SYSTEM");
        return ERIPC_ERROR_INVALID;
    }

    if (bus_type == ERIPC_BUS_SESSION) {
        conn = context->conn;
    } else {
        conn = context->sys_conn;
    }

    if (!dbus_connection_get_is_connected(conn)) {
        ULOG_ERR_F("connection %p is not open", conn);
        return ERIPC_ERROR_INVALID;
    }

    make_default_service(destination, service);
    make_default_object_path(destination, path);
    make_default_interface(destination, interface);

    msg = dbus_message_new_method_call(service, path, interface,
                                       message_name);
    if (msg == NULL) {
        ULOG_ERR_F("dbus_message_new_method_call failed");
        return ERIPC_ERROR_OOM;
    }

    if (arg_type != ERIPC_TYPE_INVALID) {
        eripc_error_t rc;
        rc = _append_args(msg, arg_type, va_args);
        if (rc != ERIPC_ERROR_SUCCESS) {
                ULOG_ERR_F("invalid type");
                dbus_message_unref(msg);
                return rc;
        }
    }

    dbus_error_init(&error);
    
    reply_msg = dbus_connection_send_with_reply_and_block(conn, msg, context->timeout_ms, &error);
    dbus_message_unref(msg);

    if (!reply_msg) {
        ULOG_ERR_F("dbus_connection_send_with_reply_and_block failed: %s", error.message);
        dbus_error_free(&error);
        return ERIPC_ERROR_TIMEOUT;
    }
 
    if (reply != NULL) 
    {
        /* Allocate reply info structure */
        eripc_event_info_t *reply_info;
        reply_info = calloc(1, sizeof(eripc_event_info_t));
        if (reply_info == NULL) {
            ULOG_ERR_F("calloc failed");
            dbus_message_unref(reply_msg);
            return ERIPC_ERROR_OOM;
        }

        reply_info->service = dbus_message_get_sender(reply_msg);
        reply_info->path = path;
        reply_info->interface = interface;
        reply_info->name = dbus_message_get_member(reply_msg);
        reply_info->bus_type = bus_type;
        reply_info->event_type = 0;
        
        if (dbus_message_get_type(reply_msg) == DBUS_MESSAGE_TYPE_METHOD_RETURN) {
            _make_id(bus_type, dbus_message_get_sender(reply_msg),
                           dbus_message_get_serial(reply_msg), id_buf);
            reply_info->message_id = id_buf;
        }

        if (dbus_message_get_type(reply_msg) == DBUS_MESSAGE_TYPE_ERROR) {
            reply_info->error = dbus_message_get_error_name(reply_msg);
        }
        
        if (dbus_message_iter_init(reply_msg, &iter)) {
            reply_info->args = _get_args(&iter);
        }
        
        reply_info->dbus_message = (char*) reply_msg;
        
        /* Return the pointer to the reply info structure */
        *reply = reply_info;
    }
    else {
        /* No reply requested by caller so unref immediately */
        dbus_message_unref(reply_msg);
    }
    
    return ERIPC_ERROR_SUCCESS;
}


eripc_error_t eripc_send_varargs(eripc_context_t *context,
                                 eripc_handler_t *reply_handler,
                                 const void *user_data,
                                 eripc_bus_t bus_type,
                                 const char *destination,
                                 const char *message_name,
                                 eripc_data_t arg_type, ...)
{
    va_list va_args;
    eripc_error_t rc;

    va_start(va_args, arg_type);
    rc = _send_helper(context, reply_handler, user_data,
                      bus_type, destination, message_name,
                      arg_type, va_args);
    va_end(va_args);
    return rc;
}


eripc_error_t eripc_send_varargs_and_wait(eripc_context_t *context,
                                          eripc_event_info_t **reply,
                                          eripc_bus_t bus_type,
                                          const char *destination,
                                          const char *message_name,
                                          eripc_data_t arg_type, ...)
{
    va_list va_args;
    eripc_error_t rc;
    
    va_start(va_args, arg_type);
    rc = _send_sync_helper(context, reply, bus_type, destination,
                           message_name, arg_type, va_args);
    va_end(va_args);
    return rc;   
}

eripc_error_t eripc_send_string_and_wait(eripc_context_t *context,
                                         eripc_event_info_t **reply,
                                         eripc_bus_t bus_type,
                                         const char *destination,
                                         const char *message_name,
                                         const char *string_to_send)


{
    eripc_error_t rc;
    rc = eripc_send_varargs_and_wait(context, reply,
                                     bus_type, destination, message_name,
                                     ERIPC_TYPE_STRING, string_to_send,
                                     ERIPC_TYPE_INVALID);
    return rc;
}

eripc_error_t eripc_send_int_and_wait(eripc_context_t *context,
                                      eripc_event_info_t **reply,
                                      eripc_bus_t bus_type,
                                      const char *destination,
                                      const char *message_name,
                                      int value_to_send)


{
    eripc_error_t rc;
    rc = eripc_send_varargs_and_wait(context, reply,
                                     bus_type, destination, message_name,
                                     ERIPC_TYPE_INT, value_to_send,
                                     ERIPC_TYPE_INVALID);
    return rc;
}

eripc_error_t eripc_send_bool_and_wait(eripc_context_t *context,
                                       eripc_event_info_t **reply,
                                       eripc_bus_t bus_type,
                                       const char *destination,
                                       const char *message_name,
                                       gboolean value_to_send)


{
    eripc_error_t rc;
    rc = eripc_send_varargs_and_wait(context, reply,
                                     bus_type, destination, message_name,
                                     ERIPC_TYPE_BOOL, value_to_send,
                                     ERIPC_TYPE_INVALID);
    return rc;
}

eripc_error_t eripc_send_string(eripc_context_t *context,
                                eripc_handler_t *reply_handler,
                                const void *user_data,
                                eripc_bus_t bus_type,
                                const char *destination,
                                const char *message_name,
                                const char *string_to_send)
{
    eripc_error_t rc;
    rc = eripc_send_varargs(context, reply_handler, user_data,
                            bus_type, destination, message_name,
                            ERIPC_TYPE_STRING, string_to_send,
                            ERIPC_TYPE_INVALID);
    return rc;
}

eripc_error_t eripc_send_int(eripc_context_t *context,
                             eripc_handler_t *reply_handler,
                             const void *user_data,
                             eripc_bus_t bus_type,
                             const char *destination,
                             const char *message_name,
                             int value_to_send)
{
    eripc_error_t rc;
    rc = eripc_send_varargs(context, reply_handler, user_data,
                            bus_type, destination, message_name,
                            ERIPC_TYPE_INT, value_to_send,
                            ERIPC_TYPE_INVALID);
    return rc;
}

eripc_error_t eripc_send_bool(eripc_context_t *context,
                              eripc_handler_t *reply_handler,
                              const void *user_data,
                              eripc_bus_t bus_type,
                              const char *destination,
                              const char *message_name,
                              gboolean value_to_send)
{
    eripc_error_t rc;
    rc = eripc_send_varargs(context, reply_handler, user_data,
                            bus_type, destination, message_name,
                            ERIPC_TYPE_BOOL, value_to_send,
                            ERIPC_TYPE_INVALID);
    return rc;
}

eripc_error_t eripc_event_info_free(eripc_context_t *context,
                                    eripc_event_info_t *info)
{
    UNUSED(context);
    if (info != NULL) {
        if (info->args != NULL) {
            free((char*)info->args);
        }
    
        if (info->dbus_message != NULL) {
            dbus_message_unref((DBusMessage *)info->dbus_message);
        }
        
        free(info);        
    }
    
    return ERIPC_ERROR_SUCCESS;
}

static
eripc_error_t _reply_helper(eripc_context_t *context,
                            const char *message_id,
                            eripc_data_t arg_type, va_list va_args)
{
    DBusConnection *conn;
    DBusMessage *reply;
    char sender[MAX_SVC_LEN + 1];
    int serial;
    eripc_bus_t bus_type;

    if (context == NULL || message_id == NULL) {
        return ERIPC_ERROR_INVALID;
    }
    if (context->reply_dummy == NULL) {
        /* OOM has happened earlier in the handler, or
         * the context is invalid */
        ULOG_ERR_F("reply_dummy has not been created");
        return ERIPC_ERROR;
    }

    _parse_id(message_id, &bus_type, sender, &serial);
    assert(bus_type == ERIPC_BUS_SYSTEM || bus_type == ERIPC_BUS_SESSION);

    if (bus_type == ERIPC_BUS_SYSTEM) {
        conn = context->sys_conn;
    } else {
        conn = context->conn;
    }
    if (!dbus_connection_get_is_connected(conn)) {
        ULOG_ERR_F("connection %p is not open", conn);
        return ERIPC_ERROR_INVALID;
    }

    /* make a copy of the reply_dummy and modify the copy */
    reply = dbus_message_copy(context->reply_dummy);
    if (reply == NULL) {
        ULOG_ERR_F("dbus_message_copy failed");
        return ERIPC_ERROR_OOM;
    }
    if (!dbus_message_set_destination(reply, sender)) {
        ULOG_ERR_F("dbus_message_set_destination failed");
        goto unref_and_exit;
    }
    if (!dbus_message_set_reply_serial(reply, serial)) {
        ULOG_ERR_F("dbus_message_set_reply_serial failed");
        goto unref_and_exit;
    }

    if (arg_type != ERIPC_TYPE_INVALID) {
        eripc_error_t rc;
        rc = _append_args(reply, arg_type, va_args);
        if (rc != ERIPC_ERROR_SUCCESS) {
            ULOG_ERR_F("dbus_message_append_args failed");
            goto unref_and_exit;
        }
    }
    
    if (!dbus_connection_send(conn, reply, NULL)) {
        ULOG_ERR_F("dbus_connection_send failed");
        goto unref_and_exit;
    }
    dbus_message_unref(reply);
    return ERIPC_ERROR_SUCCESS;

unref_and_exit:
    dbus_message_unref(reply);
    return ERIPC_ERROR_OOM;
}

eripc_error_t eripc_reply_varargs(eripc_context_t *context,
                                  const char *message_id,
                                  eripc_data_t arg_type, ...)
{
    va_list va_args;
    eripc_error_t rc;

    va_start(va_args, arg_type);
    rc = _reply_helper(context, message_id,
                            arg_type, va_args);
    va_end(va_args);
    return rc;
}

eripc_error_t eripc_reply_string(eripc_context_t *context,
                                 const char *message_id,
                                 const char *string)
{
    eripc_error_t rc;
    rc = eripc_reply_varargs(context, message_id,
                             ERIPC_TYPE_STRING, string,
                             ERIPC_TYPE_INVALID);
    return rc;
}

eripc_error_t eripc_reply_int(eripc_context_t *context,
                              const char *message_id,
                              int value)
{
    eripc_error_t rc;
    rc = eripc_reply_varargs(context, message_id,
                             ERIPC_TYPE_INT, value,
                             ERIPC_TYPE_INVALID);
    return rc;
}

eripc_error_t eripc_reply_bool(eripc_context_t *context,
                               const char *message_id,
                               gboolean value)
{
    eripc_error_t rc;
    rc = eripc_reply_varargs(context, message_id,
                             ERIPC_TYPE_BOOL, value,
                             ERIPC_TYPE_INVALID);
    return rc;
}

eripc_error_t eripc_reply_error(eripc_context_t *context,
                                const char *message_id,
                                const char *name,
                                const char *message)
{
    DBusConnection *conn;
    DBusMessage *reply;
    dbus_bool_t ret;
    char sender[MAX_SVC_LEN + 1], error_name[MAX_ERROR_LEN + 1];
    int serial;
    eripc_bus_t bus_type;

    if (context == NULL || name == NULL || message_id == NULL) {
        return ERIPC_ERROR_INVALID;
    }
    if (context->error_dummy == NULL) {
        /* OOM has happened earlier in the handler, or
         * the context is invalid */
        ULOG_ERR_F("error_dummy has not been created");
        return ERIPC_ERROR;
    }

    _parse_id(message_id, &bus_type, sender, &serial);
    assert(bus_type == ERIPC_BUS_SYSTEM || bus_type == ERIPC_BUS_SESSION);

    if (bus_type == ERIPC_BUS_SYSTEM) {
        conn = context->sys_conn;
    } else {
        conn = context->conn;
    }
    if (!dbus_connection_get_is_connected(conn)) {
        ULOG_ERR_F("connection %p is not open", conn);
        return ERIPC_ERROR_INVALID;
    }

    make_default_error_name(context->service, name, error_name);

    /* make a copy of the error_dummy and modify the copy */
    reply = dbus_message_copy(context->error_dummy);
    if (reply == NULL) {
        ULOG_ERR_F("dbus_message_copy failed");
        return ERIPC_ERROR_OOM;
    }
    if (!dbus_message_set_destination(reply, sender)) {
        ULOG_ERR_F("dbus_message_set_destination failed");
        goto unref_and_exit;
    }
    if (!dbus_message_set_reply_serial(reply, serial)) {
        ULOG_ERR_F("dbus_message_set_reply_serial failed");
        goto unref_and_exit;
    }
    if (!dbus_message_set_error_name(reply, error_name)) {
        ULOG_ERR_F("dbus_message_set_error_name failed");
        goto unref_and_exit;
    }

    if (message != NULL) {
        ret = dbus_message_append_args(reply, DBUS_TYPE_STRING,
                                       &message,
                                       DBUS_TYPE_INVALID);
        if (!ret) {
            ULOG_ERR_F("dbus_message_append_args failed");
            goto unref_and_exit;
        }
    }

    if (!dbus_connection_send(conn, reply, NULL)) {
        ULOG_ERR_F("dbus_connection_send failed");
        goto unref_and_exit;
    }
    dbus_message_unref(reply);
    return ERIPC_ERROR_SUCCESS;

unref_and_exit:
    dbus_message_unref(reply);
    return ERIPC_ERROR_OOM;
}