X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fsysdep.c;h=f8ff6df46eb0b0c06aa7132e6c80ecdfd12c0bd7;hb=466bec234ce6f495f03c67a0789b85b3440b32a1;hp=7cc7fd0c4900b159e3abec47b991cdde4af7f1f4;hpb=9d6ac635379521753572f0641718f58f154b2aa3;p=citadel.git diff --git a/citadel/sysdep.c b/citadel/sysdep.c index 7cc7fd0c4..f8ff6df46 100644 --- a/citadel/sysdep.c +++ b/citadel/sysdep.c @@ -1,8 +1,5 @@ /* - * $Id$ - * * Citadel "system dependent" stuff. - * 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. @@ -10,6 +7,15 @@ * If we ever port to a different platform and either have multiple * variants of this file or simply load it up with #ifdefs. * + * Copyright (c) 1987-2011 by the citadel.org team + * + * This program is open source software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. */ #include "sysdep.h" @@ -49,6 +55,7 @@ #include #include #include +#define SHOW_ME_VAPPEND_PRINTF #include #include "citadel.h" #include "server.h" @@ -60,146 +67,18 @@ #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 #endif -#ifndef HAVE_SNPRINTF -#include "snprintf.h" -#endif - #include "ctdl_module.h" #include "threads.h" #include "user_ops.h" #include "control.h" -#ifdef DEBUG_MEMORY_LEAKS -struct igheap { - struct igheap *next; - char file[32]; - int line; - void *block; -}; - -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; - - -/* Flag for single user mode */ -static int want_single_user = 0; - -/* Try to go single user */ - -int CtdlTrySingleUser(void) -{ - int can_do = 0; - - begin_critical_section(S_SINGLE_USER); - if (want_single_user) - can_do = 0; - else - { - can_do = 1; - want_single_user = 1; - } - end_critical_section(S_SINGLE_USER); - return can_do; -} - -void CtdlEndSingleUser(void) -{ - begin_critical_section(S_SINGLE_USER); - want_single_user = 0; - end_critical_section(S_SINGLE_USER); -} - - -int CtdlWantSingleUser(void) -{ - return want_single_user; -} - -int CtdlIsSingleUser(void) -{ - if (want_single_user) - { - /* check for only one context here */ - if (num_sessions == 1) - return TRUE; - } - return FALSE; -} - - -/* - * CtdlLogPrintf() ... Write logging information - */ -void CtdlLogPrintf(enum LogLevel loglevel, const char *format, ...) { - va_list arg_ptr; - va_start(arg_ptr, format); - vCtdlLogPrintf(loglevel, format, arg_ptr); - va_end(arg_ptr); -} - -void vCtdlLogPrintf(enum LogLevel loglevel, const char *format, va_list arg_ptr) -{ - char buf[SIZ], buf2[SIZ]; - - if (enable_syslog) { - vsyslog((syslog_facility | loglevel), format, arg_ptr); - } - - /* stderr output code */ - if (enable_syslog || running_as_daemon) return; - - /* if we run in forground and syslog is disabled, log to terminal */ - if (loglevel <= verbosity) { - struct timeval tv; - struct tm tim; - time_t unixtime; - struct 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 ((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, - CCC->cs_pid); - } else { - sprintf(buf, - "%04d/%02d/%02d %2d:%02d:%02d.%06ld ", - tim.tm_year + 1900, tim.tm_mon + 1, - tim.tm_mday, tim.tm_hour, tim.tm_min, - tim.tm_sec, (long)tv.tv_usec); - } - vsnprintf(buf2, SIZ, format, arg_ptr); - - fprintf(stderr, "%s%s", buf, buf2); - fflush(stderr); - } -} - - - /* * Signal handler to shut down the server. */ @@ -210,15 +89,13 @@ volatile int restart_server = 0; volatile int running_as_daemon = 0; static RETSIGTYPE signal_cleanup(int signum) { -#ifdef THREADS_USESIGNALS - if (CT) - CT->signal = signum; - else -#endif - { - CtdlLogPrintf(CTDL_DEBUG, "Caught signal %d; shutting down.\n", signum); - exit_signal = signum; - } + syslog(LOG_DEBUG, "Caught signal %d; shutting down.", signum); + exit_signal = signum; + server_shutting_down = 1; +} + +static RETSIGTYPE signal_exit(int signum) { + exit(1); } @@ -251,32 +128,24 @@ void init_sysdep(void) { * CitContext structure (in the ContextList linked list) of the * session to which the calling thread is currently bound. */ - if (citthread_key_create(&MyConKey, NULL) != 0) { - CtdlLogPrintf(CTDL_CRIT, "Can't create TSD key: %s\n", - strerror(errno)); + if (pthread_key_create(&MyConKey, NULL) != 0) { + syslog(LOG_CRIT, "Can't create TSD key: %s", strerror(errno)); } /* - * The action for unexpected signals and exceptions should be to - * call signal_cleanup() to gracefully shut down the server. + * Interript, hangup, and terminate signals should cause the server + * to gracefully clean up and shut down. */ sigemptyset(&set); sigaddset(&set, SIGINT); - sigaddset(&set, SIGQUIT); sigaddset(&set, SIGHUP); sigaddset(&set, SIGTERM); - // sigaddset(&set, SIGSEGV); commented out because - // sigaddset(&set, SIGILL); we want core dumps - // sigaddset(&set, SIGBUS); sigprocmask(SIG_UNBLOCK, &set, NULL); signal(SIGINT, signal_cleanup); - signal(SIGQUIT, signal_cleanup); signal(SIGHUP, signal_cleanup); signal(SIGTERM, signal_cleanup); - // signal(SIGSEGV, signal_cleanup); commented out because - // signal(SIGILL, signal_cleanup); we want core dumps - // signal(SIGBUS, signal_cleanup); + signal(SIGUSR2, signal_exit); /* * Do not shut down the server on broken pipe signals, otherwise the @@ -287,90 +156,119 @@ void init_sysdep(void) { } - - -/* +/* * This is a generic function to set up a master socket for listening on - * a TCP port. The server shuts down if the bind fails. + * a TCP port. The server shuts down if the bind fails. (IPv4/IPv6 version) * + * ip_addr IP address to bind + * port_number port number to bind + * queue_len number of incoming connections to allow in the queue */ -int ig_tcp_server(char *ip_addr, int port_number, int queue_len, char **errormessage) +int ctdl_tcp_server(char *ip_addr, int port_number, int queue_len, char *errormessage) { - struct sockaddr_in sin; - int s, i; - int actual_queue_len; - - actual_queue_len = queue_len; - if (actual_queue_len < 5) actual_queue_len = 5; - - memset(&sin, 0, sizeof(sin)); - sin.sin_family = AF_INET; - sin.sin_port = htons((u_short)port_number); - if (ip_addr == NULL) { - sin.sin_addr.s_addr = INADDR_ANY; + struct protoent *p; + struct sockaddr_in6 sin6; + struct sockaddr_in sin4; + int s, i, b; + int ip_version = 6; + + memset(&sin6, 0, sizeof(sin6)); + memset(&sin4, 0, sizeof(sin4)); + sin6.sin6_family = AF_INET6; + sin4.sin_family = AF_INET; + + if ( (ip_addr == NULL) /* any IPv6 */ + || (IsEmptyStr(ip_addr)) + || (!strcmp(ip_addr, "*")) + ) { + ip_version = 6; + sin6.sin6_addr = in6addr_any; } - else { - sin.sin_addr.s_addr = inet_addr(ip_addr); + else if (!strcmp(ip_addr, "0.0.0.0")) /* any IPv4 */ + { + ip_version = 4; + sin4.sin_addr.s_addr = INADDR_ANY; } - - if (sin.sin_addr.s_addr == !INADDR_ANY) { - sin.sin_addr.s_addr = INADDR_ANY; + else if ((strchr(ip_addr, '.')) && (!strchr(ip_addr, ':'))) /* specific IPv4 */ + { + ip_version = 4; + if (inet_pton(AF_INET, ip_addr, &sin4.sin_addr) <= 0) { + snprintf(errormessage, SIZ, + "Error binding to [%s] : %s", ip_addr, strerror(errno) + ); + syslog(LOG_ALERT, "%s", errormessage); + return (-1); + } } + else /* specific IPv6 */ + { + ip_version = 6; + if (inet_pton(AF_INET6, ip_addr, &sin6.sin6_addr) <= 0) { + snprintf(errormessage, SIZ, + "Error binding to [%s] : %s", ip_addr, strerror(errno) + ); + syslog(LOG_ALERT, "%s", errormessage); + return (-1); + } + } + + if (port_number == 0) { + snprintf(errormessage, SIZ, "Can't start: no port number specified."); + syslog(LOG_ALERT, "%s", errormessage); + return (-1); + } + sin6.sin6_port = htons((u_short) port_number); + sin4.sin_port = htons((u_short) port_number); - s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); + p = getprotobyname("tcp"); + s = socket( ((ip_version == 6) ? PF_INET6 : PF_INET), SOCK_STREAM, (p->p_proto)); if (s < 0) { - *errormessage = (char*) malloc(SIZ + 1); - snprintf(*errormessage, SIZ, - "citserver: Can't create a socket: %s", - strerror(errno)); - CtdlLogPrintf(CTDL_EMERG, "%s\n", *errormessage); - return(-1); + snprintf(errormessage, SIZ, + "Can't create a listening socket: %s", strerror(errno) + ); + syslog(LOG_ALERT, "%s", errormessage); + return (-1); } - + /* Set some socket options that make sense. */ i = 1; setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i)); - if (bind(s, (struct sockaddr *)&sin, sizeof(sin)) < 0) { - *errormessage = (char*) malloc(SIZ + 1); - snprintf(*errormessage, SIZ, - "citserver: Can't bind: %s", - strerror(errno)); - CtdlLogPrintf(CTDL_EMERG, "%s\n", *errormessage); - close(s); - return(-1); + if (ip_version == 6) { + b = bind(s, (struct sockaddr *) &sin6, sizeof(sin6)); } - - /* set to nonblock - we need this for some obscure situations */ - if (fcntl(s, F_SETFL, O_NONBLOCK) < 0) { - *errormessage = (char*) malloc(SIZ + 1); - snprintf(*errormessage, SIZ, - "citserver: Can't set socket to non-blocking: %s", - strerror(errno)); - CtdlLogPrintf(CTDL_EMERG, "%s\n", *errormessage); - close(s); - return(-1); + else { + b = bind(s, (struct sockaddr *) &sin4, sizeof(sin4)); } - if (listen(s, actual_queue_len) < 0) { - *errormessage = (char*) malloc(SIZ + 1); - snprintf(*errormessage, SIZ, - "citserver: Can't listen: %s", - strerror(errno)); - CtdlLogPrintf(CTDL_EMERG, "%s\n", *errormessage); - close(s); - return(-1); + if (b < 0) { + snprintf(errormessage, SIZ, + "Can't bind: %s", strerror(errno) + ); + syslog(LOG_ALERT, "%s", errormessage); + return (-1); } - return(s); + fcntl(s, F_SETFL, O_NONBLOCK); + + if (listen(s, ((queue_len >= 5) ? queue_len : 5) ) < 0) { + snprintf(errormessage, SIZ, + "Can't listen: %s", strerror(errno) + ); + syslog(LOG_ALERT, "%s", errormessage); + return (-1); + } + return (s); } + + /* * Create a Unix domain socket and listen on it */ -int ig_uds_server(char *sockpath, int queue_len, char **errormessage) +int ctdl_uds_server(char *sockpath, int queue_len, char *errormessage) { struct sockaddr_un addr; int s; @@ -385,10 +283,10 @@ int ig_uds_server(char *sockpath, int queue_len, char **errormessage) i = unlink(sockpath); if ((i != 0) && (errno != ENOENT)) { - *errormessage = (char*) malloc(SIZ + 1); - snprintf(*errormessage, SIZ, "citserver: can't unlink %s: %s", - sockpath, strerror(errno)); - CtdlLogPrintf(CTDL_EMERG, "%s\n", *errormessage); + snprintf(errormessage, SIZ, "citserver: can't unlink %s: %s", + sockpath, strerror(errno) + ); + syslog(LOG_EMERG, "%s", errormessage); return(-1); } @@ -398,40 +296,36 @@ int ig_uds_server(char *sockpath, int queue_len, char **errormessage) s = socket(AF_UNIX, SOCK_STREAM, 0); if (s < 0) { - *errormessage = (char*) malloc(SIZ + 1); - snprintf(*errormessage, SIZ, + snprintf(errormessage, SIZ, "citserver: Can't create a socket: %s", strerror(errno)); - CtdlLogPrintf(CTDL_EMERG, "%s\n", *errormessage); + syslog(LOG_EMERG, "%s", errormessage); return(-1); } if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) { - *errormessage = (char*) malloc(SIZ + 1); - snprintf(*errormessage, SIZ, + snprintf(errormessage, SIZ, "citserver: Can't bind: %s", strerror(errno)); - CtdlLogPrintf(CTDL_EMERG, "%s\n", *errormessage); + syslog(LOG_EMERG, "%s", errormessage); return(-1); } /* set to nonblock - we need this for some obscure situations */ if (fcntl(s, F_SETFL, O_NONBLOCK) < 0) { - *errormessage = (char*) malloc(SIZ + 1); - snprintf(*errormessage, SIZ, + snprintf(errormessage, SIZ, "citserver: Can't set socket to non-blocking: %s", strerror(errno)); - CtdlLogPrintf(CTDL_EMERG, "%s\n", *errormessage); + syslog(LOG_EMERG, "%s", errormessage); close(s); return(-1); } if (listen(s, actual_queue_len) < 0) { - *errormessage = (char*) malloc(SIZ + 1); - snprintf(*errormessage, SIZ, + snprintf(errormessage, SIZ, "citserver: Can't listen: %s", strerror(errno)); - CtdlLogPrintf(CTDL_EMERG, "%s\n", *errormessage); + syslog(LOG_EMERG, "%s", errormessage); return(-1); } @@ -445,116 +339,6 @@ 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)); - - /* Give the contaxt a name. Hopefully makes it easier to track */ - strcpy (me->user.fullname, "SYS_notauth"); - - /* 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); -} - - -struct CitContext *CtdlGetContextArray(int *count) -{ - int nContexts, i; - struct CitContext *nptr, *cptr; - - nContexts = num_sessions; - nptr = malloc(sizeof(struct CitContext) * nContexts); - if (!nptr) - return NULL; - begin_critical_section(S_SESSION_TABLE); - for (cptr = ContextList, i=0; cptr != NULL && i < nContexts; cptr = cptr->next, i++) - memcpy(&nptr[i], cptr, sizeof (struct CitContext)); - end_critical_section (S_SESSION_TABLE); - - *count = i; - return nptr; -} - - - -/** - * This function fills in a context and its user field correctly - * Then creates/loads that user - */ -void CtdlFillSystemContext(struct CitContext *context, char *name) -{ - char sysname[USERNAME_SIZE]; - - memset(context, 0, sizeof(struct CitContext)); - context->internal_pgm = 1; - context->cs_pid = 0; - strcpy (sysname, "SYS_"); - strcat (sysname, name); - /* internal_create_user has the side effect of loading the user regardless of wether they - * already existed or needed to be created - */ - internal_create_user (sysname, &(context->user), -1) ; - - /* Check to see if the system user needs upgrading */ - if (context->user.usernum == 0) - { /* old system user with number 0, upgrade it */ - context->user.usernum = get_new_user_number(); - CtdlLogPrintf(CTDL_DEBUG, "Upgrading system user \"%s\" from user number 0 to user number %d\n", context->user.fullname, context->user.usernum); - /* add user to the database */ - putuser(&(context->user)); - cdb_store(CDB_USERSBYNUMBER, &(context->user.usernum), sizeof(long), context->user.fullname, strlen(context->user.fullname)+1); - } -} - /* * The following functions implement output buffering on operating systems which * support it (such as Linux and various BSD flavors). @@ -598,12 +382,39 @@ void flush_output(void) { #endif } +/* +static void flush_client_inbuf(void) +{ + CitContext *CCC=CC; + + FlushStrBuf(CCC->ReadBuf); + CCC->RecvBuf->ReadWritePointer = NULL; + +} +*/ + + +/* + * client_close() ... close the client socket + */ +void client_close(void) { + CitContext *CCC = CC; + + if (!CCC) return; + if (CCC->client_socket <= 0) return; + syslog(LOG_DEBUG, "Closing socket %d", CCC->client_socket); + + close(CCC->client_socket); + CCC->client_socket = -1 ; +} + + /* * client_write() ... Send binary data to the client. */ -int client_write(char *buf, int nbytes) +int client_write(const char *buf, int nbytes) { int bytes_written = 0; int retval; @@ -611,19 +422,36 @@ int 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); + 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); + +#ifdef BIGBAD_IODBG + { + int rv = 0; + char fn [SIZ]; + FILE *fd; + + snprintf(fn, SIZ, "/tmp/foolog_%s.%d", Ctx->ServiceName, Ctx->cs_pid); + + fd = fopen(fn, "a+"); + if (fd) + { + fprintf(fd, "Sending: BufSize: %d BufContent: [", + nbytes); + rv = fwrite(buf, nbytes, 1, fd); + fprintf(fd, "]\n"); + fclose(fd); } - memcpy(&Ctx->redirect_buffer[Ctx->redirect_len], buf, nbytes); - Ctx->redirect_len += nbytes; - Ctx->redirect_buffer[Ctx->redirect_len] = 0; + } +#endif +// flush_client_inbuf(); + if (Ctx->redirect_buffer != NULL) { + StrBufAppendBufPlain(Ctx->redirect_buffer, + buf, nbytes, 0); return 0; } @@ -633,34 +461,51 @@ int client_write(char *buf, int nbytes) 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 -1; + if (errno == EINTR) + { + syslog(LOG_DEBUG, "client_write(%d bytes) select() interrupted.", + nbytes-bytes_written + ); + if (server_shutting_down) { + CC->kill_me = KILLME_SELECT_INTERRUPTED; + return (-1); + } else { + /* can't trust fd's and stuff so we need to re-create them */ + continue; + } + } else { + syslog(LOG_ERR, + "client_write(%d bytes) select failed: %s (%d)", + nbytes - bytes_written, + strerror(errno), errno + ); + cit_backtrace(); + client_close(); + Ctx->kill_me = KILLME_SELECT_FAILED; + return -1; + } } } - retval = write(Ctx->client_socket, &buf[bytes_written], - nbytes - bytes_written); + retval = write(Ctx->client_socket, &buf[bytes_written], nbytes - bytes_written); if (retval < 1) { - CtdlLogPrintf(CTDL_ERR, - "client_write(%d bytes) failed: %s (%d)\n", + syslog(LOG_ERR, + "client_write(%d bytes) failed: %s (%d)", nbytes - bytes_written, - strerror(errno), errno); + strerror(errno), errno + ); cit_backtrace(); - // CtdlLogPrintf(CTDL_DEBUG, "Tried to send: %s", &buf[bytes_written]); - Ctx->kill_me = 1; + client_close(); + Ctx->kill_me = KILLME_WRITE_FAILED; return -1; } bytes_written = bytes_written + retval; @@ -668,6 +513,10 @@ int client_write(char *buf, int nbytes) return 0; } +void cputbuf(const StrBuf *Buf) { + client_write(ChrPtr(Buf), StrLength(Buf)); +} + /* * cprintf() Send formatted printable data to the client. @@ -687,60 +536,200 @@ 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) { +#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, "Reading BLOB: BufSize: %d ", + bytes); + rv = fwrite(ChrPtr(Target), StrLength(Target), 1, fd); + fprintf(fd, "]\n"); + + + fclose(fd); +#endif + retval = client_read_sslblob(Target, bytes, timeout); + if (retval < 0) { + syslog(LOG_CRIT, "client_read_blob() failed"); + } +#ifdef BIGBAD_IODBG + snprintf(fn, SIZ, "/tmp/foolog_%s.%d", CCC->ServiceName, CCC->cs_pid); + + fd = fopen(fn, "a+"); + fprintf(fd, "Read: %d BufContent: [", + StrLength(Target)); + rv = fwrite(ChrPtr(Target), StrLength(Target), 1, fd); + fprintf(fd, "]\n"); + + + fclose(fd); +#endif } + else #endif - len = 0; - fd = CC->client_socket; - while(lenServiceName, CCC->cs_pid); + + fd = fopen(fn, "a+"); + fprintf(fd, "Reading BLOB: BufSize: %d ", + bytes); + rv = fwrite(ChrPtr(Target), StrLength(Target), 1, fd); + fprintf(fd, "]\n"); + + + fclose(fd); +#endif + retval = StrBufReadBLOBBuffered(Target, + CCC->RecvBuf.Buf, + &CCC->RecvBuf.ReadWritePointer, + &CCC->client_socket, + 1, + bytes, + O_TERM, + &Error); + if (retval < 0) { + syslog(LOG_CRIT, "client_read_blob() failed: %s", Error); + client_close(); + return retval; + } +#ifdef BIGBAD_IODBG + snprintf(fn, SIZ, "/tmp/foolog_%s.%d", CCC->ServiceName, CCC->cs_pid); + + fd = fopen(fn, "a+"); + fprintf(fd, "Read: %d BufContent: [", + StrLength(Target)); + rv = fwrite(ChrPtr(Target), StrLength(Target), 1, fd); + fprintf(fd, "]\n"); + fclose(fd); +#endif + } + return retval; +} + + +/* + * to make client_read_random_blob() more efficient, increase buffer size. + * just use in greeting function, else your buffer may be flushed + */ +void client_set_inbound_buf(long N) +{ + CitContext *CCC=CC; + FlushStrBuf(CCC->RecvBuf.Buf); + ReAdjustEmptyBuf(CCC->RecvBuf.Buf, N * SIZ, N * SIZ); +} - retval = select( (fd)+1, - &rfds, NULL, NULL, &tv); - if (retval < 0) +int client_read_random_blob(StrBuf *Target, int timeout) +{ + CitContext *CCC=CC; + int rc; + + rc = client_read_blob(Target, 1, timeout); + if (rc > 0) + { + long len; + const char *pch; + + len = StrLength(CCC->RecvBuf.Buf); + pch = ChrPtr(CCC->RecvBuf.Buf); + + if (len > 0) { - if (errno == EINTR) + if (CCC->RecvBuf.ReadWritePointer != NULL) { + len -= CCC->RecvBuf.ReadWritePointer - pch; + pch = CCC->RecvBuf.ReadWritePointer; + } + StrBufAppendBufPlain(Target, pch, len, 0); + FlushStrBuf(CCC->RecvBuf.Buf); + CCC->RecvBuf.ReadWritePointer = NULL; +#ifdef BIGBAD_IODBG { - CtdlLogPrintf(CTDL_DEBUG, "Interrupted select().\n"); - CC->kill_me = 1; - return (-1); + 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 + + return StrLength(Target); } + return rc; + } + else + return rc; +} - if (FD_ISSET(fd, &rfds) == 0) { - return(0); - } +int client_read_to(char *buf, int bytes, int timeout) +{ + CitContext *CCC=CC; + int rc; - rlen = read(fd, &buf[len], bytes-len); - if (rlen<1) { - /* The socket has been disconnected! */ - CC->kill_me = 1; - return(-1); - } - len = len + rlen; + 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; } - return(1); } + +int HaveMoreLinesWaiting(CitContext *CCC) +{ + if ((CCC->kill_me != 0) || + ( (CCC->RecvBuf.ReadWritePointer == NULL) && + (StrLength(CCC->RecvBuf.Buf) == 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 @@ -751,6 +740,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 = 0; + int rlen = 0; + int nlen = 0; + int nrlen = 0; + const char *pch; + + snprintf(fn, SIZ, "/tmp/foolog_%s.%d", CCC->ServiceName, CCC->cs_pid); + + fd = fopen(fn, "a+"); + pch = ChrPtr(CCC->RecvBuf.Buf); + len = StrLength(CCC->RecvBuf.Buf); + if (CCC->RecvBuf.ReadWritePointer != NULL) + rlen = CCC->RecvBuf.ReadWritePointer - pch; + else + rlen = 0; + +/* fprintf(fd, "\n\n\nBufSize: %d BufPos: %d \nBufContent: [%s]\n\n_____________________\n", + len, rlen, pch); +*/ + fprintf(fd, "\n\n\nSSL1: BufSize: %d BufPos: %d \n_____________________\n", + len, rlen); +#endif + rc = client_readline_sslbuffer(Target, + CCC->RecvBuf.Buf, + &CCC->RecvBuf.ReadWritePointer, + 1); +#ifdef BIGBAD_IODBG + pch = ChrPtr(CCC->RecvBuf.Buf); + nlen = StrLength(CCC->RecvBuf.Buf); + if (CCC->RecvBuf.ReadWritePointer != NULL) + nrlen = CCC->RecvBuf.ReadWritePointer - 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\nSSL2: BufSize: was: %d is: %d BufPos: was: %d is: %d \n", + len, nlen, rlen, nrlen); + + fprintf(fd, "SSL3: Read: BufSize: %d BufContent: [%s]\n\n*************\n", + StrLength(Target), ChrPtr(Target)); + fclose(fd); + + if (rc < 0) { + syslog(LOG_CRIT, "CtdlClientGetLine() failed"); + } +#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->RecvBuf.Buf); + len = StrLength(CCC->RecvBuf.Buf); + if (CCC->RecvBuf.ReadWritePointer != NULL) + rlen = CCC->RecvBuf.ReadWritePointer - 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->RecvBuf.Buf, + &CCC->RecvBuf.ReadWritePointer, + &CCC->client_socket, + 5, + 1, + &Error); + +#ifdef BIGBAD_IODBG + pch = ChrPtr(CCC->RecvBuf.Buf); + nlen = StrLength(CCC->RecvBuf.Buf); + if (CCC->RecvBuf.ReadWritePointer != NULL) + nrlen = CCC->RecvBuf.ReadWritePointer - 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)) { + syslog(LOG_CRIT, "CtdlClientGetLine() failed: %s", Error); + } +#endif + return rc; + } +} + /* * client_getln() ... Get a LF-terminated line of text from the client. @@ -760,74 +870,46 @@ 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; - - CtdlLogPrintf(CTDL_DEBUG, "Purging session %d\n", ptr->cs_pid); - RemoveContext(ptr); - free (ptr); - ptr = rem; - } -} - void close_masters (void) { struct ServiceFunctionHook *serviceptr; - + const char *Text; + /* * close all protocol master sockets */ @@ -836,16 +918,37 @@ void close_masters (void) if (serviceptr->tcp_port > 0) { - CtdlLogPrintf(CTDL_INFO, "Closing listener on port %d\n", - serviceptr->tcp_port); + if (serviceptr->msock == -1) + Text = "not closing again"; + else + Text = "Closing"; + + syslog(LOG_INFO, "%s %d listener on port %d\n", + Text, + serviceptr->msock, + serviceptr->tcp_port); serviceptr->tcp_port = 0; } if (serviceptr->sockpath != NULL) - CtdlLogPrintf(CTDL_INFO, "Closing listener on '%s'\n", - serviceptr->sockpath); + { + if (serviceptr->msock == -1) + Text = "not closing again"; + else + Text = "Closing"; + + syslog(LOG_INFO, "%s %d listener on '%s'\n", + Text, + serviceptr->msock, + serviceptr->sockpath); + } + + if (serviceptr->msock != -1) + { + close(serviceptr->msock); + serviceptr->msock = -1; + } - close(serviceptr->msock); /* If it's a Unix domain socket, remove the file. */ if (serviceptr->sockpath != NULL) { unlink(serviceptr->sockpath); @@ -876,32 +979,18 @@ void sysdep_master_cleanup(void) { CtdlDestroyCleanupHooks(); CtdlDestroyFixedOutputHooks(); CtdlDestroySessionHooks(); + CtdlDestroyTDAPVetoHooks(); CtdlDestroyServiceHook(); CtdlDestroyRoomHooks(); + CtdlDestroySearchHooks(); + CtdlDestroyDebugTable(); #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); @@ -928,7 +1017,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) + syslog(LOG_EMERG, + "unable to change into directory [%s]: %s", + ctdl_run_dir, strerror(errno)); child = fork(); if (child != 0) { @@ -941,9 +1033,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)) + syslog(LOG_EMERG, + "unable to reopen stdin/out/err %s", + strerror(errno)); + do { current_child = fork(); @@ -967,7 +1063,7 @@ void start_daemon(int unused) { } waitpid(current_child, &status, 0); } - do_restart = 0; + nFireUpsNonRestart = nFireUps; /* Exit code 0 means the watcher should exit */ @@ -1002,16 +1098,18 @@ void checkcrash(void) StrBuf *CrashMail; CrashMail = NewStrBuf(); - CtdlLogPrintf(CTDL_ALERT, "Posting crash message\n"); + syslog(LOG_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. You can obtain more information about this by enabling core dumps. " - "For more information, please see: " - "http://citadel.org/doku.php/faq:mastering_your_os:gdb#how.do.i.make.my.system.produce.core-files" + "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?id=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); @@ -1042,135 +1140,110 @@ 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); +void HuntBadSession(void) +{ + int highest; + CitContext *ptr; + fd_set readfds; + struct timeval tv; + struct ServiceFunctionHook *serviceptr; - /* 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); - } -} + /* Next, add all of the client sockets. */ + begin_critical_section(S_SESSION_TABLE); + for (ptr = ContextList; ptr != NULL; ptr = ptr->next) { + if ((ptr->state == CON_SYS) && (ptr->client_socket == 0)) + continue; + /* Initialize the fdset. */ + FD_ZERO(&readfds); + highest = 0; + tv.tv_sec = 0; /* wake up every second if no input */ + tv.tv_usec = 0; + /* Don't select on dead sessions, only truly idle ones */ + if ( (ptr->state == CON_IDLE) + && (ptr->kill_me == 0) + && (ptr->client_socket > 0) + ) { + FD_SET(ptr->client_socket, &readfds); + if (ptr->client_socket > highest) + highest = ptr->client_socket; + + if ((select(highest + 1, &readfds, NULL, NULL, &tv) < 0) && + (errno == EBADF)) + { + /* Gotcha! */ + syslog(LOG_EMERG, + "Killing Session CC[%d] bad FD: [%d:%d] User[%s] Host[%s:%s]\n", + ptr->cs_pid, + ptr->client_socket, + ptr->is_local_socket, + ptr->curr_user, + ptr->cs_host,ptr->cs_addr); + + ptr->kill_me = 1; + ptr->client_socket = -1; + break; + } + } + + } + end_critical_section(S_SESSION_TABLE); -/* - * 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; -} + /* First, add the various master sockets to the fdset. */ + for (serviceptr = ServiceHookTable; serviceptr != NULL; serviceptr = serviceptr->next ) { + + /* Initialize the fdset. */ + highest = 0; + tv.tv_sec = 0; /* wake up every second if no input */ + tv.tv_usec = 0; + FD_SET(serviceptr->msock, &readfds); + if (serviceptr->msock > highest) { + highest = serviceptr->msock; + } + if ((select(highest + 1, &readfds, NULL, NULL, &tv) < 0) && + (errno == EBADF)) + { + /* Gotcha! server socket dead? commit suicide! */ + syslog(LOG_EMERG, + "Found bad FD: %d and its a server socket! Shutting Down!\n", + serviceptr->msock); + server_shutting_down = 1; + break; + } + } -/* - * 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 ); } - /* * This loop just keeps going and going and going... */ -/* - * FIXME: - * This current implimentation of worker_thread creates a bottle neck in several situations - * The first thing to remember is that a single thread can handle more than one connection at a time. - * More threads mean less memory for the system to run in. - * So for efficiency we want every thread to be doing something useful or waiting in the main loop for - * something to happen anywhere. - * This current implimentation requires worker threads to wait in other locations, after it has - * been committed to a single connection which is very wasteful. - * As an extreme case consider this: - * A slow client connects and this slow client sends only one character each second. - * With this current implimentation a single worker thread is dispatched to handle that connection - * until such times as the client timeout expires, an error occurs on the socket or the client - * completes its transmission. - * THIS IS VERY BAD since that thread could have handled a read from many more clients in each one - * second interval between chars. - * - * It is my intention to re-write this code and the associated client_getln, client_read functions - * to allow any thread to read data on behalf of any connection (context). - * To do this I intend to have this main loop read chars into a buffer stored in the context. - * Once the correct criteria for a full buffer is met then we will dispatch a thread to - * process it. - * This worker thread loop also needs to be able to handle binary data. - */ - -void *worker_thread(void *arg) { - int i; +void *worker_thread(void *blah) { 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; - + struct ServiceFunctionHook *serviceptr; + int ssock; /* Descriptor for client socket */ + CitContext *con = NULL; /* Temporary context pointer */ + int i; + + pthread_mutex_lock(&ThreadCountMutex); + ++num_workers; + pthread_mutex_unlock(&ThreadCountMutex); - while (!CtdlThreadCheckStop()) { + while (!server_shutting_down) { /* make doubly sure we're not holding any stale db handles * which might cause a deadlock. @@ -1183,9 +1256,25 @@ do_select: force_purge = 0; FD_ZERO(&readfds); highest = 0; + /* First, add the various master sockets to the fdset. */ + for (serviceptr = ServiceHookTable; serviceptr != NULL; serviceptr = serviceptr->next ) { + FD_SET(serviceptr->msock, &readfds); + if (serviceptr->msock > highest) { + highest = serviceptr->msock; + } + } + + /* Next, add all of the client sockets. */ begin_critical_section(S_SESSION_TABLE); for (ptr = ContextList; ptr != NULL; ptr = ptr->next) { - if (ptr->state == CON_IDLE) { + if ((ptr->state == CON_SYS) && (ptr->client_socket == 0)) + continue; + + /* Don't select on dead sessions, only truly idle ones */ + if ( (ptr->state == CON_IDLE) + && (ptr->kill_me == 0) + && (ptr->client_socket > 0) + ) { FD_SET(ptr->client_socket, &readfds); if (ptr->client_socket > highest) highest = ptr->client_socket; @@ -1193,6 +1282,12 @@ do_select: force_purge = 0; 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); @@ -1206,65 +1301,62 @@ do_select: force_purge = 0; * ahead and get ready to select(). */ - /* First, add the various master sockets to the fdset. */ - for (serviceptr = ServiceHookTable; serviceptr != NULL; - serviceptr = serviceptr->next ) { - m = serviceptr->msock; - FD_SET(m, &readfds); - if (m > highest) { - highest = m; - } - } - - if (!CtdlThreadCheckStop()) { + if (!server_shutting_down) { tv.tv_sec = 1; /* wake up every second if no input */ tv.tv_usec = 0; - retval = CtdlThreadSelect(highest + 1, &readfds, NULL, NULL, &tv); + retval = select(highest + 1, &readfds, NULL, NULL, &tv); } - else + else { + --num_workers; 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)); + syslog(LOG_EMERG, "select() failed: (%s)\n", strerror(errno)); + HuntBadSession (); goto do_select; } if (errno != EINTR) { - CtdlLogPrintf(CTDL_EMERG, "Exiting (%s)\n", strerror(errno)); - CtdlThreadStopAll(); + syslog(LOG_EMERG, "Exiting (%s)\n", strerror(errno)); + server_shutting_down = 1; + continue; } else { - CtdlLogPrintf(CTDL_DEBUG, "Interrupted CtdlThreadSelect.\n"); - if (CtdlThreadCheckStop()) return(NULL); +#if 0 + syslog(LOG_DEBUG, "Interrupted select()\n"); +#endif + if (server_shutting_down) { + --num_workers; + return(NULL); + } goto do_select; } } - else if(retval == 0) { - if (CtdlThreadCheckStop()) return(NULL); - goto SKIP_SELECT; + else if (retval == 0) { + if (server_shutting_down) { + --num_workers; + return(NULL); + } } - /* Next, check to see if it's a new client connecting - * on a master socket. - */ - else for (serviceptr = ServiceHookTable; serviceptr != NULL; - serviceptr = serviceptr->next ) { + + /* Next, check to see if it's a new client connecting * on a master socket. */ + + else if ((retval > 0) && (!server_shutting_down)) for (serviceptr = ServiceHookTable; serviceptr != NULL; serviceptr = serviceptr->next) { if (FD_ISSET(serviceptr->msock, &readfds)) { ssock = accept(serviceptr->msock, NULL, 0); if (ssock >= 0) { - CtdlLogPrintf(CTDL_DEBUG, - "New client socket %d\n", - ssock); + syslog(LOG_DEBUG, "New client socket %d", ssock); /* The master socket is non-blocking but the client * sockets need to be blocking, otherwise certain * operations barf on FreeBSD. Not a fatal error. */ if (fcntl(ssock, F_SETFL, 0) < 0) { - CtdlLogPrintf(CTDL_EMERG, + syslog(LOG_EMERG, "citserver: Can't set socket to blocking: %s\n", strerror(errno)); } @@ -1275,30 +1367,25 @@ do_select: force_purge = 0; con = CreateNewContext(); /* Assign our new socket number to it. */ + con->tcp_port = serviceptr->tcp_port; con->client_socket = ssock; - con->h_command_function = - serviceptr->h_command_function; - con->h_async_function = - serviceptr->h_async_function; - con->ServiceName = - serviceptr->ServiceName; + con->h_command_function = serviceptr->h_command_function; + con->h_async_function = serviceptr->h_async_function; + con->h_greeting_function = serviceptr->h_greeting_function; + con->ServiceName = serviceptr->ServiceName; /* Determine whether it's a local socket */ - if (serviceptr->sockpath != NULL) + if (serviceptr->sockpath != NULL) { con->is_local_socket = 1; + } /* Set the SO_REUSEADDR socket option */ i = 1; - setsockopt(ssock, SOL_SOCKET, - 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; + setsockopt(ssock, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i)); + con->state = CON_GREETING; + retval--; + if (retval == 0) + break; } } } @@ -1311,15 +1398,25 @@ do_select: force_purge = 0; */ 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; + 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; + } } } } @@ -1327,12 +1424,25 @@ do_select: force_purge = 0; SKIP_SELECT: /* We're bound to a session */ + pthread_mutex_lock(&ThreadCountMutex); + ++active_workers; + pthread_mutex_unlock(&ThreadCountMutex); + 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; } @@ -1351,14 +1461,28 @@ SKIP_SELECT: dead_session_purge(force_purge); do_housekeeping(); + + pthread_mutex_lock(&ThreadCountMutex); + --active_workers; + if ((active_workers + config.c_min_workers < num_workers) && + (num_workers > config.c_min_workers)) + { + num_workers--; + pthread_mutex_unlock(&ThreadCountMutex); + return (NULL); + } + pthread_mutex_unlock(&ThreadCountMutex); } - /* If control reaches this point, the server is shutting down */ + + /* If control reaches this point, the server is shutting down */ + pthread_mutex_lock(&ThreadCountMutex); + --num_workers; + pthread_mutex_unlock(&ThreadCountMutex); return(NULL); } - /* * SyslogFacility() * Translate text facility name to syslog.h defined value. @@ -1395,115 +1519,5 @@ int SyslogFacility(char *name) if(!strcasecmp(name, facTbl[i].name)) return facTbl[i].facility; } - enable_syslog = 0; return LOG_DAEMON; } - - -/********** MEM CHEQQER ***********/ - -#ifdef DEBUG_MEMORY_LEAKS - -#undef malloc -#undef realloc -#undef strdup -#undef free - -void *tracked_malloc(size_t size, char *file, int line) { - struct igheap *thisheap; - void *block; - - block = malloc(size); - if (block == NULL) return(block); - - thisheap = malloc(sizeof(struct igheap)); - if (thisheap == NULL) { - free(block); - return(NULL); - } - - thisheap->block = block; - strcpy(thisheap->file, file); - thisheap->line = line; - - begin_critical_section(S_DEBUGMEMLEAKS); - thisheap->next = igheap; - igheap = thisheap; - end_critical_section(S_DEBUGMEMLEAKS); - - return(block); -} - - -void *tracked_realloc(void *ptr, size_t size, char *file, int line) { - struct igheap *thisheap; - void *block; - - block = realloc(ptr, size); - if (block == NULL) return(block); - - thisheap = malloc(sizeof(struct igheap)); - if (thisheap == NULL) { - free(block); - return(NULL); - } - - thisheap->block = block; - strcpy(thisheap->file, file); - thisheap->line = line; - - begin_critical_section(S_DEBUGMEMLEAKS); - thisheap->next = igheap; - igheap = thisheap; - end_critical_section(S_DEBUGMEMLEAKS); - - return(block); -} - - - -void tracked_free(void *ptr) { - struct igheap *thisheap; - struct igheap *trash; - - free(ptr); - - if (igheap == NULL) return; - begin_critical_section(S_DEBUGMEMLEAKS); - for (thisheap = igheap; thisheap != NULL; thisheap = thisheap->next) { - if (thisheap->next != NULL) { - if (thisheap->next->block == ptr) { - trash = thisheap->next; - thisheap->next = thisheap->next->next; - free(trash); - } - } - } - if (igheap->block == ptr) { - trash = igheap; - igheap = igheap->next; - free(trash); - } - end_critical_section(S_DEBUGMEMLEAKS); -} - -char *tracked_strdup(const char *s, char *file, int line) { - char *ptr; - - if (s == NULL) return(NULL); - ptr = tracked_malloc(strlen(s) + 1, file, line); - if (ptr == NULL) return(NULL); - strncpy(ptr, s, strlen(s)); - return(ptr); -} - -void dump_heap(void) { - struct igheap *thisheap; - - for (thisheap = igheap; thisheap != NULL; thisheap = thisheap->next) { - CtdlLogPrintf(CTDL_CRIT, "UNFREED: %30s : %d\n", - thisheap->file, thisheap->line); - } -} - -#endif /* DEBUG_MEMORY_LEAKS */