X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fsysdep.c;h=09b66f286cecabb0f6c2ff4345340a1d303f19b4;hb=56d69e5d8434e98835a2582c59b771ba69475431;hp=13c5c908928ba9b9948154f1c86e3de2be41a829;hpb=12a091b625c28d94e895901c900f4fdbd0776f7f;p=citadel.git diff --git a/citadel/sysdep.c b/citadel/sysdep.c index 13c5c9089..09b66f286 100644 --- a/citadel/sysdep.c +++ b/citadel/sysdep.c @@ -1,6 +1,4 @@ /* - * $Id$ - * * Citadel "system dependent" stuff. * See COPYING for copyright information. * @@ -49,6 +47,7 @@ #include #include #include +#define SHOW_ME_VAPPEND_PRINTF #include #include "citadel.h" #include "server.h" @@ -92,7 +91,7 @@ int verbosity = DEFAULT_VERBOSITY; /* Logging level */ int syslog_facility = LOG_DAEMON; int enable_syslog = 0; - +int print_to_logfile = 1; /* * CtdlLogPrintf() ... Write logging information @@ -106,43 +105,59 @@ void CtdlLogPrintf(enum LogLevel loglevel, const char *format, ...) { 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 (enable_syslog || !print_to_logfile) 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; - CitContext *CCC = CC; + CitContext *CCC = MyContext(); + ThreadTSD *cTSD = CTP; + CtdlThreadNode *node = NULL; + long lwpid = 0; + + if (cTSD != NULL) { + node = cTSD->self; + } + + if ((node != NULL) && (node->reltid != 0)) { + lwpid = node->reltid; + } 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); + + fprintf(stderr, + "%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 + ); + + if (lwpid != 0) { + fprintf(stderr, "[LWP:%ld] ", lwpid); + } + + if (CCC != NULL) { + if (CCC->cs_pid != 0) { + fprintf(stderr, "[%3d] ", CCC->cs_pid); + } + else if (CCC->user.usernum != 0) { + fprintf(stderr, "[:%ld] ", CCC->user.usernum); + } } - vsnprintf(buf2, SIZ, format, arg_ptr); - fprintf(stderr, "%s%s", buf, buf2); + vfprintf(stderr, format, arg_ptr); fflush(stderr); } } @@ -169,6 +184,10 @@ static RETSIGTYPE signal_cleanup(int signum) { } } +static RETSIGTYPE signal_exit(int signum) { + exit(1); +} + /* @@ -209,21 +228,22 @@ void init_sysdep(void) { * call signal_cleanup() to gracefully shut down the server. */ sigemptyset(&set); - sigaddset(&set, SIGINT); - sigaddset(&set, SIGQUIT); + sigaddset(&set, SIGINT); // intr = shutdown + // sigaddset(&set, SIGQUIT); // quit = force quit sigaddset(&set, SIGHUP); sigaddset(&set, SIGTERM); - // sigaddset(&set, SIGSEGV); commented out because - // sigaddset(&set, SIGILL); we want core dumps + // sigaddset(&set, SIGSEGV); // we want core dumps + // sigaddset(&set, SIGILL); // we want core dumps // sigaddset(&set, SIGBUS); sigprocmask(SIG_UNBLOCK, &set, NULL); - signal(SIGINT, signal_cleanup); - signal(SIGQUIT, signal_cleanup); + signal(SIGINT, signal_cleanup); // intr = shutdown + // signal(SIGQUIT, signal_cleanup); // quit = force quit signal(SIGHUP, signal_cleanup); signal(SIGTERM, signal_cleanup); - // signal(SIGSEGV, signal_cleanup); commented out because - // signal(SIGILL, signal_cleanup); we want core dumps + signal(SIGUSR2, signal_exit); + // signal(SIGSEGV, signal_cleanup); // we want coredumps + // signal(SIGILL, signal_cleanup); // we want core dumps // signal(SIGBUS, signal_cleanup); /* @@ -235,90 +255,121 @@ 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) + ); + CtdlLogPrintf(CTDL_ALERT, "%s\n", 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) + ); + CtdlLogPrintf(CTDL_ALERT, "%s\n", errormessage); + return (-1); + } + } + + if (port_number == 0) { + snprintf(errormessage, SIZ, + "Can't start: no port number specified." + ); + CtdlLogPrintf(CTDL_ALERT, "%s\n", 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) + ); + CtdlLogPrintf(CTDL_ALERT, "%s\n", 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) + ); + CtdlLogPrintf(CTDL_ALERT, "%s\n", 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) + ); + CtdlLogPrintf(CTDL_ALERT, "%s\n", 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; @@ -333,10 +384,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) + ); + CtdlLogPrintf(CTDL_EMERG, "%s\n", errormessage); return(-1); } @@ -346,40 +397,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); + CtdlLogPrintf(CTDL_EMERG, "%s\n", 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); + CtdlLogPrintf(CTDL_EMERG, "%s\n", 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); + CtdlLogPrintf(CTDL_EMERG, "%s\n", 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); + CtdlLogPrintf(CTDL_EMERG, "%s\n", errormessage); return(-1); } @@ -436,12 +483,21 @@ void flush_output(void) { #endif } +/* +static void flush_client_inbuf(void) +{ + CitContext *CCC=CC; + FlushStrBuf(CCC->ReadBuf); + CCC->Pos = NULL; + +} +*/ /* * 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; @@ -452,16 +508,32 @@ int client_write(char *buf, int nbytes) CitContext *Ctx; int fdflags; + if (nbytes < 1) return(0); + Ctx = CC; + +#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+"); + fprintf(fd, "Sending: BufSize: %d BufContent: [", + nbytes); + rv = fwrite(buf, nbytes, 1, fd); + fprintf(fd, "]\n"); + + + fclose(fd); + } +#endif +// flush_client_inbuf(); 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; + StrBufAppendBufPlain(Ctx->redirect_buffer, + buf, nbytes, 0); return 0; } @@ -471,10 +543,11 @@ 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); @@ -518,6 +591,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. @@ -537,70 +614,205 @@ 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) { + CtdlLogPrintf(CTDL_CRIT, + "%s failed\n", + __FUNCTION__); + } +#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 + { +#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 - len = 0; - fd = CC->client_socket; - while(lenReadBuf, + &CCC->Pos, + &CCC->client_socket, + 1, + bytes, + O_TERM, + &Error); + if (retval < 0) { + CtdlLogPrintf(CTDL_CRIT, + "%s failed: %s\n", + __FUNCTION__, + Error); + 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) +{ + FlushStrBuf(CC->ReadBuf); + ReAdjustEmptyBuf(CC->ReadBuf, N * SIZ, N * SIZ); +} + +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->ReadBuf); + pch = ChrPtr(CCC->ReadBuf); + + if (len > 0) { - if (errno == EINTR) - { - CtdlLogPrintf(CTDL_DEBUG, "Interrupted select() in client_read_to().\n"); - if (CtdlThreadCheckStop()) { - CC->kill_me = 1; - return (-1); - } else { - /* can't trust fd's and stuff so we need to re-create them */ - continue; - } + if (CCC->Pos != NULL) { + len -= CCC->Pos - pch; + pch = CCC->Pos; } - else { - CtdlLogPrintf(CTDL_DEBUG, "Failed select() in client_read_to().\n"); - CC->kill_me = 1; - return (-1); + StrBufAppendBufPlain(Target, pch, len, 0); + FlushStrBuf(CCC->ReadBuf); + CCC->Pos = NULL; +#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 + + 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; } - return(1); + 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 @@ -611,6 +823,130 @@ 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->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\nSSL1: BufSize: %d BufPos: %d \n_____________________\n", + len, rlen); +#endif + rc = client_readline_sslbuffer(Target, + CCC->ReadBuf, + &CCC->Pos, + 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\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) + CtdlLogPrintf(CTDL_CRIT, + "%s failed\n", + __FUNCTION__); +#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. @@ -620,32 +956,33 @@ 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); } @@ -709,7 +1046,7 @@ void sysdep_master_cleanup(void) { CtdlDestroyServiceHook(); CtdlDestroyRoomHooks(); #ifdef HAVE_BACKTRACE - eCrash_Uninit(); +/// eCrash_Uninit(); #endif } @@ -741,7 +1078,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) { @@ -754,9 +1094,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(); @@ -826,6 +1170,7 @@ void checkcrash(void) " 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); @@ -911,19 +1256,25 @@ do_select: force_purge = 0; begin_critical_section(S_SESSION_TABLE); for (ptr = ContextList; ptr != NULL; ptr = ptr->next) { + int client_socket; + client_socket = ptr->client_socket; /* Dont select on dead sessions only truly idle ones */ - if ((ptr->state == CON_IDLE)) { - FD_SET(ptr->client_socket, &readfds); - if (ptr->client_socket > highest) - highest = ptr->client_socket; + 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_STARTING)) { + if ((bind_me == NULL) && (ptr->state == CON_GREETING)) { bind_me = ptr; + ptr->state = CON_STARTING; break; } } @@ -977,15 +1328,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; + } } } } @@ -1004,6 +1365,10 @@ SKIP_SELECT: /* 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; } @@ -1046,6 +1411,10 @@ void *select_on_master (void *arg) int m; int i; int retval; + struct CitContext select_on_master_CC; + + CtdlFillSystemContext(&select_on_master_CC, "select_on_master"); + citthread_setspecific(MyConKey, (void *)&select_on_master_CC); while (!CtdlThreadCheckStop()) { /* Initialize the fdset. */ @@ -1140,7 +1509,7 @@ void *select_on_master (void *arg) SO_REUSEADDR, &i, sizeof(i)); - con->state = CON_STARTING; + con->state = CON_GREETING; retval--; if (retval == 0) @@ -1149,6 +1518,8 @@ void *select_on_master (void *arg) } } } + CtdlClearSystemContext(); + return NULL; }