Daemon.cc

Go to the documentation of this file.

/*
 * Daemon.cc
 *
 * Smalltalk like class library for C++
 * Abstract daemon application.
 *
 * Copyright (c) 2004 Milan Cermak
 */
/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include <stdio.h>
#include <pwd.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>

#include <stlib/tools/Daemon.h>
#include <stlib/tools/Filename.h>
#include <stlib/tools/FileEncodedStreamFactory.h>

#include <stlib/EncodedStream.h>
#include <stlib/Number.h>
#include <stlib/String.h>
#include <stlib/FileOpenFailed.h>

using namespace Tools;

Daemon::Daemon(void)
{
    close_std_streams = false;
    change_current_directory = false;
    pid_path = new String("/var/run");
}

/* Accessing protocol */
String *Daemon::processIdPath(void)
{
    return pid_path;
}

void Daemon::processIdPath(String *path)
{
    pid_path = path;
}

void Daemon::redirectStreamsToNull(void)
{
    close_std_streams = true;
}

void Daemon::changeRootDirectory(void)
{
    change_current_directory = true;
}

void Daemon::runUnderUser(int uid)
{
    if (uid > 0) setuid(uid);
}

void Daemon::runUnderUserNamed(String *name)
{
    struct passwd *pass;
    pass = getpwnam(name->asCString());
    runUnderUser(pass->pw_uid);
}

/* Signaling protocol */
void Daemon::hookupSignal(int signo)
{
    signal(signo, globalSignalHandler);
}

void Daemon::hookupInterruptSignal(void)
{
    hookupSignal(SIGINT);
}

void Daemon::hookupTerminateSignal(void)
{
    hookupSignal(SIGTERM);
}

/* Processing protocol */
void Daemon::run(void)
{
    /* Is server already running */
    if (loadProcessId()) {
        cerr->nextPutAll("One server is already running.\n");
        return;
    }
    if (daemon(change_current_directory ? 0 : 1,
               close_std_streams ? 0 : 1) < 0) {
        cerr->nextPutAll("Cannot start daemon process.\n");
        return;
    }
    saveProcessId();
    Application::run();
    /* Delete PID file */
    processIdFilename()->erase();
}

/* Private protocol */
Filename *Daemon::processIdFilename(void)
{
    return (new Filename(pid_path))->construct(name()->concatenateWith(".pid"));
}

int Daemon::loadProcessId(void)
{
    Stream *pidfile;
    int pid;

    try {
        pidfile = processIdFilename()->withEncoding("default")->readStream();
        pid = dynamic_cast<String *>(pidfile->nextLine())->asNumber()->asLong();
        pidfile->close();
        return(pid);
    }
    catch (FileOpenFailed *ex) {
        return 0;
    }
}

void Daemon::saveProcessId(void)
{
    Stream *pidfile;

    pidfile = processIdFilename()->withEncoding("default")->writeStream();
    pidfile->print((long int) getpid());
    pidfile->lf();
    pidfile->close();
}

void Daemon::globalSignalHandler(int signo)
{
    dynamic_cast<Daemon *>(Application::current())->signalHandler(signo);
}

---