%PDF-
%PDF-
Mini Shell
Mini Shell
/*
* Phusion Passenger - https://www.phusionpassenger.com/
* Copyright (c) 2013-2018 Phusion Holding B.V.
*
* "Passenger", "Phusion Passenger" and "Union Station" are registered
* trademarks of Phusion Holding B.V.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
/* This tool touches everything in a directory every 30 minutes to prevent
* /tmp cleaners from removing it.
*/
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <pwd.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <limits.h>
#include <errno.h>
#include <string.h>
#include <Constants.h>
#include <MainFunctions.h>
#define ERROR_PREFIX "*** TempDirToucher error"
static char *dir;
/**
* When Passenger Standalone is started with --daemonize, then it will
* pass --cleanup to this tool so that this tool is responsible
* for cleaning up the Standalone temp dir. This is because Passenger
* Standalone may be started in daemonize mode, which makes it exit asap
* in order to conserve memory. Passenger Standalone can therefore not
* be responsible for cleaning up the temp dir.
*/
static int shouldCleanup = 0;
static int shouldDaemonize = 0;
static bool verbose = false;
static const char *pidFile = NULL;
static const char *logFile = NULL;
static uid_t uid = 0;
static pid_t nginxPid = 0;
static int sleepInterval = 1800;
static int terminationPipe[2];
static sig_atomic_t shouldIgnoreNextTermSignal = 0;
#define DEBUG(message) \
do { \
if (verbose) { \
puts(message); \
} \
} while (false)
static void
usage() {
printf("Usage: " AGENT_EXE " temp-dir-toucher <DIRECTORY> [OPTIONS...]\n");
printf("Touches everything in a directory every 30 minutes, to "
"prevent /tmp cleaners from removing the directory.\n");
printf("\n");
printf("Options:\n");
printf(" --cleanup Remove directory on exit\n");
printf(" --nginx-pid PID Optional PID to wait for before cleanup\n");
printf(" --daemonize Daemonize into background\n");
printf(" --interval SECONDS Customize interval\n");
printf(" --pid-file PATH Save PID into the given file\n");
printf(" --log-file PATH Use the given log file\n");
printf(" --verbose Print debugging messages\n");
}
static void
parseArguments(int argc, char *argv[], int offset) {
dir = argv[offset];
int i;
if (dir == NULL) {
usage();
exit(1);
}
for (i = offset + 1; i < argc; i++) {
if (strcmp(argv[i], "--cleanup") == 0) {
shouldCleanup = 1;
} else if (strcmp(argv[i], "--daemonize") == 0) {
shouldDaemonize = 1;
} else if (strcmp(argv[i], "--interval") == 0) {
if (i == argc - 1) {
fprintf(stderr, ERROR_PREFIX ": --interval requires an argument\n");
exit(1);
}
sleepInterval = atoi(argv[i + 1]);
i++;
} else if (strcmp(argv[i], "--nginx-pid") == 0) {
if (i == argc - 1) {
fprintf(stderr, ERROR_PREFIX ": --nginx-pid requires the nginx master process pid as an argument\n");
exit(1);
}
nginxPid = atoi(argv[i + 1]);
i++;
} else if (strcmp(argv[i], "--pid-file") == 0) {
pidFile = argv[i + 1];
i++;
} else if (strcmp(argv[i], "--log-file") == 0) {
logFile = argv[i + 1];
i++;
} else if (strcmp(argv[i], "--verbose") == 0) {
verbose = true;
} else if (strcmp(argv[i], "--user") == 0) {
const char *user = argv[i + 1];
struct passwd *pwUser = getpwnam(user);
if (pwUser == NULL) {
int e = errno;
fprintf(stderr, ERROR_PREFIX
"Cannot lookup user information for user %s, %s (errno %d)\n",
user, strerror(e), e);
}else{
uid = pwUser->pw_uid;
}
i++;
} else {
fprintf(stderr, ERROR_PREFIX ": unrecognized argument %s\n",
argv[i]);
exit(1);
}
}
}
static void
setNonBlocking(int fd) {
int flags, ret, e;
do {
flags = fcntl(fd, F_GETFL);
} while (flags == -1 && errno == EINTR);
if (flags == -1) {
e = errno;
fprintf(stderr, ERROR_PREFIX
": cannot set pipe to non-blocking mode: "
"cannot get file descriptor flags. Error: %s (errno %d)\n",
strerror(e), e);
exit(1);
}
do {
ret = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
} while (ret == -1 && errno == EINTR);
if (ret == -1) {
e = errno;
fprintf(stderr, ERROR_PREFIX
": cannot set pipe to non-blocking mode: "
"cannot set file descriptor flags. Error: %s (errno %d)\n",
strerror(e), e);
exit(1);
}
}
static void down_privilege() {
if (getuid() == 0 && uid != 0) {
if (setreuid(uid,0) != 0) {
int e = errno;
fprintf(stderr, ERROR_PREFIX
": cannot set effective user to %d for sleeping: %s (errno %d)\n",
uid, strerror(e), e);
exit(1);
}
}
}
static void up_privilege() {
if (getuid() != 0 && uid != 0) {
if (setuid(0) != 0) {
int e = errno;
fprintf(stderr, ERROR_PREFIX
": cannot set effective user to %d for touching files: %s (errno %d)\n",
uid, strerror(e), e);
exit(1);
}
}
}
static void
initialize(int argc, char *argv[], int offset) {
int e, fd;
parseArguments(argc, argv, offset);
down_privilege();// drop priv. until needed.
if (logFile != NULL) {
fd = open(logFile, O_WRONLY | O_APPEND | O_CREAT, 0644);
if (fd == -1) {
e = errno;
fprintf(stderr, ERROR_PREFIX
": cannot open log file %s for writing: %s (errno %d)\n",
logFile, strerror(e), e);
exit(1);
}
if (dup2(fd, 1) == -1) {
e = errno;
fprintf(stderr, ERROR_PREFIX ": cannot dup2(%d, 1): %s (errno %d)\n",
fd, strerror(e), e);
}
if (dup2(fd, 2) == -1) {
e = errno;
fprintf(stderr, ERROR_PREFIX ": cannot dup2(%d, 2): %s (errno %d)\n",
fd, strerror(e), e);
}
close(fd);
}
if (pipe(terminationPipe) == -1) {
e = errno;
fprintf(stderr, ERROR_PREFIX ": cannot create a pipe: %s (errno %d)\n",
strerror(e), e);
exit(1);
}
setNonBlocking(terminationPipe[1]);
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
}
static void
exitHandler(int signo) {
if (shouldIgnoreNextTermSignal) {
shouldIgnoreNextTermSignal = 0;
} else {
int ret = write(terminationPipe[1], "x", 1);
// We can't do anything about failures, so ignore
// compiler warnings about not using the result.
(void) ret;
}
}
static void
ignoreNextTermSignalHandler(int signo) {
shouldIgnoreNextTermSignal = 1;
}
static void
installSignalHandlers() {
struct sigaction action;
action.sa_handler = exitHandler;
action.sa_flags = SA_RESTART;
sigemptyset(&action.sa_mask);
sigaction(SIGINT, &action, NULL);
sigaction(SIGTERM, &action, NULL);
action.sa_handler = ignoreNextTermSignalHandler;
action.sa_flags = SA_RESTART;
sigaction(SIGHUP, &action, NULL);
}
static void
redirectStdinToNull() {
int fd = open("/dev/null", O_RDONLY);
if (fd != -1) {
dup2(fd, 0);
close(fd);
}
}
static void
maybeDaemonize() {
pid_t pid;
int e;
if (shouldDaemonize) {
pid = fork();
if (pid == 0) {
setsid();
if (chdir("/") == -1) {
e = errno;
fprintf(stderr, ERROR_PREFIX
": cannot change working directory to /: %s (errno=%d)\n",
strerror(e), e);
_exit(1);
}
redirectStdinToNull();
} else if (pid == -1) {
e = errno;
fprintf(stderr, ERROR_PREFIX ": cannot fork: %s (errno=%d)\n",
strerror(e), e);
exit(1);
} else {
_exit(0);
}
}
}
static void
maybeWritePidfile() {
FILE *f;
if (pidFile != NULL) {
up_privilege(); // need permission to write to pid file, and set permissions
f = fopen(pidFile, "w");
if (f != NULL) {
fprintf(f, "%d\n", (int) getpid());
if (fchmod(fileno(f), S_IRWXU|S_IRWXG|S_IROTH) == -1){
int e = errno;
fprintf(stderr, ERROR_PREFIX
": cannot change permissions on pid file %s, process may remain after passenger shutdown: %s (errno %d)\n", pidFile, strerror(e), e);
}
fclose(f);
} else {
fprintf(stderr, ERROR_PREFIX ": cannot open PID file %s for writing\n",
pidFile);
exit(1);
}
down_privilege(); // drop priv now that unneeded
}
}
static int
dirExists(const char *dir) {
struct stat buf;
up_privilege(); // raise priv. to stat file
bool retVal = stat(dir, &buf) == 0 && S_ISDIR(buf.st_mode);
down_privilege(); // drop priv now that unneeded
return retVal;
}
static void
touchDir(const char *dir) {
pid_t pid;
int e, status;
up_privilege(); // raise priv. to touch files
pid = fork();
if (pid == 0) {
close(terminationPipe[0]);
close(terminationPipe[1]);
if (chdir(dir) == -1) {
e = errno;
fprintf(stderr, ERROR_PREFIX
": cannot change working directory to %s: %s (errno %d)\n",
dir, strerror(e), e);
_exit(1);
}
execlp("/bin/sh", "/bin/sh", "-c",
"find \"$1\" | xargs touch", "/bin/sh", ".",
(char *) 0);
e = errno;
fprintf(stderr, ERROR_PREFIX ": cannot execute /bin/sh: %s (errno %d)\n",
strerror(e), e);
_exit(1);
} else if (pid == -1) {
e = errno;
fprintf(stderr, ERROR_PREFIX ": cannot fork: %s (errno %d)\n",
strerror(e), e);
exit(1);
} else {
if (waitpid(pid, &status, 0) == -1) {
if (errno != ESRCH && errno != EPERM) {
fprintf(stderr, ERROR_PREFIX
": unable to wait for shell command 'find %s | xargs touch'\n",
dir);
exit(1);
}
} else if (WEXITSTATUS(status) != 0) {
fprintf(stderr, ERROR_PREFIX
": shell command 'find %s | xargs touch' failed with exit status %d\n",
dir, WEXITSTATUS(status));
exit(1);
}
}
down_privilege(); // drop priv now that unneeded
}
static int
doSleep(int sec) {
fd_set readfds;
struct timeval timeout;
int ret, e;
FD_ZERO(&readfds);
FD_SET(terminationPipe[0], &readfds);
timeout.tv_sec = sec;
timeout.tv_usec = 0;
do {
ret = select(terminationPipe[0] + 1, &readfds, NULL, NULL, &timeout);
} while (ret == -1 && errno == EINTR);
if (ret == -1) {
e = errno;
fprintf(stderr, ERROR_PREFIX ": cannot select(): %s (errno %d)\n",
strerror(e), e);
exit(1);
} else {
return ret == 0;
}
}
static void
maybeDeletePidFile() {
up_privilege();
if (pidFile != NULL) {
unlink(pidFile);
}
down_privilege();
}
static void
performCleanup(const char *dir) {
pid_t pid;
int e, status;
up_privilege(); // raise priv. so we can delete files
pid = fork();
if (pid == 0) {
close(terminationPipe[0]);
close(terminationPipe[1]);
execlp("/bin/sh", "/bin/sh", "-c",
"rm -rf \"$1\"", "/bin/sh", dir,
(char *) 0);
e = errno;
fprintf(stderr, ERROR_PREFIX ": cannot execute /bin/sh: %s (errno %d)\n",
strerror(e), e);
_exit(1);
} else if (pid == -1) {
e = errno;
fprintf(stderr, ERROR_PREFIX ": cannot fork: %s (errno %d)\n",
strerror(e), e);
exit(1);
} else {
if (waitpid(pid, &status, 0) == -1) {
if (errno != ESRCH && errno != EPERM) {
fprintf(stderr, ERROR_PREFIX
": unable to wait for shell command 'rm -rf %s'\n",
dir);
exit(1);
}
} else if (WEXITSTATUS(status) != 0) {
fprintf(stderr, ERROR_PREFIX
": shell command 'rm -rf %s' failed with exit status %d\n",
dir, WEXITSTATUS(status));
exit(1);
}
}
}
static void
maybeWaitForNginxToExit() {
// If a PID was specified, wait for kill to tell us it's gone.
if (nginxPid == 0) {
return;
}
while (0 == kill(nginxPid, 0)) {
sleep(1); // regular sleep; doSleep() can't sleep while terminating
}
}
int
tempDirToucherMain(int argc, char *argv[]) {
initialize(argc, argv, 2);
installSignalHandlers();
maybeDaemonize();
maybeWritePidfile();
DEBUG("TempDirToucher started");
while (1) {
if (dirExists(dir)) {
DEBUG("Touching directory");
touchDir(dir);
if (!doSleep(sleepInterval)) {
break;
}
} else {
DEBUG("Directory no longer exists, exiting");
break;
}
}
maybeDeletePidFile();
if (shouldCleanup) {
maybeWaitForNginxToExit();
DEBUG("Cleaning up directory");
performCleanup(dir);
}
return 0;
}
Zerion Mini Shell 1.0