mntd_dbus_manager.c

/***************************************************************************
 * CVSID: $Id: mntd_dbus_manager.c,v 1.35 2004/12/19 00:13:08 stefanb Exp $
 *
 * mntd_dbus_manager.c : D-BUS manager for MNT daemon
 *
 * Copyright (C) 2004 Stefan Bambach, <sbambach@gmx.net>
 *
 * Licensed under the GNU General Public License 2.0
 *
 * This program 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.
 *
 * This program 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 **************************************************************************/
 
#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dbus/dbus.h>
#include <dbus/dbus-glib.h>
#include <dbus/dbus-glib-lowlevel.h>

#include <libmnt/libmnt.h>   /* for common defines etc. */

#include "mntd_dbus_error.h"
#include "mntd_dbus_manager.h"
#include "mntd_volume_manager.h"
#include "mntd_volume.h"
#include "errmanager.h"
#include "main.h"
#include "dbug_mem.h"


// function prototypes
int cb_append_udi(void *data, void *userdata);


/***************************************************************************
 * MANAGER
 **************************************************************************/

DBusConnection* dbus_connection = NULL;
                                                                                                                           

int 
mntd_dbus_init(void *user_data)
{
    DBusError error;
    int res = 0;

    dbus_connection_set_change_sigpipe(TRUE);
    
    dbus_error_init(&error);
    dbus_connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
    if (dbus_connection==NULL) {
        MSG_INF("dbus_bus_get(): '%s'", error.message);
        goto error;
    }
    
    // acquire server
    dbus_bus_acquire_service(dbus_connection, DBUS_SERVICE_MNT, 0, &error);
    if (dbus_error_is_set(&error)) {
        MSG_INF("dbus_bus_acquire_service(): %s: %s", error.name, error.message);
        goto error;
    }
    
    // add filter functions to connection handler
    dbus_connection_add_filter(dbus_connection, mntd_dbus_manager_filter_function, 
                                        user_data, NULL);

    // register for Block signals
    dbus_bus_add_match(dbus_connection,
        "type='signal',"
        "interface='" DBUS_INTERFACE_MNT_BLOCK "',"
        "path='" DBUS_PATH_MNT_BLOCK "'",
        &error);
    if (dbus_error_is_set(&error)) {
        MSG_INF("Couldn't register Block signal handler: %s: %s", error.name, error.message);
        goto error;
    }
    
    // register for Disc signals
    dbus_bus_add_match(dbus_connection,
        "type='signal',"
        "interface='" DBUS_INTERFACE_MNT_DISC "',"
        "path='" DBUS_PATH_MNT_DISC "'",
        &error);
    if (dbus_error_is_set(&error)) {
        MSG_INF("Couldn't register Disc signal handler: %s: %s", error.name, error.message);
        goto error;
    }
    
    // register for udev signals
    dbus_bus_add_match(dbus_connection,
        "type='signal',"
        "interface='" DBUS_INTERFACE_UDEV "',"
        "path='" DBUS_PATH_UDEV "'",
        &error);
    if (dbus_error_is_set(&error)) {
        MSG_INF("Couldn't register udev signal handler: %s: %s", error.name, error.message);
        goto error;
    }
    
    // register for Tty signals
    dbus_bus_add_match(dbus_connection,
        "type='signal',"
        "interface='" DBUS_INTERFACE_MNT_TTY "',"
        "path='" DBUS_PATH_MNT_TTY "'",
        &error);
    if (dbus_error_is_set(&error)) {
        MSG_INF("Couldn't register Tty signal handler: %s: %s", error.name, error.message);
        goto error;
    }

    // disable _exit() on disconnect signal
    dbus_connection_set_exit_on_disconnect(dbus_connection, FALSE);
    
    // initialize dbus mainloop integration
    dbus_connection_setup_with_g_main(dbus_connection, NULL);
    
    goto cleanup;
    
error:
    res = -1;
    mntd_dbus_quit();
    
cleanup:
    if (dbus_error_is_set(&error)) {
        dbus_error_free(&error);
    }

    return res;
}


int 
mntd_dbus_quit(void)
{
    if (dbus_connection != NULL) {
        // seg fault, if disconnect called ! So do not call it :-)
        //dbus_connection_disconnect(dbus_connection);
        //dbus_connection = NULL;
    }
    
    return 0;
}


void mntd_dbus_raise_no_such_device(DBusConnection* connection,
                                            DBusMessage* in_reply_to,
                                            const char* udi)
{
    char buf[512];
    DBusMessage *reply;
    
    snprintf(buf, 511, "No device with id %s", udi);
    //MSG_ERR(buf);
    
    reply = dbus_message_new_error(in_reply_to, 
                                            DBUS_ERROR_NO_SUCH_DEVICE, 
                                            buf);
    if (reply==NULL) {
        MSG_EMERG("Out of memory");
        return;
    }
    if (!dbus_connection_send(connection, reply, NULL)) {
        MSG_EMERG("Out of memory");
        return;
    }
    dbus_message_unref(reply);
}


void mntd_dbus_raise_syntax(DBusConnection* connection,
                                            DBusMessage* in_reply_to,
                                            const char* method_name)
{
    char buf[512];
    DBusMessage *reply;
    
    snprintf(buf, 511, 
                "There is a syntax error in the invocation of "
                "the method %s", method_name);
    //MSG_ERR(buf);
    
    reply = dbus_message_new_error(in_reply_to, 
                                            DBUS_ERROR_SYNTAX, 
                                            buf);
    if (reply==NULL) {
        MSG_EMERG("Out of memory");
        return;
    }
    if (!dbus_connection_send(connection, reply, NULL)) {
        MSG_EMERG("Out of memory");
        return;
    }
    dbus_message_unref(reply);
}


void mntd_dbus_raise_no_mntpnt(DBusConnection* connection,
                                            DBusMessage* in_reply_to,
                                            const char* udi)
{
    char buf[512];
    DBusMessage *reply;
    
    snprintf(buf, 511, 
                "No mount point for '%s' found.", udi);
    //MSG_ERR(buf);
    
    reply = dbus_message_new_error(in_reply_to, 
                                            DBUS_ERROR_NO_MNTPNT, 
                                            buf);
    if (reply==NULL) {
        MSG_EMERG("Out of memory");
        return;
    }
    if (!dbus_connection_send(connection, reply, NULL)) {
        MSG_EMERG("Out of memory");
        return;
    }
    dbus_message_unref(reply);
}


DBusHandlerResult mntd_dbus_manager_filter_function(DBusConnection* connection,
                                         DBusMessage* message,
                                         void* user_data)
{
    PMNTDDATA pdata = (PMNTDDATA) user_data;
    g_assert(pdata!=NULL);
    
    //
    // CHECK FOR MANAGER SIGNALS
    //
    if (dbus_message_is_method_call(message,
                                            DBUS_INTERFACE_MNT_MANAGER,
                                            "GetAllVolumes")) {
        MSG_DEBUG("biz.bambach.Mnt.Manager::GetAllVolumes() called");
        g_assert(pdata->vols!=NULL);
        return mntd_dbus_manager_get_all_volumes(pdata->vols, connection, message);
                                                
    } else if (dbus_message_is_method_call(message,
                                            DBUS_INTERFACE_MNT_MANAGER,
                                            "GetMntPnt")) {
        MSG_DEBUG("biz.bambach.Mnt.Manager::GetMntPnt() called");
        g_assert(pdata->vols!=NULL);
        return mntd_dbus_manager_get_mntpnt(pdata->vols, connection, message);
                                                
    } else if (dbus_message_is_method_call(message,
                                            DBUS_INTERFACE_MNT_MANAGER,
                                            "Remount")) {
        MSG_DEBUG("biz.bambach.Mnt.Manager::Remount() called");
        g_assert(pdata->vols!=NULL);
        return mntd_dbus_manager_remount(pdata->vols, connection, message);
                                                
    //
    // CHECK FOR DISCONNECT SIGNAL
    //
    } else if (dbus_message_is_signal(message, 
                                            DBUS_INTERFACE_ORG_FREEDESKTOP_LOCAL, 
                                            "Disconnected")) {
        const char *path = NULL;
        path = dbus_message_get_path(message);
        if (path != NULL) {
            if (strcmp(DBUS_PATH_ORG_FREEDESKTOP_LOCAL, path) == 0) {
                if (pdata->disconnect != NULL) {
                    pdata->disconnect(pdata);
                }
            }
        }
        // unref connection object
        dbus_connection_unref(connection);
        // result is handled -> return
        return DBUS_HANDLER_RESULT_HANDLED;
        
    //
    // CHECK FOR BLOCK SIGNALS
    //
    } else if (dbus_message_is_signal(message, 
                                        DBUS_INTERFACE_MNT_BLOCK, 
                                        "Add")) {
        char *devname = NULL;
        DBusError error;
        dbus_error_init(&error);
        if (dbus_message_get_args(message, &error, 
                                            DBUS_TYPE_STRING, &devname,
                                            DBUS_TYPE_INVALID)) {
            MSG_DEBUG("Add('%s') called.", devname);
            g_assert(pdata->vols!=NULL);
            pdata->vols->add_volume(pdata->vols, devname);
            dbus_free(devname);
        }
        
    } else if (dbus_message_is_signal(message, 
                                        DBUS_INTERFACE_MNT_BLOCK, 
                                        "Remove")) {
        char *devname = NULL;
        DBusError error;
        dbus_error_init(&error);
        if (dbus_message_get_args(message, &error, 
                                            DBUS_TYPE_STRING, &devname,
                                            DBUS_TYPE_INVALID)) {
            
            MSG_DEBUG("Remove('%s') called.", devname);
            g_assert(pdata->vols!=NULL);
            pdata->vols->remove_volume(pdata->vols, devname);
            dbus_free(devname);
        }

    //
    // CHECK FOR DISC SIGNALS
    //
    } else if (dbus_message_is_signal(message, 
                                        DBUS_INTERFACE_MNT_DISC, 
                                        "Add")) {
        char *devname = NULL;
        DBusError error;
        dbus_error_init(&error);
        if (dbus_message_get_args(message, &error, 
                                            DBUS_TYPE_STRING, &devname,
                                            DBUS_TYPE_INVALID)) {
            MSG_DEBUG("Add('%s') called.", devname);
            g_assert(pdata->vols!=NULL);
            pdata->vols->add_volume(pdata->vols, devname);
            dbus_free(devname);
        }
        
    } else if (dbus_message_is_signal(message, 
                                        DBUS_INTERFACE_MNT_DISC, 
                                        "Remove")) {
        char *devname = NULL;
        DBusError error;
        dbus_error_init(&error);
        if (dbus_message_get_args(message, &error, 
                                            DBUS_TYPE_STRING, &devname,
                                            DBUS_TYPE_INVALID)) {
            
            MSG_DEBUG("Remove('%s') called.", devname);
            g_assert(pdata->vols!=NULL);
            pdata->vols->remove_volume(pdata->vols, devname);
            dbus_free(devname);
        }

    //
    // CHECK FOR TTY SIGNALS
    //
    } else if (dbus_message_is_signal(message, 
                                        DBUS_INTERFACE_MNT_TTY, 
                                        "Add")) {
        char *devname = NULL;
        DBusError error;
        dbus_error_init(&error);
        if (dbus_message_get_args(message, &error, 
                                            DBUS_TYPE_STRING, &devname,
                                            DBUS_TYPE_INVALID)) {
            MSG_DEBUG("Add('%s') called.", devname);
            dbus_free(devname);
        }
        
    } else if (dbus_message_is_signal(message, 
                                        DBUS_INTERFACE_MNT_TTY, 
                                        "Remove")) {
        char *devname = NULL;
        DBusError error;
        dbus_error_init(&error);
        if (dbus_message_get_args(message, &error, 
                                            DBUS_TYPE_STRING, &devname,
                                            DBUS_TYPE_INVALID)) {
            MSG_DEBUG("Remove('%s') called.", devname);
            dbus_free(devname);
        }

#ifdef DEBUG
    } else {
        int type;
        type = dbus_message_get_type(message);
        switch(type) {
        case DBUS_MESSAGE_TYPE_METHOD_CALL:
            MSG_DEBUG("DBUS_MESSAGE_TYPE_METHOD_CALL");
            break;
        case DBUS_MESSAGE_TYPE_METHOD_RETURN:
            MSG_DEBUG("DBUS_MESSAGE_TYPE_METHOD_RETURN");
            break;
        case DBUS_MESSAGE_TYPE_ERROR:
            MSG_DEBUG("DBUS_MESSAGE_TYPE_ERROR");
            break;
        case DBUS_MESSAGE_TYPE_SIGNAL:
            MSG_DEBUG("DBUS_MESSAGE_TYPE_SIGNAL");
            break;
        case DBUS_MESSAGE_TYPE_INVALID:
            MSG_DEBUG("DBUS_MESSAGE_TYPE_INVALID");
            break;
        default:
            MSG_DEBUG("DBUS_MESSAGE_TYPE_ .... UNKNOWN");
            break;
        }
        
        MSG_DEBUG("obj_path=%s interface=%s method=%s destination=%s sender=%s", 
                    dbus_message_get_path(message), 
                    dbus_message_get_interface(message),
                    dbus_message_get_member(message),
                    dbus_message_get_destination(message),
                    dbus_message_get_sender(message)
        );
#endif
        
    }
    
    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}


void 
mntd_dbus_manager_send_signal_volume_mounted(PVOLUME pv)
{
    DBusMessage* message;
    DBusMessageIter it;
    
    //MSG_DEBUG("mntd_dbus_manager_send_signal_volume_mounted() called");

    g_assert(pv!=NULL);
    
    message = dbus_message_new_signal(
                                            DBUS_PATH_MNT_MANAGER, 
                                            DBUS_INTERFACE_MNT_MANAGER,
                                            "VolumeMounted");
    if (message==NULL) {
        MSG_EMERG("Out of memory");
        return;
    }
    
    dbus_message_iter_init(message, &it);
    dbus_message_iter_append_string(&it, pv->udi);
    dbus_message_iter_append_string(&it, pv->mntpnt);
    
    if (!dbus_connection_send(dbus_connection, message, NULL)) {
        MSG_EMERG("error broadcasting message");
    }
    
    dbus_message_unref(message);
}


void 
mntd_dbus_manager_send_signal_volume_unmounted(PVOLUME pv)
{
    DBusMessage* message;
    DBusMessageIter it;
    
    //MSG_DEBUG("mntd_dbus_manager_send_signal_volume_unmounted() called");

    g_assert(pv!=NULL);

    message = dbus_message_new_signal(
                                            DBUS_PATH_MNT_MANAGER, 
                                            DBUS_INTERFACE_MNT_MANAGER,
                                            "VolumeUnmounted");
    if (message==NULL) {
        MSG_EMERG("Out of memory");
        return;
    }
    
    dbus_message_iter_init(message, &it);
    dbus_message_iter_append_string(&it, pv->udi);
    dbus_message_iter_append_string(&it, pv->mntpnt);
    
    if (!dbus_connection_send(dbus_connection, message, NULL)) {
        MSG_EMERG("error broadcasting message");
    }
    
    dbus_message_unref(message);
}


int cb_append_udi(void *data, void *userdata)
{
    DBusMessageIter *itarr = NULL;
    PHASHMAPELEMENT phme = NULL;
    PHASHMAP phm = NULL;
    PVOLUME pv = NULL;
    char *udi = NULL;
    void *hashdata = NULL;

    if ((data==NULL) || (userdata==NULL)) {
        return -1;
    }
    
    // get dbus iterator
    itarr = (DBusMessageIter *) userdata;
    // get volume hashmap element
    phme = (PHASHMAPELEMENT) data;
    // get hashmap object
    phm = phme->phm;
    // get hashmap elements key
    udi = phme->key;
    // get volume object
    if (phm->get(phm, udi, &hashdata) == 0) {
        pv = (PVOLUME) hashdata;
        if (pv != NULL) {
            // check for mntd handled mntpnt
            if (pv->is_in_mntpath(pv)) {
                // append it to dbus message iterator
                dbus_message_iter_append_string(itarr, udi);
                return 0;
            }
        }
    }

    return -1;
}


DBusHandlerResult 
mntd_dbus_manager_get_all_volumes(  PVOLUMEMANAGER pvm,
                                                DBusConnection* connection,
                                                DBusMessage* message)
{
    DBusMessage* reply;
    DBusMessageIter it;
    DBusMessageIter itarr;
    DBusHandlerResult res = DBUS_HANDLER_RESULT_HANDLED;
    
    g_assert(pvm!=NULL);

    // return data to library
    reply = dbus_message_new_method_return(message);
    if (reply==NULL) {
        MSG_EMERG("Out of memory");
        goto error;
    }
    
    // collect return data
    dbus_message_iter_init(reply, &it);
    dbus_message_iter_append_array(&it, &itarr, DBUS_TYPE_STRING);
    pvm->foreach_mounted(pvm, cb_append_udi, &itarr);
    
    // send it
    if(!dbus_connection_send(connection, reply, NULL)) {
        MSG_EMERG("Out of memory");
        goto error;
    }
    
    goto cleanup;
    
error:
    res = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
    
cleanup:
    if (reply!=NULL) {
        dbus_message_unref(reply);
    }
    
    return res;
}


DBusHandlerResult 
mntd_dbus_manager_get_mntpnt(           PVOLUMEMANAGER pvm,
                                                DBusConnection* connection,
                                                DBusMessage* message)
{
    DBusMessage *reply = NULL;
    DBusMessageIter it;
    DBusError error;
    DBusHandlerResult res = DBUS_HANDLER_RESULT_HANDLED;
    char *udi = NULL;
    char *mntpnt = NULL;
    
    g_assert(pvm!=NULL);

    // get parameter
    dbus_error_init(&error);
    if (!dbus_message_get_args(message, &error, 
                                        DBUS_TYPE_STRING, &udi,
                                        DBUS_TYPE_INVALID) )
    {
        mntd_dbus_raise_syntax(connection, message, "Manager.GetMntPnt");
        goto error;
    }
    
    // return data to library
    reply = dbus_message_new_method_return(message);
    if (reply==NULL) {
        MSG_EMERG("Out of memory");
        goto error;
    }
    
    // collect return data
    dbus_message_iter_init(reply, &it);
    if (pvm->contains(pvm, udi)) {
        mntpnt = pvm->get_mntpnt(pvm, udi);
        if (mntpnt==NULL) {
            mntd_dbus_raise_no_mntpnt(connection, message, udi);
            goto error;
        }
        dbus_message_iter_append_string(&it, mntpnt);
    } else {
        mntd_dbus_raise_no_such_device(connection, message, udi);
        goto error;
    }
    
    // send it
    if(!dbus_connection_send(connection, reply, NULL)) {
        MSG_EMERG("Out of memory");
        goto error;
    }
    
    goto cleanup;
    
error:
    res = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
    
cleanup:
    if (reply!=NULL) {
        dbus_message_unref(reply);
    }
    if (udi!=NULL) {
        dbus_free(udi);
    }
    if (mntpnt!=NULL) {
        free(mntpnt);
    }
    
    return res;
}


DBusHandlerResult 
mntd_dbus_manager_remount(              PVOLUMEMANAGER pvm,
                                                DBusConnection* connection,
                                                DBusMessage* message)
{
    DBusMessage *reply = NULL;
    DBusMessageIter it;
    DBusError error;
    DBusHandlerResult res = DBUS_HANDLER_RESULT_HANDLED;
    char *udi = NULL;
    int flag = 0;
    int ret = -1;
    
    g_assert(pvm!=NULL);

    // get parameter
    dbus_error_init(&error);
    if (!dbus_message_get_args(message, &error, 
                                        DBUS_TYPE_STRING, &udi,
                                        DBUS_TYPE_INT32, &flag,
                                        DBUS_TYPE_INVALID) )
    {
        mntd_dbus_raise_syntax(connection, message, "Manager.Remount");
        goto error;
    }
    
    // return data to library
    reply = dbus_message_new_method_return(message);
    if (reply==NULL) {
        MSG_EMERG("Out of memory");
        goto error;
    }
    
    // collect return data
    dbus_message_iter_init(reply, &it);
    if (pvm->contains(pvm, udi)) {
        ret = pvm->remount(pvm, udi, flag);
        if (ret == -1) {
            mntd_dbus_raise_no_mntpnt(connection, message, udi);
            goto error;
        }
        dbus_message_iter_append_int32(&it, ret);
    } else {
        mntd_dbus_raise_no_such_device(connection, message, udi);
        goto error;
    }
    
    // send it
    if(!dbus_connection_send(connection, reply, NULL)) {
        MSG_EMERG("Out of memory");
        goto error;
    }
    
    goto cleanup;
    
error:
    res = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
    
cleanup:
    if (reply!=NULL) {
        dbus_message_unref(reply);
    }
    if (udi!=NULL) {
        dbus_free(udi);
    }
    
    return res;
}


/***************************************************************************
 * VOLUME HANDLER
 **************************************************************************/

---