citadel/euidindex.c

   1 /*
   2  * Index messages by EUID per room.
   3  */
   4
   5 #include "sysdep.h"
   6 #include <stdio.h>
   7 #include <libcitadel.h>
   8
   9 #include "citserver.h"
  10 #include "room_ops.h"
  11
  12 /*
  13  * The structure of an euidindex record *key* is:
  14  *
  15  * |----room_number----|----------EUID-------------|
  16  *    (sizeof long)       (actual length of euid)
  17  *
  18  *
  19  * The structure of an euidindex record *value* is:
  20  *
  21  * |-----msg_number----|----room_number----|----------EUID-------------|
  22  *    (sizeof long)       (sizeof long)       (actual length of euid)
  23  *
  24  */
  25
  26
  27
  28 /*
  29  * Return nonzero if the supplied room is one which should have
  30  * an EUID index.
  31  */
  32 int DoesThisRoomNeedEuidIndexing(struct ctdlroom *qrbuf) {
  33
  34         switch(qrbuf->QRdefaultview) {
  35                 case VIEW_BBS:          return(0);
  36                 case VIEW_MAILBOX:      return(0);
  37                 case VIEW_ADDRESSBOOK:  return(1);
  38                 case VIEW_DRAFTS:       return(0);
  39                 case VIEW_CALENDAR:     return(1);
  40                 case VIEW_TASKS:        return(1);
  41                 case VIEW_NOTES:        return(1);
  42                 case VIEW_WIKI:         return(1);
  43                 case VIEW_WIKIMD:       return(1);
  44                 case VIEW_BLOG:         return(1);
  45         }
  46
  47         return(0);
  48 }
  49
  50
  51
  52
  53
  54
  55 /*
  56  * Locate a message in a given room with a given euid, and return
  57  * its message number.
  58  */
  59 long locate_message_by_euid(char *euid, struct ctdlroom *qrbuf) {
  60         return CtdlLocateMessageByEuid (euid, qrbuf);
  61 }
  62
  63 long CtdlLocateMessageByEuid(char *euid, struct ctdlroom *qrbuf) {
  64         char *key;
  65         int key_len;
  66         struct cdbdata *cdb_euid;
  67         long msgnum = (-1L);
  68
  69         syslog(LOG_DEBUG, "Searching for EUID <%s> in <%s>\n", euid, qrbuf->QRname);
  70
  71         key_len = strlen(euid) + sizeof(long) + 1;
  72         key = malloc(key_len);
  73         memcpy(key, &qrbuf->QRnumber, sizeof(long));
  74         strcpy(&key[sizeof(long)], euid);
  75
  76         cdb_euid = cdb_fetch(CDB_EUIDINDEX, key, key_len);
  77         free(key);
  78
  79         if (cdb_euid == NULL) {
  80                 msgnum = (-1L);
  81         }
  82         else {
  83                 /* The first (sizeof long) of the record is what we're
  84                  * looking for.  Throw away the rest.
  85                  */
  86                 memcpy(&msgnum, cdb_euid->ptr, sizeof(long));
  87                 cdb_free(cdb_euid);
  88         }
  89         syslog(LOG_DEBUG, "returning msgnum = %ld\n", msgnum);
  90         return(msgnum);
  91 }
  92
  93
  94 /*
  95  * Store the euid index for a message, which has presumably just been
  96  * stored in this room by the caller.
  97  */
  98 void index_message_by_euid(char *euid, struct ctdlroom *qrbuf, long msgnum) {
  99         char *key;
 100         int key_len;
 101         char *data;
 102         int data_len;
 103
 104         syslog(LOG_DEBUG, "Indexing message #%ld <%s> in <%s>\n", msgnum, euid, qrbuf->QRname);
 105
 106         key_len = strlen(euid) + sizeof(long) + 1;
 107         key = malloc(key_len);
 108         memcpy(key, &qrbuf->QRnumber, sizeof(long));
 109         strcpy(&key[sizeof(long)], euid);
 110
 111         data_len = sizeof(long) + key_len;
 112         data = malloc(data_len);
 113
 114         memcpy(data, &msgnum, sizeof(long));
 115         memcpy(&data[sizeof(long)], key, key_len);
 116
 117         cdb_store(CDB_EUIDINDEX, key, key_len, data, data_len);
 118         free(key);
 119         free(data);
 120 }
 121
 122
 123
 124 /*
 125  * Called by rebuild_euid_index_for_room() to index one message.
 126  */
 127 void rebuild_euid_index_for_msg(long msgnum, void *userdata) {
 128         struct CtdlMessage *msg = NULL;
 129
 130         msg = CtdlFetchMessage(msgnum, 0);
 131         if (msg == NULL) return;
 132         if (!CM_IsEmpty(msg, eExclusiveID)) {
 133                 index_message_by_euid(msg->cm_fields[eExclusiveID], &CC->room, msgnum);
 134         }
 135         CM_Free(msg);
 136 }
 137
 138
 139 void rebuild_euid_index_for_room(struct ctdlroom *qrbuf, void *data) {
 140         static struct RoomProcList *rplist = NULL;
 141         struct RoomProcList *ptr;
 142         struct ctdlroom qr;
 143
 144         /* Lazy programming here.  Call this function as a CtdlForEachRoom backend
 145          * in order to queue up the room names, or call it with a null room
 146          * to make it do the processing.
 147          */
 148         if (qrbuf != NULL) {
 149                 ptr = (struct RoomProcList *)
 150                         malloc(sizeof (struct RoomProcList));
 151                 if (ptr == NULL) return;
 152
 153                 safestrncpy(ptr->name, qrbuf->QRname, sizeof ptr->name);
 154                 ptr->next = rplist;
 155                 rplist = ptr;
 156                 return;
 157         }
 158
 159         while (rplist != NULL) {
 160                 if (CtdlGetRoom(&qr, rplist->name) == 0) {
 161                         if (DoesThisRoomNeedEuidIndexing(&qr)) {
 162                                 syslog(LOG_DEBUG,
 163                                         "Rebuilding EUID index for <%s>\n",
 164                                         rplist->name);
 165                                 CtdlUserGoto(rplist->name, 0, 0, NULL, NULL, NULL, NULL);
 166                                 CtdlForEachMessage(MSGS_ALL, 0L, NULL, NULL, NULL,
 167                                         rebuild_euid_index_for_msg, NULL);
 168                         }
 169                 }
 170                 ptr = rplist;
 171                 rplist = rplist->next;
 172                 free(ptr);
 173         }
 174 }
 175
 176
 177 /*
 178  * Globally rebuild the EUID indices in every room.
 179  */
 180 void rebuild_euid_index(void) {
 181         cdb_trunc(CDB_EUIDINDEX);               /* delete the old indices */
 182         CtdlForEachRoom(rebuild_euid_index_for_room, NULL);     /* enumerate rm names */
 183         rebuild_euid_index_for_room(NULL, NULL);        /* and index them */
 184 }
 185
 186
 187
 188 /*
 189  * Server command to fetch a message number given an euid.
 190  */
 191 void cmd_euid(char *cmdbuf) {
 192         char euid[256];
 193         long msgnum;
 194         struct cdbdata *cdbfr;
 195         long *msglist = NULL;
 196         int num_msgs = 0;
 197         int i;
 198
 199         if (CtdlAccessCheck(ac_logged_in_or_guest)) return;
 200
 201         extract_token(euid, cmdbuf, 0, '|', sizeof euid);
 202         msgnum = CtdlLocateMessageByEuid(euid, &CC->room);
 203         if (msgnum <= 0L) {
 204                 cprintf("%d not found\n", ERROR + MESSAGE_NOT_FOUND);
 205                 return;
 206         }
 207
 208         cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
 209         if (cdbfr != NULL) {
 210                 num_msgs = cdbfr->len / sizeof(long);
 211                 msglist = (long *) cdbfr->ptr;
 212                 for (i = 0; i < num_msgs; ++i) {
 213                         if (msglist[i] == msgnum) {
 214                                 cdb_free(cdbfr);
 215                                 cprintf("%d %ld\n", CIT_OK, msgnum);
 216                                 return;
 217                         }
 218                 }
 219                 cdb_free(cdbfr);
 220         }
 221
 222         cprintf("%d not found\n", ERROR + MESSAGE_NOT_FOUND);
 223 }
 224
 225 CTDL_MODULE_INIT(euidindex)
 226 {
 227         if (!threading) {
 228                 CtdlRegisterProtoHook(cmd_euid, "EUID", "Perform operations on Extended IDs for messages");
 229         }
 230         /* return our Subversion id for the Log */
 231         return "euidindex";
 232 }