libmnt.c

/***************************************************************************
 * CVSID: $Id: libmnt.c,v 1.33 2004/08/04 20:37:21 stefanb Exp $
 *
 * libmnt.c : main() for MNT daemon
 *
 * Copyright (C) 2004 Stefan Bambach, <sbambach@gmx.net>
 *
 * Licensed under the GNU Lesser General Public License 2.1
 *
 * 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 <glib.h>
#include <dbus/dbus.h>
#include <dbus/dbus-glib.h>

#include "libmnt.h"
#include <mntd/mntd_mount.h>


static DBusConnection* connection = NULL;
static int is_initialized = FALSE;
static PLIBMNTFUNCS functions = NULL;
static void *user_data = NULL;


int _mnt_remount(char *udi, int flag);


static DBusHandlerResult filter_func(DBusConnection* connection,
                                     DBusMessage*    message,
                                     void*           user_data)
{
    DBusError error;
    
    g_assert(connection!=NULL);
    g_assert(message!=NULL);
    
    dbus_error_init(&error);

    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 (functions->dbus_disconnect!=NULL) {
                    functions->dbus_disconnect(user_data);
                }
            }
        }
        
    } else if (dbus_message_is_signal(  message, 
                                                    DBUS_INTERFACE_MNT_MANAGER, 
                                                    "VolumeMounted"))
    {
        char *udi = NULL;
        char *mntpnt = NULL;
        if (dbus_message_get_args(message, &error, 
                                            DBUS_TYPE_STRING, &udi,
                                            DBUS_TYPE_STRING, &mntpnt,
                                            DBUS_TYPE_INVALID)) {
            if (functions->volume_mounted!=NULL) {
                functions->volume_mounted(udi, mntpnt, user_data);
            }
            dbus_free(udi);
        }
        
    } else if (dbus_message_is_signal(  message, 
                                                    DBUS_INTERFACE_MNT_MANAGER, 
                                                    "VolumeUnmounted"))
    {
        char *udi = NULL;
        char *mntpnt = NULL;
        if (dbus_message_get_args(message, &error, 
                                            DBUS_TYPE_STRING, &udi,
                                            DBUS_TYPE_STRING, &mntpnt,
                                            DBUS_TYPE_INVALID)) {
            if (functions->volume_unmounted!=NULL) {
                functions->volume_unmounted(udi, mntpnt, user_data);
            }
            dbus_free(udi);
        }
        
#ifdef DEBUG
    } else {
        int type;
        type = dbus_message_get_type(message);
        switch(type) {
        case DBUS_MESSAGE_TYPE_METHOD_CALL:
            printf("DBUS_MESSAGE_TYPE_METHOD_CALL\n");
            break;
        case DBUS_MESSAGE_TYPE_METHOD_RETURN:
            printf("DBUS_MESSAGE_TYPE_METHOD_RETURN\n");
            break;
        case DBUS_MESSAGE_TYPE_ERROR:
            printf("DBUS_MESSAGE_TYPE_ERROR\n");
            break;
        case DBUS_MESSAGE_TYPE_SIGNAL:
            printf("DBUS_MESSAGE_TYPE_SIGNAL\n");
            break;
        case DBUS_MESSAGE_TYPE_INVALID:
            printf("DBUS_MESSAGE_TYPE_INVALID\n");
            break;
        default:
            printf("DBUS_MESSAGE_TYPE_ .... UNKNOWN\n");
            break;
        }
        
        printf("libmnt::filter_func(): obj_path=%s interface=%s method=%s destination=%s sender=%s\n", 
                    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;
}


static LIBMNTFUNCS dummy_functions = {
    NULL, 
    NULL, 
    NULL  
};


int mnt_init(PLIBMNTFUNCS cb_functions, void *data)
{
    DBusError error;
    int res = 0;
    
    // exit, if already initialized
    if (is_initialized) {
        fprintf(stderr, "libmnt is already initialized!\n");
        goto cleanup;
    }

    // initialize the callback functions
    functions = cb_functions;
    if (cb_functions==NULL) {
        functions = &dummy_functions;
    }

    // initialize user_data
    user_data = data;
    
    // connect to dbus daemon and register myself
    dbus_error_init(&error);
    connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
    if (connection==NULL) {
        fprintf(stderr, "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(connection, DBUS_SERVICE_MNT, &error)) {
        fprintf(stderr, "Service '%s' doesn't exist !\n", DBUS_SERVICE_MNT);
        goto error;
    }
    
    // acquire server
    if (dbus_bus_acquire_service(connection, DBUS_SERVICE_MNT, 0, &error) == -1) {
        fprintf(stderr, "Error Acquiring service '" DBUS_SERVICE_MNT "'\n");
        if (dbus_error_is_set(&error)) {
            fprintf(stderr, "Can't acquire '" DBUS_SERVICE_MNT "' service, error %s: %s'",
                error.name, error.message);
        }
        goto error;
    }
    
    // call main_loop function, if needed
    if (functions->main_loop!=NULL) {
        functions->main_loop(connection, user_data);
    }

    // add filter functions to connection handler ....
    if (!dbus_connection_add_filter(connection, filter_func, user_data, NULL)) {
        fprintf(stderr, "Couldn't add filters to dbus connection handler");
        goto error;
    }
    
    // ..., but register only for signals from Manager
    dbus_bus_add_match(connection,
        "type='signal',"
        "interface='" DBUS_INTERFACE_MNT_MANAGER "',"
        "path='" DBUS_PATH_MNT_MANAGER "'",
        &error);
    if (dbus_error_is_set(&error)) {
        fprintf(stderr, "Couldn't register Manager signal handler: %s: %s", error.name, error.message);
        goto error;
    }

    // disable _exit() on disconnect signal
    dbus_connection_set_exit_on_disconnect(connection, FALSE);
    
    is_initialized = TRUE;
    
    goto cleanup;
    
error:
    dbus_connection_disconnect(connection);
    is_initialized = FALSE;
    res = -1;
    
cleanup:
    if (dbus_error_is_set(&error)) {
        dbus_error_free(&error);
    }

    return res;
}


void mnt_quit(void)
{
    if (!is_initialized) {
        return;
    }
    
    if (connection!=NULL) {
        dbus_connection_disconnect(connection);
        connection = NULL;
    }
    
    is_initialized = FALSE;
    
    return;
}


char **mnt_get_all_volumes(int *num_volumes)
{
    DBusError error;
    DBusMessage* message = NULL;
    DBusMessage* reply = NULL;
    DBusMessageIter iter;
    char **res = NULL;
    char **data_array;
    int data_length;
    int i=0;
    
    message = dbus_message_new_method_call(
                                            DBUS_SERVICE_MNT,
                                            DBUS_PATH_MNT_MANAGER,
                                            DBUS_INTERFACE_MNT_MANAGER,
                                            "GetAllVolumes");
    
    if (message==NULL) {
        goto error;
    }
    
    dbus_error_init(&error);
    
    reply = dbus_connection_send_with_reply_and_block(connection, message, -1, &error);
    if (dbus_error_is_set(&error)) {
        goto error;
    }
    if (reply==NULL) {
        goto error;
    }
    
    // get reply data
    dbus_message_iter_init(reply, &iter);
    if (!dbus_message_iter_get_string_array(&iter, &data_array, &data_length)) {
        fprintf(stderr, "wrong reply from mntd\n");
        goto error;
    }
    
    // handle data
    res = (char **) malloc(sizeof(char*)*data_length);
    if (res == NULL) {
        goto error;
    }

    // fill with data
    *num_volumes = 0;
    for(i=0; i<data_length; i++) {
        if ((data_array[i] != NULL) && (strlen(data_array[i])>0)) {
            res[i] = strdup(data_array[i]);
            (*num_volumes)++;
        }
    }

    // free dbus data array
    dbus_free_string_array(data_array);
    
    goto cleanup;
    
error:
    res = NULL;
    
cleanup:
    if (message!=NULL) dbus_message_unref(message);
    if (reply!=NULL) dbus_message_unref(reply);
    
    return res;
}


char *mnt_get_mntpnt(char *udi)
{
    DBusError error;
    DBusMessage* message = NULL;
    DBusMessage* reply = NULL;
    DBusMessageIter iter;
    char *res = NULL;
    char *mntpnt = NULL;
    
    message = dbus_message_new_method_call(
                                            DBUS_SERVICE_MNT,
                                            DBUS_PATH_MNT_MANAGER,
                                            DBUS_INTERFACE_MNT_MANAGER,
                                            "GetMntPnt");
    
    if (message==NULL) {
        goto error;
    }
    
    // construct parameter
    dbus_message_iter_init(message, &iter);
    dbus_message_iter_append_string(&iter, udi);
    
    // method invocation
    dbus_error_init(&error);
    reply = dbus_connection_send_with_reply_and_block(connection, message, -1, &error);
    if (dbus_error_is_set(&error)) {
        fprintf(stderr, "Error calling GetMntPnt('%s'): %s : %s\n", udi, error.name, error.message);
        goto error;
    }
    if (reply==NULL) {
        goto error;
    }
    
    // get return value
    if (!dbus_message_get_args(reply, &error, 
                                        DBUS_TYPE_STRING, &mntpnt,
                                        DBUS_TYPE_INVALID)) {
        fprintf(stderr, "Error getting mntpnt from GetMntPnt() call (%s : %s)\n", error.name, error.message);
        goto error;
    }
    res = strdup(mntpnt);
    if (res == NULL) {
        goto error;
    }
    
    goto cleanup;
    
error:
    res = NULL;
    
cleanup:
    if (mntpnt!=NULL) dbus_free(mntpnt);
    if (message!=NULL) dbus_message_unref(message);
    if (reply!=NULL) dbus_message_unref(reply);
    
    return res;
}


int _mnt_remount(char *udi, int flag)
{
    DBusError error;
    DBusMessage* message = NULL;
    DBusMessage* reply = NULL;
    DBusMessageIter iter;
    int res = -1;
    
    message = dbus_message_new_method_call(
                                            DBUS_SERVICE_MNT,
                                            DBUS_PATH_MNT_MANAGER,
                                            DBUS_INTERFACE_MNT_MANAGER,
                                            "Remount");
    
    if (message==NULL) {
        goto error;
    }
    
    // construct parameter
    dbus_message_iter_init(message, &iter);
    dbus_message_iter_append_string(&iter, udi);
    dbus_message_iter_append_int32(&iter, flag);
    
    // method invocation
    dbus_error_init(&error);
    reply = dbus_connection_send_with_reply_and_block(connection, message, -1, &error);
    if (dbus_error_is_set(&error)) {
        fprintf(stderr, "Error calling Remount('%s', %d): %s : %s\n", udi, flag, 
            error.name, error.message);
        goto error;
    }
    if (reply==NULL) {
        goto error;
    }
    
    // get return value
    if (!dbus_message_get_args(reply, &error, 
                                        DBUS_TYPE_INT32, &res,
                                        DBUS_TYPE_INVALID)) {
        fprintf(stderr, "Error from Remount() call (%s : %s)\n", error.name, error.message);
        goto error;
    }
    
    goto cleanup;
    
error:
    res = -1;
    
cleanup:
    if (message!=NULL) dbus_message_unref(message);
    if (reply!=NULL) dbus_message_unref(reply);
    
    return res;
}


int mnt_remount_rd(char *udi)
{
    return _mnt_remount(udi, MOUNT_RD);
}


int mnt_remount_rw(char *udi)
{
    return _mnt_remount(udi, MOUNT_RW);
}


DBusConnection *_mnt_get_connection(void)
{
    return connection;
}

---