X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fmodules%2Fexpire%2Fserv_expire.c;h=00466cf77c0274eccbbaa35f71e27c0585ec04fe;hb=8c47559cb5ae97ec0fa35660ee16fd61a9451c72;hp=96569d7a1d1f4b524a455954c1372b013e29a190;hpb=291821350831b9569546232b24bc75e3c5b34c85;p=citadel.git diff --git a/citadel/modules/expire/serv_expire.c b/citadel/modules/expire/serv_expire.c index 96569d7a1..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. */ @@ -61,7 +81,7 @@ #include "msgbase.h" #include "user_ops.h" #include "control.h" -#include "serv_network.h" /* Needed for defenition of UseTable */ +#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,6 +430,10 @@ 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 and expiring of accounts is turned on, his/her account * has expired, so purge the record. @@ -434,14 +466,55 @@ void do_user_purge(struct ctdluser *us, void *data) { /* 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; @@ -461,7 +534,7 @@ 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; switch(config.c_auth_mode) { @@ -472,7 +545,8 @@ int PurgeUsers(void) { ForEachUser(do_uid_user_purge, NULL); break; default: - lprintf(CTDL_DEBUG, "Unknown authentication mode!\n"); + CtdlLogPrintf(CTDL_DEBUG, "User purge for auth mode %d is not implemented.\n", + config.c_auth_mode); break; } @@ -508,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); } @@ -623,7 +711,7 @@ 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) { @@ -650,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; @@ -658,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); } @@ -677,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) { @@ -704,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); @@ -713,17 +801,74 @@ 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); } + +/* + * 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); + } + + /* Go through the hash list, deleting keys we stored in it */ + + 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; +} + + + + + 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, @@ -732,63 +877,73 @@ void *purge_databases(void *args) */ now = time(NULL); localtime_r(&now, &tm); - if ((tm.tm_hour != config.c_purge_hour) || ((now - last_purge) < 43200)) { + if ( + ((tm.tm_hour != config.c_purge_hour) || ((now - last_purge) < 43200)) + && (force_purge_now == 0) + ) { CtdlThreadSleep(60); continue; } - lprintf(CTDL_INFO, "Auto-purger: starting.\n"); + CtdlLogPrintf(CTDL_INFO, "Auto-purger: starting.\n"); if (!CtdlThreadCheckStop()) { retval = PurgeUsers(); - lprintf(CTDL_NOTICE, "Purged %d users.\n", retval); + CtdlLogPrintf(CTDL_NOTICE, "Purged %d users.\n", retval); } if (!CtdlThreadCheckStop()) { PurgeMessages(); - lprintf(CTDL_NOTICE, "Expired %d messages.\n", messages_purged); + CtdlLogPrintf(CTDL_NOTICE, "Expired %d messages.\n", messages_purged); } if (!CtdlThreadCheckStop()) { retval = PurgeRooms(); - lprintf(CTDL_NOTICE, "Expired %d rooms.\n", retval); + CtdlLogPrintf(CTDL_NOTICE, "Expired %d rooms.\n", retval); } if (!CtdlThreadCheckStop()) { retval = PurgeVisits(); - lprintf(CTDL_NOTICE, "Purged %d visits.\n", retval); + CtdlLogPrintf(CTDL_NOTICE, "Purged %d visits.\n", retval); } if (!CtdlThreadCheckStop()) { retval = PurgeUseTable(); - lprintf(CTDL_NOTICE, "Purged %d entries from the use table.\n", retval); + CtdlLogPrintf(CTDL_NOTICE, "Purged %d entries from the use table.\n", retval); } if (!CtdlThreadCheckStop()) { retval = PurgeEuidIndexTable(); - lprintf(CTDL_NOTICE, "Purged %d entries from the EUID index.\n", retval); + 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(); - lprintf(CTDL_NOTICE, "Processed %d message reference count adjustments.\n", retval); + CtdlLogPrintf(CTDL_NOTICE, "Processed %d message reference count adjustments.\n", retval); } if (!CtdlThreadCheckStop()) { - lprintf(CTDL_INFO, "Auto-purger: finished.\n"); + CtdlLogPrintf(CTDL_INFO, "Auto-purger: finished.\n"); last_purge = now; /* So we don't do it again soon */ + force_purge_now = 0; } else - lprintf(CTDL_INFO, "Auto-purger: STOPPED.\n"); + CtdlLogPrintf(CTDL_INFO, "Auto-purger: STOPPED.\n"); } return NULL; @@ -796,6 +951,10 @@ void *purge_databases(void *args) /*****************************************************************************/ +/* The FSCK command has been removed because people were misusing it */ + +#if 0 + void do_fsck_msg(long msgnum, void *userdata) { struct ctdlroomref *ptr; @@ -874,7 +1033,16 @@ 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); +} /*****************************************************************************/ @@ -883,7 +1051,8 @@ CTDL_MODULE_INIT(expire) { if (!threading) { - CtdlRegisterProtoHook(cmd_fsck, "FSCK", "Check message ref counts"); + /* 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);