projects/smsdaemon/daemon.cpp

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

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