mntd_volume.c

/***************************************************************************
 * CVSID: $Id: mntd_volume.c,v 1.47 2005/03/29 23:32:03 stefanb Exp $
 *
 * mntd_volume.c : Volume handler 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 <glib.h>
#include <dbus/dbus.h>
#include <dbus/dbus-glib.h>
#include <limits.h>

#include <libmnt/libmnt.h>   /* for common defines etc. */
#include "dir.h"
#include "main.h"
#include "mntd_mount.h"
#include "mntd_volume.h"
#include "mntd_volume_config.h"
#include "mntd_dbus_manager.h"
#include "errmanager.h"
#include "dbug_mem.h"


/* Private Methods */
int mntd_volume_init(PVOLUME pv);
void mntd_volume_destroy(PVOLUME pv);
int mntd_volume_set_device(PVOLUME pv, const char *device);
char *mntd_volume_get_device(PVOLUME pv);
void mntd_volume_to_string(PVOLUME pv);
int mntd_volume_set_mntpnt(PVOLUME pv, const char *mntpnt);
char *mntd_volume_get_mntpnt(PVOLUME pv);
int mntd_volume_set_fstype(PVOLUME pv, const char *fstype);
char *mntd_volume_get_fstype(PVOLUME pv);
int mntd_volume_mount(PVOLUME pv);
int mntd_volume_umount(PVOLUME pv);
char *mntd_volume_g_build_mntpnt(PVOLUME pv, const char *base, const char *prefix);
int mntd_volume_helper_base_is_in_mntpath(const char *base, const char *mntpnt);
int mntd_volume_is_in_mntpath(PVOLUME pv);
int mntd_volume_send_signal(PVOLUME pv, int what);
int mntd_volume_send_mounted(PVOLUME pv);
int mntd_volume_send_unmounted(PVOLUME pv);
int mntd_volume_remount(PVOLUME pv, int flag);


PVOLUME new_Volume(const char *udi, const char *base, const char *prefix)
{
    PVOLUME pv = NULL;
    char *s_udi = NULL;
    char *s_base = NULL;
    char *s_prefix = NULL;
    
    //MSG_DEBUG("new_Volume(%s) called", udi);
    
    g_assert(udi!=NULL);
    g_assert(base!=NULL);
    g_assert(prefix!=NULL);
    
    // get mem for volume object
    pv = (PVOLUME) malloc(sizeof(VOLUME));
    if (pv==NULL) {
        return NULL;
    }
    
    // clear structure memory
    memset(pv, 0, sizeof(VOLUME));
    
    // setting udi for this volume
    s_udi = strdup(udi);
    if (s_udi == NULL) {
        goto error;
    }
    pv->udi = s_udi;
    
    // setting base mount directory
    s_base = strdup(base);
    if (s_base == NULL) {
        goto error;
    }
    pv->base = s_base;
    
    // setting base prefix for mount directory
    s_prefix = strdup(prefix);
    if (s_prefix == NULL) {
        goto error;
    }
    pv->prefix = s_prefix;
    
    // setting methods
    pv->init = mntd_volume_init;
    pv->_send_signal = mntd_volume_send_signal;
    pv->_send_mounted = mntd_volume_send_mounted;
    pv->_send_unmounted = mntd_volume_send_unmounted;
    pv->destroy = mntd_volume_destroy;
    pv->set_device = mntd_volume_set_device;
    pv->get_device = mntd_volume_get_device;
    pv->to_string = mntd_volume_to_string;
    pv->set_mntpnt = mntd_volume_set_mntpnt;
    pv->get_mntpnt = mntd_volume_get_mntpnt;
    pv->set_fstype = mntd_volume_set_fstype;
    pv->get_fstype = mntd_volume_get_fstype;
    pv->mount = mntd_volume_mount;
    pv->umount = mntd_volume_umount;
    pv->remount = mntd_volume_remount;
    pv->is_in_mntpath = mntd_volume_is_in_mntpath;
    
    // call constructor
    if(pv->init(pv) == -1) {
        goto error;
    }
    
    // alright, return volume object
    goto exit;
    
error:
    pv->destroy(pv);
    pv = NULL;
    
exit:
    return pv;
}


int mntd_volume_init(PVOLUME pv)
{
    g_assert(pv!=NULL);
    
    //MSG_DEBUG("init(%s) called", pv->udi);

    pv->device = NULL;
    pv->mntpnt = NULL;
    pv->fstype = NULL;
    pv->last_signal = SIGNAL_UNKNOWN;
    
    return 0;
}


void mntd_volume_destroy(PVOLUME pv)
{
    g_assert(pv!=NULL);
    
    //MSG_DEBUG("mntd_volume_destroy(%p) called (key='%s')", pv, pv->udi);
    
    // umount it now
    if (pmd->configdata->umount_on_exit == UMOUNT_ON_EXIT_FALSE) {
        // nothing to do
    } else if (pmd->configdata->umount_on_exit == UMOUNT_ON_EXIT_READONLY) {
        // remount devices read only
        pv->remount(pv, MOUNT_RD);
    } else {
        // unmount devices
        pv->umount(pv);
    }
    
    // free udi memory
    if (pv->udi != NULL) {
        free(pv->udi);
        pv->udi = NULL;
    }
    
    // free base memory
    if (pv->base != NULL) {
        free(pv->base);
        pv->base = NULL;
    }
    
    // free prefix memory
    if (pv->prefix != NULL) {
        free(pv->prefix);
        pv->prefix = NULL;
    }
    
    // free device memory
    if (pv->device != NULL) {
        free(pv->device);
        pv->device = NULL;
    }
    
    // free mntpnt memory
    if (pv->mntpnt != NULL) {
        free(pv->mntpnt);
        pv->mntpnt = NULL;
    }
    
    // free fstype memory
    if (pv->fstype != NULL) {
        free(pv->fstype);
        pv->fstype = NULL;
    }
    
    // free volume manager structure
    memset(pv, 0, sizeof(VOLUME));
    free(pv);
    
    return;
}


void
mntd_volume_to_string(PVOLUME pv)
{
    //MSG_DEBUG("mntd_volume_to_string(%p) called", pv);

    MSG_DEBUG("------------------------------------------------------");
    MSG_DEBUG("udi:        %s", pv->udi);
    MSG_DEBUG("base:       %s", pv->base);
    MSG_DEBUG("prefix:     %s", pv->prefix);
    MSG_DEBUG("device:     %s", pv->device);
    MSG_DEBUG("mntpnt:     %s", pv->mntpnt);
    MSG_DEBUG("fstype:     %s", pv->fstype);
    
    return;
}


int
mntd_volume_set_device(PVOLUME pv, const char *device)
{
    char *s_device = NULL;
    
    //MSG_DEBUG("set_device(%s) called", device);

    g_assert(pv!=NULL);

    if (device == NULL) {
        if (pv->device != NULL) {
            free(pv->device);
            pv->device = NULL;
        }
        return 0;
    }
    
    // return OK, if nothing to change
    if (pv->device != NULL) {
        if (strcmp(device, pv->device)==0) {
            return 0;
        }
    }
    
    s_device = strdup(device);
    if (s_device == NULL) {
        return -1;
    }
    
    if (pv->device != NULL) {
        free(pv->device);
        pv->device = NULL;
    }
    
    pv->device = s_device;
    
    MSG_DEBUG("Set device to '%s' for udi '%s'", s_device, pv->udi);
    
    // device found, so mount it now
    pv->mount(pv);
    
    return 0;
}


char *
mntd_volume_get_device(PVOLUME pv)
{
    g_assert(pv!=NULL);
    
    if (pv->device != NULL) {
        return strdup(pv->device);
    }
    
    return NULL;
}


int
mntd_volume_set_mntpnt(PVOLUME pv, const char *mntpnt)
{
    char *s_mntpnt = NULL;
    
    //MSG_DEBUG("set_mntpnt(%s) called", mntpnt);

    g_assert(pv!=NULL);

    if (mntpnt == NULL) {
        if (pv->mntpnt != NULL) {
            
            MSG_DEBUG("Remove mount point '%s' ('%s')", pv->mntpnt, pv->udi);
            
            // sending signal
            pv->_send_signal(pv, SIGNAL_UNMOUNTED);

            free(pv->mntpnt);
            pv->mntpnt = NULL;
        }
        return 0;
    }
    
    // return OK, if nothing to change
    if (pv->mntpnt != NULL) {
        if (strcmp(mntpnt, pv->mntpnt)==0) {
            return 0;
        }
    }
    
    s_mntpnt = strdup(mntpnt);
    if (s_mntpnt == NULL) {
        return -1;
    }
    
    if (pv->mntpnt != NULL) {
        
        MSG_DEBUG("Change mount point '%s' ('%s')", pv->mntpnt, pv->udi);
        
        free(pv->mntpnt);
        pv->mntpnt = NULL;
    }
    
    pv->mntpnt = s_mntpnt;
    
    MSG_DEBUG("Set mount point to '%s' ('%s')", s_mntpnt, pv->udi);
    
    // sending signal
    pv->_send_signal(pv, SIGNAL_UNKNOWN);
    
    return 0;
}


char *
mntd_volume_get_mntpnt(PVOLUME pv)
{
    g_assert(pv!=NULL);
    
    if (pv->mntpnt != NULL) {
        return strdup(pv->mntpnt);
    }
    
    return NULL;
}


int
mntd_volume_set_fstype(PVOLUME pv, const char *fstype)
{
    char *s_fstype = NULL;
    
    //MSG_DEBUG("set_fstype(%s) called", fstype);

    g_assert(pv!=NULL);

    if (fstype == NULL) {
        if (pv->fstype != NULL) {
            free(pv->fstype);
            pv->fstype = NULL;
        }
        return 0;
    }
    
    // return OK, if nothing to change
    if (pv->fstype != NULL) {
        if (strcmp(fstype, pv->fstype)==0) {
            return 0;
        }
    }
    
    s_fstype = strdup(fstype);
    if (s_fstype == NULL) {
        return -1;
    }
    
    if (pv->fstype != NULL) {
        free(pv->fstype);
        pv->fstype = NULL;
    }
    
    pv->fstype = s_fstype;

    //MSG_DEBUG("Set filesystem type to '%s' for '%s'", s_fstype, pv->udi);
    
    return 0;
}


char *
mntd_volume_get_fstype(PVOLUME pv)
{
    g_assert(pv!=NULL);
    
    if (pv->fstype != NULL) {
        return strdup(pv->fstype);
    }
    
    return NULL;
}


int
mntd_volume_mount(PVOLUME pv)
{
    char *path = NULL;
    int error=0;
    int res = 0;
    
    //MSG_DEBUG("mntd_volume_mount(%p) called", pv);

    g_assert(pv!=NULL);
    g_assert(pv->device!=NULL);
    g_assert(pv->base!=NULL);
    g_assert(pv->prefix!=NULL);
    
    // check for error
    if (pv->base == NULL) {
        MSG_ERR("base mountpoint path is not configured");
        goto error;
    }
    
    // check for already mounted volume (mounted by mntd)
    if (pv->mntpnt != NULL) {
        MSG_INF("'%s' already mounted on '%s'.", pv->device, pv->mntpnt);
        goto error;
    }
    
    // build mount point path
    path = mntd_volume_g_build_mntpnt(pv, pv->base, pv->prefix);
    if (path == NULL) {
        MSG_ERR("Out of memory");
        goto error;
    }
    
    // create mount point
    sb_dir_rmdirs(path);
    sb_dir_mkdirs(path, 0775, &error);
    if (!sb_dir_is_dir(path)) {
        MSG_ERR("Couldn't create '%s' (%d)", path, error);
        goto error;
    }

    // mounting device
    res = mntd_mount_mount(pv->device, path);
    if (res != 0) {
        MSG_INF("Couldn't mount '%s' on '%s'. Perhaps wrong filesystem, or no filesystem on it (e.g. extended partition, ...).", pv->device, path);
        // error
        goto error;
    }
    
    // set mntpnt, so nested calls to GetMntPnt() will work
    pv->set_mntpnt(pv, path);
    
    // TODO: Test for readable / writeable
    ;
    
    MSG_INF("Mounted '%s' on '%s'.", pv->device, path);
    
    // send signal to processes listing to dbus
    pv->_send_signal(pv, SIGNAL_MOUNTED);
    
    goto cleanup;
    
error:
    // try to remove mount point
    sb_dir_remove(path);
    // error
    res = -1;
    
cleanup:
    if (path != NULL) {
        g_free(path);
        path = NULL;
    }
    
    return res;
}


int
mntd_volume_umount(PVOLUME pv)
{
    int res = 0;
    char *mntpnt = NULL;
    int status = 0;
    
    //MSG_DEBUG("mntd_volume_umount(%p) called", pv);

    g_assert(pv!=NULL);
    
    // is mounted by mntd or in configured mount path ?
    if (pv->is_in_mntpath(pv)) {
        // mount point configured ?
        if (pv->mntpnt != NULL) {
            mntpnt = pv->get_mntpnt(pv);
            if (mntpnt != NULL) {
                // unmount it
                status = mntd_mount_umount(mntpnt);
                if (status != 0) {
                    MSG_ERR("Couldn't unmount '%s' on '%s'.", pv->device, mntpnt);
                    goto error;
                } else {
                    MSG_INF("Unmounted '%s' on '%s'.", pv->device, mntpnt);
                    
                    // send signal to processes listing to dbus
                    pv->_send_signal(pv, SIGNAL_UNMOUNTED);
                }
                
                // try to remove mount point
                sb_dir_remove(mntpnt);

                // set mntpnt, so nested calls to GetMntPnt() will work
                pv->set_mntpnt(pv, NULL);
                pv->set_fstype(pv, NULL);
                
            } else {
                MSG_ERR("mntpnt==NULL for '%s' on '%s'", pv->device, pv->udi);
                goto error;
            }
        } else {
            MSG_ERR("Volume (udi='%s') on device '%s' mounted by mntd has mntpnt==NULL !", pv->udi, pv->device);
            goto error;
        }
    } else {
        //MSG_DEBUG("Device '%s' at '%s' is not mounted by mntd -> do not unmount it.", pv->device, pv->mntpnt);
        goto error;
    }
    
    goto cleanup;
    
error:
    res = -1;

cleanup:
    if (mntpnt != NULL) {
        free(mntpnt);
        mntpnt = NULL;
    }
    
    return res;
}


int
mntd_volume_remount(PVOLUME pv, int flag)
{
    int res = -1;
    
    g_assert(pv!=NULL);
    
    if (pv->mntpnt != NULL) {
        if (flag==MOUNT_RW) {
            res = mntd_mount_remount_rw(pv->mntpnt);
        } else {
            res = mntd_mount_remount_rd(pv->mntpnt);
        }
    }
    
    return res;
}


gchar *
mntd_volume_g_build_mntpnt(PVOLUME pv, const char *base, const char *prefix)
{
    gchar *res = NULL;
    char *name = NULL;
    unsigned int counter = 0;
    int maxchars = 0;
    gchar *longname = NULL;
    gchar **tokens = NULL;

    g_assert(pv!=NULL);
    g_assert(base!=NULL);
    g_assert(prefix!=NULL);
    
    if (pv->device == NULL) {
        goto error;
    }

    if (prefix==NULL || (prefix!=NULL && strlen(prefix)==0))
    {
        // long directory name (_dev_scsi_....)
        tokens = g_strsplit(pv->device, G_DIR_SEPARATOR_S, 0);
        if (tokens==NULL) {
            goto error;
        }
        longname = g_strjoinv("_", tokens);
        if (longname==NULL) {
            goto error;
        }
        if (g_path_is_absolute((gchar *)base)) {
            res = g_build_path(G_DIR_SEPARATOR_S, (gchar *)base, longname, NULL);
        } else {
            MSG_WARNING("basepath for mount point have to be absolute (adding DIRSEP) -> check your config");
            res = g_build_path(G_DIR_SEPARATOR_S, G_DIR_SEPARATOR_S, 
                                    (gchar *)base, longname, NULL);
        }
        if (res==NULL) {
            goto error;
        }
        
    } else {
        // short directory name (mnt1, mnt2, mnt3, ...)
        maxchars = strlen(prefix)+20;
        name = (char *) malloc(sizeof(char)*maxchars);
        if (name == NULL) {
            goto error;
        }
    
        // try to find next unused mntpath
        for (counter = 0; counter <= UINT_MAX; counter++) {
            // build mntpath
            memset(name, 0, maxchars);
            snprintf(name, maxchars-1, "%s%d", prefix, counter);
            if (g_path_is_absolute((gchar *)base)) {
                res = g_build_path(G_DIR_SEPARATOR_S, (gchar *)base, name, NULL);
            } else {
                MSG_WARNING("basepath for mount point have to be absolute (adding DIRSEP) -> check your config");
                res = g_build_path(G_DIR_SEPARATOR_S, G_DIR_SEPARATOR_S, (gchar *)base, name, NULL);
            }
            if (res==NULL) {
                goto error;
            }
            
            // check for existance of mntpath
            if (!sb_dir_is_dir(res)) {
                break;
            } else {
                g_free(res);
                res = NULL;
            }
        }
    }
    
    goto cleanup;
    
error:
    res = NULL;
    
cleanup:
    if (longname != NULL) {
        g_free(longname);
        longname = NULL;
    }
    if (name != NULL) {
        free(name);
        name = NULL;
    }
    
    return (char *)res;
}


int
mntd_volume_helper_base_is_in_mntpath(const char *base, const char *mntpnt)
{
    int res = TRUE;
    int abs_base = 0;
    int abs_mntpnt = 0;
    gchar *path_base = NULL;
    gchar *path_mntpnt = NULL;
    
    g_assert(base!=NULL);
    g_assert(mntpnt!=NULL);

    // check for absolute pathes
    abs_base = g_path_is_absolute((gchar *)base);
    abs_mntpnt = g_path_is_absolute((gchar *)mntpnt);
    if (abs_base != abs_mntpnt) {
        goto no;
    }
    
    // check for substring
    path_base = g_build_path(G_DIR_SEPARATOR_S, (gchar *)base, NULL);
    if (path_base == NULL) {
        goto no;
    }
    path_mntpnt = g_build_path(G_DIR_SEPARATOR_S, (gchar *)mntpnt, NULL);
    if (path_mntpnt == NULL) {
        goto no;
    }
    if (!g_str_has_prefix(path_mntpnt, path_base)) {
        goto no;
    }
    
    goto cleanup;
    
no:
    res = FALSE;
    
cleanup:
    if (path_base != NULL) {
        g_free(path_base);
        path_base = NULL;
    }
    if (path_mntpnt != NULL) {
        g_free(path_mntpnt);
        path_mntpnt = NULL;
    }
    //MSG_DEBUG("mntd_volume_helper_base_is_in_mntpath('%s', '%s') returned %s", base, mntpnt, (res==TRUE) ? "true" : "false");

    return res;
}


int
mntd_volume_is_in_mntpath(PVOLUME pv)
{
    g_assert(pv!=NULL);
    
    if ((pv->mntpnt==NULL) || (pv->base==NULL)) {
        return FALSE;
    }
    
    return mntd_volume_helper_base_is_in_mntpath(pv->base, pv->mntpnt);
}


int
mntd_volume_send_mounted(PVOLUME pv)
{
    g_assert(pv!=NULL);
    g_assert(pv->udi!=NULL);
    g_assert(pv->mntpnt!=NULL);

    if (pv->last_signal!=SIGNAL_MOUNTED) {
        pv->last_signal = SIGNAL_MOUNTED;
        MSG_DEBUG("sending 'mounted' signal for '%s' ('%s') ...", pv->mntpnt, pv->udi);
        mntd_dbus_manager_send_signal_volume_mounted(pv);
    }

    return TRUE;
}


int
mntd_volume_send_unmounted(PVOLUME pv)
{
    g_assert(pv!=NULL);
    g_assert(pv->udi!=NULL);
    g_assert(pv->mntpnt!=NULL);

    if (pv->last_signal!=SIGNAL_UNMOUNTED) {
        pv->last_signal = SIGNAL_UNMOUNTED;
        MSG_DEBUG("sending 'unmounted' signal for '%s' ('%s') ...", pv->mntpnt, pv->udi);
        mntd_dbus_manager_send_signal_volume_unmounted(pv);
    }

    return TRUE;
}


int
mntd_volume_send_signal(PVOLUME pv, int what)
{
    g_assert(pv!=NULL);
    g_assert(pv->udi!=NULL);
    
    // called from mount()
    if (what==SIGNAL_MOUNTED) {
        pv->_send_mounted(pv);
    
    // called from unmount()
    } else if (what==SIGNAL_UNMOUNTED) {
        pv->_send_unmounted(pv);
    
    // called from somewhere else
    } else {
        if (pv->is_in_mntpath(pv)) {
            if (pv->mntpnt!=NULL) {
                pv->_send_mounted(pv);
            } else {
                pv->_send_unmounted(pv);
            }
        }
    }
    
    return TRUE;
}

---