lsmnt.c

/***************************************************************************
 * CVSID: $Id: lsmnt.c,v 1.22 2004/08/28 21:07:28 stefanb Exp $
 *
 * lsmnt.c : main() 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 <unistd.h>
#include <getopt.h>

#include <glib.h>
#include <dbus/dbus-glib.h>
#include <dbus/dbus-glib-lowlevel.h>

#include <libmnt/libmnt.h>


void main_loop(DBusConnection* dbus_connection, void *user_data);
void volume_mounted(const char* udi, const char* mntpnt, void *user_data);
void volume_unmounted(const char* udi, const char* mntpnt, void *user_data);
void dbus_disconnect(void *user_data);


void main_loop(DBusConnection* dbus_connection, void *user_data)
{
    dbus_connection_setup_with_g_main(dbus_connection, NULL);
    return;
}


void volume_mounted(const char* udi, const char* mntpnt, void *user_data)
{
    printf("volume_mounted('%s', '%s', 0x%p) called\n", udi, mntpnt, user_data);
    return;
}


void volume_unmounted(const char* udi, const char* mntpnt, void *user_data)
{
    printf("volume_unmounted('%s', '%s', 0x%p) called\n", udi, mntpnt, user_data);
    return;
}


void dbus_disconnect(void *user_data)
{
    GMainLoop *loop = (GMainLoop *) user_data;
    
    printf("Disconnected from DBUS ! exiting....\n");
    
    g_main_loop_quit(loop);
    
    return;
}


LIBMNTFUNCS mnt_functions = {   main_loop,
//LIBMNTFUNCS mnt_functions = { NULL,
                                        volume_mounted, 
                                        volume_unmounted,
                                        dbus_disconnect};


DBusDispatchStatus gstatus = DBUS_DISPATCH_COMPLETE;

void _dispatch_status(DBusConnection *connection,DBusDispatchStatus new_status,void *data);
void _dispatch_status(
    DBusConnection *connection,
    DBusDispatchStatus new_status,
    void *data)
{
    gstatus = new_status;
    switch(new_status) {
        case DBUS_DISPATCH_DATA_REMAINS:
            printf("DBUS_DISPATCH_DATA_REMAINS\n");
            break;
        case DBUS_DISPATCH_COMPLETE:
            printf("DBUS_DISPATCH_COMPLETE\n");
            break;
        case DBUS_DISPATCH_NEED_MEMORY:
            printf("DBUS_DISPATCH_NEED_MEMORY\n");
            break;
        default:
            printf("UNKNOWN\n");
            break;
    }
}

dbus_bool_t _add_watch(DBusWatch *watch, void *data);
dbus_bool_t _add_watch(DBusWatch *watch, void *data)
{
    printf("_add_watch called.\n");
    if (!dbus_watch_get_enabled(watch)) {
        return TRUE;
    }
    return TRUE;
}

void _remove_watch(DBusWatch *watch, void *data);
void _remove_watch(DBusWatch *watch, void *data)
{
    printf("_remove_watch called.\n");
}

void _toggle_watch(DBusWatch *watch, void *data);
void _toggle_watch(DBusWatch *watch, void *data)
{
    printf("_toggle_watch called.\n");
    if (dbus_watch_get_enabled(watch)) {
        _add_watch(watch, data);
    } else {
        _remove_watch(watch, data);
    }
}

dbus_bool_t _add_timeout(DBusTimeout *timeout, void *data);
dbus_bool_t _add_timeout(DBusTimeout *timeout, void *data)
{
    printf("_add_timeout called.\n");
    printf("_add_timeout called. %d\n", dbus_timeout_get_interval(timeout));
    return TRUE;
}

void _remove_timeout(DBusTimeout *timeout, void *data);
void _remove_timeout(DBusTimeout *timeout, void *data)
{
    printf("_remove_timeout called.\n");
}

void _toggle_timeout(DBusTimeout *timeout, void *data);
void _toggle_timeout(DBusTimeout *timeout, void *data)
{
    printf("_toggle_timeout called.\n");
    if (dbus_timeout_get_enabled (timeout)) {
        _add_timeout(timeout, data);
    } else {
        _remove_timeout(timeout, data);
    }
}

void _wakeup_main(void *data);
void _wakeup_main(void *data)
{
    printf("_wakeup_main called.\n");
}


gboolean mntcheck(gpointer user_data);
gboolean mntcheck(gpointer user_data)
{
    int num_volumes=0;
    char **data = NULL;
    int i=0;
    char *udi = NULL;
    char *mntpnt = NULL;

    // get all data
    data = mnt_get_all_volumes(&num_volumes);
    if (data != NULL) {
        for (i=0; i<num_volumes; i++) {
            udi = data[i];
            if (udi != NULL) {
                //printf("volume%d = '%s'\n", i, udi);
                // get the mount point
                mntpnt = mnt_get_mntpnt(udi);
                if (mntpnt != NULL) {
                    printf("    -> mntpnt%d = '%s'\n", i, mntpnt);
                    free(mntpnt);
                    mntpnt = NULL;
                }
                free(udi);
                udi = NULL;
            }
        }
        free(data);
        data = NULL;
        num_volumes = 0;
    }
    return TRUE;
}


int main(int argc, char* argv[])
{
    GMainLoop* loop;
    int num_volumes=0;
    char **data = NULL;
    int i=0;
    char *udi = NULL;
    char *mntpnt = NULL;
    int res = -1;
//  DBusConnection *c = NULL;

    // print version info
    fprintf(stderr, "lsmnt v" PACKAGE_VERSION "\n");
    
    // get glib main loop
    loop = g_main_loop_new (NULL, FALSE);
    
    // initialize mnt library
    if (mnt_init(&mnt_functions, loop) == -1) {
        fprintf(stderr, "error: mnt_init failed\n");
        exit(1);
    }
    
    // TESTING
/*  c = _mnt_get_connection();
    dbus_connection_set_dispatch_status_function(c, _dispatch_status, NULL, NULL);
    dbus_connection_set_watch_functions(c, _add_watch, _remove_watch, 
                                                    _toggle_watch, NULL, NULL);
    dbus_connection_set_timeout_functions(c, _add_timeout, _remove_timeout, 
                                                    _toggle_timeout, NULL, NULL);
    dbus_connection_set_wakeup_main_function (c, _wakeup_main, NULL, NULL);
    */

    // add mount point checker
    g_timeout_add(1000, mntcheck, NULL);
    
    // get all data
    data = mnt_get_all_volumes(&num_volumes);
    if (data != NULL) {
        for (i=0; i<num_volumes; i++) {
            udi = data[i];
            if (udi != NULL) {
                printf("volume%d = '%s'\n", i, udi);
                // remount read/write
                res = mnt_remount_rw(udi);
                printf("remounting read/write '%s' returns %d\n", udi, res);
                // remount read only
                res = mnt_remount_rd(udi);
                printf("remounting read only '%s' returns %d\n", udi, res);
                // get the mount point
                mntpnt = mnt_get_mntpnt(udi);
                if (mntpnt != NULL) {
                    printf("    -> mntpnt = '%s'\n", mntpnt);
                    free(mntpnt);
                    mntpnt = NULL;
                }
                free(udi);
                udi = NULL;
            }
        }
        free(data);
        data = NULL;
        num_volumes = 0;
    }
    
    // start program
    g_main_loop_run(loop);
    
/*  while(1) {
        DBusDispatchStatus status = DBUS_DISPATCH_COMPLETE;
        status = dbus_connection_get_dispatch_status(c);
        switch(status) {
            case DBUS_DISPATCH_DATA_REMAINS:
                printf("DBUS_DISPATCH_DATA_REMAINS\n");
                break;
            case DBUS_DISPATCH_COMPLETE:
                printf("DBUS_DISPATCH_COMPLETE\n");
                break;
            case DBUS_DISPATCH_NEED_MEMORY:
                printf("DBUS_DISPATCH_NEED_MEMORY\n");
                break;
            default:
                printf("UNKNOWN\n");
                break;
        }
        if (status == DBUS_DISPATCH_DATA_REMAINS) {
            printf("dispatching ...\n");
            dbus_connection_dispatch(c);
        }
        sleep(1);
    }*/
    
    // free libraries resources
    mnt_quit();
    
    // exit
    return 0;
}

---