X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fmodules%2Fexpire%2Fserv_expire.c;h=00466cf77c0274eccbbaa35f71e27c0585ec04fe;hb=8c47559cb5ae97ec0fa35660ee16fd61a9451c72;hp=66b46570d54153bd0b202af2b454ca053ceb2b94;hpb=84aa84fdd0a02f703c5e836f258e33f950c66355;p=citadel.git diff --git a/citadel/modules/expire/serv_expire.c b/citadel/modules/expire/serv_expire.c index 66b46570d..00466cf77 100644 --- a/citadel/modules/expire/serv_expire.c +++ b/citadel/modules/expire/serv_expire.c @@ -3,10 +3,25 @@ * * This module handles the expiry of old messages and the purging of old users. * - */ - - -/* + * You might also see this module affectionately referred to as the DAP (the Dreaded Auto-Purger). + * + * Copyright (c) 1988-2009 by citadel.org (Art Cancro, Wilifried Goesgens, and others) + * + * This program is free 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. + * + * 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. + * + * 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 + * + * * A brief technical discussion: * * Several of the purge operations found in this module operate in two @@ -22,6 +37,11 @@ * * When using Berkeley DB, there's another reason for the two-phase purge: we * don't want the entire thing being done as one huge transaction. + * + * You'll also notice that we build the in-memory list of records to be deleted + * sometimes with a linked list and sometimes with a hash table. There is no + * reason for this aside from the fact that the linked list ones were written + * before we had the hash table library available. */ @@ -49,6 +69,7 @@ #include #include #include +#include #include "citadel.h" #include "server.h" #include "citserver.h" @@ -60,9 +81,8 @@ #include "msgbase.h" #include "user_ops.h" #include "control.h" -#include "serv_network.h" -#include "tools.h" - +#include "serv_network.h" /* Needed for definition of UseTable */ +#include "threads.h" #include "ctdl_module.h" @@ -114,10 +134,11 @@ struct ValidRoom *ValidRoomList = NULL; struct ValidUser *ValidUserList = NULL; int messages_purged; int users_not_purged; - +char *users_corrupt_msg = NULL; +char *users_zero_msg = NULL; struct ctdlroomref *rr = NULL; - extern struct CitContext *ContextList; +int force_purge_now = 0; /* set to nonzero to force a run right now */ /* @@ -145,6 +166,10 @@ void GatherPurgeMessages(struct ctdlroom *qrbuf, void *data) { if (epbuf.expire_mode == EXPIRE_NEXTLEVEL) return; if (epbuf.expire_mode == EXPIRE_MANUAL) return; + /* Don't purge messages containing system configuration, dumbass. */ + if (!strcasecmp(qrbuf->QRname, SYSCONFIGROOM)) return; + + /* Ok, we got this far ... now let's see what's in the room */ cdbfr = cdb_fetch(CDB_MSGLISTS, &qrbuf->QRnumber, sizeof(long)); if (cdbfr != NULL) { @@ -160,6 +185,7 @@ void GatherPurgeMessages(struct ctdlroom *qrbuf, void *data) { return; } + /* If the room is set to expire by count, do that */ if (epbuf.expire_mode == EXPIRE_NUMMSGS) { if (num_msgs > epbuf.expire_value) { @@ -224,12 +250,12 @@ void DoPurgeMessages(FILE *purgelist) { void PurgeMessages(void) { FILE *purgelist; - lprintf(CTDL_DEBUG, "PurgeMessages() called\n"); + CtdlLogPrintf(CTDL_DEBUG, "PurgeMessages() called\n"); messages_purged = 0; purgelist = tmpfile(); if (purgelist == NULL) { - lprintf(CTDL_CRIT, "Can't create purgelist temp file: %s\n", + CtdlLogPrintf(CTDL_CRIT, "Can't create purgelist temp file: %s\n", strerror(errno)); return; } @@ -283,6 +309,7 @@ void DoPurgeRooms(struct ctdlroom *qrbuf, void *data) { if (qrbuf->QRflags & QR_PERMANENT) return; if (qrbuf->QRflags & QR_DIRECTORY) return; if (qrbuf->QRflags & QR_NETWORK) return; + if (qrbuf->QRflags2 & QR2_SYSTEM) return; if (!strcasecmp(qrbuf->QRname, SYSCONFIGROOM)) return; if (is_noneditable(qrbuf)) return; @@ -296,7 +323,7 @@ void DoPurgeRooms(struct ctdlroom *qrbuf, void *data) { age = time(NULL) - (qrbuf->QRmtime); purge_secs = (time_t)config.c_roompurge * (time_t)86400; if (purge_secs <= (time_t)0) return; - lprintf(CTDL_DEBUG, "<%s> is <%ld> seconds old\n", qrbuf->QRname, (long)age); + CtdlLogPrintf(CTDL_DEBUG, "<%s> is <%ld> seconds old\n", qrbuf->QRname, (long)age); if (age > purge_secs) do_purge = 1; } /* !QR_MAILBOX */ @@ -318,7 +345,7 @@ int PurgeRooms(void) { struct ValidUser *vuptr; char *transcript = NULL; - lprintf(CTDL_DEBUG, "PurgeRooms() called\n"); + CtdlLogPrintf(CTDL_DEBUG, "PurgeRooms() called\n"); /* Load up a table full of valid user numbers so we can delete @@ -355,7 +382,7 @@ int PurgeRooms(void) { if (num_rooms_purged > 0) aide_message(transcript, "Room Autopurger Message"); free(transcript); - lprintf(CTDL_DEBUG, "Purged %d rooms.\n", num_rooms_purged); + CtdlLogPrintf(CTDL_DEBUG, "Purged %d rooms.\n", num_rooms_purged); return(num_rooms_purged); } @@ -383,6 +410,7 @@ void do_uid_user_purge(struct ctdluser *us, void *data) { + /* * Back end function to check user accounts for expiration. */ @@ -402,17 +430,19 @@ void do_user_purge(struct ctdluser *us, void *data) { /* The default rule is to not purge. */ purge = 0; + + /* don't attempt to purge system users. */ + if (!strncmp(us->fullname, "SYS_", 4)) + goto skip_all_this; - /* If the user hasn't called in two months, his/her account + /* If the user hasn't called in two months and expiring of accounts is turned on, his/her account * has expired, so purge the record. */ - now = time(NULL); - if ((now - us->lastcall) > purge_time) purge = 1; - - /* If the user set his/her password to 'deleteme', he/she - * wishes to be deleted, so purge the record. - */ - if (!strcasecmp(us->password, "deleteme")) purge = 1; + if (config.c_userpurge > 0) + { + now = time(NULL); + if ((now - us->lastcall) > purge_time) purge = 1; + } /* If the record is marked as permanent, don't purge it. */ @@ -428,16 +458,63 @@ void do_user_purge(struct ctdluser *us, void *data) { */ if (us->axlevel == 0) purge = 1; + /* If the user set his/her password to 'deleteme', he/she + * wishes to be deleted, so purge the record. + * Moved this lower down so that aides and permanent users get purged if they ask to be. + */ + if (!strcasecmp(us->password, "deleteme")) purge = 1; + /* 0 calls is impossible. If there are 0 calls, it must * be a corrupted record, so purge it. + * Actually it is possible if an Aide created the user so now we check for less than 0 (DRW) */ - if (us->timescalled == 0) purge = 1; + if (us->timescalled < 0) purge = 1; - /* User number 0, as well as any negative user number, is + /* any negative user number, is * also impossible. */ - if (us->usernum < 1L) purge = 1; + if (us->usernum < 0L) purge = 1; + + /** Don't purge user 0. That user is there for the system */ + if (us->usernum == 0L) + { + /* FIXME: Temporary log message. Until we do unauth access with user 0 we should + * try to get rid of all user 0 occurences. Many will be remnants from old code so + * we will need to try and purge them from users data bases.Some will not have names but + * those with names should be purged. + */ + CtdlLogPrintf(CTDL_DEBUG, "Auto purger found a user 0 with name \"%s\"\n", us->fullname); + // purge = 0; + } + + /* If the user has no full name entry then we can't purge them + * since the actual purge can't find them. + * This shouldn't happen but does somehow. + */ + if (IsEmptyStr(us->fullname)) + { + purge = 0; + + if (us->usernum > 0L) + { + purge=0; + if (users_corrupt_msg == NULL) + { + users_corrupt_msg = malloc(SIZ); + strcpy(users_corrupt_msg, "The auto-purger found the following user numbers with no name.\n" + "The system has no way to purge user with no name and should not be able to\n" + "create them either.\n" + "This indicates corruption of the user DB or possibly a bug.\n" + "It may be a good idea to restore your DB from a backup.\n"); + } + + users_corrupt_msg=realloc(users_corrupt_msg, strlen(users_corrupt_msg)+30); + snprintf(&users_corrupt_msg[strlen(users_corrupt_msg)], 29, " %ld\n", us->usernum); + } + } +skip_all_this: + if (purge == 1) { pptr = (struct PurgeList *) malloc(sizeof(struct PurgeList)); pptr->next = UserPurgeList; @@ -457,18 +534,20 @@ int PurgeUsers(void) { int num_users_purged = 0; char *transcript = NULL; - lprintf(CTDL_DEBUG, "PurgeUsers() called\n"); + CtdlLogPrintf(CTDL_DEBUG, "PurgeUsers() called\n"); users_not_purged = 0; - if (config.c_auth_mode == 1) { - /* host auth mode */ - ForEachUser(do_uid_user_purge, NULL); - } - else { - /* native auth mode */ - if (config.c_userpurge > 0) { + switch(config.c_auth_mode) { + case AUTHMODE_NATIVE: ForEachUser(do_user_purge, NULL); - } + break; + case AUTHMODE_HOST: + ForEachUser(do_uid_user_purge, NULL); + break; + default: + CtdlLogPrintf(CTDL_DEBUG, "User purge for auth mode %d is not implemented.\n", + config.c_auth_mode); + break; } transcript = malloc(SIZ); @@ -503,7 +582,21 @@ int PurgeUsers(void) { if (num_users_purged > 0) aide_message(transcript, "User Purge Message"); free(transcript); - lprintf(CTDL_DEBUG, "Purged %d users.\n", num_users_purged); + if(users_corrupt_msg) + { + aide_message(users_corrupt_msg, "User Corruption Message"); + free (users_corrupt_msg); + users_corrupt_msg = NULL; + } + + if(users_zero_msg) + { + aide_message(users_zero_msg, "User Zero Message"); + free (users_zero_msg); + users_zero_msg = NULL; + } + + CtdlLogPrintf(CTDL_DEBUG, "Purged %d users.\n", num_users_purged); return(num_users_purged); } @@ -618,10 +711,15 @@ int PurgeUseTable(void) { struct UPurgeList *uptr; /* Phase 1: traverse through the table, discovering old records... */ - lprintf(CTDL_DEBUG, "Purge use table: phase 1\n"); + CtdlLogPrintf(CTDL_DEBUG, "Purge use table: phase 1\n"); cdb_rewind(CDB_USETABLE); while(cdbut = cdb_next_item(CDB_USETABLE), cdbut != NULL) { + /* + * TODODRW: change this to create a new function time_t cdb_get_timestamp( struct cdbdata *) + * this will release this file from the serv_network.h + * Maybe it could be a macro that extracts and casts the reult + */ memcpy(&ut, cdbut->ptr, ((cdbut->len > sizeof(struct UseTable)) ? sizeof(struct UseTable) : cdbut->len)); @@ -640,7 +738,7 @@ int PurgeUseTable(void) { } /* Phase 2: delete the records */ - lprintf(CTDL_DEBUG, "Purge use table: phase 2\n"); + CtdlLogPrintf(CTDL_DEBUG, "Purge use table: phase 2\n"); while (ul != NULL) { cdb_delete(CDB_USETABLE, ul->up_key, strlen(ul->up_key)); uptr = ul->next; @@ -648,7 +746,7 @@ int PurgeUseTable(void) { ul = uptr; } - lprintf(CTDL_DEBUG, "Purge use table: finished (purged %d records)\n", purged); + CtdlLogPrintf(CTDL_DEBUG, "Purge use table: finished (purged %d records)\n", purged); return(purged); } @@ -667,7 +765,7 @@ int PurgeEuidIndexTable(void) { struct CtdlMessage *msg = NULL; /* Phase 1: traverse through the table, discovering old records... */ - lprintf(CTDL_DEBUG, "Purge EUID index: phase 1\n"); + CtdlLogPrintf(CTDL_DEBUG, "Purge EUID index: phase 1\n"); cdb_rewind(CDB_EUIDINDEX); while(cdbei = cdb_next_item(CDB_EUIDINDEX), cdbei != NULL) { @@ -694,7 +792,7 @@ int PurgeEuidIndexTable(void) { } /* Phase 2: delete the records */ - lprintf(CTDL_DEBUG, "Purge euid index: phase 2\n"); + CtdlLogPrintf(CTDL_DEBUG, "Purge euid index: phase 2\n"); while (el != NULL) { cdb_delete(CDB_EUIDINDEX, el->ep_key, el->ep_keylen); free(el->ep_key); @@ -703,57 +801,160 @@ int PurgeEuidIndexTable(void) { el = eptr; } - lprintf(CTDL_DEBUG, "Purge euid index: finished (purged %d records)\n", purged); + CtdlLogPrintf(CTDL_DEBUG, "Purge euid index: finished (purged %d records)\n", purged); return(purged); } -void purge_databases(void) { - int retval; - static time_t last_purge = 0; - time_t now; - struct tm tm; - /* Do the auto-purge if the current hour equals the purge hour, - * but not if the operation has already been performed in the - * last twelve hours. This is usually enough granularity. - */ - now = time(NULL); - localtime_r(&now, &tm); - if (tm.tm_hour != config.c_purge_hour) return; - if ((now - last_purge) < 43200) return; +/* + * Purge OpenID assocations for missing users (theoretically this will never delete anything) + */ +int PurgeStaleOpenIDassociations(void) { + struct cdbdata *cdboi; + struct ctdluser usbuf; + HashList *keys = NULL; + HashPos *HashPos; + char *deleteme = NULL; + long len; + void *Value; + const char *Key; + int num_deleted = 0; + long usernum = 0L; + + keys = NewHash(1, NULL); + if (!keys) return(0); + + + cdb_rewind(CDB_OPENID); + while (cdboi = cdb_next_item(CDB_OPENID), cdboi != NULL) { + if (cdboi->len > sizeof(long)) { + memcpy(&usernum, cdboi->ptr, sizeof(long)); + if (getuserbynumber(&usbuf, usernum) != 0) { + deleteme = strdup(cdboi->ptr + sizeof(long)), + Put(keys, deleteme, strlen(deleteme), deleteme, generic_free_handler); + } + } + cdb_free(cdboi); + } - lprintf(CTDL_INFO, "Auto-purger: starting.\n"); + /* Go through the hash list, deleting keys we stored in it */ - retval = PurgeUsers(); - lprintf(CTDL_NOTICE, "Purged %d users.\n", retval); + HashPos = GetNewHashPos(keys, 0); + while (GetNextHashPos(keys, HashPos, &len, &Key, &Value)!=0) + { + CtdlLogPrintf(CTDL_DEBUG, "Deleting associated OpenID <%s>\n", Value); + cdb_delete(CDB_OPENID, Value, strlen(Value)); + /* note: don't free(Value) -- deleting the hash list will handle this for us */ + ++num_deleted; + } + DeleteHashPos(&HashPos); + DeleteHash(&keys); + return num_deleted; +} - PurgeMessages(); - lprintf(CTDL_NOTICE, "Expired %d messages.\n", messages_purged); - retval = PurgeRooms(); - lprintf(CTDL_NOTICE, "Expired %d rooms.\n", retval); - retval = PurgeVisits(); - lprintf(CTDL_NOTICE, "Purged %d visits.\n", retval); - retval = PurgeUseTable(); - lprintf(CTDL_NOTICE, "Purged %d entries from the use table.\n", retval); - retval = PurgeEuidIndexTable(); - lprintf(CTDL_NOTICE, "Purged %d entries from the EUID index.\n", retval); +void *purge_databases(void *args) +{ + int retval; + static time_t last_purge = 0; + time_t now; + struct tm tm; + struct CitContext purgerCC; + + CtdlLogPrintf(CTDL_DEBUG, "Auto-purger_thread() initializing\n"); + + CtdlFillSystemContext(&purgerCC, "purger"); + citthread_setspecific(MyConKey, (void *)&purgerCC ); + + while (!CtdlThreadCheckStop()) { + /* Do the auto-purge if the current hour equals the purge hour, + * but not if the operation has already been performed in the + * last twelve hours. This is usually enough granularity. + */ + now = time(NULL); + localtime_r(&now, &tm); + if ( + ((tm.tm_hour != config.c_purge_hour) || ((now - last_purge) < 43200)) + && (force_purge_now == 0) + ) { + CtdlThreadSleep(60); + continue; + } + + + CtdlLogPrintf(CTDL_INFO, "Auto-purger: starting.\n"); + + if (!CtdlThreadCheckStop()) + { + retval = PurgeUsers(); + CtdlLogPrintf(CTDL_NOTICE, "Purged %d users.\n", retval); + } + + if (!CtdlThreadCheckStop()) + { + PurgeMessages(); + CtdlLogPrintf(CTDL_NOTICE, "Expired %d messages.\n", messages_purged); + } - retval = TDAP_ProcessAdjRefCountQueue(); - lprintf(CTDL_NOTICE, "Processed %d message reference count adjustments.\n", retval); + if (!CtdlThreadCheckStop()) + { + retval = PurgeRooms(); + CtdlLogPrintf(CTDL_NOTICE, "Expired %d rooms.\n", retval); + } - lprintf(CTDL_INFO, "Auto-purger: finished.\n"); + if (!CtdlThreadCheckStop()) + { + retval = PurgeVisits(); + CtdlLogPrintf(CTDL_NOTICE, "Purged %d visits.\n", retval); + } - last_purge = now; /* So we don't do it again soon */ -} + if (!CtdlThreadCheckStop()) + { + retval = PurgeUseTable(); + CtdlLogPrintf(CTDL_NOTICE, "Purged %d entries from the use table.\n", retval); + } + if (!CtdlThreadCheckStop()) + { + retval = PurgeEuidIndexTable(); + CtdlLogPrintf(CTDL_NOTICE, "Purged %d entries from the EUID index.\n", retval); + } + + if (!CtdlThreadCheckStop()) + { + retval = PurgeStaleOpenIDassociations(); + CtdlLogPrintf(CTDL_NOTICE, "Purged %d stale OpenID associations.\n", retval); + } + + if (!CtdlThreadCheckStop()) + { + retval = TDAP_ProcessAdjRefCountQueue(); + CtdlLogPrintf(CTDL_NOTICE, "Processed %d message reference count adjustments.\n", retval); + } + + if (!CtdlThreadCheckStop()) + { + CtdlLogPrintf(CTDL_INFO, "Auto-purger: finished.\n"); + last_purge = now; /* So we don't do it again soon */ + force_purge_now = 0; + } + else + CtdlLogPrintf(CTDL_INFO, "Auto-purger: STOPPED.\n"); + + } + return NULL; +} /*****************************************************************************/ +/* The FSCK command has been removed because people were misusing it */ + +#if 0 + void do_fsck_msg(long msgnum, void *userdata) { struct ctdlroomref *ptr; @@ -832,16 +1033,29 @@ void cmd_fsck(char *argbuf) { } +#endif /* end of commented-out fsck cmd */ +/* + * Manually initiate a run of The Dreaded Auto-Purger (tm) + */ +void cmd_tdap(char *argbuf) { + if (CtdlAccessCheck(ac_aide)) return; + force_purge_now = 1; + cprintf("%d Manually initiating a purger run now.\n", CIT_OK); +} /*****************************************************************************/ CTDL_MODULE_INIT(expire) { - CtdlRegisterSessionHook(purge_databases, EVT_TIMER); - CtdlRegisterProtoHook(cmd_fsck, "FSCK", "Check message ref counts"); - + if (!threading) + { + /* CtdlRegisterProtoHook(cmd_fsck, "FSCK", "Check message ref counts"); */ + CtdlRegisterProtoHook(cmd_tdap, "TDAP", "Manually initiate auto-purger"); + } + else + CtdlThreadCreate("Auto Purger", CTDLTHREAD_BIGSTACK, purge_databases, NULL); /* return our Subversion id for the Log */ return "$Id$"; }