X-Git-Url: https://code.citadel.org/?p=citadel.git;a=blobdiff_plain;f=citadel%2Fcontext.c;h=88ddbe21bd6581f3693bfafa0f52612e5e29c021;hp=c20ec98f7654f873a7387799e617fb3a36fd0fc4;hb=e55c9fac2d5ce1ccc9239fb4155428f9c7d1bb6d;hpb=cb45c6bab6711b3b62ca0ac8ae18a1fdb95fb44a

diff --git a/citadel/context.c b/citadel/context.c
index c20ec98f7..88ddbe21b 100644
--- a/citadel/context.c
+++ b/citadel/context.c
@@ -1,85 +1,33 @@
 /*
- * $Id: sysdep.c 7989 2009-10-31 15:29:37Z davew $
- *
  * Citadel context management stuff.
- * See COPYING for copyright information.
- *
  * Here's where we (hopefully) have all the code that manipulates contexts.
  *
+ * Copyright (c) 1987-2018 by the citadel.org team
+ *
+ * This program is open source software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  */
 
-#include "sysdep.h"
-#include <stdlib.h>
-#include <unistd.h>
-#include <stdio.h>
-#include <fcntl.h>
-#include <ctype.h>
-#include <signal.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/wait.h>
-#include <sys/socket.h>
-#include <syslog.h>
-#include <sys/syslog.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 <sys/resource.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <sys/un.h>
-#include <string.h>
-#include <pwd.h>
-#include <errno.h>
-#include <stdarg.h>
-#include <grp.h>
-#include <libcitadel.h>
-#include "citadel.h"
-#include "server.h"
-#include "sysdep_decls.h"
-#include "citserver.h"
-#include "support.h"
-#include "config.h"
-#include "database.h"
-#include "housekeeping.h"
-#include "modules/crypto/serv_crypto.h"	/* Needed for init_ssl, client_write_ssl, client_read_ssl, destruct_ssl */
-#include "ecrash.h"
-
-#ifdef HAVE_SYS_SELECT_H
-#include <sys/select.h>
-#endif
-
-#ifndef HAVE_SNPRINTF
-#include "snprintf.h"
-#endif
-
 #include "ctdl_module.h"
-#include "threads.h"
+#include "serv_extensions.h"
+#include "citserver.h"
 #include "user_ops.h"
+#include "locate_host.h"
+#include "context.h"
 #include "control.h"
+#include "config.h"
 
-
-
-citthread_key_t MyConKey;				/* TSD key for MyContext() */
-
-
+pthread_key_t MyConKey;				/* TSD key for MyContext() */
 CitContext masterCC;
 CitContext *ContextList = NULL;
-
 time_t last_purge = 0;				/* Last dead session purge */
 int num_sessions = 0;				/* Current number of sessions */
+int next_pid = 0;
 
 /* Flag for single user mode */
 static int want_single_user = 0;
@@ -102,6 +50,7 @@ int CtdlTrySingleUser(void)
 	return can_do;
 }
 
+
 void CtdlEndSingleUser(void)
 {
 	begin_critical_section(S_SINGLE_USER);
@@ -115,21 +64,19 @@ int CtdlWantSingleUser(void)
 	return want_single_user;
 }
 
+
 int CtdlIsSingleUser(void)
 {
 	if (want_single_user)
 	{
 		/* check for only one context here */
 		if (num_sessions == 1)
-			return TRUE;
+			return 1;
 	}
-	return FALSE;
+	return 0;
 }
 
 
-
-
-
 /*
  * Locate a context by its session number and terminate it if the user is able.
  * User can NOT terminate their current session.
@@ -138,26 +85,38 @@ int CtdlIsSingleUser(void)
  */
 int CtdlTerminateOtherSession (int session_num)
 {
+	struct CitContext *CCC = CC;
 	int ret = 0;
 	CitContext *ccptr;
+	int aide;
 
-	if (session_num == CC->cs_pid) {
-		return TERM_NOTALLOWED;
-	}
+	if (session_num == CCC->cs_pid) return TERM_NOTALLOWED;
+
+	aide = ( (CCC->user.axlevel >= AxAideU) || (CCC->internal_pgm) ) ;
 
-	CtdlLogPrintf(CTDL_DEBUG, "Locating session to kill\n");
+	syslog(LOG_DEBUG, "context: locating session to kill");
 	begin_critical_section(S_SESSION_TABLE);
 	for (ccptr = ContextList; ccptr != NULL; ccptr = ccptr->next) {
 		if (session_num == ccptr->cs_pid) {
 			ret |= TERM_FOUND;
-			if ((ccptr->user.usernum == CC->user.usernum)
-			   || (CC->user.axlevel >= 6)) {
+			if ((ccptr->user.usernum == CCC->user.usernum) || aide) {
 				ret |= TERM_ALLOWED;
-				ccptr->kill_me = 1;
 			}
+			break;
 		}
 	}
-	end_critical_section(S_SESSION_TABLE);
+
+	if (((ret & TERM_FOUND) != 0) && ((ret & TERM_ALLOWED) != 0))
+	{
+		if (ccptr->user.usernum == CCC->user.usernum)
+			ccptr->kill_me = KILLME_ADMIN_TERMINATE;
+		else
+			ccptr->kill_me = KILLME_IDLE;
+		end_critical_section(S_SESSION_TABLE);
+	}
+	else
+		end_critical_section(S_SESSION_TABLE);
+
 	return ret;
 }
 
@@ -245,12 +204,8 @@ int CtdlIsUserLoggedInByNum (long usernum)
  * This function is used *VERY* frequently and must be kept small.
  */
 CitContext *MyContext(void) {
-
 	register CitContext *c;
-
-	return ((c = (CitContext *) citthread_getspecific(MyConKey),
-		c == NULL) ? &masterCC : c
-	);
+	return ((c = (CitContext *) pthread_getspecific(MyConKey), c == NULL) ? &masterCC : c);
 }
 
 
@@ -266,30 +221,58 @@ void terminate_idle_sessions(void)
 {
 	CitContext *ccptr;
 	time_t now;
-	int session_to_kill;
 	int killed = 0;
 	int longrunners = 0;
 
 	now = time(NULL);
-	session_to_kill = 0;
 	begin_critical_section(S_SESSION_TABLE);
 	for (ccptr = ContextList; ccptr != NULL; ccptr = ccptr->next) {
-		if (  (ccptr!=CC)
-	   	&& (config.c_sleeping > 0)
-	   	&& (now - (ccptr->lastcmd) > config.c_sleeping) ) {
+		if (
+			(ccptr != CC)
+	   		&& (CtdlGetConfigLong("c_sleeping") > 0)
+	   		&& (now - (ccptr->lastcmd) > CtdlGetConfigLong("c_sleeping"))
+		) {
 			if (!ccptr->dont_term) {
-				ccptr->kill_me = 1;
+				ccptr->kill_me = KILLME_IDLE;
 				++killed;
 			}
-			else 
-				longrunners ++;
+			else {
+				++longrunners;
+			}
+		}
+	}
+	end_critical_section(S_SESSION_TABLE);
+	if (killed > 0) {
+		syslog(LOG_INFO, "context: scheduled %d idle sessions for termination", killed);
+	}
+	if (longrunners > 0) {
+		syslog(LOG_INFO, "context: did not terminate %d protected idle sessions", longrunners);
+	}
+}
+
+
+/*
+ * During shutdown, close the sockets of any sessions still connected.
+ */
+void terminate_all_sessions(void)
+{
+	CitContext *ccptr;
+	int killed = 0;
+
+	begin_critical_section(S_SESSION_TABLE);
+	for (ccptr = ContextList; ccptr != NULL; ccptr = ccptr->next) {
+		if (ccptr->client_socket != -1)
+		{
+			syslog(LOG_INFO, "context: terminate_all_sessions() is murdering %s CC[%d]", ccptr->curr_user, ccptr->cs_pid);
+			close(ccptr->client_socket);
+			ccptr->client_socket = -1;
+			killed++;
 		}
 	}
 	end_critical_section(S_SESSION_TABLE);
-	if (killed > 0)
-		CtdlLogPrintf(CTDL_INFO, "Terminated %d idle sessions\n", killed);
-	if (longrunners > 0)
-		CtdlLogPrintf(CTDL_INFO, "Didn't terminate %d protected idle sessions;\n", killed);
+	if (killed > 0) {
+		syslog(LOG_INFO, "context: flushed %d stuck sessions", killed);
+	}
 }
 
 
@@ -299,12 +282,16 @@ void terminate_idle_sessions(void)
  */
 void RemoveContext (CitContext *con)
 {
-	if (con==NULL) {
-		CtdlLogPrintf(CTDL_ERR,
-			"WARNING: RemoveContext() called with NULL!\n");
+	const char *c;
+	if (con == NULL) {
+		syslog(LOG_ERR, "context: RemoveContext() called with NULL, this should not happen");
 		return;
 	}
-	CtdlLogPrintf(CTDL_DEBUG, "RemoveContext() session %d\n", con->cs_pid);
+	c = con->ServiceName;
+	if (c == NULL) {
+		c = "WTF?";
+	}
+	syslog(LOG_DEBUG, "context: RemoveContext(%s) session %d", c, con->cs_pid);
 
 	/* Run any cleanup routines registered by loadable modules.
 	 * Note: We have to "become_session()" because the cleanup functions
@@ -313,25 +300,35 @@ void RemoveContext (CitContext *con)
 	become_session(con);
 	CtdlUserLogout();
 	PerformSessionHooks(EVT_STOP);
+	client_close();				/* If the client is still connected, blow 'em away. */
 	become_session(NULL);
 
-	CtdlLogPrintf(CTDL_NOTICE, "[%3d] Session ended.\n", con->cs_pid);
+	syslog(LOG_INFO, "context: [%3d]SRV[%s] Session ended.", con->cs_pid, c);
 
-	/* If the client is still connected, blow 'em away. */
-	CtdlLogPrintf(CTDL_DEBUG, "Closing socket %d\n", con->client_socket);
-	close(con->client_socket);
+	/* 
+	 * If the client is still connected, blow 'em away. 
+	 * if the socket is 0 or -1, its already gone or was never there.
+	 */
+	if (con->client_socket > 0)
+	{
+		syslog(LOG_INFO, "context: closing socket %d", con->client_socket);
+		close(con->client_socket);
+	}
 
 	/* If using AUTHMODE_LDAP, free the DN */
 	if (con->ldap_dn) {
 		free(con->ldap_dn);
 		con->ldap_dn = NULL;
 	}
-
+	FreeStrBuf(&con->StatusMessage);
 	FreeStrBuf(&con->MigrateBuf);
-	FreeStrBuf(&con->ReadBuf);
-	CtdlLogPrintf(CTDL_DEBUG, "Done with RemoveContext()\n");
-}
+	FreeStrBuf(&con->RecvBuf.Buf);
+	if (con->cached_msglist) {
+		free(con->cached_msglist);
+	}
 
+	syslog(LOG_DEBUG, "context: done with RemoveContext()");
+}
 
 
 
@@ -343,16 +340,15 @@ void RemoveContext (CitContext *con)
  */
 CitContext *CreateNewContext(void) {
 	CitContext *me;
-	static int next_pid = 0;
 
 	me = (CitContext *) malloc(sizeof(CitContext));
 	if (me == NULL) {
-		CtdlLogPrintf(CTDL_ALERT, "citserver: can't allocate memory!!\n");
+		syslog(LOG_ERR, "citserver: malloc() failed: %m");
 		return NULL;
 	}
 	memset(me, 0, sizeof(CitContext));
-	
-	/* Give the contaxt a name. Hopefully makes it easier to track */
+
+	/* Give the context a name. Hopefully makes it easier to track */
 	strcpy (me->user.fullname, "SYS_notauth");
 	
 	/* The new context will be created already in the CON_EXECUTING state
@@ -365,7 +361,12 @@ CitContext *CreateNewContext(void) {
 	 * the list.
 	 */
 	me->MigrateBuf = NewStrBuf();
-	me->ReadBuf = NewStrBuf();
+
+	me->RecvBuf.Buf = NewStrBuf();
+
+	me->lastcmd = time(NULL);	/* set lastcmd to now to prevent idle timer infanticide TODO: if we have a valid IO, use that to set the timer. */
+
+
 	begin_critical_section(S_SESSION_TABLE);
 	me->cs_pid = ++next_pid;
 	me->prev = NULL;
@@ -380,6 +381,72 @@ CitContext *CreateNewContext(void) {
 }
 
 
+/*
+ * Initialize a new context and place it in the list.  The session number
+ * used to be the PID (which is why it's called cs_pid), but that was when we
+ * had one process per session.  Now we just assign them sequentially, starting
+ * at 1 (don't change it to 0 because masterCC uses 0).
+ */
+CitContext *CloneContext(CitContext *CloneMe) {
+	CitContext *me;
+
+	me = (CitContext *) malloc(sizeof(CitContext));
+	if (me == NULL) {
+		syslog(LOG_ERR, "citserver: malloc() failed: %m");
+		return NULL;
+	}
+	memcpy(me, CloneMe, sizeof(CitContext));
+
+	memset(&me->RecvBuf, 0, sizeof(IOBuffer));
+	memset(&me->SendBuf, 0, sizeof(IOBuffer));
+	memset(&me->SBuf, 0, sizeof(IOBuffer));
+	me->MigrateBuf = NULL;
+	me->sMigrateBuf = NULL;
+	me->redirect_buffer = NULL;
+#ifdef HAVE_OPENSSL
+	me->ssl = NULL;
+#endif
+
+	me->download_fp = NULL;
+	me->upload_fp = NULL;
+	/// TODO: what about the room/user?
+	me->ma = NULL;
+	me->openid_data = NULL;
+	me->ldap_dn = NULL;
+	me->session_specific_data = NULL;
+	
+	me->CIT_ICAL = NULL;
+
+	me->cached_msglist = NULL;
+	me->download_fp = NULL;
+	me->upload_fp = NULL;
+	me->client_socket = 0;
+
+	me->MigrateBuf = NewStrBuf();
+	me->RecvBuf.Buf = NewStrBuf();
+	
+	begin_critical_section(S_SESSION_TABLE);
+	{
+		me->cs_pid = ++next_pid;
+		me->prev = NULL;
+		me->next = ContextList;
+		me->lastcmd = time(NULL);	/* set lastcmd to now to prevent idle timer infanticide */
+		ContextList = me;
+		if (me->next != NULL) {
+			me->next->prev = me;
+		}
+		++num_sessions;
+	}
+	end_critical_section(S_SESSION_TABLE);
+	return (me);
+}
+
+
+/*
+ * Return an array containing a copy of the context list.
+ * This allows worker threads to perform "for each context" operations without
+ * having to lock and traverse the live list.
+ */
 CitContext *CtdlGetContextArray(int *count)
 {
 	int nContexts, i;
@@ -387,11 +454,14 @@ CitContext *CtdlGetContextArray(int *count)
 	
 	nContexts = num_sessions;
 	nptr = malloc(sizeof(CitContext) * nContexts);
-	if (!nptr)
+	if (!nptr) {
+		*count = 0;
 		return NULL;
+	}
 	begin_critical_section(S_SESSION_TABLE);
-	for (cptr = ContextList, i=0; cptr != NULL && i < nContexts; cptr = cptr->next, i++)
+	for (cptr = ContextList, i=0; cptr != NULL && i < nContexts; cptr = cptr->next, i++) {
 		memcpy(&nptr[i], cptr, sizeof (CitContext));
+	}
 	end_critical_section (S_SESSION_TABLE);
 	
 	*count = i;
@@ -400,35 +470,133 @@ CitContext *CtdlGetContextArray(int *count)
 
 
 
-/**
+/*
+ * Back-end function for starting a session
+ */
+void begin_session(CitContext *con)
+{
+	/* 
+	 * Initialize some variables specific to our context.
+	 */
+	con->logged_in = 0;
+	con->internal_pgm = 0;
+	con->download_fp = NULL;
+	con->upload_fp = NULL;
+	con->cached_msglist = NULL;
+	con->cached_num_msgs = 0;
+	con->FirstExpressMessage = NULL;
+	time(&con->lastcmd);
+	time(&con->lastidle);
+	strcpy(con->lastcmdname, "    ");
+	strcpy(con->cs_clientname, "(unknown)");
+	strcpy(con->curr_user, NLI);
+	*con->fake_username = '\0';
+	*con->fake_hostname = '\0';
+	*con->fake_roomname = '\0';
+	*con->cs_clientinfo = '\0';
+	safestrncpy(con->cs_host, CtdlGetConfigStr("c_fqdn"), sizeof con->cs_host);
+	safestrncpy(con->cs_addr, "", sizeof con->cs_addr);
+	con->cs_UDSclientUID = -1;
+	con->cs_host[sizeof con->cs_host - 1] = 0;
+	if (!CC->is_local_socket) {
+		locate_host(con->cs_host, sizeof con->cs_host,
+			con->cs_addr, sizeof con->cs_addr,
+			con->client_socket
+		);
+	}
+	else {
+		con->cs_host[0] = 0;
+		con->cs_addr[0] = 0;
+#ifdef HAVE_STRUCT_UCRED
+		{
+			/* as http://www.wsinnovations.com/softeng/articles/uds.html told us... */
+			struct ucred credentials;
+			socklen_t ucred_length = sizeof(struct ucred);
+			
+			/*fill in the user data structure */
+			if(getsockopt(con->client_socket, SOL_SOCKET, SO_PEERCRED, &credentials, &ucred_length)) {
+				syslog(LOG_ERR, "context: could obtain credentials from unix domain socket");
+				
+			}
+			else {		
+				/* the process ID of the process on the other side of the socket */
+				/* credentials.pid; */
+				
+				/* the effective UID of the process on the other side of the socket  */
+				con->cs_UDSclientUID = credentials.uid;
+				
+				/* the effective primary GID of the process on the other side of the socket */
+				/* credentials.gid; */
+				
+				/* To get supplemental groups, we will have to look them up in our account
+				   database, after a reverse lookup on the UID to get the account name.
+				   We can take this opportunity to check to see if this is a legit account.
+				*/
+				snprintf(con->cs_clientinfo, sizeof(con->cs_clientinfo),
+					 "PID: "F_PID_T"; UID: "F_UID_T"; GID: "F_XPID_T" ", 
+					 credentials.pid,
+					 credentials.uid,
+					 credentials.gid);
+			}
+		}
+#endif
+	}
+	con->cs_flags = 0;
+
+	con->nologin = 0;
+	if (((CtdlGetConfigInt("c_maxsessions") > 0)&&(num_sessions > CtdlGetConfigInt("c_maxsessions"))) || CtdlWantSingleUser()) {
+		con->nologin = 1;
+	}
+
+	if (!CC->is_local_socket) {
+		syslog(LOG_INFO, "context: session (%s) started from %s (%s)", con->ServiceName, con->cs_host, con->cs_addr);
+	}
+	else {
+		syslog(LOG_INFO, "context: session (%s) started via local socket with uid=%d", con->ServiceName, con->cs_UDSclientUID);
+	}
+
+	/* Run any session startup routines registered by loadable modules */
+	PerformSessionHooks(EVT_START);
+}
+
+
+/*
  * This function fills in a context and its user field correctly
  * Then creates/loads that user
  */
 void CtdlFillSystemContext(CitContext *context, char *name)
 {
-	char sysname[USERNAME_SIZE];
+	char sysname[SIZ];
+	long len;
 
 	memset(context, 0, sizeof(CitContext));
 	context->internal_pgm = 1;
 	context->cs_pid = 0;
 	strcpy (sysname, "SYS_");
 	strcat (sysname, name);
-	/* internal_create_user has the side effect of loading the user regardless of wether they
+	len = cutuserkey(sysname);
+	memcpy(context->curr_user, sysname, len + 1);
+	context->client_socket = (-1);
+	context->state = CON_SYS;
+	context->ServiceName = name;
+
+	/* internal_create_user has the side effect of loading the user regardless of whether they
 	 * already existed or needed to be created
 	 */
-	internal_create_user (sysname, &(context->user), -1) ;
+	internal_create_user(sysname, &(context->user), -1) ;
 	
 	/* Check to see if the system user needs upgrading */
 	if (context->user.usernum == 0)
 	{	/* old system user with number 0, upgrade it */
 		context->user.usernum = get_new_user_number();
-		CtdlLogPrintf(CTDL_DEBUG, "Upgrading system user \"%s\" from user number 0 to user number %d\n", context->user.fullname, context->user.usernum);
+		syslog(LOG_INFO, "context: upgrading system user \"%s\" from user number 0 to user number %ld", context->user.fullname, context->user.usernum);
 		/* add user to the database */
 		CtdlPutUser(&(context->user));
 		cdb_store(CDB_USERSBYNUMBER, &(context->user.usernum), sizeof(long), context->user.fullname, strlen(context->user.fullname)+1);
 	}
 }
 
+
 /*
  * Cleanup any contexts that are left lying around
  */
@@ -454,8 +622,8 @@ void context_cleanup(void)
 		/* Remove the session from the active list */
 		rem = ptr->next;
 		--num_sessions;
-		
-		CtdlLogPrintf(CTDL_DEBUG, "Purging session %d\n", ptr->cs_pid);
+
+		syslog(LOG_DEBUG, "context: context_cleanup() purging session %d", ptr->cs_pid);
 		RemoveContext(ptr);
 		free (ptr);
 		ptr = rem;
@@ -464,23 +632,6 @@ void context_cleanup(void)
 
 
 
-/*
- * Terminate another session.
- * (This could justifiably be moved out of sysdep.c because it
- * no longer does anything that is system-dependent.)
- */
-void kill_session(int session_to_kill) {
-	CitContext *ptr;
-
-	begin_critical_section(S_SESSION_TABLE);
-	for (ptr = ContextList; ptr != NULL; ptr = ptr->next) {
-		if (ptr->cs_pid == session_to_kill) {
-			ptr->kill_me = 1;
-		}
-	}
-	end_critical_section(S_SESSION_TABLE);
-}
-
 /*
  * Purge all sessions which have the 'kill_me' flag set.
  * This function has code to prevent it from running more than once every
@@ -490,7 +641,7 @@ void kill_session(int session_to_kill) {
  */
 void dead_session_purge(int force) {
 	CitContext *ptr, *ptr2;		/* general-purpose utility pointer */
-	CitContext *rem = NULL;	/* list of sessions to be destroyed */
+	CitContext *rem = NULL;		/* list of sessions to be destroyed */
 	
 	if (force == 0) {
 		if ( (time(NULL) - last_purge) < 5 ) {
@@ -532,7 +683,7 @@ void dead_session_purge(int force) {
 	 * is allocated privately on this thread's stack.
 	 */
 	while (rem != NULL) {
-		CtdlLogPrintf(CTDL_DEBUG, "Purging session %d\n", rem->cs_pid);
+		syslog(LOG_DEBUG, "context: dead_session_purge() purging session %d, reason=%d", rem->cs_pid, rem->kill_me);
 		RemoveContext(rem);
 		ptr = rem;
 		rem = rem->next;
@@ -549,7 +700,7 @@ void dead_session_purge(int force) {
  * function initializes it.
  */
 void InitializeMasterCC(void) {
-	memset(&masterCC, 0, sizeof( CitContext));
+	memset(&masterCC, 0, sizeof(struct CitContext));
 	masterCC.internal_pgm = 1;
 	masterCC.cs_pid = 0;
 }
@@ -557,12 +708,25 @@ void InitializeMasterCC(void) {
 
 
 
+
 /*
- * Bind a thread to a context.  (It's inline merely to speed things up.)
+ * Set the "async waiting" flag for a session, if applicable
  */
-INLINE void become_session(CitContext *which_con) {
-	citthread_setspecific(MyConKey, (void *)which_con );
+void set_async_waiting(struct CitContext *ccptr)
+{
+	syslog(LOG_DEBUG, "context: setting async_waiting flag for session %d", ccptr->cs_pid);
+	if (ccptr->is_async) {
+		ccptr->async_waiting++;
+		if (ccptr->state == CON_IDLE) {
+			ccptr->state = CON_READY;
+		}
+	}
 }
 
 
-
+CTDL_MODULE_INIT(session)
+{
+	if (!threading) {
+	}
+	return "session";
+}