main.c

/***************************************************************************
 * CVSID: $Id: main.c,v 1.61 2004/12/18 23:38:53 stefanb Exp $
 *
 * main.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 <sys/types.h>
#include <pwd.h>
#include <grp.h>

#include <libmnt/libmnt.h>   /* for common defines etc. */

#define _GNU_SOURCE
#include <getopt.h>

#include "errmanager.h"
#include "file.h"
#include "mntd_dbus_manager.h"
#include "mntd_volume_manager.h"
#include "mntd_volume_config.h"
#include "daemonize.h"
#include "main.h"
#include "sig.h"
#include "dbug_mem.h"


PMNTDDATA pmd = NULL;


void usage(void);
void sig_quit(int signum);
void sig_reload(int signum);


void 
usage(void)
{
    printf("Mount Daemon " PACKAGE_VERSION "\n");
    printf("Mounts devices automatically and unmount it again. It's meant\n");
    printf("to handle hotplug devices like USB storage or similar stuff.\n");
    printf("\n");
    printf("usage: mntd [-h] [-d] [-f configfile]\n");
    printf("\n");
    printf("    -h              Help (this text)\n");
    printf("    -d              Daemonize it\n");
    printf("    -r,--reload     Reload daemons configuration\n");
    printf("    -q,--quit       Quit daemon\n");
    printf("    -f,--file       Use given configfile\n");
    printf("    -p,--pidfile    Use given pidfile\n");
    printf("\n");
}


void sig_quit(int signum)
{
    sb_signal_handler_t old = signal(signum, SIG_IGN);
    
    // set quit flag
    pmd->quit_reason = QUIT_NORMAL;
    
    // quit main loop
    g_main_loop_quit(pmd->loop);
    
    signal(signum, old);
}


void sig_reload(int signum)
{
    sb_signal_handler_t old = signal(signum, SIG_IGN);
    
    // set reload flag
    pmd->quit_reason = QUIT_RELOAD;
    
    // quit main loop
    g_main_loop_quit(pmd->loop);
    
    signal(signum, old);
}


void mntd_cb_disconnect(void *user_data);
void mntd_cb_disconnect(void *user_data)
{
    PMNTDDATA pmntddata = (PMNTDDATA) user_data;
    
    // set disconnected flag
    pmntddata->quit_reason = QUIT_DISCONNECTED;
    
    // quit main loop
    g_main_loop_quit(pmntddata->loop);
}


int main(int argc, char* argv[])
{
    char *config = NULL;
    char *pidfile = DEFAULT_PIDFILE;
    int i=0;
    char *configfile = NULL;
    char *configfiles[] = {
#ifdef DEBUG
        "./mntd.conf",
        "../mntd.conf",
#endif
        MNTD_CONF_DIR "/mntd.conf",
        "/etc/mntd/mntd.conf",
        "/etc/mntd.conf",
        NULL
    };
    int daemonize = FALSE;
    int reload = FALSE;
    int quit = FALSE;
    //ConfigData c;
    struct passwd *pwd;
    struct group *grp;
        
    // parse commandline options
    while(1) {
        int c;
        int option_index = 0;
        static struct option long_options[] = {
            {"help", no_argument, 0, 'h'},
            {"daemonize", no_argument, 0, 'd'},
            {"reload", no_argument, 0, 'r'},
            {"quit", no_argument, 0, 'q'},
            {"file", required_argument, 0, 'f'},
            {"pidfile", required_argument, 0, 'p'},
            {0, 0, 0, 0}
        };
        c = getopt_long (argc, argv, "hf:dqrp:", long_options, &option_index);
        if (c == -1) {
            break;
        }
        switch (c) {
        case 'h':
            usage();
            exit(EXIT_SUCCESS);
            break;
        
        case 'd':
            daemonize = TRUE;
            break;
        
        case 'r':
            reload = TRUE;
            break;
        
        case 'q':
            quit = TRUE;
            break;
        
        case 'f':
            config = optarg;
            break;
        
        case 'p':
            pidfile = optarg;
            break;
        
        default:
            usage();
            exit(EXIT_FAILURE);
            break;
        }
    }
    
    // initialize error manager
#ifdef DEBUG
    emInit(LOG_DEBUG, EM_TYPE_SYSLOG, NULL, NULL, NULL, PACKAGE);
#else
    emInit(LOG_NOTICE, EM_TYPE_SYSLOG, NULL, NULL, NULL, PACKAGE);
#endif
    
    // activate memory debugging
    DBUG_MEM_INIT();
    
    // show version
    MSG_NOTICE("MNT daemon version " PACKAGE_VERSION " starting up");
    
    // get mem for mntd data structure
    pmd = (PMNTDDATA) malloc(sizeof(MNTDDATA));
    if (pmd==NULL) {
        MSG_ERR("No memory for mntd data structure left -> exiting ...");
        exit(EXIT_FAILURE);
    }
    
    // clear main structure
    memset(pmd, 0, sizeof(MNTDDATA));
    
    // initialize disconnect callback
    pmd->disconnect = mntd_cb_disconnect;
    
    // try to load config file
    if (config == NULL) {
        MSG_DEBUG("No config file specified. trying to find it.");
        i=0;
        while (configfiles[i]!=NULL) {
            configfile = configfiles[i];
            MSG_DEBUG("trying '%s' ...", configfile);
            if (sb_file_is_file(configfile)) {
                MSG_DEBUG("found '%s'", configfile);
                config = configfile;
                break;
            }
            i++;
        }
    }
    
    if (config == NULL) {
        MSG_EMERG("No config file given and nothing found. exiting.");
        exit(EXIT_FAILURE);
    }
    if (!sb_file_is_file(config)) {
        MSG_EMERG("Config file '%s' cannot be accessed.", config);
        exit(EXIT_FAILURE);
    }
    
    // read in config file
    pmd->configdata = mntd_volume_config_parse(config, pidfile);
    if (pmd->configdata==NULL) {
        MSG_ERR("Error reading configfile '%s'.", config);
        exit(EXIT_FAILURE);
    }
    
    // reinit with new loglevel
#ifndef DEBUG
    emInit(pmd->configdata->loglevel, EM_TYPE_SYSLOG, NULL, NULL, NULL, PACKAGE);
#endif

    // handle quit daemon
    if (quit == TRUE) {
        // check for running daemon, and send SIGTERM
        if (sb_daemon_is_running(pmd->configdata->pidfile) == 1) {
            pid_t pid = sb_daemon_pidfile_read(pmd->configdata->pidfile);
            if (pid != -1) {
                MSG_DEBUG("running daemon has pid %d -> sending SIGTERM", pid);
                kill(pid, SIGTERM);
            }
        } else {
            MSG_ERR("No daemon to shutdown found! (If running with another pidfile than '%s', shutdown it manually by sending SIGTERM to it)", pmd->configdata->pidfile);
            exit(EXIT_FAILURE);
        }
        mntd_volume_config_free(&(pmd->configdata));
        exit(EXIT_SUCCESS);
    }
    
    // handle reload daemon
    if (reload == TRUE) {
        // check for running daemon, and send SIGHUP
        if (sb_daemon_is_running(pmd->configdata->pidfile) == 1) {
            pid_t pid = sb_daemon_pidfile_read(pmd->configdata->pidfile);
            if (pid != -1) {
                MSG_DEBUG("running daemon has pid %d -> sending SIGHUP", pid);
                kill(pid, SIGHUP);
            }
        } else {
            MSG_ERR("No daemon to reload found! (If running with another pidfile than '%s', reload it manually by sending SIGHUP to it)", pmd->configdata->pidfile);
            exit(EXIT_FAILURE);
        }
        mntd_volume_config_free(&(pmd->configdata));
        exit(EXIT_SUCCESS);
    }
    
    // handle daemon mode
    if (daemonize == TRUE) {
        // is started by root ?
        if (sb_daemon_is_started_by_root() == 0) {
            MSG_ERR("You have to be root to start this daemon!");
            exit(EXIT_FAILURE);
        }
        // is started suid ?
        if (sb_daemon_is_started_suid() == 1) {
            MSG_ERR("Do not start this daemon with suid bits set!");
            exit(EXIT_FAILURE);
        }
        // drop privileges
        sb_daemon_drop_privileges();
        // create no core files
        sb_daemon_no_corefile();
        // check for running daemon
        if (sb_daemon_is_running(pmd->configdata->pidfile) == 1) {
            pid_t pid = sb_daemon_pidfile_read(pmd->configdata->pidfile);
            MSG_ERR("Daemon (pid=%d) already running. exiting.", pid);
            exit(EXIT_FAILURE);
        }
        // detach daemon
        if (sb_daemon_init(PACKAGE, pmd->configdata->wdir, 
                pmd->configdata->pidfile) != 0) {
            MSG_EMERG("Couldn't daemonize.");
            exit(EXIT_FAILURE);
        }
    } else {
        // generate pidfile
        int fd = -1;
        if (pmd->configdata->pidfile != NULL) {
            if ((fd = sb_daemon_pidfile_create_and_lock(pmd->configdata->pidfile)) == -1) {
                return -1;
            }
            if (sb_daemon_pidfile_write(fd) == -1) {
                return -1;
            }
        }
    }
    
    // get users data
    pwd = getpwuid(getuid());
    if (pwd == NULL) {
        MSG_ERR("Couldn't get user entry.");
        exit(EXIT_FAILURE);
    }
    grp = getgrgid(pwd->pw_gid);
    if (grp == NULL) {
        MSG_ERR("Couldn't get group entry.");
        exit(EXIT_FAILURE);
    }

    // print some daemon information
    MSG_INF("running as user '%s' (%d) and group '%s' (%d)", 
                pwd->pw_name, pwd->pw_uid, grp->gr_name, pwd->pw_gid);
    
    // installing signal handler
    sb_signal_set_handler(SIGTERM, sig_quit);
    sb_signal_set_handler(SIGINT, sig_quit);
    sb_signal_set_handler(SIGQUIT, sig_quit);
    sb_signal_set_handler(SIGABRT, sig_quit);
    sb_signal_set_handler(SIGHUP, sig_reload);
    
    // start volume manager
    pmd->vols = new_VolumeManager(pmd->configdata->mountpath, 
                                            pmd->configdata->mountprefix);
    if (pmd->vols == NULL) {
        MSG_EMERG("Couldn't not initialize system.");
        exit(EXIT_FAILURE);
    }
    
    pmd->loop = g_main_loop_new(NULL, FALSE);
    
    // reconnect loop
    int retries = 0;
    while(1) {
        int isconnected = -1;
        
        // initialize my dbus stuff
        isconnected = mntd_dbus_init(pmd);
        if (isconnected == 0) {
            
            // reset retries counter
            retries = 0;
            
            // Scan for Volumes
            pmd->vols->rescan(pmd->vols);
        
            // run the main loop
            g_main_loop_run(pmd->loop);
            
        } else {
            
            pmd->quit_reason = QUIT_NOT_CONNECTED;
            
        }
        
        // check first (sleep can be interrupted by signals (quit/reload) )
        if (pmd->quit_reason == QUIT_DISCONNECTED) {
            
            MSG_WARNING("Disconnected from DBUS (Retrying if configured).");
            
            // quit dbus connection
            mntd_dbus_quit();
            
            // increment retry counter
            retries++;
            
            // wait a little bit
            if (pmd->configdata->dbus_reconnect != -1) {
                usleep((pmd->configdata->sleep_millis)*1000);   // wait some second
            }
            
        } else if (pmd->quit_reason == QUIT_NOT_CONNECTED) {
            
            MSG_WARNING("Not connected to DBUS (Retrying if configured).");
            
            // increment retry counter
            retries++;
            
            // wait a little bit
            if (pmd->configdata->dbus_reconnect != -1) {
                usleep((pmd->configdata->sleep_millis)*1000);   // wait some second
            }
            
        }
        
        // show quit reason
        if (pmd->quit_reason == QUIT_NORMAL) {
            
            MSG_INF("QUIT requested -> shutting down daemon ...");
            
            // exit
            break;
            
        } else if (pmd->quit_reason == QUIT_RELOAD) {
            
            MSG_INF("RELOAD requested -> reloading configuration ...");
            
            // reload config
            mntd_volume_config_reload(&(pmd->configdata), pidfile);
            
            // goon
            continue;
            
        }

        // check for retry config
        if (pmd->configdata->dbus_reconnect == -1) {
            break;
        } else if (pmd->configdata->dbus_reconnect == 0) {
            continue;
        }
        
        MSG_DEBUG("trying to connect... %d", retries);

        // check for maximum retries
        if (retries >= pmd->configdata->dbus_reconnect) {
            MSG_INF("maximum retries reached -> exit");
            break;
        }
        
    }
    
    // restore all signal handler to default values
    sb_signal_restore_all_handlers();
    
    // destroy dbus handler
    mntd_dbus_quit();
    
    // free volume storage
    g_assert(pmd->vols!=NULL);
    pmd->vols->destroy(pmd->vols);
    
    // remove pidfile
    g_assert(pmd->configdata!=NULL);
    sb_daemon_destroy(pmd->configdata->pidfile);
    
    // free config
    mntd_volume_config_free(&(pmd->configdata));
    
    // free mntd data structure
    if (pmd != NULL) {
        memset(pmd, 0, sizeof(MNTDDATA));
        free(pmd);
        pmd = NULL;
    }
    
    // MNT daemon exists
    MSG_NOTICE("MNT daemon version " PACKAGE_VERSION " exited.");
    
    // deactivate memory debugging
    DBUG_MEM_QUIT();
    
    return 0;
}

---