Нужно создать демон....как?

#ifndef MAIN_H_FILE
#define MAIN_H_FILE
 
#include <unistd.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <syslog.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/stat.h>
#include <sys/resource.h>
 
 
/***************************************************************************/
 
struct process_signal_args {
    void(*reread_func_t)(const void*);
    void* reread_arg;
    void(*terminate_func_t)(const void*);
    void* terminate_arg;
    /**  */
    sigset_t* mask;
    volatile int running;
};
 
/***************************************************************************/
 
void demonize(const char* cmd) {
    pid_t pid;
    struct rlimit limits;
    struct sigaction sa;
 
    umask(0);
 
    if ( getrlimit(RLIMIT_NOFILE, &limits) < 0 ) {
        perror("can`t get RLIMIT_NOFILE");
        exit(EXIT_FAILURE);
    }
 
    if ( (pid = fork()) < 0 ) {
        perror("fork error");
        exit(EXIT_FAILURE);
    } else if ( 0 != pid ) {
        exit(0);
    }
 
    if ( (setsid()) == (pid_t)-1 ) {
        perror("setsig error");
        exit(EXIT_FAILURE);
    }
 
    sa.sa_handler = SIG_IGN;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    if ( sigaction(SIGHUP, &sa, NULL) < 0 ) {
        perror("can`t ignore SIGHUP");
        exit(EXIT_FAILURE);
    }
 
    if ( (pid = fork()) < 0 ) {
        perror("fork error");
        exit(EXIT_FAILURE);
    } else if ( 0 != pid ) {
        exit(0);
    }
 
    if ( chdir("/") < 0 ) {
        perror("can`t chdir() to /");
        exit(EXIT_FAILURE);
    }
 
    if ( limits.rlim_max == RLIM_INFINITY )
        limits.rlim_max = 1024;
 
    u_int32_t idx;
    for ( idx = 0; idx < limits.rlim_max; ++idx ) {
        close(idx);
    }
 
    int fd0 = open("/dev/null", O_RDWR);
    int fd1 = dup(0);
    int fd2 = dup(0);
 
    openlog(cmd, LOG_CONS, LOG_DAEMON);
    if ( fd0 != 0 || fd1 != 1 || fd2 != 2 ) {
        syslog(LOG_ERR, "bad file descriptors: %d, %d, %d", fd0, fd1, fd2);
        exit(EXIT_FAILURE);
    }
}
 
/***************************************************************************/
 
int already_running(const char* cmd) {
    char buff[4096] = "\0";
    sprintf(buff, "%s%s", "/var/run/", cmd);
    /**  */
    int fd = open(buff, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
    if ( fd < 0 ) {
        perror("can`t open PID file");
        exit(EXIT_FAILURE);
    }
    if ( lockf(fd, F_TLOCK, 0) ) {
        if ( errno == EACCES || errno == EAGAIN ) {
            close(fd);
            return 1;
        }
        perror("can`t lock PID file");
        exit(EXIT_FAILURE);
    }
 
    ftruncate(fd, 0);
    sprintf(buff, "%d", (int)getpid());
    write(fd, buff, strlen(buff));
 
    return 0;
}
 
/***************************************************************************/
 
void* process_signal_thr(void* arg) {
    struct process_signal_args* opt = (struct process_signal_args*)arg;
    while ( opt->running ) {
        int signo = 0;
        if ( 0 != sigwait(opt->mask, &signo) ) {
            syslog(LOG_ERR, "error in sigwait: %s", strerror(errno));
            exit(EXIT_FAILURE);
        }
        switch ( signo ) {
            case SIGHUP:
                syslog(LOG_INFO, "reread configuration");
                if ( opt->reread_func_t ) {
                    opt->reread_func_t(opt->reread_arg);
                }
                break;
            case SIGTERM:
                syslog(LOG_INFO, "receive signal SIGTERM. exiting...");
                if ( opt->terminate_func_t ) {
                    opt->terminate_func_t(opt->terminate_arg);
                }
                opt->running = 0;
                break;
            default:
                syslog(LOG_INFO, "unspecified signal '%d' received. ignored.", signo);
                break;
        }
    }
    return NULL;
}
 
/***************************************************************************/
 
#endif // MAIN_H_FILE

#include <pthread.h>
#include "main.h"
 
volatile int runflag = 1;
/***************************************************************************/
 
void reread_func(const void* ptr) {
    printf("reread_func() called(%s)", (const char*)ptr);
}
 
void terminate_func(const void* ptr) {
    printf("terminate_func() called(%s)", (const char*)ptr);
    runflag = 0;
}
 
/***************************************************************************/
/** прежняя main() функция */
int main2(int argc, char** argv) {
    int idx = 0;
    for ( ; runflag; ++idx ) {
        syslog(LOG_INFO, "ping %d", idx);
        sleep(1);
    }
    return 0;
}
 
/***************************************************************************/
 
int main(int argc, char** argv) {
    sigset_t mask;
    struct sigaction sa;
    pthread_t tid;
    struct process_signal_args thread_args;
    memset(&thread_args, 0, sizeof(struct process_signal_args));
 
    const char* cmd = (NULL == strrchr(argv[0], '/')) ? argv[0] : strrchr(argv[0], '/')+1;
    demonize(cmd);
 
    if ( already_running(cmd) ) {
        perror("daemon already running");
        exit(EXIT_FAILURE);
    }
 
    sa.sa_handler = SIG_DFL;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    if ( sigaction(SIGHUP, &sa, NULL) < 0 ) {
        perror("sigaction error");
        exit(EXIT_FAILURE);
    }
 
    sigfillset(&mask);
    if ( 0 != pthread_sigmask(SIG_BLOCK, &mask, NULL) ) {
        perror("pthread_sigmask error");
        exit(EXIT_FAILURE);
    }
 
    thread_args.mask = &mask;
    thread_args.running = 1;
    /**  */
    thread_args.reread_func_t = reread_func;
    thread_args.reread_arg = "reread_arg";
    /**  */
    thread_args.terminate_func_t = terminate_func;
    thread_args.terminate_arg = "terminate_arg";
    /**  */
    if ( pthread_create(&tid, NULL, process_signal_thr, &thread_args) ) {
        perror("can`t create thread");
        exit(EXIT_FAILURE);
    }
 
    /* тут код программы */
    syslog(LOG_INFO, "process \"%s\" running...", cmd);
    return main2(argc, argv);
}
 
/***************************************************************************/