aboutsummaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/server/sockfilt.c196
1 files changed, 172 insertions, 24 deletions
diff --git a/tests/server/sockfilt.c b/tests/server/sockfilt.c
index 2d1a47ba2..921ce6c2b 100644
--- a/tests/server/sockfilt.c
+++ b/tests/server/sockfilt.c
@@ -46,6 +46,40 @@
*
* (Source originally based on sws.c)
*/
+
+/*
+ * Signal handling notes for sockfilt
+ * ----------------------------------
+ *
+ * This program is a single-threaded process.
+ *
+ * This program is intended to be highly portable and as such it must be kept as
+ * simple as possible, due to this the only signal handling mechanisms used will
+ * be those of ANSI C, and used only in the most basic form which is good enough
+ * for the purpose of this program.
+ *
+ * For the above reason and the specific needs of this program signals SIGHUP,
+ * SIGPIPE and SIGALRM will be simply ignored on systems where this can be done.
+ * If possible, signals SIGINT and SIGTERM will be handled by this program as an
+ * indication to cleanup and finish execution as soon as possible. This will be
+ * achieved with a single signal handler 'exit_signal_handler' for both signals.
+ *
+ * The 'exit_signal_handler' upon the first SIGINT or SIGTERM received signal
+ * will just set to one the global var 'got_exit_signal' storing in global var
+ * 'exit_signal' the signal that triggered this change.
+ *
+ * Nothing fancy that could introduce problems is used, the program at certain
+ * points in its normal flow checks if var 'got_exit_signal' is set and in case
+ * this is true it just makes its way out of loops and functions in structured
+ * and well behaved manner to achieve proper program cleanup and termination.
+ *
+ * Even with the above mechanism implemented it is worthwile to note that other
+ * signals might still be received, or that there might be systems on which it
+ * is not possible to trap and ignore some of the above signals. This implies
+ * that for increased portability and reliability the program must be coded as
+ * if no signal was being ignored or handled at all. Enjoy it!
+ */
+
#include "setup.h" /* portability help from the lib directory */
#ifdef HAVE_SIGNAL_H
@@ -85,10 +119,6 @@
#define DEFAULT_LOGFILE "log/sockfilt.log"
#endif
-#ifdef SIGPIPE
-static volatile int sigpipe; /* Why? It's not used */
-#endif
-
const char *serverlogfile = (char *)DEFAULT_LOGFILE;
bool verbose = FALSE;
@@ -103,6 +133,103 @@ enum sockmode {
ACTIVE_DISCONNECT /* as a client, disconnected from server */
};
+/* do-nothing macro replacement for systems which lack siginterrupt() */
+
+#ifndef HAVE_SIGINTERRUPT
+#define siginterrupt(x,y) do {} while(0)
+#endif
+
+/* vars used to keep around previous signal handlers */
+
+typedef RETSIGTYPE (*SIGHANDLER_T)(int);
+
+static SIGHANDLER_T old_sighup_handler = SIG_ERR;
+static SIGHANDLER_T old_sigpipe_handler = SIG_ERR;
+static SIGHANDLER_T old_sigalrm_handler = SIG_ERR;
+static SIGHANDLER_T old_sigint_handler = SIG_ERR;
+static SIGHANDLER_T old_sigterm_handler = SIG_ERR;
+
+/* var which if set indicates that the program should finish execution */
+
+SIG_ATOMIC_T got_exit_signal = 0;
+
+/* if next is set indicates the first signal handled in exit_signal_handler */
+
+static volatile int exit_signal = 0;
+
+/* signal handler that will be triggered to indicate that the program
+ should finish its execution in a controlled manner as soon as possible.
+ The first time this is called it will set got_exit_signal to one and
+ store in exit_signal the signal that triggered its execution. */
+
+static RETSIGTYPE exit_signal_handler(int signum)
+{
+ int old_errno = ERRNO;
+ if(got_exit_signal == 0) {
+ got_exit_signal = 1;
+ exit_signal = signum;
+ }
+ (void)signal(signum, exit_signal_handler);
+ SET_ERRNO(old_errno);
+}
+
+static void install_signal_handlers(void)
+{
+#ifdef SIGHUP
+ /* ignore SIGHUP signal */
+ if((old_sighup_handler = signal(SIGHUP, SIG_IGN)) == SIG_ERR)
+ logmsg("cannot install SIGHUP handler: 5s", strerror(ERRNO));
+#endif
+#ifdef SIGPIPE
+ /* ignore SIGPIPE signal */
+ if((old_sigpipe_handler = signal(SIGPIPE, SIG_IGN)) == SIG_ERR)
+ logmsg("cannot install SIGPIPE handler: 5s", strerror(ERRNO));
+#endif
+#ifdef SIGALRM
+ /* ignore SIGALRM signal */
+ if((old_sigalrm_handler = signal(SIGALRM, SIG_IGN)) == SIG_ERR)
+ logmsg("cannot install SIGALRM handler: 5s", strerror(ERRNO));
+#endif
+#ifdef SIGINT
+ /* handle SIGINT signal with our exit_signal_handler */
+ if((old_sigint_handler = signal(SIGINT, exit_signal_handler)) == SIG_ERR)
+ logmsg("cannot install SIGINT handler: 5s", strerror(ERRNO));
+ else
+ siginterrupt(SIGINT, 1);
+#endif
+#ifdef SIGTERM
+ /* handle SIGTERM signal with our exit_signal_handler */
+ if((old_sigterm_handler = signal(SIGTERM, exit_signal_handler)) == SIG_ERR)
+ logmsg("cannot install SIGTERM handler: 5s", strerror(ERRNO));
+ else
+ siginterrupt(SIGTERM, 1);
+#endif
+}
+
+static void restore_signal_handlers(void)
+{
+#ifdef SIGHUP
+ if(SIG_ERR != old_sighup_handler)
+ (void)signal(SIGHUP, old_sighup_handler);
+#endif
+#ifdef SIGPIPE
+ if(SIG_ERR != old_sigpipe_handler)
+ (void)signal(SIGPIPE, old_sigpipe_handler);
+#endif
+#ifdef SIGALRM
+ if(SIG_ERR != old_sigalrm_handler)
+ (void)signal(SIGALRM, old_sigalrm_handler);
+#endif
+#ifdef SIGINT
+ if(SIG_ERR != old_sigint_handler)
+ (void)signal(SIGINT, old_sigint_handler);
+#endif
+#ifdef SIGTERM
+ if(SIG_ERR != old_sigterm_handler)
+ (void)signal(SIGTERM, old_sigterm_handler);
+#endif
+}
+
/*
* fullread is a wrapper around the read() function. This will repeat the call
* to read() until it actually has read the complete number of bytes indicated
@@ -119,6 +246,11 @@ static ssize_t fullread(int filedes, void *buffer, size_t nbytes)
do {
rc = read(filedes, (unsigned char *)buffer + nread, nbytes - nread);
+ if(got_exit_signal) {
+ logmsg("signalled to die");
+ return -1;
+ }
+
if(rc < 0) {
error = ERRNO;
if((error == EINTR) || (error == EAGAIN))
@@ -158,6 +290,11 @@ static ssize_t fullwrite(int filedes, const void *buffer, size_t nbytes)
do {
wc = write(filedes, (unsigned char *)buffer + nwrite, nbytes - nwrite);
+ if(got_exit_signal) {
+ logmsg("signalled to die");
+ return -1;
+ }
+
if(wc < 0) {
error = ERRNO;
if((error == EINTR) || (error == EAGAIN))
@@ -252,14 +389,6 @@ static void lograw(unsigned char *buffer, ssize_t len)
logmsg("'%s'", data);
}
-#ifdef SIGPIPE
-static void sigpipe_handler(int sig)
-{
- (void)sig; /* prevent warning */
- sigpipe = 1;
-}
-#endif
-
/*
sockfdp is a pointer to an established stream or CURL_SOCKET_BAD
@@ -287,6 +416,11 @@ static bool juggle(curl_socket_t *sockfdp,
unsigned char buffer[17010];
char data[16];
+ if(got_exit_signal) {
+ logmsg("signalled to die, exiting...");
+ return FALSE;
+ }
+
#ifdef HAVE_GETPPID
/* As a last resort, quit if sockfilt process becomes orphan. Just in case
parent ftpserver process has died without killing its sockfilt children */
@@ -359,6 +493,11 @@ static bool juggle(curl_socket_t *sockfdp,
rc = select((int)maxfd + 1, &fds_read, &fds_write, &fds_err, &timeout);
+ if(got_exit_signal) {
+ logmsg("signalled to die, exiting...");
+ return FALSE;
+ }
+
} while((rc == -1) && ((error = SOCKERRNO) == EINTR));
if(rc < 0) {
@@ -549,6 +688,11 @@ static curl_socket_t sockdaemon(curl_socket_t sock,
sclose(sock);
return CURL_SOCKET_BAD;
}
+ if(got_exit_signal) {
+ logmsg("signalled to die, exiting...");
+ sclose(sock);
+ return CURL_SOCKET_BAD;
+ }
totdelay += delay;
delay *= 2; /* double the sleep for next attempt */
}
@@ -712,18 +856,10 @@ int main(int argc, char *argv[])
#ifdef WIN32
win32_init();
atexit(win32_cleanup);
-#else
-
-#ifdef SIGPIPE
-#ifdef HAVE_SIGNAL
- signal(SIGPIPE, sigpipe_handler);
-#endif
-#ifdef HAVE_SIGINTERRUPT
- siginterrupt(SIGPIPE, 1);
-#endif
-#endif
#endif
+ install_signal_handlers();
+
#ifdef ENABLE_IPV6
if(!use_ipv6)
#endif
@@ -805,10 +941,22 @@ sockfilt_cleanup:
sclose(msgsock);
if(sock != CURL_SOCKET_BAD)
- sclose(sock);
+ sclose(sock);
if(wrotepidfile)
- unlink(pidname);
+ unlink(pidname);
+
+ restore_signal_handlers();
+
+ if(got_exit_signal) {
+ logmsg("============> sockfilt exits with signal (%d)", exit_signal);
+ /*
+ * To properly set the return status of the process we
+ * must raise the same signal SIGINT or SIGTERM that we
+ * caught and let the old handler take care of it.
+ */
+ raise(exit_signal);
+ }
logmsg("============> sockfilt quits");
return 0;