X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=webcit%2Fwebserver.c;h=9d7829c3d6ca05fb62cdd720f51d89d4340c8a89;hb=44c30618e25ce2eb103b87e84e10dcd51dad0879;hp=7924feaeb0809ba36986277cfaee8086a2837ba5;hpb=5ae04697cc31604cb3e6a4d96c26c78c3824bb1b;p=citadel.git diff --git a/webcit/webserver.c b/webcit/webserver.c index 7924feaeb..9d7829c3d 100644 --- a/webcit/webserver.c +++ b/webcit/webserver.c @@ -1,74 +1,61 @@ /* - * webserver.c - * - * This contains a simple multithreaded TCP server manager. It sits around + * $Id$ + */ +/** + * \defgroup Webserver This contains a simple multithreaded TCP server manager. It sits around * waiting on the specified port for incoming HTTP connections. When a * connection is established, it calls context_loop() from context_loop.c. * - * $Id$ */ -#include -#include -#ifdef HAVE_UNISTD_H -#include -#endif -#include -#ifdef HAVE_FCNTL_H -#include -#endif -#include -#include -#include -#include -#ifdef HAVE_SYS_TIME_H -#include -#endif -#ifdef HAVE_LIMITS_H -#include -#endif -#include -#include -#include -#include -#include -#include -#include -#include - -#include "webcit.h" +/*@{*/ #include "webserver.h" #ifndef HAVE_SNPRINTF int vsnprintf(char *buf, size_t max, const char *fmt, va_list argp); #endif -int verbosity = 9; /* Logging level */ -int msock; /* master listening socket */ +int verbosity = 9; /**< Logging level */ +int msock; /**< master listening socket */ +int is_https = 0; /**< Nonzero if I am an HTTPS service */ +int follow_xff = 0; /**< Follow X-Forwarded-For: header */ extern void *context_loop(int); extern void *housekeeping_loop(void); extern pthread_mutex_t SessionListMutex; extern pthread_key_t MyConKey; -char *server_cookie = NULL; +char *server_cookie = NULL; /**< our Cookie connection to the client */ -char *ctdlhost = DEFAULT_HOST; -char *ctdlport = DEFAULT_PORT; +char *ctdlhost = DEFAULT_HOST; /**< our name */ +char *ctdlport = DEFAULT_PORT; /**< our Port */ +int setup_wizard = 0; /**< should we run the setup wizard? \todo */ +char wizard_filename[PATH_MAX];/**< where's the setup wizard? */ -/* - * This is a generic function to set up a master socket for listening on +/** + * \brief 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. + * \param ip_addr ip to bind to + * \param port_number the port to bind to + * \param queue_len the size of the input queue ???? */ -int ig_tcp_server(int port_number, int queue_len) +int ig_tcp_server(char *ip_addr, int port_number, int queue_len) { struct sockaddr_in sin; int s, i; memset(&sin, 0, sizeof(sin)); sin.sin_family = AF_INET; - sin.sin_addr.s_addr = INADDR_ANY; + if (ip_addr == NULL) { + sin.sin_addr.s_addr = INADDR_ANY; + } else { + sin.sin_addr.s_addr = inet_addr(ip_addr); + } + + if (sin.sin_addr.s_addr == INADDR_NONE) { + sin.sin_addr.s_addr = INADDR_ANY; + } if (port_number == 0) { lprintf(1, "Cannot start: no port number specified.\n"); @@ -78,11 +65,10 @@ int ig_tcp_server(int port_number, int queue_len) s = socket(PF_INET, SOCK_STREAM, (getprotobyname("tcp")->p_proto)); if (s < 0) { - lprintf(1, "Can't create a socket: %s\n", - strerror(errno)); + lprintf(1, "Can't create a socket: %s\n", strerror(errno)); exit(errno); } - /* Set some socket options that make sense. */ + /** Set some socket options that make sense. */ i = 1; setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i)); @@ -98,12 +84,69 @@ int ig_tcp_server(int port_number, int queue_len) } -/* - * Read data from the client socket. - * Return values are: - * 1 Requested number of bytes has been read. - * 0 Request timed out. - * -1 Connection is broken, or other error. + +/** + * \brief Create a Unix domain socket and listen on it + * \param sockpath file name of the unix domain socket + * \param queue_len queue size of the kernel fifo???? + */ +int ig_uds_server(char *sockpath, int queue_len) +{ + struct sockaddr_un addr; + int s; + int i; + int actual_queue_len; + + actual_queue_len = queue_len; + if (actual_queue_len < 5) actual_queue_len = 5; + + i = unlink(sockpath); + if (i != 0) if (errno != ENOENT) { + lprintf(1, "citserver: can't unlink %s: %s\n", + sockpath, strerror(errno)); + exit(errno); + } + + memset(&addr, 0, sizeof(addr)); + addr.sun_family = AF_UNIX; + safestrncpy(addr.sun_path, sockpath, sizeof addr.sun_path); + + s = socket(AF_UNIX, SOCK_STREAM, 0); + if (s < 0) { + lprintf(1, "citserver: Can't create a socket: %s\n", + strerror(errno)); + exit(errno); + } + + if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) { + lprintf(1, "citserver: Can't bind: %s\n", + strerror(errno)); + exit(errno); + } + + if (listen(s, actual_queue_len) < 0) { + lprintf(1, "citserver: Can't listen: %s\n", + strerror(errno)); + exit(errno); + } + + chmod(sockpath, 0777); + return(s); +} + + + + +/** + * \brief Read data from the client socket. + * \param sock socket fd to read from ??? + * \param buf buffer to read into + * \param bytes how large is the read buffer? + * \param timeout how long should we wait for input? + * \return values are\ + * 1 Requested number of bytes has been read.\ + * 0 Request timed out.\ + * -1 Connection is broken, or other error. */ int client_read_to(int sock, char *buf, int bytes, int timeout) { @@ -112,6 +155,13 @@ int client_read_to(int sock, char *buf, int bytes, int timeout) struct timeval tv; int retval; + +#ifdef HAVE_OPENSSL + if (is_https) { + return (client_read_ssl(buf, bytes, timeout)); + } +#endif + len = 0; while (len < bytes) { FD_ZERO(&rfds); @@ -119,26 +169,191 @@ int client_read_to(int sock, char *buf, int bytes, int timeout) tv.tv_sec = timeout; tv.tv_usec = 0; - retval = select((sock) + 1, - &rfds, NULL, NULL, &tv); + retval = select((sock) + 1, &rfds, NULL, NULL, &tv); if (FD_ISSET(sock, &rfds) == 0) { return (0); } + rlen = read(sock, &buf[len], bytes - len); + if (rlen < 1) { lprintf(2, "client_read() failed: %s\n", - strerror(errno)); - return(-1); + strerror(errno)); + return (-1); } len = len + rlen; } + +#ifdef HTTP_TRACING + write(2, "\033[32m", 5); + write(2, buf, bytes); + write(2, "\033[30m", 5); +#endif return (1); } -/* - * Read data from the client socket with default timeout. +/** + * \brief write data to the client + * \param buf data to write to the client + * \param count size of buffer + */ +ssize_t client_write(const void *buf, size_t count) +{ + + if (WC->burst != NULL) { + WC->burst = + realloc(WC->burst, (WC->burst_len + count + 2)); + memcpy(&WC->burst[WC->burst_len], buf, count); + WC->burst_len += count; + return (count); + } +#ifdef HAVE_OPENSSL + if (is_https) { + client_write_ssl((char *) buf, count); + return (count); + } +#endif +#ifdef HTTP_TRACING + write(2, "\033[34m", 5); + write(2, buf, count); + write(2, "\033[30m", 5); +#endif + return (write(WC->http_sock, buf, count)); +} + +/** + * \brief what burst??? + */ +void begin_burst(void) +{ + if (WC->burst != NULL) { + free(WC->burst); + WC->burst = NULL; + } + WC->burst_len = 0; + WC->burst = malloc(SIZ); +} + + +/** + * \brief uses the same calling syntax as compress2(), but it + * creates a stream compatible with HTTP "Content-encoding: gzip" + */ +#ifdef HAVE_ZLIB +#define DEF_MEM_LEVEL 8 /**< memlevel??? */ +#define OS_CODE 0x03 /**< unix */ +int ZEXPORT compress_gzip(Bytef * dest, /**< compressed buffer*/ + uLongf * destLen, /**< length of the compresed data */ + const Bytef * source, /**< source to encode */ + uLong sourceLen, /**< length of the source to encode */ + int level) /**< what level??? */ +{ + const int gz_magic[2] = { 0x1f, 0x8b }; /** gzip magic header */ + + /** write gzip header */ + sprintf((char *) dest, "%c%c%c%c%c%c%c%c%c%c", + gz_magic[0], gz_magic[1], Z_DEFLATED, + 0 /*flags */ , 0, 0, 0, 0 /*time */ , 0 /** xflags */ , + OS_CODE); + + /* normal deflate */ + z_stream stream; + int err; + stream.next_in = (Bytef *) source; + stream.avail_in = (uInt) sourceLen; + stream.next_out = dest + 10L; // after header + stream.avail_out = (uInt) * destLen; + if ((uLong) stream.avail_out != *destLen) + return Z_BUF_ERROR; + + stream.zalloc = (alloc_func) 0; + stream.zfree = (free_func) 0; + stream.opaque = (voidpf) 0; + + err = deflateInit2(&stream, level, Z_DEFLATED, -MAX_WBITS, + DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY); + if (err != Z_OK) + return err; + + err = deflate(&stream, Z_FINISH); + if (err != Z_STREAM_END) { + deflateEnd(&stream); + return err == Z_OK ? Z_BUF_ERROR : err; + } + *destLen = stream.total_out + 10L; + + /* write CRC and Length */ + uLong crc = crc32(0L, source, sourceLen); + int n; + for (n = 0; n < 4; ++n, ++*destLen) { + dest[*destLen] = (int) (crc & 0xff); + crc >>= 8; + } + uLong len = stream.total_in; + for (n = 0; n < 4; ++n, ++*destLen) { + dest[*destLen] = (int) (len & 0xff); + len >>= 8; + } + err = deflateEnd(&stream); + return err; +} +#endif + +/** + * \brief what burst??? + */ +void end_burst(void) +{ + size_t the_len; + char *the_data; + + if (WC->burst == NULL) + return; + + the_len = WC->burst_len; + the_data = WC->burst; + + WC->burst_len = 0; + WC->burst = NULL; + +#ifdef HAVE_ZLIB + /* Handle gzip compression */ + if (WC->gzip_ok) { + char *compressed_data = NULL; + uLongf compressed_len; + + compressed_len = (uLongf) ((the_len * 101) / 100) + 100; + compressed_data = malloc(compressed_len); + + if (compress_gzip((Bytef *) compressed_data, + &compressed_len, + (Bytef *) the_data, + (uLongf) the_len, Z_BEST_SPEED) == Z_OK) { + wprintf("Content-encoding: gzip\r\n"); + free(the_data); + the_data = compressed_data; + the_len = compressed_len; + } else { + free(compressed_data); + } + } +#endif /* HAVE_ZLIB */ + + wprintf("Content-length: %d\r\n\r\n", the_len); + client_write(the_data, the_len); + free(the_data); + return; +} + + + +/** + * \brief Read data from the client socket with default timeout. * (This is implemented in terms of client_read_to() and could be * justifiably moved out of sysdep.c) + * \param sock the socket fd to read from??? + * \param buf the buffer to write to + * \param bytes how large is the buffer */ int client_read(int sock, char *buf, int bytes) { @@ -146,30 +361,32 @@ int client_read(int sock, char *buf, int bytes) } -/* - * client_gets() ... Get a LF-terminated line of text from the client. +/** + * \brief Get a LF-terminated line of text from the client. * (This is implemented in terms of client_read() and could be * justifiably moved out of sysdep.c) + * \param sock socket fd to get client line from??? + * \param buf buffer to write read data to + * \param bufsiz how many bytes to read + * \return numer of bytes read??? */ -int client_gets(int sock, char *buf) +int client_getln(int sock, char *buf, int bufsiz) { int i, retval; - /* Read one character at a time. - */ + /** Read one character at a time.*/ for (i = 0;; i++) { retval = client_read(sock, &buf[i], 1); - if (retval != 1 || buf[i] == '\n' || i == 255) + if (retval != 1 || buf[i] == '\n' || i == (bufsiz-1)) break; } - /* If we got a long line, discard characters until the newline. - */ - if (i == 255) + /** If we got a long line, discard characters until the newline. */ + if (i == (bufsiz-1)) while (buf[i] != '\n' && retval == 1) retval = client_read(sock, &buf[i], 1); - /* + /** * Strip any trailing non-printable characters. */ buf[i] = 0; @@ -180,8 +397,9 @@ int client_gets(int sock, char *buf) } -/* - * Start running as a daemon. Only close stdio if do_close_stdio is set. +/** + * \brief Start running as a daemon. + * param do_close_stdio Only close stdio if set. */ void start_daemon(int do_close_stdio) { @@ -197,44 +415,83 @@ void start_daemon(int do_close_stdio) exit(0); } -void spawn_another_worker_thread() { - pthread_t SessThread; /* Thread descriptor */ - pthread_attr_t attr; /* Thread attributes */ +void spawn_another_worker_thread() +{ + pthread_t SessThread; /**< Thread descriptor */ + pthread_attr_t attr; /**< Thread attributes */ + int ret; lprintf(3, "Creating a new thread\n"); - /* set attributes for the new thread */ + /** set attributes for the new thread */ pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); - /* now create the thread */ + /** + * Our per-thread stacks need to be bigger than the default size, otherwise + * the MIME parser crashes on FreeBSD, and the IMAP service crashes on + * 64-bit Linux. + */ + if ((ret = pthread_attr_setstacksize(&attr, 1024 * 1024))) { + lprintf(1, "pthread_attr_setstacksize: %s\n", + strerror(ret)); + pthread_attr_destroy(&attr); + } + + /** now create the thread */ if (pthread_create(&SessThread, &attr, - (void *(*)(void *)) worker_entry, NULL) - != 0) { - lprintf(1, "Can't create thread: %s\n", - strerror(errno)); + (void *(*)(void *)) worker_entry, NULL) + != 0) { + lprintf(1, "Can't create thread: %s\n", strerror(errno)); } + + /** free up the attributes */ + pthread_attr_destroy(&attr); } -/* - * Here's where it all begins. +/** + * \brief Here's where it all begins. + * \param argc number of commandline args + * \param argv the commandline arguments */ int main(int argc, char **argv) { - pthread_t SessThread; /* Thread descriptor */ - pthread_attr_t attr; /* Thread attributes */ - int a, i; /* General-purpose variables */ - int port = PORT_NUM; /* Port to listen on */ + pthread_t SessThread; /**< Thread descriptor */ + pthread_attr_t attr; /**< Thread attributes */ + int a, i; /**< General-purpose variables */ + int port = PORT_NUM; /**< Port to listen on */ char tracefile[PATH_MAX]; - - /* Parse command line */ - while ((a = getopt(argc, argv, "hp:t:c")) != EOF) + char ip_addr[256]; + char *webcitdir = WEBCITDIR; +#ifdef ENABLE_NLS + char *locale = NULL; + char *mo = NULL; +#endif /* ENABLE_NLS */ + char uds_listen_path[PATH_MAX]; /**< listen on a unix domain socket? */ + + strcpy(uds_listen_path, ""); + + /** Parse command line */ +#ifdef HAVE_OPENSSL + while ((a = getopt(argc, argv, "h:i:p:t:x:cfs")) != EOF) +#else + while ((a = getopt(argc, argv, "h:i:p:t:x:cf")) != EOF) +#endif switch (a) { + case 'h': + webcitdir = strdup(optarg); + break; + case 'i': + safestrncpy(ip_addr, optarg, sizeof ip_addr); + break; case 'p': port = atoi(optarg); + if (port == 0) { + safestrncpy(uds_listen_path, optarg, sizeof uds_listen_path); + } break; case 't': - strcpy(tracefile, optarg); + safestrncpy(tracefile, optarg, sizeof tracefile); freopen(tracefile, "w", stdout); freopen(tracefile, "w", stderr); freopen(tracefile, "r", stdin); @@ -242,22 +499,34 @@ int main(int argc, char **argv) case 'x': verbosity = atoi(optarg); break; + case 'f': + follow_xff = 1; + break; case 'c': - server_cookie = malloc(SIZ); + server_cookie = malloc(256); if (server_cookie != NULL) { - strcpy(server_cookie, "Set-cookie: wcserver="); - if (gethostname( - &server_cookie[strlen(server_cookie)], - 200) != 0) { + safestrncpy(server_cookie, + "Set-cookie: wcserver=", + 256); + if (gethostname + (&server_cookie[strlen(server_cookie)], + 200) != 0) { lprintf(2, "gethostname: %s\n", strerror(errno)); free(server_cookie); } } break; + case 's': + is_https = 1; + break; default: - fprintf(stderr, "usage: webserver [-p localport] " - "[-t tracefile] [-c] " + fprintf(stderr, "usage: webserver " + "[-i ip_addr] [-p http_port] " + "[-t tracefile] [-c] [-f] " +#ifdef HAVE_OPENSSL + "[-s] " +#endif "[remotehost [remoteport]]\n"); return 1; } @@ -267,37 +536,84 @@ int main(int argc, char **argv) if (++optind < argc) ctdlport = argv[optind]; } - /* Tell 'em who's in da house */ - lprintf(1, SERVER "\n" -"Copyright (C) 1996-2003 by the Citadel/UX development team.\n" -"This software is distributed under the terms of the GNU General Public\n" -"License. If you paid for this software, someone is ripping you off.\n\n"); - - if (chdir(WEBCITDIR) != 0) + /** Tell 'em who's in da house */ + lprintf(1, SERVER "\n"); + lprintf(1, "Copyright (C) 1996-2005 by the Citadel development team.\n" + "This software is distributed under the terms of the " + "GNU General Public License.\n\n" + ); + + lprintf(9, "Changing directory to %s\n", webcitdir); + if (chdir(webcitdir) != 0) { perror("chdir"); + } - /* - * Set up a place to put thread-specific data. - * We only need a single pointer per thread - it points to the - * wcsession struct to which the thread is currently bound. - */ - if (pthread_key_create(&MyConKey, NULL) != 0) { - lprintf(1, "Can't create TSD key: %s\n", strerror(errno)); - } + /** initialize the International Bright Young Thing */ +#ifdef ENABLE_NLS + + initialize_locales(); + + locale = setlocale(LC_ALL, ""); + + mo = malloc(strlen(webcitdir) + 20); + sprintf(mo, "%s/locale", webcitdir); + lprintf(9, "Message catalog directory: %s\n", + bindtextdomain("webcit", mo) + ); + free(mo); + lprintf(9, "Text domain: %s\n", + textdomain("webcit") + ); + lprintf(9, "Text domain Charset: %s\n", + bind_textdomain_codeset("webcit","UTF8") + ); +#endif - /* + initialize_viewdefs(); + initialize_axdefs(); + + /** + * Set up a place to put thread-specific data. + * We only need a single pointer per thread - it points to the + * wcsession struct to which the thread is currently bound. + */ + if (pthread_key_create(&MyConKey, NULL) != 0) { + lprintf(1, "Can't create TSD key: %s\n", strerror(errno)); + } + + /** + * Set up a place to put thread-specific SSL data. + * We don't stick this in the wcsession struct because SSL starts + * up before the session is bound, and it gets torn down between + * transactions. + */ +#ifdef HAVE_OPENSSL + if (pthread_key_create(&ThreadSSL, NULL) != 0) { + lprintf(1, "Can't create TSD key: %s\n", strerror(errno)); + } +#endif + + /** * Bind the server to our favorite port. * There is no need to check for errors, because ig_tcp_server() * exits if it doesn't succeed. */ - lprintf(2, "Attempting to bind to port %d...\n", port); - msock = ig_tcp_server(port, LISTEN_QUEUE_LENGTH); + + if (strlen(uds_listen_path) > 0) { + lprintf(2, "Attempting to create listener socket at %s...\n", uds_listen_path); + msock = ig_uds_server(uds_listen_path, LISTEN_QUEUE_LENGTH); + } + else { + lprintf(2, "Attempting to bind to port %d...\n", port); + msock = ig_tcp_server(ip_addr, port, LISTEN_QUEUE_LENGTH); + } + lprintf(2, "Listening on socket %d\n", msock); signal(SIGPIPE, SIG_IGN); pthread_mutex_init(&SessionListMutex, NULL); - /* + /** * Start up the housekeeping thread */ pthread_attr_init(&attr); @@ -306,50 +622,66 @@ int main(int argc, char **argv) (void *(*)(void *)) housekeeping_loop, NULL); - /* Start a few initial worker threads */ - for (i=0; i<(INITIAL_WORKER_THREADS); ++i) { + /** + * If this is an HTTPS server, fire up SSL + */ +#ifdef HAVE_OPENSSL + if (is_https) { + init_ssl(); + } +#endif + + /** Start a few initial worker threads */ + for (i = 0; i < (MIN_WORKER_THREADS); ++i) { spawn_another_worker_thread(); } - /* now the original thread can go away. */ - pthread_exit(NULL); + /* now the original thread becomes another worker */ + worker_entry(); return 0; } -/* +/** * Entry point for worker threads */ -void worker_entry(void) { +void worker_entry(void) +{ int ssock; int i = 0; int time_to_die = 0; - time_t start_time, stop_time; + int fail_this_transaction = 0; do { - /* Only one thread can accept at a time */ - start_time = time(NULL); + /** Only one thread can accept at a time */ + fail_this_transaction = 0; ssock = accept(msock, NULL, 0); - stop_time = time(NULL); - - /* Augment the thread pool if we're not blocking at all */ - if ( (stop_time - start_time) == 0L) { - spawn_another_worker_thread(); - } - if (ssock < 0) { - lprintf(2, "accept() failed: %s\n", strerror(errno)); + lprintf(2, "accept() failed: %s\n", + strerror(errno)); } else { - /* Set the SO_REUSEADDR socket option */ + /** Set the SO_REUSEADDR socket option */ i = 1; setsockopt(ssock, SOL_SOCKET, SO_REUSEADDR, - &i, sizeof(i)); + &i, sizeof(i)); + + /** If we are an HTTPS server, go crypto now. */ +#ifdef HAVE_OPENSSL + if (is_https) { + if (starttls(ssock) != 0) { + fail_this_transaction = 1; + close(ssock); + } + } +#endif - /* Perform an HTTP transaction... */ - context_loop(ssock); + if (fail_this_transaction == 0) { + /** Perform an HTTP transaction... */ + context_loop(ssock); + /** ...and close the socket. */ + lingering_close(ssock); + } - /* ...and close the socket. */ - lingering_close(ssock); } } while (!time_to_die); @@ -357,41 +689,25 @@ void worker_entry(void) { pthread_exit(NULL); } - +/** + * \brief logprintf. log messages + * logs to stderr if loglevel is lower than the verbosity set at startup + * \param loglevel level of the message + * \param format the printf like format string + * \param ... the strings to put into format + */ int lprintf(int loglevel, const char *format, ...) { va_list ap; - char buf[4096]; - - va_start(ap, format); - vsprintf(buf, format, ap); - va_end(ap); if (loglevel <= verbosity) { - struct timeval tv; - struct tm *tim; - - gettimeofday(&tv, NULL); - tim = localtime((time_t *)&(tv.tv_sec)); - - if (WC && WC->wc_session) { - fprintf(stderr, - "%04d/%02d/%02d %2d:%02d:%02d.%03ld [%ld:%d] %s", - tim->tm_year + 1900, tim->tm_mon + 1, - tim->tm_mday, tim->tm_hour, tim->tm_min, - tim->tm_sec, (long)tv.tv_usec / 1000, - (long)pthread_self(), - WC->wc_session, buf); - } else { - fprintf(stderr, - "%04d/%02d/%02d %2d:%02d:%02d.%03ld [%ld] %s", - tim->tm_year + 1900, tim->tm_mon + 1, - tim->tm_mday, tim->tm_hour, tim->tm_min, - tim->tm_sec, (long)tv.tv_usec / 1000, - (long)pthread_self(), - buf); - } + va_start(ap, format); + vfprintf(stderr, format, ap); + va_end(ap); fflush(stderr); } return 1; } + + +/*@}*/