{

switch(type)

{

case SigInt:

return SIGINT;

case SigHup:

return SIGHUP;

case SigAbrt:

return SIGABRT;

case SigSegv:

return SIGSEGV;

case SigIll:

return SIGILL;

case SigUsr1:

return SIGUSR1;

case SigUsr2:

return SIGUSR2;

case SigPipe:

return SIGPIPE;

case SigChld:

return SIGCHLD;

case SigTerm:

return SIGTERM;

default:

return -1;

}

{

std::string path = string_utils::utf8ToSystem(filePath.getAbsolutePath());

char buffer[PATH_MAX*2];

char* realPath = ::realpath(path.c_str(), buffer);

if (realPath == nullptr)

{

Error error = systemError(errno, ERROR_LOCATION);

error.addProperty("path", filePath);

return error;

}

*pRealPath = FilePath(string_utils::systemToUtf8(realPath));

return Success();

{

char buffer[PATH_MAX * 2];

char* realPath = ::realpath(path.c_str(), buffer);

if (realPath == nullptr)

{

Error error = systemError(errno, ERROR_LOCATION);

error.addProperty("path", path);

return error;

}

*pRealPath = FilePath(realPath);

return Success();

core::FilePath* pProgramPath)

{

std::string path = core::system::getenv("PATH");

auto paths = core::algorithm::split(path, ":");

for (auto&& path : paths)

{

// get file descriptor for path entry

int fd = ::open(path.c_str(), 0);

if (fd == -1)

continue;

// clean up when we're done

BOOST_SCOPE_EXIT( (&fd) )

{

::close(fd);

}

BOOST_SCOPE_EXIT_END;

// confirm that it's a regular file

struct stat sb;

int status = ::fstatat(fd, program.c_str(), &sb, 0);

if (status == -1)

continue;

bool isRegularFile = S_ISREG(sb.st_mode);

if (!isRegularFile)

continue;

// confirm that it's executable

// note that we use AT_EACCESS to ensure checks are done using

// the effective user id

status = ::faccessat(fd, program.c_str(), X_OK, AT_EACCESS);

if (status == -1)

continue;

// all checks passed; return full path

*pProgramPath = FilePath(path).completeChildPath(program);

return Success();

}

return fileNotFoundError(program, ERROR_LOCATION);

log::LogLevel logLevel,

bool enableConfigReload)

{

RECURSIVE_LOCK_MUTEX(s_loggingMutex)

{

// create default syslog logger options

log::SysLogOptions options;

s_logOptions.reset(new log::LogOptions(programIdentity, logLevel, log::LoggerType::kSysLog, log::LogMessageFormatType::PRETTY, options));

s_programIdentity = programIdentity;

Error error = initLog();

if (error)

return error;

}

END_LOCK_MUTEX

if (enableConfigReload)

initializeLogConfigReload();

return Success();

{

for(;;)

{

// wait for SIGHUP

int sig = 0;

int result = ::sigwait(&waitMask, &sig);

if (result != 0)

return;

if (sig == SIGHUP)

{

LOG_INFO_MESSAGE("Reloading logging configuration...");

Error error = reinitLog();

if (error)

{

LOG_ERROR(error);

LOG_ERROR_MESSAGE("Failed to reload logging configuration");

}

else

{

LOG_INFO_MESSAGE("Successfully reloaded logging configuration");

}

// call previously registered SIGHUP handlder

if (s_sighupHandler)

s_sighupHandler();

}

}

{

// block the SIGHUP signal

sigset_t waitMask;

sigemptyset(&waitMask);

sigaddset(&waitMask, SIGHUP);

int result = ::pthread_sigmask(SIG_BLOCK, &waitMask, nullptr);

if (result != 0)

return;

// start a thread to handle the SIGHUP signal

boost::thread thread(boost::bind(logConfigReloadThreadFunc, waitMask));

{

ExecBlock ignoreBlock;

ignoreBlock.addFunctions()

(boost::bind(posix::ignoreSignal, SIGHUP))

(boost::bind(posix::ignoreSignal, SIGTSTP))

(boost::bind(posix::ignoreSignal, SIGTTOU))

(boost::bind(posix::ignoreSignal, SIGTTIN));

return ignoreBlock.execute();

{

#if defined(HAVE_SA_NOCLDWAIT) // POSIX compliant

struct sigaction reapchildren;

::memset( &reapchildren, 0, sizeof reapchildren );

reapchildren.sa_flags = SA_NOCLDWAIT;

int result = ::sigaction( SIGCHLD, &reapchildren, 0);

if (result != 0)

return systemError(result, ERROR_LOCATION);

#else // other systems

if (::signal(SIGCHLD, SIG_IGN) == SIG_ERR)

return systemError(errno, ERROR_LOCATION);

#endif // NO_CLDWAIT

return Success();

{

int stat;

while (::waitpid (-1, &stat, WNOHANG) > 0)

{

}

{

// setup signal handler

struct sigaction sa;

::memset(&sa, 0, sizeof sa);

sa.sa_handler = handleSIGCHLD;

sigemptyset(&sa.sa_mask);

sa.sa_flags = SA_RESTART;

// install it

int result = ::sigaction(SIGCHLD, &sa, nullptr);

if (result != 0)

return systemError(errno, ERROR_LOCATION);

else

return Success();

{

// install mask

int result = ::pthread_sigmask(SIG_BLOCK, pBlockMask, &oldMask);

if (result != 0)

return systemError(result, ERROR_LOCATION);

// set restore bit and return success

blocked = true;

return Success();

{

// get signal

int sig = signalForType(signal);

if (sig < 0)

return systemError(EINVAL, ERROR_LOCATION);

// create a mask for blocking the signal

sigset_t blockMask;

sigemptyset(&blockMask);

sigaddset(&blockMask, sig);

// block

return pImpl_->block(&blockMask);

{

// create mask to block all signals

sigset_t blockMask;

sigfillset(&blockMask);

// block

return pImpl_->block(&blockMask);

{

int result = signal_safe::clearSignalMask();

if (result != 0)

return systemError(result, ERROR_LOCATION);

else

return Success();

{

int sig = signalForType(signal);

if (sig < 0)

return systemError(EINVAL, ERROR_LOCATION);

::signal(sig, handler);

return Success();

{

int sig = signalForType(signal);

if (sig < 0)

return systemError(EINVAL, ERROR_LOCATION);

return posix::ignoreSignal(sig);

{

int sig = signalForType(signal);

if (sig < 0) return systemError(EINVAL, ERROR_LOCATION);

struct sigaction sa;

::memset(&sa, 0, sizeof sa);

sa.sa_handler = SIG_DFL;

int result = ::sigaction(sig, &sa, nullptr);

if (result != 0)

{

Error error = systemError(result, ERROR_LOCATION);

return error;

}

else

{

return Success();

}

const std::string& appName,

bool ensureDirectory)

{

std::string lower = appName;

boost::to_lower(lower);

FilePath path = userHomeDirectory.completeChildPath("." + lower);

if (ensureDirectory)

{

Error error = path.ensureDirectory();

if (error)

{

LOG_ERROR(error);

}

}

return path;

{

// get limit

struct rlimit rl;

if (::getrlimit(RLIMIT_NOFILE, &rl) < 0)

return systemError(errno, ERROR_LOCATION);

if (rl.rlim_max == RLIM_INFINITY)

rl.rlim_max = 1024; // default on linux

// close file descriptors

for (int i=fdStart; i< (int)rl.rlim_max; i++)

{

if (::close(i) < 0 && errno != EBADF)

return systemError(errno, ERROR_LOCATION);

}

return Success();

{

std::vector<unsigned int> fds;

Error error = getOpenFds(&fds);

if (error)

return error;

for (int fd : fds)

{

if (fd >= fdStart)

{

if (::close(fd) < 0 && errno != EBADF)

return systemError(errno, ERROR_LOCATION);

}

}

return Success();

{

std::string pidStr = safe_convert::numberToString(pid);

boost::format fmt("/proc/%1%/fd");

FilePath filePath(boost::str(fmt % pidStr));

// note: we use a FileScanner to list the pids instead of using boost

// (FilePath class), because there is a bug in boost filesystem where

// directory iterators can segfault under heavy load while reading the /proc filesystem

// there aren't many details on this, but see https://svn.boost.org/trac10/ticket/10450

core::system::FileScannerOptions options;

options.recursive = false;

tree<FileInfo> subDirs;

Error error = core::system::scanFiles(core::toFileInfo(filePath), options, &subDirs);

if (error)

return error;

for (const FileInfo& info : subDirs)

{

FilePath path(info.absolutePath());

boost::optional<uint32_t> fd = safe_convert::stringTo<uint32_t>(path.getFilename());

if (fd)

{

pFds->push_back(fd.get());

}

}

return Success();

{

// get size of the buffer needed to hold the list of fds

int bufferSize = proc_pidinfo(pid, PROC_PIDLISTFDS, 0, 0, 0);

if (bufferSize == -1)

return systemError(errno, ERROR_LOCATION);

// get the list of open fds

struct proc_fdinfo* procFdInfo = static_cast<struct proc_fdinfo*>(malloc(bufferSize));

if (!procFdInfo)

return systemError(boost::system::errc::not_enough_memory, ERROR_LOCATION);

int filledSize = proc_pidinfo(pid, PROC_PIDLISTFDS, 0, procFdInfo, bufferSize);

int numFds = filledSize / PROC_PIDLISTFD_SIZE;

for (int i = 0; i < numFds; ++i)

{

pFds->push_back(procFdInfo[i].proc_fd);

}

free(procFdInfo);

return Success();

{

std::size_t written;

std::vector<uint32_t> fds;

Error error = getOpenFds(childPid, &fds);

if (!error)

{

for (uint32_t fd : fds)

{

error = posix::posixCall<std::size_t>(

boost::bind(

::write,

pipeFd,

&fd,

4),

ERROR_LOCATION,

&written);

if (error)

{

return error;

}

}

}

else

{

// we simply log the error instead of returning it because this is generally benign and can

// happen in certain normal scenarios, such as if /proc/x/fd is only readable by root

// (if core dumps are turned off)

core::log::logErrorAsDebug(error);

}

// write message close (-1) even if we failed to retrieve pids above

// this prevents the child from being stuck in limbo or interpreting its

// actual stdin as fds

int close = -1;

Error closeError = posix::posixCall<std::size_t>(

boost::bind(

::write,

pipeFd,

&close,

4),

ERROR_LOCATION,

&written);

if (closeError)

{

return error;

}

return closeError;

{

while (::close(fd) == -1)

{

// keep trying the close operation if it was interrupted

// otherwise, the file descriptor is not open, so return

if (errno != EINTR)

break;

}

{

// safe function is best effort - swallow all errors

// this is necessary when invoked in a signal handler or

// during a fork in multithreaded processes to prevent hangs

if (fdLimit == RLIM_INFINITY)

fdLimit = 1024; // default on linux

// close file descriptors

for (uint32_t i = fdStart; i < fdLimit; ++i)

{

safeClose(i);

}

{

// read fds that we own from parent process pipe until we've read them all

// the parent must give us this list because we cannot fetch it ourselves

// in a signal-safe way, but we can read from the pipe safely

bool error = false;

bool fdsRead = false;

int32_t buff;

while (true)

{

ssize_t bytesRead = ::read(pipeFd, &buff, 4);

// check for error

if (bytesRead == -1 || bytesRead == 0)

{

if (errno != EINTR &&

errno != EAGAIN)

{

error = true;

break;

}

continue;

}

// determine which fd was just read from the parent

if (buff == -1)

{

break; // indicates no more fds are open by the process

}

fdsRead = true;

uint32_t fd = static_cast<uint32_t>(buff);

// close the reported fd if it is in range

if (fd >= fdStart && fd < fdLimit && buff != pipeFd)

safeClose(fd);

}

// if no descriptors could be read from the parent for whatever reason,

// or there was an error reading from the pipe,

// fall back to the slow close method detailed above

if (error || !fdsRead)

{

closeFileDescriptorsFromSafe(fdStart, pipeFd);

closeFileDescriptorsFromSafe(pipeFd + 1, fdLimit);

}

{

sigset_t blockNoneMask;

sigemptyset(&blockNoneMask);

return ::pthread_sigmask(SIG_SETMASK, &blockNoneMask, nullptr);

{

::close(STDIN_FILENO);

::close(STDOUT_FILENO);

::close(STDERR_FILENO);

{

int fd0 = ::open("/dev/null", O_RDWR);

if (fd0 == -1)

LOG_ERROR(systemError(errno, ERROR_LOCATION));

int fd1 = ::dup(fd0);

if (fd1 == -1)

LOG_ERROR(systemError(errno, ERROR_LOCATION));

int fd2 = ::dup(fd0);

if (fd2 == -1)

LOG_ERROR(systemError(errno, ERROR_LOCATION));

{

core::system::closeStdFileDescriptors();

core::system::attachStdFileDescriptorsToDevNull();

std::ios::sync_with_stdio();

{

std::string filename = filePath.getFilename();

return (!filename.empty() && (filename[0] == '.'));

{

if (::access(filePath.getAbsolutePath().c_str(), W_OK) == -1)

{

if (errno == EACCES)

{

return true;

}

else

{

Error error = systemError(errno, ERROR_LOCATION);

error.addProperty("path", filePath);

LOG_ERROR(error);

return false;

}

}

else

{

return false;

}

{

// generaate the uuid and convert it to a strting

uuid_t uuid;

::uuid_generate_random(uuid);

char uuidBuffer[40];

::uuid_unparse_lower(uuid, uuidBuffer);

std::string uuidStr(uuidBuffer);

// remove dashes if requested

if (!includeDashes)

boost::algorithm::replace_all(uuidStr, "-", "");

return uuidStr;

FilePath* pExecutablePath)

{

return executablePath(argv[0], pExecutablePath);

FilePath* pExecutablePath)

{

std::string executablePath;

#if defined(__APPLE__)

// get path to current executable

uint32_t buffSize = 2048;

std::vector<char> buffer(buffSize);

if (_NSGetExecutablePath(&(buffer[0]), &buffSize) == -1)

{

buffer.resize(buffSize);

_NSGetExecutablePath(&(buffer[0]), &buffSize);

}

// set it

executablePath = std::string(&(buffer[0]));

#elif defined(HAVE_PROCSELF)

executablePath = std::string("/proc/self/exe");

#else

// Note that this technique will NOT work if the executable was located

// via a search of the PATH. To make this fallback fully robust we would

// need to also search the PATH for the exe name in argv[0]

//

// use argv[0] and initial path

FilePath initialPath = FilePath::initialPath();

executablePath = initialPath.completePath(argv0).getAbsolutePath();

#endif