X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fmodules%2Fexpire%2Fserv_expire.c;h=00466cf77c0274eccbbaa35f71e27c0585ec04fe;hb=8c47559cb5ae97ec0fa35660ee16fd61a9451c72;hp=ea852dd49dd135b016e33d98f29020c09bf78a2f;hpb=e739cb7572012e2a0a9b820757f4e2adf7b37a63;p=citadel.git diff --git a/citadel/modules/expire/serv_expire.c b/citadel/modules/expire/serv_expire.c index ea852dd49..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" @@ -116,10 +136,9 @@ 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 */ /* @@ -147,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) { @@ -162,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) { @@ -285,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; @@ -405,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. @@ -441,21 +470,31 @@ void do_user_purge(struct ctdluser *us, void *data) { */ 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 < 0L) purge = 1; /** Don't purge user 0. That user is there for the system */ - if (us->usernum == 0) purge = 0; + 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. - * So we make an Aide message to alert to it but don't add it to the purge list */ if (IsEmptyStr(us->fullname)) { + purge = 0; + if (us->usernum > 0L) { purge=0; @@ -463,43 +502,19 @@ void do_user_purge(struct ctdluser *us, void *data) { { users_corrupt_msg = malloc(SIZ); strcpy(users_corrupt_msg, "The auto-purger found the following user numbers with no name.\n" - "If the user number is 0 you should report this to the Citadel development\n" - "team either by a bugzilla report at http://bugzilla.citadel.org or\n" - "posting a message in the Citadel Support room on Uncensored at\n" - "https://uncensored.citadel.org You should make it clear that you have seen a\n" - "user 0 messages in the Aide room which means a module has not named its\n" - "private context.\n" - "Unfortunately the auto-purger is not yet able to fix this problem.\n" - "This problem is not considered serious since a user with no name can\n" - "not log in.\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)+SIZ); - snprintf(&users_corrupt_msg[strlen(users_corrupt_msg)], SIZ, " %ld\n", us->usernum); + 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); } - else if (us->usernum == 0L) - { - purge=0; - if (users_zero_msg == NULL) - { - users_zero_msg = malloc(SIZ); - strcpy(users_zero_msg, "The auto-purger found a user with a user number of 0 but no name.\n" - "This is the result of a bug where a private contaxt has been created but\n" - "not named.\n\n" - "Please report this to the Citadel development team either by a bugzilla\n" - "report at http://bugzilla.citadel.org or by posting a message in the\n" - "Citadel Support room on Uncensored at https://uncensored.citadel.org\n" - "You should make it clear that you have seen a user 0 messages in the\n" - "Aide room which means a module has not named its private context.\n\n" - "This problem is not considered serious since it does not constitute a\n" - "security risk and should not impare system operation.\n" - ); - } - } - } - +skip_all_this: + if (purge == 1) { pptr = (struct PurgeList *) malloc(sizeof(struct PurgeList)); pptr->next = UserPurgeList; @@ -530,7 +545,8 @@ int PurgeUsers(void) { ForEachUser(do_uid_user_purge, NULL); break; default: - CtdlLogPrintf(CTDL_DEBUG, "Unknown authentication mode!\n"); + CtdlLogPrintf(CTDL_DEBUG, "User purge for auth mode %d is not implemented.\n", + config.c_auth_mode); break; } @@ -790,6 +806,57 @@ int PurgeEuidIndexTable(void) { } + +/* + * 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; @@ -800,7 +867,7 @@ void *purge_databases(void *args) CtdlLogPrintf(CTDL_DEBUG, "Auto-purger_thread() initializing\n"); - CtdlFillPrivateContext(&purgerCC, "purger"); + CtdlFillSystemContext(&purgerCC, "purger"); citthread_setspecific(MyConKey, (void *)&purgerCC ); while (!CtdlThreadCheckStop()) { @@ -810,7 +877,10 @@ 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; } @@ -854,6 +924,12 @@ void *purge_databases(void *args) 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(); @@ -864,6 +940,7 @@ void *purge_databases(void *args) { 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"); @@ -874,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; @@ -952,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); +} /*****************************************************************************/ @@ -961,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);