int daemonize(int chdir2root)
{
switch (fork()) {
case -1: /* error */
return TRACKD_ERR;
case 0: /* child */
break;
default: /* parent */
_exit(EXIT_SUCCESS);
}
if (setsid() == -1)
return TRACKD_ERR;
if (chdir2root) {
if(chdir("/") != 0) {
perror("chdir");
return TRACKD_ERR;
}
}
createPidFile(g_settings->pidfile);
return TRACKD_OK;
}
// ----------------------------------------------------
// Function called when we want to start the server.
// This function expects the following parameter to be passed:
// the directory of the server we want to start and the
// command line (and its argumets) that we want to execute (basically the java
// command that we want to start the server). The main reasons
// to have the command line passed are:
// 1. Keep the native code as minimal as possible.
// 2. Allow the administrator some flexibility in the way the
// server is started by leaving most of the logic in the command-line.
//
// This approach makes things to be closer between what is proposed
// in windows and in UNIX systems.
//
// If the instance could be started the code will write the pid of the process
// of the server in file that can be used for instance to stop the server
// (see stop.c).
//
// Returns the pid of the process of the instance if it could be started and -1
// otherwise.
// ----------------------------------------------------
int start(const char* instanceDir, char* argv[])
{
int returnValue;
int childPid;
char command[COMMAND_SIZE];
if (getCommandLine(argv, command, COMMAND_SIZE))
{
childPid = spawn(command, TRUE);
if (childPid > 0)
{
createPidFile(instanceDir, childPid);
returnValue = childPid;
}
else
{
debugError("Couldn't start the child process because the spawn failed.");
returnValue = -1;
}
}
else
{
debugError("Couldn't start the child process because the full command line could not be constructed.");
returnValue = -1;
}
return returnValue;
} // start
void Initializer::initDaemon() {
if (FLAGS_config_check) {
// No need to daemonize, emit log lines, or create process mutexes.
return;
}
#ifndef __APPLE__
// OSX uses launchd to daemonize.
if (osquery::FLAGS_daemonize) {
if (daemon(0, 0) == -1) {
::exit(EXIT_FAILURE);
}
}
#endif
// Print the version to SYSLOG.
syslog(
LOG_NOTICE, "%s started [version=%s]", binary_.c_str(), OSQUERY_VERSION);
// Check if /var/osquery exists
if ((Flag::isDefault("pidfile") || Flag::isDefault("database_path")) &&
!isDirectory("/var/osquery")) {
std::cerr << CONFIG_ERROR
}
// Create a process mutex around the daemon.
auto pid_status = createPidFile();
if (!pid_status.ok()) {
LOG(ERROR) << binary_ << " initialize failed: " << pid_status.toString();
::exit(EXIT_FAILURE);
}
}
bool VoxMain::initialize(int argc, char** argv)
{
if(!readUserInput(argc, argv))
return false;
installSignalHandler();
if(!setToDaemon())
return false;
if(!setupLog())
return false;
if(!INIT_WIRING)
{
ERROR("INIT_WIRING failed!");
return false;
}
if(!VoxControl::getInstance().start())
{
ERROR("(MAIN) failed to start controller thread");
return false;
}
if(!VoxSensor::getInstance().start())
{
ERROR("(MAIN) failed to start sensor thread");
return false;
}
if(!VoxPlayer::getInstance().start())
{
ERROR("(MAIN) failed to start player thread");
return false;
}
if(!VoxVision::getInstance().start())
{
ERROR("(MAIN) failed to start vision thread");
return false;
}
if(!VoxVoice::getInstance().start())
{
ERROR("(MAIN) failed to start voice thread");
return false;
}
if(!createPidFile())
{
ERROR("(MAIN) pid file '%s' create failed", m_pidfile.c_str());
return false;
}
return true;
}
int main(int argc, char** argv)
{
printf("%s %s, Copyright 2015 by OneXSoft\n\n", APP_NAME, APP_VERSION);
const char* cfgFile = "onecache.xml";
if (argc == 1) {
LOG(Logger::Message, "No config file specified. using the default config(%s)", cfgFile);
}
if (argc >= 2) {
cfgFile = argv[1];
}
CRedisProxyCfg* cfg = CRedisProxyCfg::instance();
if (!cfg->loadCfg(cfgFile)) {
LOG(Logger::Error, "Failed to read config file");
return 1;
}
const char* errInfo;
if (!CRedisProxyCfgChecker::isValid(cfg, errInfo)) {
LOG(Logger::Error, "Invalid configuration: %s", errInfo);
return 1;
}
FileLogger fileLogger;
if (fileLogger.setFileName(cfg->logFile())) {
LOG(Logger::Message, "Using the log file(%s) output", fileLogger.fileName());
Logger::setDefaultLogger(&fileLogger);
}
GlobalLogOption::__debug = cfg->debug();
const char* pidfile = cfg->pidFile();
bool pidfile_enabled = (strlen(pidfile) > 0);
if (pidfile_enabled) {
createPidFile(pidfile);
}
//Background
if (cfg->daemonize()) {
NonPortable::daemonize();
}
//Guard
if (cfg->guard()) {
NonPortable::guard(startOneCache, APP_EXIT_KEY);
} else {
startOneCache();
}
if (pidfile_enabled) {
remove(pidfile);
}
return 0;
}
PidFile::PidFile(
const char * path,
const char * name,
const char * ext
)
: fileName( path, name, ext ),
osErrno( 0 )
{
createPidFile();
}
void Initializer::initDaemon() const {
if (FLAGS_config_check) {
// No need to daemonize, emit log lines, or create process mutexes.
return;
}
#ifndef __APPLE__
// OS X uses launchd to daemonize.
if (osquery::FLAGS_daemonize) {
if (daemon(0, 0) == -1) {
shutdown(EXIT_FAILURE);
}
}
#endif
// Print the version to SYSLOG.
syslog(
LOG_NOTICE, "%s started [version=%s]", binary_.c_str(), kVersion.c_str());
// Check if /var/osquery exists
if ((Flag::isDefault("pidfile") || Flag::isDefault("database_path")) &&
!isDirectory(OSQUERY_HOME)) {
std::cerr << CONFIG_ERROR;
}
// Create a process mutex around the daemon.
auto pid_status = createPidFile();
if (!pid_status.ok()) {
LOG(ERROR) << binary_ << " initialize failed: " << pid_status.toString();
shutdown(EXIT_FAILURE);
}
// Nice ourselves if using a watchdog and the level is not too permissive.
if (!FLAGS_disable_watchdog &&
FLAGS_watchdog_level >= WATCHDOG_LEVEL_DEFAULT &&
FLAGS_watchdog_level != WATCHDOG_LEVEL_DEBUG) {
// Set CPU scheduling I/O limits.
setpriority(PRIO_PGRP, 0, 10);
#ifdef __linux__
// Using: ioprio_set(IOPRIO_WHO_PGRP, 0, IOPRIO_CLASS_IDLE);
syscall(SYS_ioprio_set, IOPRIO_WHO_PGRP, 0, IOPRIO_CLASS_IDLE);
#elif defined(__APPLE__)
setiopolicy_np(IOPOL_TYPE_DISK, IOPOL_SCOPE_PROCESS, IOPOL_THROTTLE);
#endif
}
}
void Initializer::initDaemon() const {
if (FLAGS_config_check) {
// No need to daemonize, emit log lines, or create process mutexes.
return;
}
#if !defined(__APPLE__) && !defined(WIN32)
// OS X uses launchd to daemonize.
if (osquery::FLAGS_daemonize) {
if (daemon(0, 0) == -1) {
shutdown(EXIT_FAILURE);
}
}
#endif
// Print the version to the OS system log.
systemLog(binary_ + " started [version=" + kVersion + "]");
if (!FLAGS_ephemeral) {
if ((Flag::isDefault("pidfile") || Flag::isDefault("database_path")) &&
!isDirectory(OSQUERY_HOME)) {
std::cerr << CONFIG_ERROR;
}
// Create a process mutex around the daemon.
auto pid_status = createPidFile();
if (!pid_status.ok()) {
LOG(ERROR) << binary_ << " initialize failed: " << pid_status.toString();
shutdown(EXIT_FAILURE);
}
}
// Nice ourselves if using a watchdog and the level is not too permissive.
if (!FLAGS_disable_watchdog && FLAGS_watchdog_level >= 0) {
// Set CPU scheduling I/O limits.
setToBackgroundPriority();
#ifdef __linux__
// Using: ioprio_set(IOPRIO_WHO_PGRP, 0, IOPRIO_CLASS_IDLE);
syscall(SYS_ioprio_set, IOPRIO_WHO_PGRP, 0, IOPRIO_CLASS_IDLE);
#elif defined(__APPLE__)
setiopolicy_np(IOPOL_TYPE_DISK, IOPOL_SCOPE_PROCESS, IOPOL_THROTTLE);
#endif
}
}
void *sfs_init(struct fuse_conn_info *conn) {
char pidpath[PATH_MAX];
// open syslog
openlog(config.ident, 0, LOG_DAEMON);
// write PID into .pid file
// we can't do it in main(), because fuse clones this process
snprintf(pidpath, PATH_MAX, "/var/run/syncedfs/fs/%s.pid", config.resource);
config.pidfd = createPidFile(config.ident, pidpath, 0);
// setup signal handlers
struct sigaction act;
sigemptyset(&act.sa_mask);
act.sa_sigaction = handleSIGUSR1;
act.sa_flags = SA_SIGINFO;
if (sigaction(SIGUSR1, &act, NULL) == -1)
errMsg(LOG_ERR, "Could not setup signal handlers.");
return NULL;
}
void startServer(void) {
int pidfd;
char pidpath[PATH_MAX];
int lfd, cfd;
socklen_t addrlen;
struct sockaddr claddr;
lfd = inetListen(config.port, 0, &addrlen);
if (lfd == -1) {
errMsg(LOG_ERR, "Could not listen on port %s.", config.port);
return;
}
snprintf(pidpath, PATH_MAX, "/var/run/syncedfs/server/%s.pid",
config.resource);
pidfd = createPidFile(config.ident, pidpath, 0);
if (pidfd == -1) {
errMsg(LOG_ERR, "Could not create pid file %s, Exiting server.", pidpath);
return;
}
errMsg(LOG_INFO, "Server booted.");
//setup signal handler to stop handling requests
for (;;) {
cfd = accept(lfd, (struct sockaddr *) &claddr, &addrlen);
if (cfd == -1) {
errnoMsg(LOG_ERR, "Error accepting client.");
continue;
}
handleClient(cfd, &claddr, &addrlen);
}
// delete pid file
if (deletePidFile(pidfd, pidpath) == -1)
errExit(LOG_ERR, "Deleting PID file '%s'", pidpath);
}
int main(int argc, char **argv)
{
if (3 != argc)
{
help(argc, argv);
return -1;
}
int opt = -1;
char configfile[MIN_BUFSZ] = "";
while ((opt = getopt(argc, argv, "c:")) != -1)
{
switch (opt)
{
case 'c':
strcpy(configfile, optarg);
break;
default:
help(argc, argv);
return -1;
}
}
initServerConfig();
if (-1 == loadServerConfig(configfile))
{
return -1;
}
if (g_Server.daemonize)
{
daemonize();
}
initServer();
if (g_Server.daemonize)
{
createPidFile();
}
g_ListenThread = new ListenThread();
if (NULL == g_ListenThread)
{
myepollLog(MY_WARNING, "new ListenThread() err");
return -1;
}
if (-1 == g_ListenThread->Bind())
{
kill(getpid(), SIGTERM);
}
myepollLog(MY_NOTICE, "Epoll server is running :) ... (press CTRL-C to stop)");
poll(NULL, 0, -1);
return 0;
}
int synchronize(void) {
int pidfd;
char pidpath[PATH_MAX];
int logfd;
char logpath[PATH_MAX];
int newsync = 0;
// make sure, that there isn't another client process for this resource
// already running
snprintf(pidpath, PATH_MAX, "/var/run/syncedfs/client/%s.pid",
config.resource);
pidfd = createPidFile(config.ident, pidpath, 0);
if (pidfd == -1) {
errMsg(LOG_ERR, "Could not create pid file %s, Exiting sync.", pidpath);
return -1;
}
// if sync log does not exist, switch log
snprintf(logpath, PATH_MAX, "%s/%s.sync", config.logdir, config.resource);
errMsg(LOG_INFO, "logpath: %s", logpath);
logfd = open(logpath, O_RDONLY);
if (logfd == -1) {
if (switchLog() != 0) {
errMsg(LOG_ERR, "Could not switch log file. Stopping.");
return -1;
}
logfd = open(logpath, O_RDONLY);
if (logfd == -1) {
errnoMsg(LOG_ERR, "Could not open log file %s", logpath);
return -1;
}
newsync = 1;
}
// sync-id
char id[SYNCID_MAX];
char idpath[PATH_MAX];
snprintf(idpath, PATH_MAX, "%s/%s.id", config.logdir, config.resource);
// second part of the condition covers weird states after crash etc.
if (newsync == 1 || readSyncId(id, idpath, SYNCID_MAX) != 0) {
if (generateSyncId(id, SYNCID_MAX) != 0) {
errMsg(LOG_ERR, "Could not get sync-id. Stopping.");
return -1;
}
if (writeSyncId(id, idpath) != 0) {
errMsg(LOG_ERR, "Could not write sync-id. Stopping.");
return -1;
}
}
// create snapshot
if (newsync || !fileExists(config.snapshot)) {
if (createSnapshot(config.rootdir, config.snapshot, 1) == -1) {
errMsg(LOG_ERR, "Could not create snapshot of %s to %s Stopping.",
config.rootdir, config.snapshot);
return -1;
}
}
// load log
if (loadLog(logfd) != 0) {
errMsg(LOG_ERR, "Could not load log %s", logpath);
return -1;
}
// transfer changes
if (transfer(config.host, config.port) == -1) {
errMsg(LOG_ERR, "Error in transfer. Exiting sync.");
// in case of failure only delete pid file
if (deletePidFile(pidfd, pidpath) == -1)
errExit(LOG_ERR, "Deleting PID file '%s'", pidpath);
return -1;
}
// delete snapshot
if (deleteSnapshot(config.snapshot) == -1)
errMsg(LOG_ERR, "Could not delete snapshot %s", config.snapshot);
// delete syncid
if (unlink(idpath) == -1)
errExit(LOG_ERR, "Deleting sync-id file '%s'", idpath);
// delete sync log
close(logfd);
if (unlink(logpath) == -1)
errExit(LOG_ERR, "Deleting log file '%s'", logpath);
// delete pid file
if (deletePidFile(pidfd, pidpath) == -1)
errExit(LOG_ERR, "Deleting PID file '%s'", pidpath);
return 0;
}
int main(int argc, char** argv) {
struct mg_server *server;
char buf[100];
char cert[100];
const char* pidFile = "/var/run/checkip.pid";
char port[140];
char* user = "******";
int jail_mode = FALSE;
int c;
int fd = -1;
// init variables
pid_t process_id = 0;
pid_t sid = 0;
daemon_mode = FALSE;
letsencrypt_req[0] = '\0';
letsencrypt_resp[0] = '\0';
strncpy(cert, "checkip-cert.pem", sizeof cert);
initValidIP();
jailDir[0] = '\0';
// Get the start time
time(&start);
// Parse command line for "-h -p nnn -c /path/to/file"
while((c = getopt(argc, argv, "dhj:p:u:r:R:c:")) != -1)
{
switch(c)
{
case 'c': strncpy(cert, optarg, sizeof cert);
break;
case 'd': daemon_mode = TRUE;
break;
case 'j': jail_mode = TRUE;
char* temp_dir = optarg;
if (!dir_exists(temp_dir)) {
printf("Jail root dir '%s' does not exist, or is not a directory\n", jailDir);
return -1;
}
strncpy(jailDir, realpath(temp_dir, NULL), sizeof jailDir);
break;
case 'r': strcpy(letsencrypt_req, optarg);
break;
case 'R': strcpy(letsencrypt_resp, optarg);
break;
case 'p': strcpy(port, optarg);
break;
case 'u': user = optarg;
if (!user_exists(user)) {
printf("User '%s' does not exist\n", user);
return -1;
}
break;
case 'h': usage();
return -1;
break;
case '?': printf("Invalid option '%c'\n", optopt);
usage();
return -1;
break;
default: printf("Getopt error\n");
return -100;
}
}
if (jail_mode && !daemon_mode) {
printf("-j (chroot jail) requires -d (daemon) by specified\n");
return -1;
}
strcpy(ipAddr, getIPaddr());
strcpy(port, "80,ssl://0.0.0.0:443:");
strncat(port, cert, (sizeof port)-strlen(port)-1);
// Open the log
if (daemon_mode)
openlog(NULL, LOG_CONS | LOG_PID, LOG_DAEMON);
// lock the pid file
fd = createPidFile(argv[0], pidFile, 0);
// If a daemon, fork a child process and exit the parent
if (daemon_mode) {
// 1. create a child process
process_id = fork();
if (process_id < 0) {
log_msg(daemon_mode, "fork() failed! - exiting");
exit(-1);
}
// 2. kill the parent process
if (process_id > 0)
exit(0);
// 3. unmask the file mode
umask(0);
// 4. start a new session
sid = setsid();
if (sid < 0) {
log_msg(daemon_mode, "setsid() failed! - exiting");
exit(-1);
}
// 5. redirect stdin, stdout and stderr to null
redir2null(stdin, O_RDONLY);
redir2null(stdout, O_WRONLY);
redir2null(stderr, O_RDWR); // Note stderr must be r/w
// 6. Update the PID file with the child PID
updateChildPid(fd, (long) getpid());
}
// Create and configure the server
log_msg(daemon_mode, "CheckIP version %s starting", VERSION);
printTZ();
log_msg(daemon_mode, "Using SSL certificate '%s'", cert);
server = mg_create_server(NULL, ev_handler);
mg_set_option(server, "listening_port", port);
strcpy(buf, mg_get_option(server, "listening_port"));
if (buf[0] == '\0') {
log_msg(daemon_mode, "open listening ports failed - exiting");
goto exit;
}
// chroot jail the process
if (jail_mode && !isChrooted()) {
// adjust the path
putenv("PATH=/bin:/sbin");
// set the new root dir
int err = chroot(jailDir);
if (err != 0) {
log_msg(daemon_mode, "chroot() failed! (err %d) - exiting", errno);
exit(-1);
}
log_msg(daemon_mode, "Established chroot() jail under '%s'", jailDir);
// Set the curr dir to be within the chroot
chdir("/");
}
// Trap KILL's - cause 'running' flag to be set false, HUP dumps the stats
running = -1;
signal(SIGINT, intHandler);
signal(SIGTERM, intHandler);
signal(SIGHUP, intHandler);
// load robots.txt to robots variable
loadRobots(jailDir);
// load sitemap.xml to robots variable
loadSitemap(jailDir);
// load the GeoIP database
initGeoIP();
// Log LetsEncrypt settings
if (letsencrypt_req[0] != '\0')
log_msg(daemon_mode, "LE req = '%s'\n", letsencrypt_req);
if (letsencrypt_resp[0] != '\0')
log_msg(daemon_mode, "LE resp = '%s'\n", letsencrypt_resp);
// Serve request. Hit Ctrl-C or SIGTERM to terminate the program
mg_set_option(server, "run_as_user", user);
if (user != NULL)
log_msg(daemon_mode, "Server executing as user '%s'", user);
log_msg(daemon_mode, "Listening on port %s", buf);
while (running) {
mg_poll_server(server, 250);
}
if(!daemon_mode) printf("\n");
// Get the finish time and compute the duration
exit:
time(&finish);
// Cleanup, and free server instance
mg_destroy_server(&server);
// Close and delete the pid file;
if (fd != -1) {
close(fd);
unlink(pidFile);
}
// Print stats
print_stats(daemon_mode, start, finish, "stopping after");
// Clean up GeoIP2
closeGeoIP();
if (!daemon_mode) printf("\nClean shutdown\n");
return 0;
}
int XzeroDaemon::run()
{
::signal(SIGPIPE, SIG_IGN);
unsigned generation = 1;
if (const char* v = getenv("XZERO_UPGRADE")) {
generation = atoi(v) + 1;
unsetenv("XZERO_UPGRADE");
}
#if defined(HAVE_SYSLOG_H)
x0::SyslogSink::open("x0d", LOG_PID | LOG_NDELAY, LOG_DAEMON);
#endif
if (!parse())
return 1;
eventHandler_ = new XzeroEventHandler(this, ev::default_loop(evFlags_));
server_ = new x0::HttpServer(eventHandler_->loop(), generation);
// Load core plugins
registerPlugin(core_ = new XzeroCore(this));
#ifndef XZERO_NDEBUG
server_->logLevel(x0::Severity::debug3);
#endif
if (systemd_) {
nofork_ = true;
server_->setLogger(std::make_shared<x0::SystemdLogger>());
} else {
if (logTarget_ == "file") {
if (!logFile_.empty()) {
auto logger = std::make_shared<x0::FileLogger>(logFile_, [this]() {
return static_cast<time_t>(ev_now(server_->loop()));
});
if (logger->handle() < 0) {
fprintf(stderr, "Could not open log file '%s': %s\n",
logFile_.c_str(), strerror(errno));
return 1;
}
server_->setLogger(logger);
} else {
server_->setLogger(std::make_shared<x0::SystemLogger>());
}
} else if (logTarget_ == "console") {
server_->setLogger(std::make_shared<x0::ConsoleLogger>());
} else if (logTarget_ == "syslog") {
server_->setLogger(std::make_shared<x0::SystemLogger>());
} else if (logTarget_ == "systemd") {
server_->setLogger(std::make_shared<x0::SystemdLogger>());
}
}
server_->logger()->setLevel(logLevel_);
if (!setupConfig()) {
log(x0::Severity::error, "Could not start x0d.");
return -1;
}
unsetenv("XZERO_LISTEN_FDS");
if (dumpIR_)
dumpIR();
if (!nofork_)
daemonize();
if (!createPidFile())
return -1;
if (group_.empty())
group_ = user_;
if (!drop_privileges(user_, group_))
return -1;
if (showGreeter_) {
printf("\n\n"
"\e[1;37m"
" XXXXXXXXXXX\n"
" XX XX XX XX\n"
" XX XX XX XX\n"
" XX XX XX XX\n"
" XXX XX 0 XX - Web Server\n"
" XX XX XX XX Version " PACKAGE_VERSION "\n"
" XX XX XX XX\n"
" XX XX XX XX\n"
" XXXXXXXXXXX\n"
"\n"
" " PACKAGE_HOMEPAGE_URL
"\e[0m"
"\n\n"
);
}
eventHandler_->setState(XzeroState::Running);
int rv = server_->run();
// remove PID-file, if exists and not in systemd-mode
if (!systemd_ && !pidfile_.empty())
unlink(pidfile_.c_str());
return rv;
}
PidFile::PidFile( const char * fullName )
: fileName( fullName ),
osErrno( 0 )
{
createPidFile();
}
static int
initServer ()
{
int sfd, on = 1;
struct sockaddr_in sa;
arc_t *arc;
/* Daemonize */
if (server.conf->daemonize)
{
daemonize ();
createPidFile ();
}
/* Init CAPI */
arc = initCapi (server.conf);
if (arc == NULL)
return -1;
/* Init server socket */
if ((sfd = socket (AF_INET, SOCK_STREAM, 0)) == -1)
{
perror ("creating socket");
return -1;
}
if (setsockopt (sfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) == -1)
{
perror ("setsockopt SO_REUSEADDR");
return -1;
}
memset (&sa, 0, sizeof (sa));
sa.sin_family = AF_INET;
sa.sin_port = htons (server.conf->port);
sa.sin_addr.s_addr = htonl (INADDR_ANY);
if (bind (sfd, (struct sockaddr *) &sa, sizeof (sa)) == -1)
{
perror ("bind");
close (sfd);
return -1;
}
if (listen (sfd, MAX_LISTEN_BACKLOG) == -1)
{
perror ("listen");
close (sfd);
return -1;
}
server.fd = sfd;
/* Create arrays of client thread ids */
server.client_tid = calloc (MAX_CLIENT_THREAD, sizeof (pthread_t));
/* Initialize reconfig thread */
pthread_create (&server.reconfig_tid, NULL, reconfigThread, arc);
return 0;
}
