X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fmodules%2Fexpire%2Fserv_expire.c;h=ac1a6f8aadf44af7bd38c17f4d34f252c51b2b10;hb=74b50d8c01f53fdd201f262fa14c59b116fbbb73;hp=b494d9755495cd513c6ca5856464cd9f2a0a6047;hpb=a2fda4eafb51bbf58c04471522aa2d0f116c797e;p=citadel.git diff --git a/citadel/modules/expire/serv_expire.c b/citadel/modules/expire/serv_expire.c index b494d9755..ac1a6f8aa 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. */ @@ -55,14 +75,14 @@ #include "citserver.h" #include "support.h" #include "config.h" -#include "room_ops.h" #include "policy.h" #include "database.h" #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 "context.h" #include "ctdl_module.h" @@ -115,10 +135,9 @@ 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 */ /* @@ -146,6 +165,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) { @@ -161,6 +184,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) { @@ -235,7 +259,7 @@ void PurgeMessages(void) { return; } - ForEachRoom(GatherPurgeMessages, (void *)purgelist ); + CtdlForEachRoom(GatherPurgeMessages, (void *)purgelist ); DoPurgeMessages(purgelist); fclose(purgelist); } @@ -284,8 +308,9 @@ 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; + if (CtdlIsNonEditable(qrbuf)) return; /* If we don't know the modification date, be safe and don't purge */ if (qrbuf->QRmtime <= (time_t)0) return; @@ -327,7 +352,7 @@ int PurgeRooms(void) { ForEachUser(AddValidUser, NULL); /* Then cycle through the room file */ - ForEachRoom(DoPurgeRooms, NULL); + CtdlForEachRoom(DoPurgeRooms, NULL); /* Free the valid user list */ while (ValidUserList != NULL) { @@ -341,11 +366,11 @@ int PurgeRooms(void) { strcpy(transcript, "The following rooms have been auto-purged:\n"); while (RoomPurgeList != NULL) { - if (getroom(&qrbuf, RoomPurgeList->name) == 0) { + if (CtdlGetRoom(&qrbuf, RoomPurgeList->name) == 0) { transcript=realloc(transcript, strlen(transcript)+SIZ); snprintf(&transcript[strlen(transcript)], SIZ, " %s\n", qrbuf.QRname); - delete_room(&qrbuf); + CtdlDeleteRoom(&qrbuf); } pptr = RoomPurgeList->next; free(RoomPurgeList); @@ -353,7 +378,7 @@ int PurgeRooms(void) { ++num_rooms_purged; } - if (num_rooms_purged > 0) aide_message(transcript, "Room Autopurger Message"); + if (num_rooms_purged > 0) CtdlAideMessage(transcript, "Room Autopurger Message"); free(transcript); CtdlLogPrintf(CTDL_DEBUG, "Purged %d rooms.\n", num_rooms_purged); @@ -404,6 +429,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. @@ -440,33 +469,51 @@ 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 < 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. - * 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 (users_corrupt_msg == NULL) + purge = 0; + + if (us->usernum > 0L) { - users_corrupt_msg = malloc(SIZ); - strcpy(users_corrupt_msg, "The auto-purger found the following user numbers with no name.\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"); - } + 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)+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); + } } - +skip_all_this: + if (purge == 1) { pptr = (struct PurgeList *) malloc(sizeof(struct PurgeList)); pptr->next = UserPurgeList; @@ -497,7 +544,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; } @@ -530,16 +578,22 @@ int PurgeUsers(void) { } } - if (num_users_purged > 0) aide_message(transcript, "User Purge Message"); + if (num_users_purged > 0) CtdlAideMessage(transcript, "User Purge Message"); free(transcript); if(users_corrupt_msg) { - aide_message(users_corrupt_msg, "User Corruption Message"); + CtdlAideMessage(users_corrupt_msg, "User Corruption Message"); free (users_corrupt_msg); users_corrupt_msg = NULL; } + if(users_zero_msg) + { + CtdlAideMessage(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); @@ -571,7 +625,7 @@ int PurgeVisits(void) { int RoomIsValid, UserIsValid; /* First, load up a table full of valid room/gen combinations */ - ForEachRoom(AddValidRoom, NULL); + CtdlForEachRoom(AddValidRoom, NULL); /* Then load up a table full of valid user numbers */ ForEachUser(AddValidUser, NULL); @@ -751,6 +805,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 (CtdlGetUserByNumber(&usbuf, usernum) != 0) { + deleteme = strdup(cdboi->ptr + sizeof(long)), + Put(keys, deleteme, strlen(deleteme), deleteme, NULL); + } + } + 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; @@ -761,10 +866,8 @@ void *purge_databases(void *args) CtdlLogPrintf(CTDL_DEBUG, "Auto-purger_thread() initializing\n"); - memset(&purgerCC, 0, sizeof(struct CitContext)); - purgerCC.internal_pgm = 1; - purgerCC.cs_pid = 0; - pthread_setspecific(MyConKey, (void *)&purgerCC ); + CtdlFillSystemContext(&purgerCC, "purger"); + citthread_setspecific(MyConKey, (void *)&purgerCC ); while (!CtdlThreadCheckStop()) { /* Do the auto-purge if the current hour equals the purge hour, @@ -773,7 +876,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; } @@ -817,6 +923,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(); @@ -827,6 +939,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"); @@ -837,6 +950,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; @@ -848,7 +965,7 @@ void do_fsck_msg(long msgnum, void *userdata) { void do_fsck_room(struct ctdlroom *qrbuf, void *data) { - getroom(&CC->room, qrbuf->QRname); + CtdlGetRoom(&CC->room, qrbuf->QRname); CtdlForEachMessage(MSGS_ALL, 0L, NULL, NULL, NULL, do_fsck_msg, NULL); } @@ -874,7 +991,7 @@ void cmd_fsck(char *argbuf) { cprintf("\nThis could take a while. Please be patient!\n\n"); cprintf("Gathering pointers...\n"); - ForEachRoom(do_fsck_room, NULL); + CtdlForEachRoom(do_fsck_room, NULL); get_control(); cprintf("Checking message base...\n"); @@ -915,7 +1032,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); +} /*****************************************************************************/ @@ -924,7 +1050,11 @@ 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"); + + CtdlRegisterProtoHook(cmd_gpex, "GPEX", "Autoconverted. TODO: document me."); + CtdlRegisterProtoHook(cmd_spex, "SPEX", "Autoconverted. TODO: document me."); } else CtdlThreadCreate("Auto Purger", CTDLTHREAD_BIGSTACK, purge_databases, NULL);