misc/exampled/exampled.c

/*
 * UNIX Damon Server Programming Sample Program
 * To compile:          cc -o exampled exampled.c
 * TO run:              ./exampled
 * To test daemon:      ps aux | grep exampled
 * To test log:         tail -f /tmp/exampled.log
 * To test signal:      kill -HUP `cat /tmp/exampled.lock`
 * To terminate:        kill `cat /tmp/exampled.lock`
 */

#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>

#define RUNNING_DIR     "/tmp"
#define LOCK_FILE       "exampled.lock"
#define LOG_FILE        "exampled.log"
static const char *months[] = {
        "Jan","Feb","Mar","Apr","May","Jun",
        "Jul","Aug","Sep","Oct","Nov","Dec"};

void log_message(char *filename, char *message)
{
        FILE *logfile;
        char buf[30];
        long n = time(NULL);
        struct tm *now;
        now = localtime(&n);

        sprintf(buf, "%02d:%02d:%02d %s %02d %02d", 
                now->tm_hour, now->tm_min, now->tm_sec,months[now->tm_mon],
                now->tm_mday,now->tm_year % 100);
        
        logfile = fopen(filename, "a");
        if (!logfile) 
                return;
        fprintf(logfile, "%s: %s\n", buf, message);
        fclose(logfile);
}

void signal_handler(int sig)
{
        switch(sig) {
        case SIGHUP:
                log_message(LOG_FILE, "hangup signal catched");
                break;
        case SIGTERM:
                log_message(LOG_FILE, "terminate signal catched...exiting");
                unlink(LOCK_FILE);
                exit(0);
                break;
        }
}

void daemonize()
{
        int i, lfp;
        char str[10];
        
        if (getppid() == 1) /* already a daemon */
                return;
                
        i=fork();
        
        if (i<0) /* fork error */
                exit(1);
        if (i>0) /* parent exits */
                exit(0);
        /* child daemon continues */
        
        setsid(); /* obtain a new process group */
        
        for (i=getdtablesize(); i>=0; --i)
                close(i); /*close all descriptors*/
                
        i=open("/dev/null", O_RDWR); /* handle std. io */
        dup(i);
        dup(i);
        
        umask(027); /* set newly created file permissions */
        
        chdir(RUNNING_DIR); /* change running directory*/
        
        //attempt to create lockfile and put a file-lock on it
        lfp=open(LOCK_FILE,O_RDWR|O_CREAT, 0640);
        if (lfp<0) /* can not open */
                exit(1);
        if (lockf(lfp,F_TLOCK,0) < 0) /* can not lock */
                exit(0);
        
        /* first instance continues */
        sprintf(str, "%d\n", getpid() ); /* record pid to lockfile */
        write(lfp, str, strlen(str) );
        signal(SIGCHLD, SIG_IGN); /* ignore child */
        signal(SIGTSTP, SIG_IGN); /* ignore tty signals */
        signal(SIGTTOU, SIG_IGN);
        signal(SIGTTIN, SIG_IGN);
        signal(SIGHUP, signal_handler); /* catch hangup signal */
        signal(SIGTERM, signal_handler); /* catch kill signal */        
        log_message(LOG_FILE, "exampled started ...");
}

int main()
{
        daemonize();
        while(1)
                sleep(1); /*run*/
        return 0;
}
1	/*
2	* UNIX Damon Server Programming Sample Program
3	* To compile: cc -o exampled exampled.c
4	* TO run: ./exampled
5	* To test daemon: ps aux \| grep exampled
6	* To test log: tail -f /tmp/exampled.log
7	* To test signal: kill -HUP `cat /tmp/exampled.lock`
8	* To terminate: kill `cat /tmp/exampled.lock`
9	*/
10
11	#include <stdlib.h>
12	#include <stdio.h>
13	#include <fcntl.h>
14	#include <signal.h>
15	#include <unistd.h>
16	#include <string.h>
17	#include <time.h>
18	#include <sys/types.h>
19	#include <sys/stat.h>
20
21	#define RUNNING_DIR "/tmp"
22	#define LOCK_FILE "exampled.lock"
23	#define LOG_FILE "exampled.log"
24	static const char *months[] = {
25	"Jan","Feb","Mar","Apr","May","Jun",
26	"Jul","Aug","Sep","Oct","Nov","Dec"};
27
28	void log_message(char filename, char message)
29	{
30	FILE *logfile;
31	char buf[30];
32	long n = time(NULL);
33	struct tm *now;
34	now = localtime(&n);
35
36	sprintf(buf, "%02d:%02d:%02d %s %02d %02d",
37	now->tm_hour, now->tm_min, now->tm_sec,months[now->tm_mon],
38	now->tm_mday,now->tm_year % 100);
39
40	logfile = fopen(filename, "a");
41	if (!logfile)
42	return;
43	fprintf(logfile, "%s: %s\n", buf, message);
44	fclose(logfile);
45	}
46
47	void signal_handler(int sig)
48	{
49	switch(sig) {
50	case SIGHUP:
51	log_message(LOG_FILE, "hangup signal catched");
52	break;
53	case SIGTERM:
54	log_message(LOG_FILE, "terminate signal catched...exiting");
55	unlink(LOCK_FILE);
56	exit(0);
57	break;
58	}
59	}
60
61	void daemonize()
62	{
63	int i, lfp;
64	char str[10];
65
66	if (getppid() == 1) /* already a daemon */
67	return;
68
69	i=fork();
70
71	if (i<0) /* fork error */
72	exit(1);
73	if (i>0) /* parent exits */
74	exit(0);
75	/* child daemon continues */
76
77	setsid(); /* obtain a new process group */
78
79	for (i=getdtablesize(); i>=0; --i)
80	close(i); /close all descriptors/
81
82	i=open("/dev/null", O_RDWR); /* handle std. io */
83	dup(i);
84	dup(i);
85
86	umask(027); /* set newly created file permissions */
87
88	chdir(RUNNING_DIR); /* change running directory*/
89
90	//attempt to create lockfile and put a file-lock on it
91	lfp=open(LOCK_FILE,O_RDWR\|O_CREAT, 0640);
92	if (lfp<0) /* can not open */
93	exit(1);
94	if (lockf(lfp,F_TLOCK,0) < 0) /* can not lock */
95	exit(0);
96
97	/* first instance continues */
98	sprintf(str, "%d\n", getpid() ); /* record pid to lockfile */
99	write(lfp, str, strlen(str) );
100	signal(SIGCHLD, SIG_IGN); /* ignore child */
101	signal(SIGTSTP, SIG_IGN); /* ignore tty signals */
102	signal(SIGTTOU, SIG_IGN);
103	signal(SIGTTIN, SIG_IGN);
104	signal(SIGHUP, signal_handler); /* catch hangup signal */
105	signal(SIGTERM, signal_handler); /* catch kill signal */
106	log_message(LOG_FILE, "exampled started ...");
107	}
108
109	int main()
110	{
111	daemonize();
112	while(1)
113	sleep(1); /run/
114	return 0;
115	}