c++ create daemonizeMe-526互联

daemonizeMe

// Copyright (c) 2017 Deep Aggarwal
#include <getopt.h>
#include <grp.h>
#include <pwd.h>
#include <stdlib.h>
#include <syslog.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#include <fstream>
#include <iostream>
#include <stdexcept>
#include <string>
#include <thread>

static char *applicationName = NULL;
static char *pidFileName = NULL;
static int pidFd = -1;

/**
* @brief Callback function for handling signals.
*
* @param sig Identifier of a signal
*/
void handleSignal(int sig) {
if (sig == SIGINT) {
syslog(LOG_INFO, "Stopping %s", applicationName);

// Unlock and close lockfile
if (pidFd != -1) {
lockf(pidFd, F_ULOCK, 0);
close(pidFd);
}

// Delete lockfile
if (pidFileName != NULL) {
unlink(pidFileName);
}

// Reset signal handling to default behavior
signal(SIGINT, SIG_DFL);
}
}

static uid_t getUserID(const char *name) {
struct passwd pwentry;
struct passwd *result;
char *buf;
size_t bufsize;
int s;

// Call to sysconf(_SC_GETPW_R_SIZE_MAX) returns either -1
// without changing errno or an initial value suggested for
// the size for buf
bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
if (bufsize == -1) {
// Should be more than enough
bufsize = 16384;
}

buf = new char[bufsize];
if (buf == NULL) {
exit(EXIT_FAILURE);
}

s = getpwnam_r(name, &pwentry, buf, bufsize, &result);
if (result == NULL) {
if (s == 0) {
std::string sname = name;
throw std::runtime_error("User \""+ sname +"\" is not found");
} else {
std::cerr << "Error in getpwnam_r(...)" << std::endl;
}
exit(EXIT_FAILURE);
}

return pwentry.pw_uid;
}

static gid_t getGroupID(const char *name) {
struct group grentry;
struct group *result;
char *buf;
size_t bufsize;
int s;

// Call to sysconf(_SC_GETGR_R_SIZE_MAX) returns either -1
// without changing errno or an initial value suggested for
// the size for buf
bufsize = sysconf(_SC_GETGR_R_SIZE_MAX);
if (bufsize == -1) {
// Should be more than enough
bufsize = 16384;
}

buf = new char[bufsize];
if (buf == NULL) {
exit(EXIT_FAILURE);
}

s = getgrnam_r(name, &grentry, buf, bufsize, &result);
if (result == NULL) {
if (s == 0) {
std::string sname = name;
throw std::runtime_error("User \""+ sname +"\" is not found");
} else {
std::cerr << "Error in getgrnam_r(...)" << std::endl;
}
exit(EXIT_FAILURE);
}

return grentry.gr_gid;
}

/**
* @brief This function will daemonize this application
*/
static void daemonizeMe() {
pid_t pid = 0;
int fd;

// Fork off the parent process to ensures that
// the child process is not a process group leader, so
// that it is possible for that process tocreate
// a new session and become a session leader
pid = fork();

// If error occurred
if (pid < 0) {
exit(EXIT_FAILURE);
}

// On success, terminate the parent
if (pid > 0) {
exit(EXIT_SUCCESS);
}

// On success, the child process becomes processgroup
// and session group leader. Since a controlling terminal
// is associated with a session, and this new session
// has not yet acquired a controlling terminal our
// process now has no controlling terminal,
// which is a good thing for daemons
if (setsid() < 0) {
exit(EXIT_FAILURE);
}

// Ignore signal sent from child to parent process
signal(SIGCHLD, SIG_IGN);

// Fork off for the second time to ensure that
// the new child process is not a session leader,
// so it won't be able to (accidentally) allocate
// a controlling terminal, since daemons are not
// supposed to ever have a controlling terminal
pid = fork();

// If error occurred
if (pid < 0) {
exit(EXIT_FAILURE);
}

// On success, terminate the parent
if (pid > 0) {
exit(EXIT_SUCCESS);
}

// Set new file permissions
//
// "0" means that new files this daemon will
// create will have read and write permission for everyone
// (0666 or -rw-rw-rw-), and new directories that
// this daemon will create will have read, write and
// search permissions for everyone (0777 or drwxrwxrwx)
// This measn that we have complete control over the
// permissions of anything we write
umask(0);

// Change the working directory to the root directory
// This is to ensure that our process doesn't keep any directory in use.
// Failure to do this could make it so that an administrator couldn't unmount
// a filesystem, because it was our current directory
if (chdir("/") != 0) {
exit(EXIT_FAILURE);
}

// Drop priviledges since running network based daemons
// with root permissions is considered to be a serious risk
if (getuid() == 0) {
// If here that means process is running as root,
// so drop the root privileges
uid_t userid = NULL;
gid_t groupid = NULL;
try {
// FIXME: Hard-coded since this is the user that we will deal with
userid = getUserID("mydaemon");
groupid = getGroupID("mydaemon");
} catch(const std::runtime_error& error) {
syslog(LOG_ERR, "\"mydaemon\" couldn't be found");
exit(EXIT_FAILURE);
}

if (setgid(groupid) != 0) {
exit(EXIT_FAILURE);
}
if (setuid(userid) != 0) {
exit(EXIT_FAILURE);
}
}

// If we try to get root privileges back, it
// should fail. If it doesn't fail, we exit with failure
if (setuid(0) != -1) {
exit(EXIT_FAILURE);
}

// Close all open file descriptors
for (fd = sysconf(_SC_OPEN_MAX); fd > 0; fd--) {
close(fd);
}

// Reopen stdin (fd = 0), stdout (fd = 1), stderr (fd = 2) as /dev/null
stdin = fopen("/dev/null", "r");
stdout = fopen("/dev/null", "w+");
stderr = fopen("/dev/null", "w+");

// Write PID of daemon to lockfile
if (pidFileName != NULL) {
char str[256];
pidFd = open(pidFileName, O_RDWR|O_CREAT, 0640);
if (pidFd < 0) {
// Can't open lockfile
exit(EXIT_FAILURE);
}
if (lockf(pidFd, F_TLOCK, 0) < 0) {
// Can't lock file
exit(EXIT_FAILURE);
}

// Get current PID
sprintf(str, "%d\n", getpid());

// Write PID to lockfile
write(pidFd, str, strlen(str));
}
}

/**
* @brief This function starts the application
*/
static void startApplication() {
syslog(LOG_NOTICE, "I am daemonizeMe and I am writing to my syslog");
while (true) {
// Run your server here
// For example, a server running in background as a daemon process
// listening for incoming requests from clients
}
}

/**
* @brief Free allocated memory
*/
static void cleanGlobalMemory() {
if (pidFileName) {
free(pidFileName);
}

return;
}

/**
* @brief Print usage on the stdout
*/
void printHelp(void) {
printf("\nUsage: %s [OPTIONS]\n\n", applicationName);
printf("Options:\n");
printf(" -h --help Print this help message\n");
printf(" -p --pid_file filename PID file used by this application\n");
printf(" -d --daemon Daemonize this application\n");
printf("\n");
}

int main(int argc, char **argv) {
// Get the application name
applicationName = argv[0];

static struct option commandLineOptions[] = {
{"pid_file", required_argument, 0, 'p'},
{"daemon", no_argument, 0, 'd'},
{"help", no_argument, 0, 'h'},
{NULL, 0, 0, 0 }
};

// Process all the command line arguments
int getopt_longRV;
int optionIndex = 0;
int daemonize = 0; // 0 means do not daemonize
while ((getopt_longRV = getopt_long(argc,
argv,
"p:dh",
commandLineOptions,
&optionIndex)) != -1) {
switch (getopt_longRV) {
case 'p':
pidFileName = strdup(optarg);
break;
case 'd':
daemonize = 1;
break;
case 'h':
printHelp();
return EXIT_SUCCESS;
case '?':
printHelp();
return EXIT_FAILURE;
default:
break;
}
}