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