X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fcontext.c;h=86bf5c0d9a199b67cd2617158243fc048d226e44;hb=cbefcb9d9b85519fd1b098f622255ea318e78fd7;hp=c678829149b0179a51be598c7a5151ebe7c73005;hpb=390901bcc3d171cc42fe259d8a8e55687efbdf4f;p=citadel.git diff --git a/citadel/context.c b/citadel/context.c index c67882914..86bf5c0d9 100644 --- a/citadel/context.c +++ b/citadel/context.c @@ -1,11 +1,16 @@ /* - * $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-2011 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" @@ -21,6 +26,9 @@ #include #include #include +/* +#include +*/ #if TIME_WITH_SYS_TIME # include @@ -61,18 +69,14 @@ #include #endif -#ifndef HAVE_SNPRINTF -#include "snprintf.h" -#endif - #include "ctdl_module.h" #include "threads.h" #include "user_ops.h" #include "control.h" +int DebugSession = 0; - -citthread_key_t MyConKey; /* TSD key for MyContext() */ +pthread_key_t MyConKey; /* TSD key for MyContext() */ CitContext masterCC; @@ -80,6 +84,7 @@ 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; @@ -129,6 +134,60 @@ int CtdlIsSingleUser(void) + +/* + * Locate a context by its session number and terminate it if the user is able. + * User can NOT terminate their current session. + * User CAN terminate any other session that has them logged in. + * Aide CAN terminate any session except the current one. + */ +int CtdlTerminateOtherSession (int session_num) +{ + struct CitContext *CCC = CC; + int ret = 0; + CitContext *ccptr; + int aide; + + if (session_num == CCC->cs_pid) return TERM_NOTALLOWED; + + aide = ( (CCC->user.axlevel >= AxAideU) || (CCC->internal_pgm) ) ; + + CONM_syslog(LOG_DEBUG, "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) { + ret |= TERM_FOUND; + if ((ccptr->user.usernum == CCC->user.usernum) || aide) { + ret |= TERM_ALLOWED; + } + break; + } + } + + if (((ret & TERM_FOUND) != 0) && ((ret & TERM_ALLOWED) != 0)) + { + if (ccptr->IO != NULL) { + AsyncIO *IO = ccptr->IO; + end_critical_section(S_SESSION_TABLE); + KillAsyncIOContext(IO); + } + else + { + 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; +} + + + /* * Check to see if the user who we just sent mail to is logged in. If yes, * bump the 'new mail' counter for their session. That enables them to @@ -211,12 +270,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); } @@ -232,30 +287,56 @@ 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) + && (config.c_sleeping > 0) + && (now - (ccptr->lastcmd) > config.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) - CtdlLogPrintf(CTDL_INFO, "Terminated %d idle sessions\n", killed); + CON_syslog(LOG_INFO, "Scheduled %d idle sessions for termination\n", killed); if (longrunners > 0) - CtdlLogPrintf(CTDL_INFO, "Didn't terminate %d protected idle sessions;\n", killed); + CON_syslog(LOG_INFO, "Didn't 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) + { + CON_syslog(LOG_INFO, "terminate_all_sessions() is murdering %s", ccptr->curr_user); + close(ccptr->client_socket); + ccptr->client_socket = -1; + killed++; + } + } + end_critical_section(S_SESSION_TABLE); + if (killed > 0) { + CON_syslog(LOG_INFO, "Flushed %d stuck sessions\n", killed); + } } @@ -265,12 +346,17 @@ 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) { + CONM_syslog(LOG_ERR, "WARNING: RemoveContext() called with NULL!"); return; } - CtdlLogPrintf(CTDL_DEBUG, "RemoveContext() session %d\n", con->cs_pid); + c = con->ServiceName; + if (c == NULL) { + c = "WTF?"; + } + CON_syslog(LOG_DEBUG, "RemoveContext(%s) session %d", c, con->cs_pid); +/// cit_backtrace(); /* Run any cleanup routines registered by loadable modules. * Note: We have to "become_session()" because the cleanup functions @@ -279,26 +365,38 @@ 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); + CON_syslog(LOG_NOTICE, "[%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) + { + CON_syslog(LOG_NOTICE, "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->RecvBuf.Buf); + if (con->cached_msglist) { + free(con->cached_msglist); + } - CtdlLogPrintf(CTDL_DEBUG, "Done with RemoveContext()\n"); + CONM_syslog(LOG_DEBUG, "Done with RemoveContext()"); } - /* * 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 @@ -307,16 +405,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"); + CONM_syslog(LOG_ALERT, "citserver: can't allocate memory!!\n"); 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 @@ -328,6 +425,13 @@ CitContext *CreateNewContext(void) { * Generate a unique session number and insert this context into * the list. */ + me->MigrateBuf = 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; @@ -342,6 +446,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) { + CONM_syslog(LOG_ALERT, "citserver: can't allocate memory!!\n"); + 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; @@ -349,11 +519,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; @@ -362,35 +535,43 @@ CitContext *CtdlGetContextArray(int *count) -/** +/* * 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); + 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 wether they * already existed or needed to be created */ - internal_create_user (sysname, &(context->user), -1) ; + internal_create_user (sysname, len, &(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); + CON_syslog(LOG_INFO, "Upgrading system user \"%s\" from user number 0 to user number %ld\n", 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 */ @@ -416,8 +597,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); + + CON_syslog(LOG_DEBUG, "context_cleanup(): purging session %d\n", ptr->cs_pid); RemoveContext(ptr); free (ptr); ptr = rem; @@ -426,23 +607,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 @@ -452,7 +616,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 ) { @@ -494,7 +658,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); + CON_syslog(LOG_DEBUG, "dead_session_purge(): purging session %d, reason=%d\n", rem->cs_pid, rem->kill_me); RemoveContext(rem); ptr = rem; rem = rem->next; @@ -511,7 +675,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; } @@ -519,12 +683,30 @@ 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) +{ + CON_syslog(LOG_DEBUG, "Setting async_waiting flag for session %d\n", ccptr->cs_pid); + if (ccptr->is_async) { + ccptr->async_waiting++; + if (ccptr->state == CON_IDLE) { + ccptr->state = CON_READY; + } + } } - +void DebugSessionEnable(const int n) +{ + DebugSession = n; +} +CTDL_MODULE_INIT(session) +{ + if (!threading) { + CtdlRegisterDebugFlagHook(HKEY("session"), DebugSessionEnable, &DebugSession); + } + return "session"; +}