X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fsysdep.c;h=cb5b3a650458d22013992b9e1ee374a9711cdf41;hb=3e0de9cee21c23e63a6b3557fa0d74caf7c104fc;hp=164cafd5a70e2e530d888cb2b4df3695d5fb057e;hpb=b4a3cc69841bca455fc7a80548e99831268d4ff8;p=citadel.git diff --git a/citadel/sysdep.c b/citadel/sysdep.c index 164cafd5a..cb5b3a650 100644 --- a/citadel/sysdep.c +++ b/citadel/sysdep.c @@ -2,7 +2,7 @@ * $Id$ * * Citadel "system dependent" stuff. - * See copyright.txt for copyright information. + * See COPYING for copyright information. * * Here's where we (hopefully) have most parts of the Citadel server that * would need to be altered to run the server in a non-POSIX environment. @@ -60,6 +60,7 @@ #include "housekeeping.h" #include "modules/crypto/serv_crypto.h" /* Needed for init_ssl, client_write_ssl, client_read_ssl, destruct_ssl */ #include "ecrash.h" +#include "context.h" #ifdef HAVE_SYS_SELECT_H #include @@ -71,6 +72,9 @@ #include "ctdl_module.h" #include "threads.h" +#include "user_ops.h" +#include "control.h" + #ifdef DEBUG_MEMORY_LEAKS struct igheap { @@ -84,43 +88,23 @@ struct igheap *igheap = NULL; #endif -citthread_key_t MyConKey; /* TSD key for MyContext() */ - int verbosity = DEFAULT_VERBOSITY; /* Logging level */ -struct CitContext masterCC; -time_t last_purge = 0; /* Last dead session purge */ -int num_sessions = 0; /* Current number of sessions */ - int syslog_facility = LOG_DAEMON; int enable_syslog = 0; /* - * Create an interface to lprintf that follows the coding convention. - * This is here until such time as we have replaced all calls to lprintf with CtdlLogPrintf + * CtdlLogPrintf() ... Write logging information */ - -void CtdlLogPrintf(enum LogLevel loglevel, const char *format, ...) -{ +void CtdlLogPrintf(enum LogLevel loglevel, const char *format, ...) { va_list arg_ptr; va_start(arg_ptr, format); - vlprintf(loglevel, format, arg_ptr); + vCtdlLogPrintf(loglevel, format, arg_ptr); va_end(arg_ptr); } - -/* - * lprintf() ... Write logging information - */ -void lprintf(enum LogLevel loglevel, const char *format, ...) { - va_list arg_ptr; - va_start(arg_ptr, format); - vlprintf(loglevel, format, arg_ptr); - va_end(arg_ptr); -} - -void vlprintf(enum LogLevel loglevel, const char *format, va_list arg_ptr) +void vCtdlLogPrintf(enum LogLevel loglevel, const char *format, va_list arg_ptr) { char buf[SIZ], buf2[SIZ]; @@ -136,18 +120,19 @@ void vlprintf(enum LogLevel loglevel, const char *format, va_list arg_ptr) struct timeval tv; struct tm tim; time_t unixtime; + CitContext *CCC = CC; gettimeofday(&tv, NULL); /* Promote to time_t; types differ on some OSes (like darwin) */ unixtime = tv.tv_sec; localtime_r(&unixtime, &tim); - if (CC->cs_pid != 0) { + if ((CCC != NULL) && (CCC->cs_pid != 0)) { sprintf(buf, "%04d/%02d/%02d %2d:%02d:%02d.%06ld [%3d] ", tim.tm_year + 1900, tim.tm_mon + 1, tim.tm_mday, tim.tm_hour, tim.tm_min, tim.tm_sec, (long)tv.tv_usec, - CC->cs_pid); + CCC->cs_pid); } else { sprintf(buf, "%04d/%02d/%02d %2d:%02d:%02d.%06ld ", @@ -174,16 +159,18 @@ volatile int restart_server = 0; volatile int running_as_daemon = 0; static RETSIGTYPE signal_cleanup(int signum) { - CtdlLogPrintf(CTDL_DEBUG, "Caught signal %d; shutting down.\n", signum); -#ifdef THREADS_USESIGNALS + if (CT) - { - CtdlLogPrintf(CTDL_DEBUG, "Thread \"%s\" caught signal %d.\n", CT->name, signum); CT->signal = signum; - } else -#endif + { + CtdlLogPrintf(CTDL_DEBUG, "Caught signal %d; shutting down.\n", signum); exit_signal = signum; + } +} + +static RETSIGTYPE signal_exit(int signum) { + exit(1); } @@ -239,6 +226,7 @@ void init_sysdep(void) { signal(SIGQUIT, signal_cleanup); signal(SIGHUP, signal_cleanup); signal(SIGTERM, signal_cleanup); + signal(SIGUSR2, signal_exit); // signal(SIGSEGV, signal_cleanup); commented out because // signal(SIGILL, signal_cleanup); we want core dumps // signal(SIGBUS, signal_cleanup); @@ -341,12 +329,15 @@ int ig_uds_server(char *sockpath, int queue_len, char **errormessage) int s; int i; int actual_queue_len; +#ifdef HAVE_STRUCT_UCRED + int passcred = 1; +#endif actual_queue_len = queue_len; if (actual_queue_len < 5) actual_queue_len = 5; i = unlink(sockpath); - if (i != 0) if (errno != ENOENT) { + if ((i != 0) && (errno != ENOENT)) { *errormessage = (char*) malloc(SIZ + 1); snprintf(*errormessage, SIZ, "citserver: can't unlink %s: %s", sockpath, strerror(errno)); @@ -397,6 +388,10 @@ int ig_uds_server(char *sockpath, int queue_len, char **errormessage) return(-1); } +#ifdef HAVE_STRUCT_UCRED + setsockopt(s, SOL_SOCKET, SO_PASSCRED, &passcred, sizeof(passcred)); +#endif + chmod(sockpath, S_ISGID|S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IWGRP|S_IXGRP|S_IROTH|S_IWOTH|S_IXOTH); return(s); } @@ -404,66 +399,8 @@ int ig_uds_server(char *sockpath, int queue_len, char **errormessage) /* - * Return a pointer to the CitContext structure bound to the thread which - * called this function. If there's no such binding (for example, if it's - * called by the housekeeper thread) then a generic 'master' CC is returned. - * - * This function is used *VERY* frequently and must be kept small. - */ -struct CitContext *MyContext(void) { - - register struct CitContext *c; - - return ((c = (struct CitContext *) citthread_getspecific(MyConKey), - c == NULL) ? &masterCC : c - ); -} - - -/* - * Initialize a new context and place it in the list. The session number - * used to be the PID (which is why it's called cs_pid), but that was when we - * had one process per session. Now we just assign them sequentially, starting - * at 1 (don't change it to 0 because masterCC uses 0). - */ -struct CitContext *CreateNewContext(void) { - struct CitContext *me; - static int next_pid = 0; - - me = (struct CitContext *) malloc(sizeof(struct CitContext)); - if (me == NULL) { - CtdlLogPrintf(CTDL_ALERT, "citserver: can't allocate memory!!\n"); - return NULL; - } - memset(me, 0, sizeof(struct CitContext)); - - /* The new context will be created already in the CON_EXECUTING state - * in order to prevent another thread from grabbing it while it's - * being set up. - */ - me->state = CON_EXECUTING; - /* - * Generate a unique session number and insert this context into - * the list. - */ - begin_critical_section(S_SESSION_TABLE); - me->cs_pid = ++next_pid; - me->prev = NULL; - me->next = ContextList; - ContextList = me; - if (me->next != NULL) { - me->next->prev = me; - } - ++num_sessions; - end_critical_section(S_SESSION_TABLE); - return (me); -} - - -/* - * The following functions implement output buffering. If the kernel supplies - * native TCP buffering (Linux & *BSD), use that; otherwise, emulate it with - * user-space buffering. + * The following functions implement output buffering on operating systems which + * support it (such as Linux and various BSD flavors). */ #ifndef HAVE_DARWIN #ifdef TCP_CORK @@ -476,71 +413,49 @@ struct CitContext *CreateNewContext(void) { #endif /* TCP_CORK */ #endif /* HAVE_DARWIN */ -#ifdef HAVE_TCP_BUFFERING static unsigned on = 1, off = 0; -void buffer_output(void) { - struct CitContext *ctx = MyContext(); - setsockopt(ctx->client_socket, IPPROTO_TCP, TCP_CORK, &on, 4); - ctx->buffering = 1; -} - -void unbuffer_output(void) { - struct CitContext *ctx = MyContext(); - setsockopt(ctx->client_socket, IPPROTO_TCP, TCP_CORK, &off, 4); - ctx->buffering = 0; -} -void flush_output(void) { - struct CitContext *ctx = MyContext(); - setsockopt(ctx->client_socket, IPPROTO_TCP, TCP_CORK, &off, 4); - setsockopt(ctx->client_socket, IPPROTO_TCP, TCP_CORK, &on, 4); -} -#else -#ifdef HAVE_DARWIN -/* Stub functions for Darwin/OS X where TCP buffering isn't liked at all */ void buffer_output(void) { - CC->buffering = 0; +#ifdef HAVE_TCP_BUFFERING +#ifdef HAVE_OPENSSL + if (!CC->redirect_ssl) +#endif + setsockopt(CC->client_socket, IPPROTO_TCP, TCP_CORK, &on, 4); +#endif } + void unbuffer_output(void) { - CC->buffering = 0; -} -void flush_output(void) { -} -#else -void buffer_output(void) { - if (CC->buffering == 0) { - CC->buffering = 1; - CC->buffer_len = 0; - CC->output_buffer = malloc(SIZ); - } +#ifdef HAVE_TCP_BUFFERING +#ifdef HAVE_OPENSSL + if (!CC->redirect_ssl) +#endif + setsockopt(CC->client_socket, IPPROTO_TCP, TCP_CORK, &off, 4); +#endif } void flush_output(void) { - if (CC->buffering == 1) { - client_write(CC->output_buffer, CC->buffer_len); - CC->buffer_len = 0; - } +#ifdef HAVE_TCP_BUFFERING + struct CitContext *CCC = CC; + setsockopt(CCC->client_socket, IPPROTO_TCP, TCP_CORK, &off, 4); + setsockopt(CCC->client_socket, IPPROTO_TCP, TCP_CORK, &on, 4); +#endif } -void unbuffer_output(void) { - if (CC->buffering == 1) { - CC->buffering = 0; - /* We don't call flush_output because we can't. */ - client_write(CC->output_buffer, CC->buffer_len); - CC->buffer_len = 0; - free(CC->output_buffer); - CC->output_buffer = NULL; - } -} -#endif /* HAVE_DARWIN */ -#endif /* HAVE_TCP_BUFFERING */ +/* +static void flush_client_inbuf(void) +{ + CitContext *CCC=CC; + FlushStrBuf(CCC->ReadBuf); + CCC->Pos = NULL; +} +*/ /* * client_write() ... Send binary data to the client. */ -void client_write(char *buf, int nbytes) +int client_write(const char *buf, int nbytes) { int bytes_written = 0; int retval; @@ -548,56 +463,53 @@ void client_write(char *buf, int nbytes) int old_buffer_len = 0; #endif fd_set wset; - t_context *Ctx; + CitContext *Ctx; int fdflags; + if (nbytes < 1) return(0); + +// flush_client_inbuf(); Ctx = CC; if (Ctx->redirect_buffer != NULL) { - if ((Ctx->redirect_len + nbytes + 2) >= Ctx->redirect_alloc) { - Ctx->redirect_alloc = (Ctx->redirect_alloc * 2) + nbytes; - Ctx->redirect_buffer = realloc(Ctx->redirect_buffer, - Ctx->redirect_alloc); - } - memcpy(&Ctx->redirect_buffer[Ctx->redirect_len], buf, nbytes); - Ctx->redirect_len += nbytes; - Ctx->redirect_buffer[Ctx->redirect_len] = 0; - return; - } - -#ifndef HAVE_TCP_BUFFERING - /* If we're buffering for later, do that now. */ - if (Ctx->buffering) { - old_buffer_len = Ctx->buffer_len; - Ctx->buffer_len += nbytes; - Ctx->output_buffer = realloc(Ctx->output_buffer, Ctx->buffer_len); - memcpy(&Ctx->output_buffer[old_buffer_len], buf, nbytes); - return; + StrBufAppendBufPlain(Ctx->redirect_buffer, + buf, nbytes, 0); + return 0; } -#endif - - /* Ok, at this point we're not buffering. Go ahead and write. */ #ifdef HAVE_OPENSSL if (Ctx->redirect_ssl) { client_write_ssl(buf, nbytes); - return; + return 0; } #endif + if (Ctx->client_socket == -1) return -1; fdflags = fcntl(Ctx->client_socket, F_GETFL); - while (bytes_written < nbytes) { + while ((bytes_written < nbytes) && (Ctx->client_socket != -1)){ if ((fdflags & O_NONBLOCK) == O_NONBLOCK) { FD_ZERO(&wset); FD_SET(Ctx->client_socket, &wset); if (select(1, NULL, &wset, NULL, NULL) == -1) { - CtdlLogPrintf(CTDL_ERR, - "client_write(%d bytes) select failed: %s (%d)\n", - nbytes - bytes_written, - strerror(errno), errno); - cit_backtrace(); - Ctx->kill_me = 1; - return; + if (errno == EINTR) + { + CtdlLogPrintf(CTDL_DEBUG, "client_write(%d bytes) select() interrupted.\n", nbytes-bytes_written); + if (CtdlThreadCheckStop()) { + CC->kill_me = 1; + return (-1); + } else { + /* can't trust fd's and stuff so we need to re-create them */ + continue; + } + } else { + CtdlLogPrintf(CTDL_ERR, + "client_write(%d bytes) select failed: %s (%d)\n", + nbytes - bytes_written, + strerror(errno), errno); + cit_backtrace(); + Ctx->kill_me = 1; + return -1; + } } } @@ -611,21 +523,25 @@ void client_write(char *buf, int nbytes) cit_backtrace(); // CtdlLogPrintf(CTDL_DEBUG, "Tried to send: %s", &buf[bytes_written]); Ctx->kill_me = 1; - return; + return -1; } bytes_written = bytes_written + retval; } + return 0; } +void cputbuf(const StrBuf *Buf) { + client_write(ChrPtr(Buf), StrLength(Buf)); +} + /* - * cprintf() ... Send formatted printable data to the client. It is - * implemented in terms of client_write() but remains in - * sysdep.c in case we port to somewhere without va_args... + * cprintf() Send formatted printable data to the client. + * Implemented in terms of client_write() so it's technically not sysdep... */ void cprintf(const char *format, ...) { va_list arg_ptr; - char buf[1024]; + char buf[1024]; va_start(arg_ptr, format); if (vsnprintf(buf, sizeof buf, format, arg_ptr) == -1) @@ -637,51 +553,101 @@ void cprintf(const char *format, ...) { /* * Read data from the client socket. - * Return values are: - * 1 Requested number of bytes has been read. - * 0 Request timed out. - * -1 The socket is broken. - * If the socket breaks, the session will be terminated. + * + * sock socket fd to read from + * buf buffer to read into + * bytes number of bytes to read + * timeout Number of seconds to wait before timing out + * + * Possible return values: + * 1 Requested number of bytes has been read. + * 0 Request timed out. + * -1 Connection is broken, or other error. */ -int client_read_to(char *buf, int bytes, int timeout) +int client_read_blob(StrBuf *Target, int bytes, int timeout) { - int len,rlen; - fd_set rfds; - int fd; - struct timeval tv; - int retval; + CitContext *CCC=CC; + const char *Error; + int retval = 0; #ifdef HAVE_OPENSSL - if (CC->redirect_ssl) { - return (client_read_ssl(buf, bytes, timeout)); + if (CCC->redirect_ssl) { + retval = client_read_sslblob(Target, bytes, timeout); } + else +#endif + + retval = StrBufReadBLOBBuffered(Target, + CCC->ReadBuf, + &CCC->Pos, + &CCC->client_socket, + 1, + bytes, + O_TERM, + &Error); + if (retval < 0) { + CtdlLogPrintf(CTDL_CRIT, + "%s failed: %s\n", + __FUNCTION__, + Error); + } + else + { +#ifdef BIGBAD_IODBG + int rv = 0; + char fn [SIZ]; + FILE *fd; + + snprintf(fn, SIZ, "/tmp/foolog_%s.%d", CCC->ServiceName, CCC->cs_pid); + + fd = fopen(fn, "a+"); + fprintf(fd, "Read: BufSize: %d BufContent: [", + StrLength(Target)); + rv = fwrite(ChrPtr(Target), StrLength(Target), 1, fd); + fprintf(fd, "]\n"); + + + fclose(fd); #endif - len = 0; - fd = CC->client_socket; - while(lenkill_me = 1; - return(-1); - } - len = len + rlen; } - return(1); + return retval == bytes; } +int client_read_to(char *buf, int bytes, int timeout) +{ + CitContext *CCC=CC; + int rc; + + rc = client_read_blob(CCC->MigrateBuf, bytes, timeout); + if (rc < 0) + { + *buf = '\0'; + return rc; + } + else + { + memcpy(buf, + ChrPtr(CCC->MigrateBuf), + StrLength(CCC->MigrateBuf) + 1); + FlushStrBuf(CCC->MigrateBuf); + return rc; + } +} + + +int HaveMoreLinesWaiting(CitContext *CCC) +{ + if ((CCC->kill_me == 1) || ( + (CCC->Pos == NULL) && + (StrLength(CCC->ReadBuf) == 0) && + (CCC->client_socket != -1)) ) + return 0; + else + return 1; +} + + /* * Read data from the client socket with default timeout. * (This is implemented in terms of client_read_to() and could be @@ -692,6 +658,127 @@ INLINE int client_read(char *buf, int bytes) return(client_read_to(buf, bytes, config.c_sleeping)); } +int CtdlClientGetLine(StrBuf *Target) +{ + CitContext *CCC=CC; + const char *Error; + int rc; + + FlushStrBuf(Target); +#ifdef HAVE_OPENSSL + if (CCC->redirect_ssl) { +#ifdef BIGBAD_IODBG + char fn [SIZ]; + FILE *fd; + int len, rlen, nlen, nrlen; + const char *pch; + + snprintf(fn, SIZ, "/tmp/foolog_%s.%d", CCC->ServiceName, CCC->cs_pid); + + fd = fopen(fn, "a+"); + pch = ChrPtr(CCC->ReadBuf); + len = StrLength(CCC->ReadBuf); + if (CCC->Pos != NULL) + rlen = CC->Pos - pch; + else + rlen = 0; + +/* fprintf(fd, "\n\n\nBufSize: %d BufPos: %d \nBufContent: [%s]\n\n_____________________\n", + len, rlen, pch); +*/ + fprintf(fd, "\n\n\nBufSize: %d BufPos: %d \n_____________________\n", + len, rlen); +#endif + rc = client_readline_sslbuffer(Target, + CCC->ReadBuf, + 1); +#ifdef BIGBAD_IODBG + pch = ChrPtr(CCC->ReadBuf); + nlen = StrLength(CCC->ReadBuf); + if (CCC->Pos != NULL) + nrlen = CC->Pos - pch; + else + nrlen = 0; +/* + fprintf(fd, "\n\n\nBufSize: was: %d is: %d BufPos: was: %d is: %d \nBufContent: [%s]\n\n_____________________\n", + len, nlen, rlen, nrlen, pch); +*/ + fprintf(fd, "\n\n\nBufSize: was: %d is: %d BufPos: was: %d is: %d \n", + len, nlen, rlen, nrlen); + + fprintf(fd, "Read: BufSize: %d BufContent: [%s]\n\n*************\n", + StrLength(Target), ChrPtr(Target)); + fclose(fd); + + if ((rc < 0) && (Error != NULL)) + CtdlLogPrintf(CTDL_CRIT, + "%s failed: %s\n", + __FUNCTION__, + Error); +#endif + return rc; + } + else +#endif + { +#ifdef BIGBAD_IODBG + char fn [SIZ]; + FILE *fd; + int len, rlen, nlen, nrlen; + const char *pch; + + snprintf(fn, SIZ, "/tmp/foolog_%s.%d", CCC->ServiceName, CCC->cs_pid); + + fd = fopen(fn, "a+"); + pch = ChrPtr(CCC->ReadBuf); + len = StrLength(CCC->ReadBuf); + if (CCC->Pos != NULL) + rlen = CC->Pos - pch; + else + rlen = 0; + +/* fprintf(fd, "\n\n\nBufSize: %d BufPos: %d \nBufContent: [%s]\n\n_____________________\n", + len, rlen, pch); +*/ + fprintf(fd, "\n\n\nBufSize: %d BufPos: %d \n_____________________\n", + len, rlen); +#endif + rc = StrBufTCP_read_buffered_line_fast(Target, + CCC->ReadBuf, + &CCC->Pos, + &CCC->client_socket, + 5, + 1, + &Error); + +#ifdef BIGBAD_IODBG + pch = ChrPtr(CCC->ReadBuf); + nlen = StrLength(CCC->ReadBuf); + if (CCC->Pos != NULL) + nrlen = CC->Pos - pch; + else + nrlen = 0; +/* + fprintf(fd, "\n\n\nBufSize: was: %d is: %d BufPos: was: %d is: %d \nBufContent: [%s]\n\n_____________________\n", + len, nlen, rlen, nrlen, pch); +*/ + fprintf(fd, "\n\n\nBufSize: was: %d is: %d BufPos: was: %d is: %d \n", + len, nlen, rlen, nrlen); + + fprintf(fd, "Read: BufSize: %d BufContent: [%s]\n\n*************\n", + StrLength(Target), ChrPtr(Target)); + fclose(fd); + + if ((rc < 0) && (Error != NULL)) + CtdlLogPrintf(CTDL_CRIT, + "%s failed: %s\n", + __FUNCTION__, + Error); +#endif + return rc; + } +} + /* * client_getln() ... Get a LF-terminated line of text from the client. @@ -701,68 +788,39 @@ INLINE int client_read(char *buf, int bytes) int client_getln(char *buf, int bufsize) { int i, retval; + CitContext *CCC=CC; + const char *pCh; - /* Read one character at a time. - */ - for (i = 0;;i++) { - retval = client_read(&buf[i], 1); - if (retval != 1 || buf[i] == '\n' || i == (bufsize-1)) - break; - } + retval = CtdlClientGetLine(CCC->MigrateBuf); + if (retval < 0) + return(retval >= 0); - /* If we got a long line, discard characters until the newline. - */ - if (i == (bufsize-1)) - while (buf[i] != '\n' && retval == 1) - retval = client_read(&buf[i], 1); + i = StrLength(CCC->MigrateBuf); + pCh = ChrPtr(CCC->MigrateBuf); /* Strip the trailing LF, and the trailing CR if present. */ - buf[i] = 0; + if (bufsize <= i) + i = bufsize - 1; while ( (i > 0) - && ( (buf[i - 1]==13) - || ( buf[i - 1]==10)) ) { + && ( (pCh[i - 1]==13) + || ( pCh[i - 1]==10)) ) { i--; - buf[i] = 0; } - if (retval < 0) safestrncpy(&buf[i], "000", bufsize - i); - return(retval); + memcpy(buf, pCh, i); + buf[i] = 0; + + FlushStrBuf(CCC->MigrateBuf); + if (retval < 0) { + safestrncpy(&buf[i], "000", bufsize - i); + } + return(retval >= 0); } /* * Cleanup any contexts that are left lying around */ -void context_cleanup(void) -{ - struct CitContext *ptr = NULL; - struct CitContext *rem = NULL; - - /* - * Clean up the contexts. - * There are no threads so no critical_section stuff is needed. - */ - ptr = ContextList; - - /* We need to update the ContextList because some modules may want to itterate it - * Question is should we NULL it before iterating here or should we just keep updating it - * as we remove items? - * - * Answer is to NULL it first to prevent modules from doing any actions on the list at all - */ - ContextList=NULL; - while (ptr != NULL){ - /* Remove the session from the active list */ - rem = ptr->next; - --num_sessions; - - lprintf(CTDL_DEBUG, "Purging session %d\n", ptr->cs_pid); - RemoveContext(ptr); - free (ptr); - ptr = rem; - } -} - void close_masters (void) @@ -819,31 +877,13 @@ void sysdep_master_cleanup(void) { CtdlDestroySessionHooks(); CtdlDestroyServiceHook(); CtdlDestroyRoomHooks(); - CtdlDestroyDirectoryServiceFuncs(); #ifdef HAVE_BACKTRACE - eCrash_Uninit(); +/// eCrash_Uninit(); #endif } -/* - * Terminate another session. - * (This could justifiably be moved out of sysdep.c because it - * no longer does anything that is system-dependent.) - */ -void kill_session(int session_to_kill) { - struct CitContext *ptr; - - begin_critical_section(S_SESSION_TABLE); - for (ptr = ContextList; ptr != NULL; ptr = ptr->next) { - if (ptr->cs_pid == session_to_kill) { - ptr->kill_me = 1; - } - } - end_critical_section(S_SESSION_TABLE); -} - pid_t current_child; void graceful_shutdown(int signum) { kill(current_child, signum); @@ -851,6 +891,9 @@ void graceful_shutdown(int signum) { exit(0); } +int nFireUps = 0; +int nFireUpsNonRestart = 0; +pid_t ForkedPid = 1; /* * Start running as a daemon. @@ -867,7 +910,10 @@ void start_daemon(int unused) { * We don't just call close() because we don't want these fd's * to be reused for other files. */ - chdir(ctdl_run_dir); + if (chdir(ctdl_run_dir) != 0) + CtdlLogPrintf(CTDL_EMERG, + "unable to change into directory [%s]: %s", + ctdl_run_dir, strerror(errno)); child = fork(); if (child != 0) { @@ -880,9 +926,13 @@ void start_daemon(int unused) { setsid(); umask(0); - freopen("/dev/null", "r", stdin); - freopen("/dev/null", "w", stdout); - freopen("/dev/null", "w", stderr); + if ((freopen("/dev/null", "r", stdin) != stdin) || + (freopen("/dev/null", "w", stdout) != stdout) || + (freopen("/dev/null", "w", stderr) != stderr)) + CtdlLogPrintf(CTDL_EMERG, + "unable to reopen stdin/out/err %s", + strerror(errno)); + do { current_child = fork(); @@ -906,31 +956,24 @@ void start_daemon(int unused) { } waitpid(current_child, &status, 0); } - do_restart = 0; + nFireUpsNonRestart = nFireUps; + + /* Exit code 0 means the watcher should exit */ + if (WIFEXITED(status) && (WEXITSTATUS(status) == CTDLEXIT_SHUTDOWN)) { + do_restart = 0; + } - /* Did the main process exit with an actual exit code? */ - if (WIFEXITED(status)) { - - /* Exit code 0 means the watcher should exit */ - if (WEXITSTATUS(status) == 0) { - do_restart = 0; - } - - /* Exit code 101-109 means the watcher should exit */ - else if ( (WEXITSTATUS(status) >= 101) && (WEXITSTATUS(status) <= 109) ) { - do_restart = 0; - } - - /* Any other exit code means we should restart. */ - else { - do_restart = 1; - } + /* Exit code 101-109 means the watcher should exit */ + else if (WIFEXITED(status) && (WEXITSTATUS(status) >= 101) && (WEXITSTATUS(status) <= 109)) { + do_restart = 0; } - /* Any other type of termination (signals, etc.) should also restart. */ + /* Any other exit code, or no exit code, means we should restart. */ else { do_restart = 1; + nFireUps++; + ForkedPid = current_child; } } while (do_restart); @@ -941,6 +984,34 @@ void start_daemon(int unused) { +void checkcrash(void) +{ + if (nFireUpsNonRestart != nFireUps) + { + StrBuf *CrashMail; + + CrashMail = NewStrBuf(); + CtdlLogPrintf(CTDL_ALERT, "Posting crash message\n"); + StrBufPrintf(CrashMail, + " \n" + " The Citadel server process (citserver) terminated unexpectedly." + "\n \n" + " This could be the result of a bug in the server program, or some external " + "factor.\n \n" + " You can obtain more information about this by enabling core dumps.\n \n" + " For more information, please see:\n \n" + " http://citadel.org/doku.php/faq:mastering_your_os:gdb#how.do.i.make.my.system.produce.core-files" + "\n \n" + + " If you have already done this, the core dump is likely to be found at %score.%d\n" + , + ctdl_run_dir, ForkedPid); + CtdlAideMessage(ChrPtr(CrashMail), "Citadel server process terminated unexpectedly"); + FreeStrBuf(&CrashMail); + } +} + + /* * Generic routine to convert a login name to a full name (gecos) * Returns nonzero if a conversion took place @@ -962,91 +1033,6 @@ int convert_login(char NameToConvert[]) { } } -/* - * Purge all sessions which have the 'kill_me' flag set. - * This function has code to prevent it from running more than once every - * few seconds, because running it after every single unbind would waste a lot - * of CPU time and keep the context list locked too much. To force it to run - * anyway, set "force" to nonzero. - */ -void dead_session_purge(int force) { - struct CitContext *ptr, *ptr2; /* general-purpose utility pointer */ - struct CitContext *rem = NULL; /* list of sessions to be destroyed */ - - if (force == 0) { - if ( (time(NULL) - last_purge) < 5 ) { - return; /* Too soon, go away */ - } - } - time(&last_purge); - - if (try_critical_section(S_SESSION_TABLE)) - return; - - ptr = ContextList; - while (ptr) { - ptr2 = ptr; - ptr = ptr->next; - - if ( (ptr2->state == CON_IDLE) && (ptr2->kill_me) ) { - /* Remove the session from the active list */ - if (ptr2->prev) { - ptr2->prev->next = ptr2->next; - } - else { - ContextList = ptr2->next; - } - if (ptr2->next) { - ptr2->next->prev = ptr2->prev; - } - - --num_sessions; - /* And put it on our to-be-destroyed list */ - ptr2->next = rem; - rem = ptr2; - } - } - end_critical_section(S_SESSION_TABLE); - - /* Now that we no longer have the session list locked, we can take - * our time and destroy any sessions on the to-be-killed list, which - * is allocated privately on this thread's stack. - */ - while (rem != NULL) { - CtdlLogPrintf(CTDL_DEBUG, "Purging session %d\n", rem->cs_pid); - RemoveContext(rem); - ptr = rem; - rem = rem->next; - free(ptr); - } -} - - - - - -/* - * masterCC is the context we use when not attached to a session. This - * function initializes it. - */ -void InitializeMasterCC(void) { - memset(&masterCC, 0, sizeof(struct CitContext)); - masterCC.internal_pgm = 1; - masterCC.cs_pid = 0; -} - - - - - - -/* - * Bind a thread to a context. (It's inline merely to speed things up.) - */ -INLINE void become_session(struct CitContext *which_con) { - citthread_setspecific(MyConKey, (void *)which_con ); -} - /* @@ -1078,18 +1064,13 @@ INLINE void become_session(struct CitContext *which_con) { */ void *worker_thread(void *arg) { - int i; int highest; - struct CitContext *ptr; - struct CitContext *bind_me = NULL; + CitContext *ptr; + CitContext *bind_me = NULL; fd_set readfds; int retval = 0; - struct CitContext *con= NULL; /* Temporary context pointer */ - struct ServiceFunctionHook *serviceptr; - int ssock; /* Descriptor for client socket */ struct timeval tv; int force_purge = 0; - int m; while (!CtdlThreadCheckStop()) { @@ -1107,14 +1088,26 @@ do_select: force_purge = 0; begin_critical_section(S_SESSION_TABLE); for (ptr = ContextList; ptr != NULL; ptr = ptr->next) { - if (ptr->state == CON_IDLE) { - FD_SET(ptr->client_socket, &readfds); - if (ptr->client_socket > highest) - highest = ptr->client_socket; + int client_socket; + client_socket = ptr->client_socket; + /* Dont select on dead sessions only truly idle ones */ + if ((ptr->state == CON_IDLE) && + (CC->kill_me == 0) && + (client_socket != -1)) + { + FD_SET(client_socket, &readfds); + if (client_socket > highest) + highest = client_socket; } if ((bind_me == NULL) && (ptr->state == CON_READY)) { bind_me = ptr; ptr->state = CON_EXECUTING; + break; + } + if ((bind_me == NULL) && (ptr->state == CON_GREETING)) { + bind_me = ptr; + ptr->state = CON_STARTING; + break; } } end_critical_section(S_SESSION_TABLE); @@ -1128,23 +1121,151 @@ do_select: force_purge = 0; * ahead and get ready to select(). */ + if (!CtdlThreadCheckStop()) { + tv.tv_sec = 1; /* wake up every second if no input */ + tv.tv_usec = 0; + retval = CtdlThreadSelect(highest + 1, &readfds, NULL, NULL, &tv); + } + else + return NULL; + + /* Now figure out who made this select() unblock. + * First, check for an error or exit condition. + */ + if (retval < 0) { + if (errno == EBADF) { + CtdlLogPrintf(CTDL_NOTICE, "select() failed: (%s)\n", + strerror(errno)); + goto do_select; + } + if (errno != EINTR) { + CtdlLogPrintf(CTDL_EMERG, "Exiting (%s)\n", strerror(errno)); + CtdlThreadStopAll(); + continue; + } else { + CtdlLogPrintf(CTDL_DEBUG, "Interrupted CtdlThreadSelect.\n"); + if (CtdlThreadCheckStop()) return(NULL); + goto do_select; + } + } + else if(retval == 0) { + if (CtdlThreadCheckStop()) return(NULL); + } + + /* It must be a client socket. Find a context that has data + * waiting on its socket *and* is in the CON_IDLE state. Any + * active sockets other than our chosen one are marked as + * CON_READY so the next thread that comes around can just bind + * to one without having to select() again. + */ + begin_critical_section(S_SESSION_TABLE); + for (ptr = ContextList; ptr != NULL; ptr = ptr->next) { + int checkfd = ptr->client_socket; + if ((checkfd != -1) && (ptr->state == CON_IDLE) ){ + if (FD_ISSET(checkfd, &readfds)) { + ptr->input_waiting = 1; + if (!bind_me) { + bind_me = ptr; /* I choose you! */ + bind_me->state = CON_EXECUTING; + } + else { + ptr->state = CON_READY; + } + } else if ((ptr->is_async) && (ptr->async_waiting) && (ptr->h_async_function)) { + if (!bind_me) { + bind_me = ptr; /* I choose you! */ + bind_me->state = CON_EXECUTING; + } + else { + ptr->state = CON_READY; + } + } + } + } + end_critical_section(S_SESSION_TABLE); + +SKIP_SELECT: + /* We're bound to a session */ + if (bind_me != NULL) { + become_session(bind_me); + + if (bind_me->state == CON_STARTING) { + bind_me->state = CON_EXECUTING; + begin_session(bind_me); + bind_me->h_greeting_function(); + } + /* If the client has sent a command, execute it. */ + if (CC->input_waiting) { + CC->h_command_function(); + + while (HaveMoreLinesWaiting(CC)) + CC->h_command_function(); + + CC->input_waiting = 0; + } + + /* If there are asynchronous messages waiting and the + * client supports it, do those now */ + if ((CC->is_async) && (CC->async_waiting) + && (CC->h_async_function != NULL)) { + CC->h_async_function(); + CC->async_waiting = 0; + } + + force_purge = CC->kill_me; + become_session(NULL); + bind_me->state = CON_IDLE; + } + + dead_session_purge(force_purge); + do_housekeeping(); + } + /* If control reaches this point, the server is shutting down */ + return(NULL); +} + + + + +/* + * A function to handle selecting on master sockets. + * In other words it handles new connections. + * It is a thread. + */ +void *select_on_master (void *arg) +{ + struct ServiceFunctionHook *serviceptr; + fd_set master_fds; + int highest; + struct timeval tv; + int ssock; /* Descriptor for client socket */ + CitContext *con= NULL; /* Temporary context pointer */ + int m; + int i; + int retval; + + while (!CtdlThreadCheckStop()) { + /* Initialize the fdset. */ + FD_ZERO(&master_fds); + highest = 0; + /* First, add the various master sockets to the fdset. */ for (serviceptr = ServiceHookTable; serviceptr != NULL; serviceptr = serviceptr->next ) { m = serviceptr->msock; - FD_SET(m, &readfds); + FD_SET(m, &master_fds); if (m > highest) { highest = m; } } if (!CtdlThreadCheckStop()) { - tv.tv_sec = 1; /* wake up every second if no input */ + tv.tv_sec = 60; /* wake up every second if no input */ tv.tv_usec = 0; - retval = CtdlThreadSelect(highest + 1, &readfds, NULL, NULL, &tv); + retval = CtdlThreadSelect(highest + 1, &master_fds, NULL, NULL, &tv); } - - if (CtdlThreadCheckStop()) return(NULL); + else + return NULL; /* Now figure out who made this select() unblock. * First, check for an error or exit condition. @@ -1153,18 +1274,20 @@ do_select: force_purge = 0; if (errno == EBADF) { CtdlLogPrintf(CTDL_NOTICE, "select() failed: (%s)\n", strerror(errno)); - goto do_select; + continue; } if (errno != EINTR) { CtdlLogPrintf(CTDL_EMERG, "Exiting (%s)\n", strerror(errno)); CtdlThreadStopAll(); - } else if (!CtdlThreadCheckStop()) { - CtdlLogPrintf(CTDL_DEBUG, "Interrupted select.\n"); - goto do_select; + } else { + CtdlLogPrintf(CTDL_DEBUG, "Interrupted CtdlThreadSelect.\n"); + if (CtdlThreadCheckStop()) return(NULL); + continue; } } else if(retval == 0) { - goto SKIP_SELECT; + if (CtdlThreadCheckStop()) return(NULL); + continue; } /* Next, check to see if it's a new client connecting * on a master socket. @@ -1172,7 +1295,7 @@ do_select: force_purge = 0; else for (serviceptr = ServiceHookTable; serviceptr != NULL; serviceptr = serviceptr->next ) { - if (FD_ISSET(serviceptr->msock, &readfds)) { + if (FD_ISSET(serviceptr->msock, &master_fds)) { ssock = accept(serviceptr->msock, NULL, 0); if (ssock >= 0) { CtdlLogPrintf(CTDL_DEBUG, @@ -1200,6 +1323,7 @@ do_select: force_purge = 0; serviceptr->h_command_function; con->h_async_function = serviceptr->h_async_function; + con->h_greeting_function = serviceptr->h_greeting_function; con->ServiceName = serviceptr->ServiceName; @@ -1213,72 +1337,20 @@ do_select: force_purge = 0; SO_REUSEADDR, &i, sizeof(i)); - become_session(con); - begin_session(con); - serviceptr->h_greeting_function(); - become_session(NULL); - con->state = CON_IDLE; - goto do_select; - } - } - } + con->state = CON_GREETING; - /* It must be a client socket. Find a context that has data - * waiting on its socket *and* is in the CON_IDLE state. Any - * active sockets other than our chosen one are marked as - * CON_READY so the next thread that comes around can just bind - * to one without having to select() again. - */ - begin_critical_section(S_SESSION_TABLE); - for (ptr = ContextList; ptr != NULL; ptr = ptr->next) { - if ( (FD_ISSET(ptr->client_socket, &readfds)) - && (ptr->state != CON_EXECUTING) ) { - ptr->input_waiting = 1; - if (!bind_me) { - bind_me = ptr; /* I choose you! */ - bind_me->state = CON_EXECUTING; - } - else { - ptr->state = CON_READY; + retval--; + if (retval == 0) + break; } } } - end_critical_section(S_SESSION_TABLE); - -SKIP_SELECT: - /* We're bound to a session */ - if (bind_me != NULL) { - become_session(bind_me); - - /* If the client has sent a command, execute it. */ - if (CC->input_waiting) { - CC->h_command_function(); - CC->input_waiting = 0; - } - - /* If there are asynchronous messages waiting and the - * client supports it, do those now */ - if ((CC->is_async) && (CC->async_waiting) - && (CC->h_async_function != NULL)) { - CC->h_async_function(); - CC->async_waiting = 0; - } - - force_purge = CC->kill_me; - become_session(NULL); - bind_me->state = CON_IDLE; - } - - dead_session_purge(force_purge); - do_housekeeping(); } - /* If control reaches this point, the server is shutting down */ - return(NULL); + return NULL; } - /* * SyslogFacility() * Translate text facility name to syslog.h defined value.