Return to daemonize.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / miniupnpd / minissdpd

Annotation of embedaddon/miniupnpd/minissdpd/daemonize.c, revision 1.1.1.1

1.1       misho       1: /* $Id: daemonize.c,v 1.12 2011/05/27 09:35:02 nanard Exp $ */
                      2: /* MiniUPnP project
                      3:  * http://miniupnp.free.fr/ or http://miniupnp.tuxfamily.org/
                      4:  * (c) 2006 Thomas Bernard
                      5:  * This software is subject to the conditions detailed
                      6:  * in the LICENCE file provided within the distribution */
                      7: 
                      8: #include <sys/types.h>
                      9: #include <sys/stat.h>
                     10: #include <unistd.h>
                     11: #include <fcntl.h>
                     12: #include <stdio.h>
                     13: #include <stdlib.h>
                     14: #include <syslog.h>
                     15: #include <string.h>
                     16: #include <signal.h>
                     17: 
                     18: #include "daemonize.h"
                     19: #include "config.h"
                     20: 
                     21: #ifndef USE_DAEMON
                     22: 
                     23: int
                     24: daemonize(void)
                     25: {
                     26:        int pid, i;
                     27: 
                     28:        switch(fork())
                     29:        {
                     30:        /* fork error */
                     31:        case -1:
                     32:                perror("fork()");
                     33:                exit(1);
                     34: 
                     35:        /* child process */
                     36:        case 0:
                     37:                /* obtain a new process group */
                     38:                if( (pid = setsid()) < 0)
                     39:                {
                     40:                        perror("setsid()");
                     41:                        exit(1);
                     42:                }
                     43: 
                     44:                /* close all descriptors */
                     45:                for (i=getdtablesize();i>=0;--i) close(i);
                     46: 
                     47:                i = open("/dev/null", O_RDWR); /* open stdin */
                     48:                dup(i); /* stdout */
                     49:                dup(i); /* stderr */
                     50: 
                     51:                umask(027);
                     52:                chdir("/"); /* chdir to /tmp ? */
                     53: 
                     54:                return pid;
                     55: 
                     56:        /* parent process */
                     57:        default:
                     58:                exit(0);
                     59:        }
                     60: }
                     61: #endif
                     62: 
                     63: int
                     64: writepidfile(const char * fname, int pid)
                     65: {
                     66:        char pidstring[16];
                     67:        int pidstringlen;
                     68:        int pidfile;
                     69: 
                     70:        if(!fname || fname[0] == '\0')
                     71:                return -1;
                     72: 
                     73:        if( (pidfile = open(fname, O_WRONLY|O_CREAT, 0644)) < 0)
                     74:        {
                     75:                syslog(LOG_ERR, "Unable to open pidfile for writing %s: %m", fname);
                     76:                return -1;
                     77:        }
                     78: 
                     79:        pidstringlen = snprintf(pidstring, sizeof(pidstring), "%d\n", pid);
                     80:        if(pidstringlen <= 0)
                     81:        {
                     82:                syslog(LOG_ERR,
                     83:                        "Unable to write to pidfile %s: snprintf(): FAILED", fname);
                     84:                close(pidfile);
                     85:                return -1;
                     86:        }
                     87:        else
                     88:        {
                     89:                if(write(pidfile, pidstring, pidstringlen) < 0)
                     90:                        syslog(LOG_ERR, "Unable to write to pidfile %s: %m", fname);
                     91:        }
                     92: 
                     93:        close(pidfile);
                     94: 
                     95:        return 0;
                     96: }
                     97: 
                     98: int
                     99: checkforrunning(const char * fname)
                    100: {
                    101:        char buffer[64];
                    102:        int pidfile;
                    103:        pid_t pid;
                    104: 
                    105:        if(!fname || fname[0] == '\0')
                    106:                return -1;
                    107: 
                    108:        if( (pidfile = open(fname, O_RDONLY)) < 0)
                    109:                return 0;
                    110: 
                    111:        memset(buffer, 0, 64);
                    112: 
                    113:        if(read(pidfile, buffer, 63))
                    114:        {
                    115:                if( (pid = atol(buffer)) > 0)
                    116:                {
                    117:                        if(!kill(pid, 0))
                    118:                        {
                    119:                                close(pidfile);
                    120:                                return -2;
                    121:                        }
                    122:                }
                    123:        }
                    124: 
                    125:        close(pidfile);
                    126: 
                    127:        return 0;
                    128: }
                    129: