mntd_volume_manager.c

/***************************************************************************
 * CVSID: $Id: mntd_volume_manager.c,v 1.38 2004/12/18 23:38:53 stefanb Exp $
 *
 * mntd_volume_manager.c : Volume Manager 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 <libmnt/libmnt.h>   /* for common defines etc. */

#include "mntd_volume_manager.h"
#include "mntd_volume_hash.h"
#include "mntd_volume_config.h"
#include "mntd_volume.h"
#include "mntd_mount.h"
#include "errmanager.h"
#include "dbug_mem.h"


/* Private Methods */
int mntd_volume_manager_init(PVOLUMEMANAGER pvm);
void mntd_volume_manager_destroy(PVOLUMEMANAGER pvm);
void mntd_volume_manager_func_free(void *userdata);
void mntd_volume_manager_add_volume(PVOLUMEMANAGER pvm, const char *udi);
void mntd_volume_manager_remove_volume(PVOLUMEMANAGER pvm, const char *udi);
void mntd_volume_manager_rescan(PVOLUMEMANAGER pvm);
void mntd_volume_manager_foreach_mounted(PVOLUMEMANAGER pvm, 
                                                int (*func)(void *data, void *userdata), 
                                                void *userdata);
char *mntd_volume_manager_get_mntpnt(PVOLUMEMANAGER pvm, const char *udi);
int mntd_volume_manager_contains(PVOLUMEMANAGER pvm, const char *udi);
int mntd_volume_manager_remount(PVOLUMEMANAGER pvm, const char *udi, int flag);


PVOLUMEMANAGER new_VolumeManager(const char *base, const char *prefix)
{
    PVOLUMEMANAGER pvm = NULL;
    PHASHMAP phm = NULL;
    char *s_base = NULL;
    char *s_prefix = NULL;
    
    // check for error
    g_assert(base!=NULL);
    g_assert(prefix!=NULL);
    
    // get mem for volume object
    pvm = (PVOLUMEMANAGER) malloc(sizeof(VOLUMEMANAGER));
    if (pvm == NULL) {
        return NULL;
    }
    
    // clear structure memory
    memset(pvm, 0, sizeof(VOLUMEMANAGER));
    
    // generate hashmap
    phm = new_HashMap(DEFAULT_BUCKETS, mntd_volume_manager_func_free);
    if (phm == NULL) {
        goto error;
    }
    pvm->phm = phm;
    
    // setting basepath
    s_base = strdup(base);
    if (s_base == NULL) {
        goto error;
    }
    pvm->base = s_base;
    
    // setting basepath
    s_prefix = strdup(prefix);
    if (s_prefix == NULL) {
        goto error;
    }
    pvm->prefix = s_prefix;
    
    // private methods
    pvm->init = mntd_volume_manager_init;
    
    // public methods
    pvm->destroy = mntd_volume_manager_destroy;
    pvm->add_volume = mntd_volume_manager_add_volume;
    pvm->remove_volume = mntd_volume_manager_remove_volume;
    pvm->rescan = mntd_volume_manager_rescan;
    pvm->foreach_mounted = mntd_volume_manager_foreach_mounted;
    pvm->get_mntpnt = mntd_volume_manager_get_mntpnt;
    pvm->contains = mntd_volume_manager_contains;
    pvm->remount = mntd_volume_manager_remount;
    
    // call constructor
    if(pvm->init(pvm) == -1) {
        goto error;
    }
    
    goto exit;
    
error:
    pvm->destroy(pvm);
    pvm = NULL;
    
exit:
    // return object
    return pvm;
}


int mntd_volume_manager_init(PVOLUMEMANAGER pvm)
{
    g_assert(pvm!=NULL);
    
    return 0;
}


void mntd_volume_manager_destroy(PVOLUMEMANAGER pvm)
{
    PHASHMAP phm = NULL;
    
    g_assert(pvm!=NULL);
    
    // destroy base path name
    if (pvm->base != NULL) {
        free(pvm->base);
        pvm->base = NULL;
    }

    // destroy base path prefix
    if (pvm->prefix != NULL) {
        free(pvm->prefix);
        pvm->prefix = NULL;
    }

    // destroy hash
    phm = pvm->phm;
    if (phm != NULL) {
        phm->destroy(phm);
    }
    pvm->phm = NULL;
    
    // free volume manager structure
    memset(pvm, 0, sizeof(VOLUMEMANAGER));
    free(pvm);
    
    return;
}


void mntd_volume_manager_func_free(void *userdata)
{
    PVOLUME pv = NULL;
    
    if (userdata != NULL) {
        
        //MSG_DEBUG("----------==========  DESTROYING VOLUME OBJECT  ==========----------");
        
        pv = (PVOLUME) userdata;
        pv->destroy(pv);
        pv = NULL;
    } else {
        //MSG_ERR("No volume object to be freed given");
    }
    
    return;
}


void mntd_volume_manager_add_volume(PVOLUMEMANAGER pvm, const char *udi)
{
    PVOLUME pv = NULL;
    PHASHMAP phm = NULL;
    
    g_assert(pvm!=NULL);
    g_assert(udi!=NULL);
    g_assert((pvm->phm)!=NULL);
    phm = pvm->phm;

    //MSG_DEBUG("----------==========  ADD VOLUME  ==========---------- (%s)", udi);

    // generate new volume object
    pv = new_Volume(udi, pvm->base, pvm->prefix);
    
    if (pv!=NULL) {
        if (phm->add(phm, udi, pv) == 0) {
            if ((pv->set_device(pv, udi)) == -1) {
                MSG_WARNING("Couldn't set device '%s' for '%s'", udi, udi);
                return;
            }
        } else {
            pv->destroy(pv);
            pv = NULL;
            //MSG_ERR("Couldn't add Volume (%s) to Manager", udi);
        }
    }
    
    return;
}


void mntd_volume_manager_remove_volume(PVOLUMEMANAGER pvm, const char *udi)
{
    PHASHMAP phm = NULL;
    
    g_assert(pvm!=NULL);
    g_assert(udi!=NULL);
    
    phm = pvm->phm;
    if (phm!=NULL) {
        if (phm->contains(phm, udi)) {
            
            //MSG_DEBUG("----------==========  REMOVE VOLUME  ==========---------- (%s)", udi);
        
            phm->remove(phm, udi);
        }
    } else {
        //MSG_ERR("Hashmap pointer is NULL -> Cannot remove volume");
    }
    
    return;
}


void mntd_volume_manager_rescan(PVOLUMEMANAGER pvm)
{
    int res = -1;
    res = system(MNTRESCAN_BIN_PATH);
    if (res != 0) {
        MSG_ERR("'" MNTRESCAN_BIN_PATH "' failed !");
    }
    return;
}


void mntd_volume_manager_foreach_mounted(PVOLUMEMANAGER pvm, 
                                                int (*func)(void *data, void *userdata), 
                                                void *userdata)
{
    PHASHMAP phm = NULL;
    
    g_assert(pvm!=NULL);
    g_assert(func!=NULL);
    g_assert((pvm->phm)!=NULL);
    phm = pvm->phm;
    
    phm->foreach(phm, func, userdata);
    
    return;
}


char *mntd_volume_manager_get_mntpnt(PVOLUMEMANAGER pvm, const char *udi)
{
    PHASHMAP phm = NULL;
    PVOLUME pv = NULL;
    void *data = NULL;
    char *mntpnt = NULL;
    
    g_assert(pvm!=NULL);
    g_assert(udi!=NULL);
    g_assert((pvm->phm)!=NULL);
    phm = pvm->phm;
    
    if (phm->get(phm, udi, &data) == 0) {
        pv = (PVOLUME) data;
        if (pv!=NULL) {
            // check for mntd handled mntpnt
            if (pv->is_in_mntpath(pv)) {
                mntpnt = pv->get_mntpnt(pv);
                if (mntpnt!=NULL) {
                    return mntpnt;
                }
            }
        }
    }
    
    return NULL;
}


int mntd_volume_manager_contains(PVOLUMEMANAGER pvm, const char *udi)
{
    PHASHMAP phm = NULL;
    
    g_assert(pvm!=NULL);
    g_assert(udi!=NULL);
    g_assert((pvm->phm)!=NULL);
    phm = pvm->phm;
    
    return phm->contains(phm, udi);
}


int mntd_volume_manager_remount(PVOLUMEMANAGER pvm, const char *udi, int flag)
{
    PHASHMAP phm = NULL;
    PVOLUME pv = NULL;
    void *data = NULL;
    int res = -1;
    
    g_assert(pvm!=NULL);
    g_assert(udi!=NULL);
    g_assert((pvm->phm)!=NULL);
    phm = pvm->phm;
    
    if (phm->get(phm, udi, &data) == 0) {
        pv = (PVOLUME) data;
        if (pv!=NULL) {
            // check for mntd handled mntpnt
            if (pv->is_in_mntpath(pv)) {
                res = pv->remount(pv, flag);
            }
        }
    }
    
    return res;
}

---