X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fcontext.c;h=0b433502e4fd4c9e234c4012eb643df2ea829d7f;hb=e26a8dee20d1726b4995821f717f867f50fc5659;hp=03638d2992e3b65ed32cb1ce73dbe003072caadf;hpb=0a73d05f8a5fc4d37c2c7ae9b16daba304e37c6e;p=citadel.git diff --git a/citadel/context.c b/citadel/context.c index 03638d299..0b433502e 100644 --- a/citadel/context.c +++ b/citadel/context.c @@ -1,12 +1,10 @@ /* - * $Id: sysdep.c 7989 2009-10-31 15:29:37Z davew $ - * * Citadel context management stuff. * Here's where we (hopefully) have all the code that manipulates contexts. * - * Copyright (c) 1987-2010 by the citadel.org team + * Copyright (c) 1987-2011 by the citadel.org team * - * This program is free software; you can redistribute it and/or modify + * This program is open source software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. @@ -18,7 +16,7 @@ * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "sysdep.h" @@ -88,7 +86,7 @@ -citthread_key_t MyConKey; /* TSD key for MyContext() */ +pthread_key_t MyConKey; /* TSD key for MyContext() */ CitContext masterCC; @@ -161,7 +159,7 @@ int CtdlTerminateOtherSession (int session_num) return TERM_NOTALLOWED; } - CtdlLogPrintf(CTDL_DEBUG, "Locating session to kill\n"); + 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) { @@ -169,7 +167,7 @@ int CtdlTerminateOtherSession (int session_num) if ((ccptr->user.usernum == CC->user.usernum) || (CC->user.axlevel >= AxAideU)) { ret |= TERM_ALLOWED; - ccptr->kill_me = 1; + ccptr->kill_me = KILLME_ADMIN_TERMINATE; } } } @@ -261,12 +259,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); } @@ -282,30 +276,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); + 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); + 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) + { + 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) { + syslog(LOG_INFO, "Flushed %d stuck sessions\n", killed); + } } @@ -315,12 +335,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) { + 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?"; + } + 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 @@ -329,13 +354,20 @@ 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_NOTICE, "[%3d] Session ended.", con->cs_pid); - /* 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_NOTICE, "Closing socket %d", con->client_socket); + close(con->client_socket); + } /* If using AUTHMODE_LDAP, free the DN */ if (con->ldap_dn) { @@ -344,10 +376,13 @@ void RemoveContext (CitContext *con) } 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, "Done with RemoveContext()"); +} @@ -363,12 +398,12 @@ CitContext *CreateNewContext(void) { me = (CitContext *) malloc(sizeof(CitContext)); if (me == NULL) { - CtdlLogPrintf(CTDL_ALERT, "citserver: can't allocate memory!!\n"); + 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 @@ -381,7 +416,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; @@ -396,6 +436,65 @@ 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; + static int next_pid = 0; + + me = (CitContext *) malloc(sizeof(CitContext)); + if (me == NULL) { + 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->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 @@ -439,6 +538,11 @@ void CtdlFillSystemContext(CitContext *context, char *name) 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 */ @@ -448,13 +552,14 @@ void CtdlFillSystemContext(CitContext *context, char *name) 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_DEBUG, "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 */ @@ -480,8 +585,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_cleanup(): purging session %d\n", ptr->cs_pid); RemoveContext(ptr); free (ptr); ptr = rem; @@ -490,23 +595,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 @@ -516,7 +604,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 ) { @@ -558,7 +646,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, "dead_session_purge(): purging session %d, reason=%d\n", rem->cs_pid, rem->kill_me); RemoveContext(rem); ptr = rem; rem = rem->next; @@ -575,7 +663,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; } @@ -589,7 +677,7 @@ void InitializeMasterCC(void) { */ void set_async_waiting(struct CitContext *ccptr) { - CtdlLogPrintf(CTDL_DEBUG, "Setting async_waiting flag for session %d\n", ccptr->cs_pid); + 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) {