projects/smsdaemon/daemon.cpp

#include <iostream>
#include <sstream>
#include <signal.h>
#include <fcntl.h>
#include <stdlib.h>
#include <cstring>
#include <cstdio>

#include <sys/types.h>
#include <pwd.h>
#include <grp.h>


#include "ConfigFile.h"
#include "daemon.h"
#include "Common.h"
#include "Logger.h"


using namespace std;


void signal_handler(int sig)
{
        switch (sig)
        {
        case SIGHUP:
                Logger::logMessage("Reload config");
                Common::instance()->reloadConfig = true;

                break;

        case SIGTERM:
                Logger::logMessage("terminate signal catched...exiting");
                Common::instance()->mainContinue = false;
                break;
        default:
                std::stringstream ss;
                ss << "Received unknown signal: " << sig;
                Logger::logMessage(ss.str());
                break;
        }
}

void lookup_uid_values()
{
        Common* cmn = Common::instance();

        std::string userstr = cmn->GetConfigfile()->GetValue("smsdaemon","user","");
        std::string groupstr = cmn->GetConfigfile()->GetValue("smsdaemon","group","");

        passwd* pass = getpwnam(userstr.c_str());
        if (pass != 0)
        {
                cmn->uid = pass->pw_uid;
        }
        else
        {
                Logger::logMessage( string("could not lookup userid: ") + userstr );
                exit(1);
        }


        group* grp = getgrnam(groupstr.c_str() );
        if (grp != 0)
        {
                cmn->gid = grp->gr_gid;
        }
        else
        {
                Logger::logMessage( string("could not lookup groupid: ") + groupstr );
                exit(1);
        }
}


void daemonCleanup()
{
        Common* cmn = Common::instance();
        Logger::logMessage("Cleaning up daemon");

        seteuid(0);
        setegid(0);
        unlink( cmn->pidfile.c_str() );

}

void daemonize()
{
        int i, lfp;
        char str[10];
        Common* cmn = Common::instance();

        if (getuid() != 0)
        {
                cout << "Please start this daemon as root\n" << endl;
                daemon_shutdown(0);
        }


        if (getppid() == 1) /* already a daemon */
                return;

        i=fork();

        if (i<0) /* fork error */
                daemon_shutdown(FORK_ERROR);
        if (i>0) /* parent exits */
                daemon_shutdown(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("/tmp"); /* change running directory*/

        /*attempt to create lockfile and put a file-lock on it*/
        lfp=open(cmn->pidfile.c_str(), O_RDWR|O_CREAT, 0640);
        if (lfp<0) /* can not open */
                daemon_shutdown(CANT_OPEN_LOCK);
        if (lockf(lfp,F_TLOCK,0) < 0) /* can not lock */
                daemon_shutdown(ALREADY_LOCKED);

        /* 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 */
        signal(SIGINT, signal_handler); /* keyboard interrupt */
        signal(SIGQUIT, signal_handler); /* QUIT */

        /*this program is now a daemon*/
        setegid( cmn->gid );
        seteuid( cmn->uid );
}
1	#include <iostream>
2	#include <sstream>
3	#include <signal.h>
4	#include <fcntl.h>
5	#include <stdlib.h>
6	#include <cstring>
7	#include <cstdio>
8
9	#include <sys/types.h>
10	#include <pwd.h>
11	#include <grp.h>
12
13
14	#include "ConfigFile.h"
15	#include "daemon.h"
16	#include "Common.h"
17	#include "Logger.h"
18
19
20
21	using namespace std;
22
23
24	void signal_handler(int sig)
25	{
26	switch (sig)
27	{
28	case SIGHUP:
29	Logger::logMessage("Reload config");
30	Common::instance()->reloadConfig = true;
31
32	break;
33
34	case SIGTERM:
35	Logger::logMessage("terminate signal catched...exiting");
36	Common::instance()->mainContinue = false;
37	break;
38	default:
39	std::stringstream ss;
40	ss << "Received unknown signal: " << sig;
41	Logger::logMessage(ss.str());
42	break;
43	}
44	}
45
46	void lookup_uid_values()
47	{
48	Common* cmn = Common::instance();
49
50	std::string userstr = cmn->GetConfigfile()->GetValue("smsdaemon","user","");
51	std::string groupstr = cmn->GetConfigfile()->GetValue("smsdaemon","group","");
52
53	passwd* pass = getpwnam(userstr.c_str());
54	if (pass != 0)
55	{
56	cmn->uid = pass->pw_uid;
57	}
58	else
59	{
60	Logger::logMessage( string("could not lookup userid: ") + userstr );
61	exit(1);
62	}
63
64
65	group* grp = getgrnam(groupstr.c_str() );
66	if (grp != 0)
67	{
68	cmn->gid = grp->gr_gid;
69	}
70	else
71	{
72	Logger::logMessage( string("could not lookup groupid: ") + groupstr );
73	exit(1);
74	}
75	}
76
77
78	void daemonCleanup()
79	{
80	Common* cmn = Common::instance();
81	Logger::logMessage("Cleaning up daemon");
82
83	seteuid(0);
84	setegid(0);
85	unlink( cmn->pidfile.c_str() );
86
87	}
88
89	void daemonize()
90	{
91	int i, lfp;
92	char str[10];
93	Common* cmn = Common::instance();
94
95	if (getuid() != 0)
96	{
97	cout << "Please start this daemon as root\n" << endl;
98	daemon_shutdown(0);
99	}
100
101
102	if (getppid() == 1) /* already a daemon */
103	return;
104
105	i=fork();
106
107	if (i<0) /* fork error */
108	daemon_shutdown(FORK_ERROR);
109	if (i>0) /* parent exits */
110	daemon_shutdown(0);
111	/* child daemon continues */
112
113	setsid(); /* obtain a new process group */
114
115	for (i=getdtablesize(); i>=0; --i)
116	close(i); /close all descriptors/
117
118	i=open("/dev/null", O_RDWR); /* handle std. io */
119	dup(i);
120	dup(i);
121
122	umask(027); /* set newly created file permissions */
123
124	chdir("/tmp"); /* change running directory*/
125
126	/attempt to create lockfile and put a file-lock on it/
127	lfp=open(cmn->pidfile.c_str(), O_RDWR\|O_CREAT, 0640);
128	if (lfp<0) /* can not open */
129	daemon_shutdown(CANT_OPEN_LOCK);
130	if (lockf(lfp,F_TLOCK,0) < 0) /* can not lock */
131	daemon_shutdown(ALREADY_LOCKED);
132
133	/* first instance continues */
134	sprintf(str, "%d\n", getpid() ); /* record pid to lockfile */
135	write(lfp, str, strlen(str) );
136	//signal(SIGCHLD, SIG_IGN); /* ignore child */
137	signal(SIGTSTP, SIG_IGN); /* ignore tty signals */
138	signal(SIGTTOU, SIG_IGN);
139	signal(SIGTTIN, SIG_IGN);
140	signal(SIGHUP, signal_handler); /* catch hangup signal */
141	signal(SIGTERM, signal_handler); /* catch kill signal */
142	signal(SIGINT, signal_handler); /* keyboard interrupt */
143	signal(SIGQUIT, signal_handler); /* QUIT */
144
145	/this program is now a daemon/
146	setegid( cmn->gid );
147	seteuid( cmn->uid );
148	}