]> code.citadel.org Git - citadel.git/blobdiff - citadel/sysdep.c
warning fixes and cleanups for 64-bit machines
[citadel.git] / citadel / sysdep.c
index e592b1415395bf3c76ed9a52ce337f6569f70f1f..86534cf078d9b916d07e4b99f689996f825ce8a6 100644 (file)
@@ -12,6 +12,9 @@
  *
  */
 
+#ifdef DLL_EXPORT
+#define IN_LIBCIT
+#endif
 
 #include "sysdep.h"
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
 #include <sys/socket.h>
-#include <sys/time.h>
+
+#if TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif
+
 #include <limits.h>
 #include <netinet/in.h>
 #include <netdb.h>
 #endif
 #include "citadel.h"
 #include "server.h"
+#include "dynloader.h"
 #include "sysdep_decls.h"
 #include "citserver.h"
 #include "support.h"
 #include "config.h"
 #include "database.h"
 #include "housekeeping.h"
-#include "dynloader.h"
 #include "tools.h"
 
 #ifdef HAVE_SYS_SELECT_H
@@ -72,28 +86,44 @@ int verbosity = DEFAULT_VERBOSITY;          /* Logging level */
 struct CitContext masterCC;
 int rescan[2];                                 /* The Rescan Pipe */
 time_t last_purge = 0;                         /* Last dead session purge */
-int num_threads = 0;                           /* Current number of threads */
+static int num_threads = 0;                    /* Current number of threads */
 int num_sessions = 0;                          /* Current number of sessions */
 
 fd_set masterfds;                              /* Master sockets etc. */
 int masterhighest;
 
-time_t last_timer = 0L;                                /* Last timer hook processing */
+pthread_t initial_thread;              /* tid for main() thread */
 
 
 /*
  * lprintf()  ...   Write logging information
+ * 
+ * Note: the variable "buf" below needs to be large enough to handle any
+ * log data sent through this function.  BE CAREFUL!
  */
 void lprintf(int loglevel, const char *format, ...) {   
         va_list arg_ptr;
-       char buf[512];
+       char buf[4096];
   
         va_start(arg_ptr, format);   
         vsprintf(buf, format, arg_ptr);   
         va_end(arg_ptr);   
 
        if (loglevel <= verbosity) { 
-               fprintf(stderr, "%s", buf);
+               struct timeval tv;
+               struct tm *tim;
+
+               gettimeofday(&tv, NULL);
+               tim = localtime(&(tv.tv_sec));
+               /*
+                * Log provides millisecond accuracy.  If you need
+                * microsecond accuracy and your OS supports it, change
+                * %03ld to %06ld and remove " / 1000" after tv.tv_usec.
+                */
+               fprintf(stderr, "%04d/%02d/%02d %2d:%02d:%02d.%03ld %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, buf);
                fflush(stderr);
        }
 
@@ -194,7 +224,7 @@ void dump_tracked() {
  * that it's time to call master_cleanup() and exit.
  */
 
-static volatile int time_to_die = 0;
+volatile int time_to_die = 0;
 
 static RETSIGTYPE signal_cleanup(int signum) {
        time_to_die = 1;
@@ -246,6 +276,9 @@ void init_sysdep(void) {
 void begin_critical_section(int which_one)
 {
        /* lprintf(9, "begin_critical_section(%d)\n", which_one); */
+       /* ensure nobody ever tries to do a critical section within a
+          transaction; this could lead to deadlock. */
+       cdb_check_handles();
        pthread_mutex_lock(&Critters[which_one]);
 }
 
@@ -279,8 +312,7 @@ int ig_tcp_server(int port_number, int queue_len)
        sin.sin_addr.s_addr = INADDR_ANY;
        sin.sin_port = htons((u_short)port_number);
 
-       s = socket(PF_INET, SOCK_STREAM,
-               (getprotobyname("tcp")->p_proto));
+       s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
 
        if (s < 0) {
                lprintf(1, "citserver: Can't create a socket: %s\n",
@@ -379,8 +411,6 @@ struct CitContext *MyContext(void) {
  */
 struct CitContext *CreateNewContext(void) {
        struct CitContext *me, *ptr;
-       int num = 1;
-       int startover = 0;
 
        me = (struct CitContext *) mallok(sizeof(struct CitContext));
        if (me == NULL) {
@@ -395,24 +425,43 @@ struct CitContext *CreateNewContext(void) {
         */
        me->state = CON_EXECUTING;
 
+
+       /*
+        * Generate a unique session number and insert this context into
+        * the list.
+        */
        begin_critical_section(S_SESSION_TABLE);
 
-       /* obtain a unique session number */
-       do {
-               startover = 0;
+       if (ContextList == NULL) {
+               ContextList = me;
+               me->cs_pid = 1;
+               me->next = NULL;
+       }
+
+       else if (ContextList->cs_pid > 1) {
+               me->next = ContextList;
+               ContextList = me;
+               me->cs_pid = 1;
+       }
+
+       else {
                for (ptr = ContextList; ptr != NULL; ptr = ptr->next) {
-                       if (ptr->cs_pid == num) {
-                               ++num;
-                               startover = 1;
+                       if (ptr->next == NULL) {
+                               ptr->next = me;
+                               me->cs_pid = ptr->cs_pid + 1;
+                               me->next = NULL;
+                               goto DONE;
+                       }
+                       else if (ptr->next->cs_pid > (ptr->cs_pid+1)) {
+                               me->next = ptr->next;
+                               ptr->next = me;
+                               me->cs_pid = ptr->cs_pid + 1;
+                               goto DONE;
                        }
                }
-       } while (startover == 1);
-
-       me->cs_pid = num;
-       me->next = ContextList;
-       ContextList = me;
-       ++num_sessions;
+       }
 
+DONE:  ++num_sessions;
        end_critical_section(S_SESSION_TABLE);
        return(me);
 }
@@ -428,6 +477,7 @@ void client_write(char *buf, int nbytes)
        int retval;
        int sock;
 
+
        if (CC->redirect_fp != NULL) {
                fwrite(buf, nbytes, 1, CC->redirect_fp);
                return;
@@ -461,7 +511,7 @@ void client_write(char *buf, int nbytes)
  */
 void cprintf(const char *format, ...) {   
         va_list arg_ptr;   
-        char buf[256];   
+        char buf[SIZ];   
    
         va_start(arg_ptr, format);   
         if (vsnprintf(buf, sizeof buf, format, arg_ptr) == -1)
@@ -536,13 +586,13 @@ int client_gets(char *buf)
         */
        for (i = 0;;i++) {
                retval = client_read(&buf[i], 1);
-               if (retval != 1 || buf[i] == '\n' || i == 255)
+               if (retval != 1 || buf[i] == '\n' || i == (SIZ-1))
                        break;
        }
 
        /* If we got a long line, discard characters until the newline.
         */
-       if (i == 255)
+       if (i == (SIZ-1))
                while (buf[i] != '\n' && retval == 1)
                        retval = client_read(&buf[i], 1);
 
@@ -636,7 +686,7 @@ void cmd_nset(char *cmdbuf)
        FILE *netsetup;
        int ch;
        int a, b;
-       char netsetup_args[3][256];
+       char netsetup_args[3][SIZ];
 
        if (CC->usersupp.axlevel < 6) {
                cprintf("%d Higher access required.\n", 
@@ -712,6 +762,34 @@ int convert_login(char NameToConvert[]) {
        }
 }
 
+struct worker_node *worker_list = NULL;
+
+
+/*
+ * create a worker thread. this function must always be called from within
+ * an S_WORKER_LIST critical section!
+ */
+void create_worker(void) {
+       int ret;
+       struct worker_node *n = mallok(sizeof *n);
+
+       if (n == NULL) {
+               lprintf(1, "can't allocate worker_node, exiting\n");
+               time_to_die = -1;
+               return;
+       }
+
+       if ((ret = pthread_create(&n->tid, NULL, worker_thread, NULL) != 0))
+       {
+
+               lprintf(1, "Can't create worker thread: %s\n",
+                       strerror(ret));
+       }
+
+       n->next = worker_list;
+       worker_list = n;
+}
+
 
 
 /*
@@ -725,8 +803,8 @@ int convert_login(char NameToConvert[]) {
  */
 void dead_session_purge(void) {
        struct CitContext *ptr, *rem;
-        pthread_attr_t attr;
-       pthread_t newthread;
+       struct worker_node **node, *tmp;
+       pthread_t self;
 
        if ( (time(NULL) - last_purge) < 5 ) return;    /* Too soon, go away */
        time(&last_purge);
@@ -756,22 +834,38 @@ void dead_session_purge(void) {
         * an action is appropriate.
         */
 
+       self = pthread_self();
+
        if ( (num_sessions > num_threads)
           && (num_threads < config.c_max_workers) ) {
-
-               pthread_attr_init(&attr);
-                       pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
-               if (pthread_create(&newthread, &attr,
-                  (void* (*)(void*)) worker_thread, NULL) != 0) {
-                       lprintf(1, "Can't create worker thead: %s\n",
-                       strerror(errno));
-               }
-
+               begin_critical_section(S_WORKER_LIST);
+               create_worker();
+               end_critical_section(S_WORKER_LIST);
        }
        
+       /* don't let the initial thread die since it's responsible for
+          waiting for all the other threads to terminate. */
        else if ( (num_sessions < num_threads)
-          && (num_threads > config.c_min_workers) ) {
+          && (num_threads > config.c_min_workers)
+          && (self != initial_thread) ) {
+               cdb_free_tsd();
+               begin_critical_section(S_WORKER_LIST);
                --num_threads;
+
+               /* we're exiting before server shutdown... unlink ourself from
+                  the worker list and detach our thread to avoid memory leaks
+                */
+
+               for (node = &worker_list; *node != NULL; node = &(*node)->next)
+                       if ((*node)->tid == self) {
+                               tmp = *node;
+                               *node = (*node)->next;
+                               phree(tmp);
+                               break;
+                       }
+
+               pthread_detach(self);
+               end_critical_section(S_WORKER_LIST);
                pthread_exit(NULL);
        }
 
@@ -842,186 +936,10 @@ void init_master_fdset(void) {
 }
 
 
-
-/*
- * Here's where it all begins.
- */
-int main(int argc, char **argv)
-{
-       pthread_t WorkerThread; /* Thread descriptor */
-        pthread_attr_t attr;           /* Thread attributes */
-       char tracefile[128];            /* Name of file to log traces to */
-       int a, i;                       /* General-purpose variables */
-       struct passwd *pw;
-       int drop_root_perms = 1;
-       char *moddir;
-        
-       /* specify default port name and trace file */
-       strcpy(tracefile, "");
-
-       /* initialize the master context */
-       InitializeMasterCC();
-
-       /* parse command-line arguments */
-       for (a=1; a<argc; ++a) {
-
-               /* -t specifies where to log trace messages to */
-               if (!strncmp(argv[a], "-t", 2)) {
-                       strcpy(tracefile, argv[a]);
-                       strcpy(tracefile, &tracefile[2]);
-                       freopen(tracefile, "r", stdin);
-                       freopen(tracefile, "w", stdout);
-                       freopen(tracefile, "w", stderr);
-               }
-
-               /* run in the background if -d was specified */
-               else if (!strcmp(argv[a], "-d")) {
-                       start_daemon( (strlen(tracefile) > 0) ? 0 : 1 ) ;
-               }
-
-               /* -x specifies the desired logging level */
-               else if (!strncmp(argv[a], "-x", 2)) {
-                       verbosity = atoi(&argv[a][2]);
-               }
-
-               else if (!strncmp(argv[a], "-h", 2)) {
-                       safestrncpy(bbs_home_directory, &argv[a][2],
-                                   sizeof bbs_home_directory);
-                       home_specified = 1;
-               }
-
-               else if (!strncmp(argv[a], "-f", 2)) {
-                       do_defrag = 1;
-               }
-
-               /* -r tells the server not to drop root permissions. don't use
-                * this unless you know what you're doing. this should be
-                * removed in the next release if it proves unnecessary. */
-               else if (!strcmp(argv[a], "-r"))
-                       drop_root_perms = 0;
-
-               /* any other parameter makes it crash and burn */
-               else {
-                       lprintf(1,      "citserver: usage: "
-                                       "citserver [-tTraceFile] [-d] [-f]"
-                                       " [-xLogLevel] [-hHomeDir]\n");
-                       exit(1);
-               }
-
-       }
-
-       /* Tell 'em who's in da house */
-       lprintf(1,
-"\nMultithreaded message server for Citadel/UX\n"
-"Copyright (C) 1987-2000 by the Citadel/UX development team.\n"
-"Citadel/UX is free software, covered by the GNU General Public License, and\n"
-"you are welcome to change it and/or distribute copies of it under certain\n"
-"conditions.  There is absolutely no warranty for this software.  Please\n"
-"read the 'COPYING.txt' file for details.\n\n");
-
-       /* Initialize... */
-       init_sysdep();
-       openlog("citserver", LOG_PID, LOG_USER);
-
-       /* Load site-specific parameters */
-       lprintf(7, "Loading citadel.config\n");
-       get_config();
-
-
-       /*
-        * Do non system dependent startup functions.
-        */
-       master_startup();
-
-       /*
-        * Bind the server to a Unix-domain socket.
-        */
-       CtdlRegisterServiceHook(0,
-                               "citadel.socket",
-                               citproto_begin_session,
-                               do_command_loop);
-
-       /*
-        * Bind the server to our favorite TCP port (usually 504).
-        */
-       CtdlRegisterServiceHook(config.c_port_number,
-                               NULL,
-                               citproto_begin_session,
-                               do_command_loop);
-
-       /*
-        * Load any server-side modules (plugins) available here.
-        */
-       lprintf(7, "Initializing loadable modules\n");
-       cdb_begin_transaction();
-       if ((moddir = malloc(strlen(bbs_home_directory) + 9)) != NULL) {
-               sprintf(moddir, "%s/modules", bbs_home_directory);
-               DLoader_Init(moddir);
-               free(moddir);
-       }
-       cdb_end_transaction();
-
-       /*
-        * The rescan pipe exists so that worker threads can be woken up and
-        * told to re-scan the context list for fd's to listen on.  This is
-        * necessary, for example, when a context is about to go idle and needs
-        * to get back on that list.
-        */
-       if (pipe(rescan)) {
-               lprintf(1, "Can't create rescan pipe!\n");
-               exit(errno);
-       }
-
-       init_master_fdset();
-
-       /*
-        * Now that we've bound the sockets, change to the BBS user id and its
-        * corresponding group ids
-        */
-       if (drop_root_perms) {
-               if ((pw = getpwuid(BBSUID)) == NULL)
-                       lprintf(1, "WARNING: getpwuid(%d): %s\n"
-                                  "Group IDs will be incorrect.\n", BBSUID,
-                               strerror(errno));
-               else {
-                       initgroups(pw->pw_name, pw->pw_gid);
-                       if (setgid(pw->pw_gid))
-                               lprintf(3, "setgid(%d): %s\n", pw->pw_gid,
-                                       strerror(errno));
-               }
-               lprintf(7, "Changing uid to %d\n", BBSUID);
-               if (setuid(BBSUID) != 0) {
-                       lprintf(3, "setuid() failed: %s\n", strerror(errno));
-               }
-       }
-
-       /* We want to check for idle sessions once per minute */
-       CtdlRegisterSessionHook(terminate_idle_sessions, EVT_TIMER);
-
-       /*
-        * Now create a bunch of worker threads.
-        */
-       for (i=0; i<(config.c_min_workers-1); ++i) {
-               pthread_attr_init(&attr);
-                       pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
-               if (pthread_create(&WorkerThread, &attr,
-                  (void* (*)(void*)) worker_thread, NULL) != 0) {
-                       lprintf(1, "Can't create worker thead: %s\n",
-                       strerror(errno));
-               }
-       }
-
-       /* Now this thread can become a worker as well. */
-       worker_thread();
-
-       return(0);
-}
-
-
 /*
  * Bind a thread to a context.  (It's inline merely to speed things up.)
  */
-inline void become_session(struct CitContext *which_con) {
+INLINE void become_session(struct CitContext *which_con) {
        pthread_setspecific(MyConKey, (void *)which_con );
 }
 
@@ -1030,7 +948,7 @@ inline void become_session(struct CitContext *which_con) {
 /* 
  * This loop just keeps going and going and going...
  */    
-void worker_thread(void) {
+void *worker_thread(void *arg) {
        int i;
        char junk;
        int highest;
@@ -1045,11 +963,11 @@ void worker_thread(void) {
        int ssock;                      /* Descriptor for client socket */
        struct timeval tv;
 
-       ++num_threads;
+       num_threads++;
 
-       while (!time_to_die) {
+       cdb_allocate_tsd();
 
-               cdb_begin_transaction();
+       while (!time_to_die) {
 
                /* 
                 * A naive implementation would have all idle threads
@@ -1061,6 +979,11 @@ void worker_thread(void) {
                 * context we want and go on our merry way.
                 */
 
+               /* make doubly sure we're not holding any stale db handles
+                * which might cause a deadlock.
+                */
+               cdb_check_handles();
+
                begin_critical_section(S_I_WANNA_SELECT);
 SETUP_FD:      memcpy(&readfds, &masterfds, sizeof masterfds);
                highest = masterhighest;
@@ -1074,17 +997,26 @@ SETUP_FD:        memcpy(&readfds, &masterfds, sizeof masterfds);
                }
                end_critical_section(S_SESSION_TABLE);
 
-               tv.tv_sec = 60;         /* wake up every minute if no input */
+               tv.tv_sec = 1;          /* wake up every second if no input */
                tv.tv_usec = 0;
-               retval = select(highest + 1, &readfds, NULL, NULL, &tv);
+
+               do_select:
+               if (!time_to_die)
+                       retval = select(highest + 1, &readfds, NULL, NULL, &tv);
+               else {
+                       end_critical_section(S_I_WANNA_SELECT);
+                       break;
+               }
 
                /* Now figure out who made this select() unblock.
                 * First, check for an error or exit condition.
                 */
                if (retval < 0) {
-                       end_critical_section(S_I_WANNA_SELECT);
-                       lprintf(9, "Exiting (%s)\n", strerror(errno));
-                       time_to_die = 1;
+                       if (errno != EINTR) {
+                               lprintf(9, "Exiting (%s)\n", strerror(errno));
+                               time_to_die = 1;
+                       } else if (!time_to_die)
+                               goto do_select;
                }
 
                /* Next, check to see if it's a new client connecting
@@ -1140,8 +1072,10 @@ SETUP_FD:        memcpy(&readfds, &masterfds, sizeof masterfds);
                 * thread that the &readfds needs to be refreshed with more
                 * current data.
                 */
-               if (time_to_die)
+               if (time_to_die) {
+                       end_critical_section(S_I_WANNA_SELECT);
                        break;
+               }
 
                if (FD_ISSET(rescan[0], &readfds)) {
                        read(rescan[0], &junk, 1);
@@ -1186,19 +1120,14 @@ SETUP_FD:       memcpy(&readfds, &masterfds, sizeof masterfds);
 
                }
                dead_session_purge();
-               if ((time(NULL) - last_timer) > 60L) {
-                       last_timer = time(NULL);
-                       PerformSessionHooks(EVT_TIMER);
-               }
-
+               do_housekeeping();
                check_sched_shutdown();
-
-               cdb_end_transaction();
        }
 
        /* If control reaches this point, the server is shutting down */        
-       master_cleanup();
        --num_threads;
-       pthread_exit(NULL);
+       return NULL;
 }
 
+
+