mntdbus.c

/***************************************************************************
 * CVSID: $Id: mntdbus.c,v 1.3 2004/12/19 00:13:08 stefanb Exp $
 *
 * mntdbus.c : Sending dbus signal to 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 <stdlib.h>

#include "mntdbus.h"
#include "errmanager.h"
#include "libmnt/libmnt.h"
#include "dbug_mem.h"


char *mntdbus_getenv(char *name)
{
    char *value = NULL;
    
    value = getenv(name);
    if (value == NULL) {
        MSG_ERR("No '%s' in environment found!", name);
        return NULL;
    }
    if (strlen(value)==0) {
        MSG_ERR("'%s' is empty!", name);
        return NULL;
    }
    return value;
}


DBusConnection *mntdbus_init(void)
{
    DBusConnection *conn = NULL;
    DBusError error;

    // connect to dbus daemon and register myself
    dbus_error_init(&error);
    conn = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
    if (conn==NULL) {
        MSG_ERR("Couldn't connect to DBUS, error %s: %s", 
            error.name, error.message);
        goto error;
    }
    
    // test for running service from mntd
    if (!dbus_bus_service_exists(conn, DBUS_SERVICE_MNT, &error)) {
        MSG_ERR("Service '%s' doesn't exist !\n", DBUS_SERVICE_MNT);
        goto error;
    }
    
    if (dbus_bus_acquire_service(conn, DBUS_SERVICE_MNT, 0, &error) == -1) {
        MSG_ERR("Error Acquiring service '" DBUS_SERVICE_MNT "'\n");
        if (dbus_error_is_set(&error)) {
            MSG_ERR("Can't acquire '" DBUS_SERVICE_MNT "' service, error %s: %s'",
                error.name, error.message);
        }
        goto error;
    }

    goto cleanup;
    
error:
    if (conn != NULL) {
        dbus_connection_disconnect(conn);
    }
    conn = NULL;
    
cleanup:    
    if (dbus_error_is_set(&error)) {
        dbus_error_free(&error);
    }

    return conn;
}


void mntdbus_quit(DBusConnection* conn)
{
    // check parameter
    if (conn == NULL) {
        MSG_ERR("Connection is NULL ! Cannot disconnect.");
        return;
    }
    
    dbus_connection_disconnect(conn);
    
    return;
}


int _mntdbus_signal(DBusConnection* conn, char *signalname, char *subsystem, char *devname)
{
    DBusMessage *message = NULL;
    DBusMessageIter it;
    char *dbuspath = NULL;
    char *dbusinterface = NULL;

    // check parameter
    if (conn == NULL) {
        MSG_ERR("Connection is NULL ! Cannot send device signal ('%s', '%s', '%s').", 
                  signalname, subsystem, devname);
        return -1;
    }
    
    // send signal
    if (strcmp(subsystem, "block") == 0) {
        dbuspath = DBUS_PATH_MNT_BLOCK;
        dbusinterface = DBUS_INTERFACE_MNT_BLOCK;
    } else if (strcmp(subsystem, "disc") == 0) {
        dbuspath = DBUS_PATH_MNT_DISC;
        dbusinterface = DBUS_INTERFACE_MNT_DISC;
    } else if (strcmp(subsystem, "tty") == 0) {
        dbuspath = DBUS_PATH_MNT_TTY;
        dbusinterface = DBUS_INTERFACE_MNT_TTY;
    }
    
    // check for errors
    if ((dbuspath==NULL) || (dbusinterface==NULL)) {
        return -1;
    }
    
    // create message
    message = dbus_message_new_signal(
                                            dbuspath, 
                                            dbusinterface,
                                            signalname);
    if (message==NULL) {
        MSG_EMERG("Out of memory");
        return -1;
    }
    
    // append parameter
    dbus_message_iter_init(message, &it);
    dbus_message_iter_append_string(&it, devname);
    
    // send it
    if (!dbus_connection_send(conn, message, NULL)) {
        MSG_EMERG("error broadcasting message");
        return -1;
    }
    
    dbus_message_unref(message);
    
    dbus_connection_flush(conn);
    
    return 0;
}


int mntdbus_add(DBusConnection* conn, char *subsystem, char *devname)
{
    MSG_DEBUG("mntdbus_add('%s', '%s') called.", subsystem, devname);

    // check parameter
    if (conn == NULL) {
        MSG_ERR("Connection is NULL ! Cannot send Add('%s', '%s').", 
                  subsystem, devname);
        return -1;
    }

    // send signal
    return _mntdbus_signal(conn, "Add", subsystem, devname);
}


int mntdbus_remove(DBusConnection* conn, char *subsystem, char *devname)
{
    MSG_DEBUG("mntdbus_remove('%s', '%s') called.", subsystem, devname);

    // check parameter
    if (conn == NULL) {
        MSG_ERR("Connection is NULL ! Cannot send Remove('%s', '%s').", 
                  subsystem, devname);
        return -1;
    }
    
    // send signal
    return _mntdbus_signal(conn, "Remove", subsystem, devname);
}

---