X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fcitserver.c;h=0f96bf0686c25664e667996b97ad8f6d51fa1c18;hb=e61f1a6d8553b85b86457ca6ad0e69b2c1d1a2cb;hp=d3cd6ed3d576c305b023372a071b1659ecd7fb7a;hpb=efee1d4b0c8287c4c4daa819d87dffd1c55f62c4;p=citadel.git

diff --git a/citadel/citserver.c b/citadel/citserver.c
index d3cd6ed3d..0f96bf068 100644
--- a/citadel/citserver.c
+++ b/citadel/citserver.c
@@ -1,3 +1,5 @@
+/* $Id$ */
+#include "sysdep.h"
 #include <stdlib.h>
 #include <unistd.h>
 #include <stdio.h>
@@ -7,38 +9,73 @@
 #include <ctype.h>
 #include <string.h>
 #include <errno.h>
-#include <pthread.h>
+#include <limits.h>
 #include <syslog.h>
+#include <dlfcn.h>
+#include <netdb.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
 #include "citadel.h"
 #include "server.h"
-#include "proto.h"
-
-struct config config;
+#include "sysdep_decls.h"
+#include "citserver.h"
+#include "config.h"
+#include "database.h"
+#include "housekeeping.h"
+#include "user_ops.h"
+#include "logging.h"
+#include "msgbase.h"
+#include "support.h"
+#include "locate_host.h"
+#include "room_ops.h"
+#include "file_ops.h"
+#include "dynloader.h"
+#include "policy.h"
+#include "control.h"
+#include "tools.h"
 
 struct CitContext *ContextList = NULL;
+char *unique_session_numbers;
 int ScheduledShutdown = 0;
+int do_defrag = 0;
 
-	
 /*
  * Various things that need to be initialized at startup
  */
-void master_startup() {
+void master_startup(void) {
 	lprintf(7, "Opening databases\n");
 	open_databases();
 
+	if (do_defrag)
+		defrag_databases();
+
 	lprintf(7, "Checking floor reference counts\n");
 	check_ref_counts();
+
+	lprintf(7, "Creating base rooms (if necessary)\n");
+	create_room(BASEROOM, 0, "", 0);
+	create_room(AIDEROOM, 4, "", 0);
+	create_room(config.c_twitroom, 0, "", 0);
 	}
 
 /*
  * Cleanup routine to be called when the server is shutting down.
  */
-void master_cleanup() {
+void master_cleanup(void) {
+	struct CleanupFunctionHook *fcn;
 
 	/* Cancel all running sessions */
 	lprintf(7, "Cancelling running sessions...\n");
+
+/* FIX do something here
 	while (ContextList != NULL) {
-		kill_session(ContextList->cs_pid);
+		}
+ */
+
+	/* Run any cleanup routines registered by loadable modules */
+	for (fcn = CleanupHookTable; fcn != NULL; fcn = fcn->next) {
+		(*fcn->h_function_pointer)();
 		}
 
 	/* Close databases */
@@ -49,62 +86,172 @@ void master_cleanup() {
 	sysdep_master_cleanup();
 
 	/* Now go away. */
-	hook_cleanup();
 	lprintf(3, "citserver: exiting.\n");
+	fflush(stdout); fflush(stderr);
 	exit(0);
 	}
 
 
 /*
- * Gracefully terminate the session and thread.
- * (This is called as a cleanup handler by the thread library.)
+ * Free any per-session data allocated by modules or whatever
  */
-void cleanup_stuff()
+void deallocate_user_data(struct CitContext *con)
 {
-	struct ExpressMessage *emptr;
+	struct CtdlSessData *ptr;
+
+	begin_critical_section(S_SESSION_TABLE);
+	while (con->FirstSessData != NULL) {
+		lprintf(9, "Deallocating user data symbol %ld\n",
+			con->FirstSessData->sym_id);
+		if (con->FirstSessData->sym_data != NULL)
+			phree(con->FirstSessData->sym_data);
+		ptr = con->FirstSessData->next;
+		phree(con->FirstSessData);
+		con->FirstSessData = ptr;
+	}
+	end_critical_section(S_SESSION_TABLE);
+}
 
-	lprintf(9, "cleanup_stuff() called\n");
 
-	lprintf(7, "Calling logout(%d)\n", CC->cs_pid);
-	logout(CC);
 
-	rec_log(CL_TERMINATE,CC->curr_user);
-	unlink(CC->temp);
-	lprintf(3, "citserver[%3d]: ended.\n",CC->cs_pid);
-	hook_end_session(CC->cs_pid);
-	syslog(LOG_NOTICE,"session %d ended", CC->cs_pid);
-	
-	/* Deallocate any unsent express messages */
+
+/*
+ * Terminate a session and remove its context data structure.
+ */
+void RemoveContext (struct CitContext *con)
+{
+	struct CitContext *ptr = NULL;
+	struct CitContext *ToFree = NULL;
+
+	lprintf(9, "RemoveContext() called\n");
+	if (con==NULL) {
+		lprintf(5, "WARNING: RemoveContext() called with NULL!\n");
+		return;
+		}
+
+	/* Remove the context from the global context list.  This needs
+	 * to get done FIRST to avoid concurrency problems.
+	 */
+	lprintf(7, "Removing context for session %d\n", con->cs_pid);
 	begin_critical_section(S_SESSION_TABLE);
-	while (CC->FirstExpressMessage != NULL) {
-		emptr = CC->FirstExpressMessage;
-		CC->FirstExpressMessage = CC->FirstExpressMessage->next;
-		free(emptr);
+	if (ContextList == con) {
+		ToFree = ContextList;
+		ContextList = ContextList->next;
+		}
+	else {
+		for (ptr = ContextList; ptr != NULL; ptr = ptr->next) {
+			if (ptr->next == con) {
+				ToFree = ptr->next;
+				ptr->next = ptr->next->next;
+				}
+			}
 		}
 	end_critical_section(S_SESSION_TABLE);
 
-	/* Now get rid of the session and context */
-	lprintf(7, "cleanup_stuff() is calling RemoveContext(%d)\n", CC->cs_pid);
-	RemoveContext(CC);
-
-	/* While we still have an extra thread with no user attached to it,
-	 * take the opportunity to do some housekeeping before exiting.
-	 */
-	do_housekeeping();
+	if (ToFree == NULL) {
+		lprintf(9, "RemoveContext() found nothing to remove\n");
+		return;
 	}
 
+	/* Now handle all of the administrivia. */
+	lprintf(7, "Calling logout(%d)\n", con->cs_pid);
+	logout(con);
+
+	rec_log(CL_TERMINATE, con->curr_user);
+	unlink(con->temp);
+	lprintf(3, "citserver[%3d]: ended.\n", con->cs_pid);
+	
+	/* Run any cleanup routines registered by loadable modules */
+	PerformSessionHooks(EVT_STOP);
+
+	syslog(LOG_NOTICE,"session %d ended", con->cs_pid);
+	
+	/* Deallocate any user-data attached to this session */
+	deallocate_user_data(con);
+
+	/* If the client is still connected, blow 'em away. */
+	lprintf(7, "Closing socket %d\n", con->client_socket);
+	close(con->client_socket);
+
+        /* Tell the housekeeping thread to check to see if this is the time
+         * to initiate a scheduled shutdown event.
+         */
+        enter_housekeeping_cmd("SCHED_SHUTDOWN");
+
+	/* Free up the memory used by this context */
+	phree(con);
+
+	lprintf(7, "Done with RemoveContext()\n");
+}
+
+
+
+/*
+ * Get a dynamic symbol number for per-session user data.
+ * This API call should be made only ONCE per symbol per citserver run.
+ */
+int CtdlGetDynamicSymbol() 
+{
+	static unsigned int next_symbol = SYM_MAX;
+	return ++next_symbol;
+}
+
+
+
+/*
+ * Return a pointer to some generic per-session user data.
+ * (This function returns NULL if the requested symbol is not allocated.)
+ *
+ * NOTE: we use critical sections for allocating and de-allocating these,
+ *       but not for locating one.
+ */
+void *CtdlGetUserData(unsigned long requested_sym) 
+{
+	struct CtdlSessData *ptr;
+
+	for (ptr = CC->FirstSessData; ptr != NULL; ptr = ptr->next)
+		if (ptr->sym_id == requested_sym)
+			return(ptr->sym_data);
+
+	lprintf(2, "ERROR! CtdlGetUserData(%ld) symbol not allocated\n",
+		requested_sym);
+	return NULL;
+}
+
 
 /*
- * set_wtmpsupp()  -  alter the session listing
+ * Allocate some generic per-session user data.
  */
-void set_wtmpsupp(char *newtext)
+void CtdlAllocUserData(unsigned long requested_sym, size_t num_bytes)
 {
-	strncpy(CC->cs_room,newtext,19);
-	CC->cs_room[19] = 0;
-	time(&CC->cs_lastupdt);
-	hook_room_name(CC->cs_pid, CC->cs_room);
+	struct CtdlSessData *ptr;
+
+	lprintf(9, "CtdlAllocUserData(%ld) called\n", requested_sym);
+
+	/* Fail silently if the symbol is already registered. */
+	for (ptr = CC->FirstSessData; ptr != NULL; ptr = ptr->next)  {
+		if (ptr->sym_id == requested_sym) {
+			return;
+		}
 	}
 
+	/* Grab us some memory!  Dem's good eatin' !!  */
+	ptr = mallok(sizeof(struct CtdlSessData));
+	ptr->sym_id = requested_sym;
+	ptr->sym_data = mallok(num_bytes);
+
+	begin_critical_section(S_SESSION_TABLE);
+	ptr->next = CC->FirstSessData;
+	CC->FirstSessData = ptr;
+	end_critical_section(S_SESSION_TABLE);
+
+	lprintf(9, "CtdlAllocUserData(%ld) finished\n", requested_sym);
+}
+
+
+
+
+
 
 /*
  * cmd_info()  -  tell the client about this server
@@ -122,65 +269,122 @@ void cmd_info(void) {
 	cprintf("%d\n",SERVER_TYPE);
 	cprintf("%s\n",config.c_moreprompt);
 	cprintf("1\n");	/* 1 = yes, this system supports floors */
+	cprintf("1\n"); /* 1 = we support the extended paging options */
 	cprintf("000\n");
 	}
 
-void cmd_rchg(char *newroomname)
+void cmd_rchg(char *argbuf)
 {
-   if ((newroomname) && (newroomname[0]))
-   {
-      bzero(CC->fake_roomname, 20);
-      strncpy(CC->fake_roomname, newroomname, 19);
-   }
-   else
-      CC->fake_roomname[0] = '\0';
-   cprintf("%d\n",OK);
+	char newroomname[256];
+
+	extract(newroomname, argbuf, 0);
+	newroomname[ROOMNAMELEN-1] = 0;
+	if (strlen(newroomname) > 0) {
+		safestrncpy(CC->fake_roomname, newroomname,
+			sizeof(CC->fake_roomname) );
+		}
+	else {
+		strcpy(CC->fake_roomname, "");
+		}
+	cprintf("%d OK\n", OK);
 }
 
-void cmd_hchg(char *newhostname)
+void cmd_hchg(char *argbuf)
 {
-   if ((newhostname) && (newhostname[0]))
-   {
-      bzero(CC->fake_hostname, 25);
-      strncpy(CC->fake_hostname, newhostname, 24);
-   }
-   else
-      CC->fake_hostname[0] = '\0';
-   cprintf("%d\n",OK);
+	char newhostname[256];
+
+	extract(newhostname, argbuf, 0);
+	if (strlen(newhostname) > 0) {
+		safestrncpy(CC->fake_hostname, newhostname,
+			sizeof(CC->fake_hostname) );
+		}
+	else {
+		strcpy(CC->fake_hostname, "");
+		}
+	cprintf("%d OK\n", OK);
 }
 
-void cmd_uchg(char *newusername)
+void cmd_uchg(char *argbuf)
 {
-   if (CC->usersupp.axlevel < 6) 
-   {
-      cprintf("%d You must be an Aide to use UCHG.\n",
-		ERROR+HIGHER_ACCESS_REQUIRED);
-      return;
-   }
-   if ((newusername) && (newusername[0]))
-   {
-      CC->cs_flags &= ~CS_STEALTH;
-      bzero(CC->fake_username, 32);
-      if (struncmp(newusername, CC->curr_user, strlen(CC->curr_user)))
-         strncpy(CC->fake_username, newusername, 31);
-   }
-   else
-   {
-      CC->fake_username[0] = '\0';
-      CC->cs_flags |= CS_STEALTH;
-   }
-   cprintf("%d\n",OK);
+
+	char newusername[256];
+
+	extract(newusername, argbuf, 0);
+
+	if (CC->usersupp.axlevel < 6) {
+		cprintf("%d You must be an Aide to masquerade your name.\n",
+			ERROR+HIGHER_ACCESS_REQUIRED);
+		return;
+	}
+
+	if (strlen(newusername) > 0) {
+		CC->cs_flags &= ~CS_STEALTH;
+		memset(CC->fake_username, 0, 32);
+		if (strncasecmp(newusername, CC->curr_user,
+				strlen(CC->curr_user)))
+			safestrncpy(CC->fake_username, newusername,
+				sizeof(CC->fake_username));
+	}
+	else {
+		CC->fake_username[0] = '\0';
+		CC->cs_flags |= CS_STEALTH;
+	}
+	cprintf("%d\n",OK);
 }
 
-void cmd_time()
+
+
+/*
+ * returns an asterisk if there are any express messages waiting,
+ * space otherwise.
+ */
+char check_express(void) {
+	if (CC->FirstExpressMessage == NULL) {
+		return(' ');
+		}
+	else {
+		return('*');
+		}
+	}
+
+void cmd_time(void)
 {
    time_t tv;
    
    tv = time(NULL);
    
-   cprintf("%d|%ld\n", OK, tv);
+   cprintf("%d %ld\n", OK, tv);
 }
 
+/*
+ * Check whether two hostnames match.
+ * "Realname" should be an actual name of a client that is trying to connect;
+ * "testname" should be the value we are comparing it with. The idea is that we
+ * want to compare with both the abbreviated and fully-qualified versions of
+ * "testname;" some people define "localhost" as "localhost.foo.com," etc.
+ */
+static int hostnames_match(const char *realname, const char *testname) {
+	struct hostent *he;
+	int retval = 0;
+
+	if (!strcasecmp(realname, testname))
+		return 1;
+
+#ifdef HAVE_NONREENTRANT_NETDB
+	begin_critical_section(S_NETDB);
+#endif
+
+	if ((he = gethostbyname(testname)) != NULL)
+		if (!strcasecmp(realname, he->h_name))
+			retval = 1;
+
+#ifdef HAVE_NONREENTRANT_NETDB
+	end_critical_section(S_NETDB);
+#endif
+
+	return retval;
+	}
+
 /*
  * check a hostname against the public_clients file
  */
@@ -189,8 +393,8 @@ int is_public_client(char *where)
 	char buf[256];
 	FILE *fp;
 
-	if (!strucmp(where,"localhost")) return(1);
-	if (!strucmp(where,config.c_fqdn)) return(1);
+	if (hostnames_match(where,"localhost")) return(1);
+	if (hostnames_match(where,config.c_fqdn)) return(1);
 
 	fp = fopen("public_clients","r");
 	if (fp == NULL) return(0);
@@ -198,7 +402,7 @@ int is_public_client(char *where)
 	while (fgets(buf,256,fp)!=NULL) {
 		while (isspace((buf[strlen(buf)-1]))) 
 			buf[strlen(buf)-1] = 0;
-		if (!strucmp(buf,where)) {
+		if (hostnames_match(where,buf)) {
 			fclose(fp);
 			return(1);
 			}
@@ -219,6 +423,7 @@ void cmd_iden(char *argbuf)
 	int rev_level;
 	char desc[256];
 	char from_host[256];
+	struct in_addr addr;
 
 	if (num_parms(argbuf)<4) {
 		cprintf("%d usage error\n",ERROR);
@@ -230,21 +435,26 @@ void cmd_iden(char *argbuf)
 	rev_level = extract_int(argbuf,2);
 	extract(desc,argbuf,3);
 
-	strcpy(from_host,config.c_fqdn);
+	safestrncpy(from_host, config.c_fqdn, sizeof from_host);
+	from_host[sizeof from_host - 1] = 0;
 	if (num_parms(argbuf)>=5) extract(from_host,argbuf,4);
 
 	CC->cs_clientdev = dev_code;
 	CC->cs_clienttyp = cli_code;
 	CC->cs_clientver = rev_level;
-	strncpy(CC->cs_clientname,desc,31);
+	safestrncpy(CC->cs_clientname, desc, sizeof CC->cs_clientname);
 	CC->cs_clientname[31] = 0;
 
+	lprintf(9, "Looking up hostname '%s'\n", from_host);
 	if ((strlen(from_host)>0) && 
 	   (is_public_client(CC->cs_host))) {
-	   	strncpy(CC->cs_host,from_host,24);
-		CC->cs_host[24] = 0;
+		if (inet_aton(from_host, &addr))
+			locate_host(CC->cs_host, &addr);
+	   	else {
+			safestrncpy(CC->cs_host, from_host, sizeof CC->cs_host);
+			CC->cs_host[24] = 0;
+			}
 		}
-	set_wtmpsupp(CC->quickroom.QRname);
 
 	syslog(LOG_NOTICE,"client %d/%d/%01d.%02d (%s)\n",
 		dev_code,
@@ -286,7 +496,6 @@ void cmd_stel(char *cmdbuf)
 			CC->cs_flags = CC->cs_flags|CS_STEALTH;
 		}
 
-	set_wtmpsupp(CC->quickroom.QRname);
 	cprintf("%d Ok\n",OK);
 	}
 
@@ -306,13 +515,13 @@ void cmd_mesg(char *mname)
 	extract(buf,mname,0);
 
 
-	dirs[0]=malloc(64);
-	dirs[1]=malloc(64);
+	dirs[0]=mallok(64);
+	dirs[1]=mallok(64);
 	strcpy(dirs[0],"messages");
 	strcpy(dirs[1],"help");
 	mesg_locate(targ,buf,2,dirs);
-	free(dirs[0]);
-	free(dirs[1]);
+	phree(dirs[0]);
+	phree(dirs[1]);
 
 
 	if (strlen(targ)==0) {
@@ -361,16 +570,16 @@ void cmd_emsg(char *mname)
 		if (buf[a] == '/') buf[a] = '.';
 		}
 
-	dirs[0]=malloc(64);
-	dirs[1]=malloc(64);
+	dirs[0]=mallok(64);
+	dirs[1]=mallok(64);
 	strcpy(dirs[0],"messages");
 	strcpy(dirs[1],"help");
 	mesg_locate(targ,buf,2,dirs);
-	free(dirs[0]);
-	free(dirs[1]);
+	phree(dirs[0]);
+	phree(dirs[1]);
 
 	if (strlen(targ)==0) {
-		sprintf(targ, "./help/%s", buf);
+		snprintf(targ, sizeof targ, "./help/%s", buf);
 		}
 
 	mfp = fopen(targ,"w");
@@ -389,6 +598,34 @@ void cmd_emsg(char *mname)
 	}
 
 
+/* Don't show the names of private rooms unless the viewing
+ * user also knows the rooms.
+ */
+void GenerateRoomDisplay(char *real_room,
+			struct CitContext *viewed,
+			struct CitContext *viewer) {
+
+	strcpy(real_room, viewed->quickroom.QRname);
+	if (viewed->quickroom.QRflags & QR_MAILBOX) {
+		strcpy(real_room, &real_room[11]);
+	}
+	if (viewed->quickroom.QRflags & QR_PRIVATE) {
+		if ( (CtdlRoomAccess(&viewed->quickroom, &viewer->usersupp)
+		   & UA_KNOWN) == 0) {
+			strcpy(real_room, "<private room>");
+		}
+	}
+
+	if (viewed->cs_flags & CS_CHAT) {
+		while (strlen(real_room) < 14)
+			strcat(real_room, " ");
+
+		strcpy(&real_room[14], "<chat>");
+	}
+
+}
+
+
 /*
  * who's online
  */
@@ -396,10 +633,12 @@ void cmd_rwho(void) {
 	struct CitContext *cptr;
 	int spoofed = 0;
 	int aide;
-	char un[40], room[40], host[40], flags[5];
+	char un[40];
+	char real_room[ROOMNAMELEN], room[ROOMNAMELEN];
+	char host[40], flags[5];
 	
 	aide = CC->usersupp.axlevel >= 6;
-	cprintf("%d\n",LISTING_FOLLOWS);
+	cprintf("%d%c \n", LISTING_FOLLOWS, check_express() );
 	
 	for (cptr = ContextList; cptr != NULL; cptr = cptr->next) 
 	{
@@ -427,14 +666,15 @@ void cmd_rwho(void) {
 		else
 		   strcpy(host, cptr->cs_host);
 
-		if (cptr->fake_roomname[0])
-		{
-		   strcpy(room, cptr->fake_roomname);
-		   spoofed = 1;
+		GenerateRoomDisplay(real_room, cptr, CC);
+
+		if (cptr->fake_roomname[0]) {
+			strcpy(room, cptr->fake_roomname);
+			spoofed = 1;
+		}
+		else {
+			strcpy(room, real_room);
 		}
-		else
-		   strcpy(room, cptr->cs_room);
-		   
 		
                 if ((aide) && (spoofed))
                    strcat(flags, "+");
@@ -453,13 +693,20 @@ void cmd_rwho(void) {
 		if ((spoofed) && (aide))
 		{
 			cprintf("%d|%s|%s|%s|%s|%ld|%s|%s\n",
-				cptr->cs_pid, cptr->curr_user, cptr->cs_room,
+				cptr->cs_pid, cptr->curr_user,
+				real_room,
 				cptr->cs_host, cptr->cs_clientname,
 				(long)(cptr->lastidle),
 				cptr->lastcmdname, flags);
 		
 		}
 	}
+
+	/* Now it's magic time.  Before we finish, call any EVT_RWHO hooks
+	 * so that external paging modules such as serv_icq can add more
+	 * content to the Wholist.
+	 */
+	PerformSessionHooks(EVT_RWHO);
 	cprintf("000\n");
 	}
 
@@ -471,6 +718,7 @@ void cmd_term(char *cmdbuf)
 {
 	int session_num;
 	struct CitContext *ccptr;
+	int found_it = 0;
 
 	if (!CC->logged_in) {
 		cprintf("%d Not logged in.\n",ERROR+NOT_LOGGED_IN);
@@ -489,15 +737,22 @@ void cmd_term(char *cmdbuf)
 		return;
 		}
 
+	lprintf(9, "Locating session to kill\n");
+	begin_critical_section(S_SESSION_TABLE);
 	for (ccptr = ContextList; ccptr != NULL; ccptr = ccptr->next) {
 		if (session_num == ccptr->cs_pid) {
-			kill_session(ccptr->cs_pid);
-			cprintf("%d Session terminated.\n", OK);
-			return;
+			ccptr->kill_me = 1;
+			found_it = 1;
 			}
 		}
+	end_critical_section(S_SESSION_TABLE);
 
-	cprintf("%d No such session.\n", ERROR);
+	if (found_it) {
+		cprintf("%d Session terminated.\n", OK);
+		}
+	else {
+		cprintf("%d No such session.\n", ERROR);
+		}
 	}
 
 
@@ -537,6 +792,7 @@ void cmd_ipgm(char *argbuf)
 		}
 	else {
 		cprintf("%d Authentication failed.\n",ERROR);
+		lprintf(3, "Warning: ipgm authentication failed.\n");
 		}
 	}
 
@@ -546,7 +802,7 @@ void cmd_ipgm(char *argbuf)
  */
 void cmd_down(void) {
 	if (!CC->logged_in) {
-		cprintf("%d Not logged in.\n",ERROR+NOT_LOGGED_IN);
+		cprintf("%d Not logged in.\n", ERROR+NOT_LOGGED_IN);
 		return;
 		}
 
@@ -561,7 +817,7 @@ void cmd_down(void) {
 	}
 
 /*
- * Shut down the server
+ * Schedule or cancel a server shutdown
  */
 void cmd_scdn(char *argbuf)
 {
@@ -585,428 +841,464 @@ void cmd_scdn(char *argbuf)
 	cprintf("%d %d\n", OK, ScheduledShutdown);
 	}
 
+
 /*
- * main context loop
+ * 
  */
-void *context_loop(struct CitContext *con)
+void begin_session(struct CitContext *con)
 {
-	char cmdbuf[256];
-	int session_num;
-
-	/*
-	 * Wedge our way into the context table.
-	 */
-	InitMyContext(con);
+	int num_sessions, len;
+	struct sockaddr_in sin;
 
 	/* 
 	 * Initialize some variables specific to our context.
 	 */
-	CC->curr_rm = (-1);
-	CC->logged_in = 0;
-	CC->internal_pgm = 0;
-	CC->download_fp = NULL;
-	CC->upload_fp = NULL;
-	CC->cs_pid = con->client_socket;	/* not necessarily portable */
-	CC->FirstExpressMessage = NULL;
-	time(&CC->lastcmd);
-	time(&CC->lastidle);
-	strcpy(CC->lastcmdname, "    ");
-	strcpy(CC->cs_clientname, "(unknown)");
-	strcpy(CC->curr_user,"");
-	strcpy(CC->net_node,"");
-	sprintf(CC->temp,"/tmp/CitServer.%d.%d", getpid(), CC->cs_pid);
-	strcpy(CC->cs_room, "");
-	strcpy(CC->cs_host, config.c_fqdn);
-	locate_host(CC->cs_host);
-	CC->cs_flags = 0;
-	CC->upload_type = UPL_FILE;
-	CC->dl_is_net = 0;
-
-	session_num = session_count();
-	CC->nologin = 0;
-	if ((config.c_maxsessions > 0)&&(session_num >= config.c_maxsessions))
-		CC->nologin = 1;
-
-	if (CC->nologin==1) {
-	   cprintf("%d %s: Too many users are already online (maximum is %d)\n",
-		ERROR+MAX_SESSIONS_EXCEEDED,
-		config.c_nodename,config.c_maxsessions);
+	con->logged_in = 0;
+	con->internal_pgm = 0;
+	con->download_fp = NULL;
+	con->upload_fp = NULL;
+	con->FirstExpressMessage = NULL;
+	time(&con->lastcmd);
+	time(&con->lastidle);
+	strcpy(con->lastcmdname, "    ");
+	strcpy(con->cs_clientname, "(unknown)");
+	strcpy(con->curr_user,"(not logged in)");
+	strcpy(con->net_node,"");
+	snprintf(con->temp, sizeof con->temp, tmpnam(NULL));
+	safestrncpy(con->cs_host, config.c_fqdn, sizeof con->cs_host);
+	con->cs_host[sizeof con->cs_host - 1] = 0;
+	len = sizeof sin;
+	if (!getpeername(con->client_socket, (struct sockaddr *) &sin, &len))
+		locate_host(con->cs_host, &sin.sin_addr);
+	con->cs_flags = 0;
+	con->upload_type = UPL_FILE;
+	con->dl_is_net = 0;
+	con->FirstSessData = NULL;
+
+	num_sessions = session_count();
+	con->nologin = 0;
+	if ((config.c_maxsessions > 0)&&(num_sessions > config.c_maxsessions))
+		con->nologin = 1;
+
+	if (con->nologin==1) {
+		cprintf("%d %s: Too many users are already online "
+			"(maximum is %d)\n",
+			ERROR+MAX_SESSIONS_EXCEEDED,
+			config.c_nodename, config.c_maxsessions);
 		}
 	else {
-	   cprintf("%d %s Citadel/UX server ready.\n",OK,config.c_nodename);
-		}
-
-	lprintf(3, "citserver[%3d]: started.\n", CC->cs_pid);
-	hook_start_session(CC->cs_pid);
-
-	do {
-		time(&CC->lastcmd);
-		if (client_gets(cmdbuf) < 1) cleanup(EXIT_NULL);
-		lprintf(5, "citserver[%3d]: %s\n", CC->cs_pid, cmdbuf);
-		hook_command_received(CC->cs_pid, cmdbuf);
-
-		/*
-		 * Let other clients see the last command we executed, but
-		 * exclude NOOP because that would be boring.
-		 */
-		if (struncmp(cmdbuf, "NOOP", 4)) {
-			strcpy(CC->lastcmdname, "    ");
-			strncpy(CC->lastcmdname, cmdbuf, 4);
-			time(&CC->lastidle);
-			}
-			
-		if ((struncmp(cmdbuf, "ENT0", 4)) && (struncmp(cmdbuf, "MESG", 4)) && (struncmp(cmdbuf, "MSGS", 4)))
-		{
-		   CC->cs_flags &= ~CS_POSTING;
+		cprintf("%d %s Citadel/UX server ready.\n",
+			OK, config.c_nodename);
 		}
-		   
+
+	lprintf(3, "citserver[%3d]: started.\n", con->cs_pid);
+
+	/* Run any session startup routines registered by loadable modules */
+	PerformSessionHooks(EVT_START);
+
+	rec_log(CL_CONNECT, "");
+}
+
+
+
+
 /*
  * This loop recognizes all server commands.
  */
+void do_command_loop(void) {
+	char cmdbuf[256];
 
-		if (!struncmp(cmdbuf,"NOOP",4)) {
-			cprintf("%d%cok\n",OK,check_express());
-			}
+	time(&CC->lastcmd);
+	memset(cmdbuf, 0, sizeof cmdbuf); /* Clear it, just in case */
+	if (client_gets(cmdbuf) < 1) {
+		lprintf(3, "Client socket is broken.  Ending session.\n");
+		CC->kill_me = 1;
+		return;
+	}
+	lprintf(5, "citserver[%3d]: %s\n", CC->cs_pid, cmdbuf);
 
-		else if (!struncmp(cmdbuf,"QUIT",4)) {
-			cprintf("%d Goodbye.\n",OK);
-			}
+	/*
+	 * Let other clients see the last command we executed, and
+	 * update the idle time, but not NOOP, PEXP, or GEXP.
+	 */
+	if ( (strncasecmp(cmdbuf, "NOOP", 4))
+	   && (strncasecmp(cmdbuf, "PEXP", 4))
+	   && (strncasecmp(cmdbuf, "GEXP", 4)) ) {
+		strcpy(CC->lastcmdname, "    ");
+		safestrncpy(CC->lastcmdname, cmdbuf, 
+			sizeof(CC->lastcmdname) );
+		time(&CC->lastidle);
+		}
+		
+	if ((strncasecmp(cmdbuf, "ENT0", 4))
+	   && (strncasecmp(cmdbuf, "MESG", 4))
+	   && (strncasecmp(cmdbuf, "MSGS", 4)))
+	{
+	   CC->cs_flags &= ~CS_POSTING;
+	}
+		   
+	if (!strncasecmp(cmdbuf,"NOOP",4)) {
+		cprintf("%d%cok\n",OK,check_express());
+		}
 
-		else if (!struncmp(cmdbuf,"LOUT",4)) {
-			if (CC->logged_in) logout(CC);
-			cprintf("%d logged out.\n",OK);
-			}
+	else if (!strncasecmp(cmdbuf,"QUIT",4)) {
+		cprintf("%d Goodbye.\n",OK);
+		CC->kill_me = 1;
+		}
 
-		else if (!struncmp(cmdbuf,"USER",4)) {
-			cmd_user(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"LOUT",4)) {
+		if (CC->logged_in) logout(CC);
+		cprintf("%d logged out.\n",OK);
+		}
 
-		else if (!struncmp(cmdbuf,"PASS",4)) {
-			cmd_pass(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"USER",4)) {
+		cmd_user(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"NEWU",4)) {
-			cmd_newu(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"PASS",4)) {
+		cmd_pass(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"SETP",4)) {
-			cmd_setp(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"NEWU",4)) {
+		cmd_newu(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"LRMS",4)) {
-			cmd_lrms(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"SETP",4)) {
+		cmd_setp(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"LKRA",4)) {
-			cmd_lkra(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"LRMS",4)) {
+		cmd_lrms(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"LKRN",4)) {
-			cmd_lkrn(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"LKRA",4)) {
+		cmd_lkra(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"LKRO",4)) {
-			cmd_lkro(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"LKRN",4)) {
+		cmd_lkrn(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"LZRM",4)) {
-			cmd_lzrm(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"LKRO",4)) {
+		cmd_lkro(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"GETU",4)) {
-			cmd_getu();
-			}
+	else if (!strncasecmp(cmdbuf,"LZRM",4)) {
+		cmd_lzrm(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"SETU",4)) {
-			cmd_setu(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"GETU",4)) {
+		cmd_getu();
+		}
 
-		else if (!struncmp(cmdbuf,"GOTO",4)) {
-			cmd_goto(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"SETU",4)) {
+		cmd_setu(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"MSGS",4)) {
-			cmd_msgs(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"GOTO",4)) {
+		cmd_goto(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"WHOK",4)) {
-			cmd_whok();
-			}
+	else if (!strncasecmp(cmdbuf,"MSGS",4)) {
+		cmd_msgs(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"RDIR",4)) {
-			cmd_rdir();
-			}
+	else if (!strncasecmp(cmdbuf,"WHOK",4)) {
+		cmd_whok();
+		}
 
-		else if (!struncmp(cmdbuf,"MSG0",4)) {
-			cmd_msg0(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"RDIR",4)) {
+		cmd_rdir();
+		}
 
-		else if (!struncmp(cmdbuf,"MSG2",4)) {
-			cmd_msg2(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"MSG0",4)) {
+		cmd_msg0(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"MSG3",4)) {
-			cmd_msg3(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"MSG2",4)) {
+		cmd_msg2(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"INFO",4)) {
-			cmd_info();
-			}
+	else if (!strncasecmp(cmdbuf,"MSG3",4)) {
+		cmd_msg3(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"SLRP",4)) {
-			cmd_slrp(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"MSG4",4)) {
+		cmd_msg4(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"INVT",4)) {
-			cmd_invt_kick(&cmdbuf[5],1);
-			}
+	else if (!strncasecmp(cmdbuf,"OPNA",4)) {
+		cmd_opna(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"KICK",4)) {
-			cmd_invt_kick(&cmdbuf[5],0);
-			}
+	else if (!strncasecmp(cmdbuf,"INFO",4)) {
+		cmd_info();
+		}
 
-		else if (!struncmp(cmdbuf,"GETR",4)) {
-			cmd_getr();
-			}
+	else if (!strncasecmp(cmdbuf,"SLRP",4)) {
+		cmd_slrp(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"SETR",4)) {
-			cmd_setr(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"INVT",4)) {
+		cmd_invt_kick(&cmdbuf[5],1);
+		}
 
-		else if (!struncmp(cmdbuf,"GETA",4)) {
-			cmd_geta();
-			}
+	else if (!strncasecmp(cmdbuf,"KICK",4)) {
+		cmd_invt_kick(&cmdbuf[5],0);
+		}
 
-		else if (!struncmp(cmdbuf,"SETA",4)) {
-			cmd_seta(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"GETR",4)) {
+		cmd_getr();
+		}
 
-		else if (!struncmp(cmdbuf,"ENT0",4)) {
-			cmd_ent0(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"SETR",4)) {
+		cmd_setr(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"ENT3",4)) {
-			cmd_ent3(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"GETA",4)) {
+		cmd_geta();
+		}
 
-		else if (!struncmp(cmdbuf,"RINF",4)) {
-			cmd_rinf();
-			}
+	else if (!strncasecmp(cmdbuf,"SETA",4)) {
+		cmd_seta(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"DELE",4)) {
-			cmd_dele(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"ENT0",4)) {
+		cmd_ent0(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"KILL",4)) {
-			cmd_kill(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"ENT3",4)) {
+		cmd_ent3(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"CRE8",4)) {
-			cmd_cre8(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"RINF",4)) {
+		cmd_rinf();
+		}
 
-		else if (!struncmp(cmdbuf,"MOVE",4)) {
-			cmd_move(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"DELE",4)) {
+		cmd_dele(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"FORG",4)) {
-			cmd_forg();
-			}
+	else if (!strncasecmp(cmdbuf,"KILL",4)) {
+		cmd_kill(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"MESG",4)) {
-			cmd_mesg(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"CRE8",4)) {
+		cmd_cre8(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"EMSG",4)) {
-			cmd_emsg(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"MOVE",4)) {
+		cmd_move(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"GNUR",4)) {
-			cmd_gnur();
-			}
+	else if (!strncasecmp(cmdbuf,"FORG",4)) {
+		cmd_forg();
+		}
 
-		else if (!struncmp(cmdbuf,"GREG",4)) {
-			cmd_greg(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"MESG",4)) {
+		cmd_mesg(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"VALI",4)) {
-			cmd_vali(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"EMSG",4)) {
+		cmd_emsg(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"EINF",4)) {
-			cmd_einf(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"GNUR",4)) {
+		cmd_gnur();
+		}
 
-		else if (!struncmp(cmdbuf,"LIST",4)) {
-			cmd_list();
-			}
+	else if (!strncasecmp(cmdbuf,"VALI",4)) {
+		cmd_vali(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"REGI",4)) {
-			cmd_regi();
-			}
+	else if (!strncasecmp(cmdbuf,"EINF",4)) {
+		cmd_einf(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"CHEK",4)) {
-			cmd_chek();
-			}
+	else if (!strncasecmp(cmdbuf,"LIST",4)) {
+		cmd_list();
+		}
 
-		else if (!struncmp(cmdbuf,"DELF",4)) {
-			cmd_delf(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"CHEK",4)) {
+		cmd_chek();
+		}
 
-		else if (!struncmp(cmdbuf,"MOVF",4)) {
-			cmd_movf(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"DELF",4)) {
+		cmd_delf(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"NETF",4)) {
-			cmd_netf(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"MOVF",4)) {
+		cmd_movf(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"RWHO",4)) {
-			cmd_rwho();
-			}
+	else if (!strncasecmp(cmdbuf,"NETF",4)) {
+		cmd_netf(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"OPEN",4)) {
-			cmd_open(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"RWHO",4)) {
+		cmd_rwho();
+		}
 
-		else if (!struncmp(cmdbuf,"CLOS",4)) {
-			cmd_clos();
-			}
+	else if (!strncasecmp(cmdbuf,"OPEN",4)) {
+		cmd_open(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"UOPN",4)) {
-			cmd_uopn(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"CLOS",4)) {
+		cmd_clos();
+		}
 
-		else if (!struncmp(cmdbuf,"UCLS",4)) {
-			cmd_ucls(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"UOPN",4)) {
+		cmd_uopn(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"READ",4)) {
-			cmd_read(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"UCLS",4)) {
+		cmd_ucls(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"WRIT",4)) {
-			cmd_writ(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"READ",4)) {
+		cmd_read(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"QUSR",4)) {
-			cmd_qusr(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"WRIT",4)) {
+		cmd_writ(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"ECHO",4)) {
-			cmd_echo(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"QUSR",4)) {
+		cmd_qusr(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"OIMG",4)) {
-			cmd_oimg(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"ECHO",4)) {
+		cmd_echo(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"MORE",4)) {
-			cmd_more();
-			}
+	else if (!strncasecmp(cmdbuf,"OIMG",4)) {
+		cmd_oimg(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"NETP",4)) {
-			cmd_netp(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"MORE",4)) {
+		cmd_more();
+		}
 
-		else if (!struncmp(cmdbuf,"NDOP",4)) {
-			cmd_ndop(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"NETP",4)) {
+		cmd_netp(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"NUOP",4)) {
-			cmd_nuop(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"NDOP",4)) {
+		cmd_ndop(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"LFLR",4)) {
-			cmd_lflr();
-			}
+	else if (!strncasecmp(cmdbuf,"NUOP",4)) {
+		cmd_nuop(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"CFLR",4)) {
-			cmd_cflr(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"LFLR",4)) {
+		cmd_lflr();
+		}
 
-		else if (!struncmp(cmdbuf,"KFLR",4)) {
-			cmd_kflr(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"CFLR",4)) {
+		cmd_cflr(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"EFLR",4)) {
-			cmd_eflr(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"KFLR",4)) {
+		cmd_kflr(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"IDEN",4)) {
-			cmd_iden(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"EFLR",4)) {
+		cmd_eflr(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"IPGM",4)) {
-			cmd_ipgm(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"IDEN",4)) {
+		cmd_iden(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"CHAT",4)) {
-			cmd_chat(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"IPGM",4)) {
+		cmd_ipgm(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"PEXP",4)) {
-			cmd_pexp();
-			}
+	else if (!strncasecmp(cmdbuf,"EBIO",4)) {
+		cmd_ebio();
+		}
 
-		else if (!struncmp(cmdbuf,"SEXP",4)) {
-			cmd_sexp(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"RBIO",4)) {
+		cmd_rbio(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"EBIO",4)) {
-			cmd_ebio();
-			}
+	else if (!strncasecmp(cmdbuf,"LBIO",4)) {
+		cmd_lbio();
+		}
 
-		else if (!struncmp(cmdbuf,"RBIO",4)) {
-			cmd_rbio(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"STEL",4)) {
+		cmd_stel(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"LBIO",4)) {
-			cmd_lbio();
-			}
+	else if (!strncasecmp(cmdbuf,"TERM",4)) {
+		cmd_term(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"STEL",4)) {
-			cmd_stel(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"DOWN",4)) {
+		cmd_down();
+		}
 
-		else if (!struncmp(cmdbuf,"TERM",4)) {
-			cmd_term(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf,"SCDN",4)) {
+		cmd_scdn(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"DOWN",4)) {
-			cmd_down();
-			}
+	else if (!strncasecmp(cmdbuf, "NSET", 4)) {
+		cmd_nset(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf,"SCDN",4)) {
-			cmd_scdn(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf, "UIMG", 4)) {
+		cmd_uimg(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf, "NSET", 4)) {
-			cmd_nset(&cmdbuf[5]);
-			}
+	else if (!strncasecmp(cmdbuf, "UCHG", 4)) {
+		cmd_uchg(&cmdbuf[5]);
+		}
 
-		else if (!struncmp(cmdbuf, "UIMG", 4)) {
-			cmd_uimg(&cmdbuf[5]);
-			}
-		else if (!struncmp(cmdbuf, "UCHG", 4)) {
-			cmd_uchg(&cmdbuf[5]);
-			}
-		else if (!struncmp(cmdbuf, "TIME", 4)) {
-			cmd_time(&cmdbuf[5]);
-			}
-		else if (!struncmp(cmdbuf, "HCHG", 4)) {
-			cmd_hchg(&cmdbuf[5]);
-			}
-		else if (!struncmp(cmdbuf, "RCHG", 4)) {
-			cmd_rchg(&cmdbuf[5]);
-			}
-		else {
-			cprintf("%d Unrecognized or unsupported command.\n",
-				ERROR);
-			}
+	else if (!strncasecmp(cmdbuf, "TIME", 4)) {
+		cmd_time();
+		}
+
+	else if (!strncasecmp(cmdbuf, "HCHG", 4)) {
+		cmd_hchg(&cmdbuf[5]);
+		}
 
-		} while(struncmp(cmdbuf,"QUIT",4));
+	else if (!strncasecmp(cmdbuf, "RCHG", 4)) {
+		cmd_rchg(&cmdbuf[5]);
+		}
 
-	cleanup(EXIT_NORMAL);
-	return(NULL);
-	}
+	else if (!strncasecmp(cmdbuf, "AGUP", 4)) {
+		cmd_agup(&cmdbuf[5]);
+		}
+
+	else if (!strncasecmp(cmdbuf, "ASUP", 4)) {
+		cmd_asup(&cmdbuf[5]);
+		}
+
+	else if (!strncasecmp(cmdbuf, "GPEX", 4)) {
+		cmd_gpex(&cmdbuf[5]);
+		}
+
+	else if (!strncasecmp(cmdbuf, "SPEX", 4)) {
+		cmd_spex(&cmdbuf[5]);
+		}
+
+	else if (!strncasecmp(cmdbuf, "CONF", 4)) {
+		cmd_conf(&cmdbuf[5]);
+		}
+
+#ifdef DEBUG_MEMORY_LEAKS
+	else if (!strncasecmp(cmdbuf, "LEAK", 4)) {
+		dump_tracked();
+		}
+#endif
+
+	else if (!DLoader_Exec_Cmd(cmdbuf))
+		{
+		   cprintf("%d Unrecognized or unsupported command.\n",
+		            ERROR);
+	        }
+
+	/* Run any after-each-command outines registered by modules */
+	PerformSessionHooks(EVT_CMD);
+}