MESSAGES: store 1 & 2 field to db - it has to be permanent.
[citadel] / citadel / msgbase.c
1 /*
2  * Implements the message store.
3  *
4  * Copyright (c) 1987-2012 by the citadel.org team
5  *
6  * This program is open source software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 3.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  */
14
15 #include "sysdep.h"
16 #include <stdlib.h>
17 #include <unistd.h>
18 #include <stdio.h>
19 #include <fcntl.h>
20
21 #if TIME_WITH_SYS_TIME
22 # include <sys/time.h>
23 # include <time.h>
24 #else
25 # if HAVE_SYS_TIME_H
26 #  include <sys/time.h>
27 # else
28 #  include <time.h>
29 # endif
30 #endif
31
32
33 #include <ctype.h>
34 #include <string.h>
35 #include <limits.h>
36 #include <errno.h>
37 #include <stdarg.h>
38 #include <sys/stat.h>
39 #include <sys/types.h>
40 #include <regex.h>
41
42 #include "md5.h"
43
44 #include <libcitadel.h>
45 #include "citadel.h"
46 #include "server.h"
47 #include "serv_extensions.h"
48 #include "database.h"
49 #include "msgbase.h"
50 #include "support.h"
51 #include "sysdep_decls.h"
52 #include "citserver.h"
53 #include "room_ops.h"
54 #include "user_ops.h"
55 #include "file_ops.h"
56 #include "config.h"
57 #include "control.h"
58 #include "genstamp.h"
59 #include "internet_addressing.h"
60 #include "euidindex.h"
61 #include "journaling.h"
62 #include "citadel_dirs.h"
63 #include "clientsocket.h"
64 #include "threads.h"
65
66 #include "ctdl_module.h"
67
68 long config_msgnum;
69 struct addresses_to_be_filed *atbf = NULL;
70
71 /* This temp file holds the queue of operations for AdjRefCount() */
72 static FILE *arcfp = NULL;
73 void AdjRefCountList(long *msgnum, long nmsg, int incr);
74
75 int MessageDebugEnabled = 0;
76
77 /*
78  * These are the four-character field headers we use when outputting
79  * messages in Citadel format (as opposed to RFC822 format).
80  */
81 char *msgkeys[] = {
82         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 
83         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 
84         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 
85         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 
86         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 
87         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 
88         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 
89         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 
90         NULL, 
91         "from", /* A */
92         NULL,   /* B */
93         NULL,   /* C */
94         NULL,   /* D */
95         "exti", /* E */
96         "rfca", /* F */
97         NULL,   /* G */
98         "hnod", /* H */
99         "msgn", /* I */
100         "jrnl", /* J */
101         "rep2", /* K */
102         "list", /* L */
103         "text", /* M */
104         "node", /* N */
105         "room", /* O */
106         "path", /* P */
107         NULL,   /* Q */
108         "rcpt", /* R */
109         "spec", /* S */
110         "time", /* T */
111         "subj", /* U */
112         "nvto", /* V */
113         "wefw", /* W */
114         NULL,   /* X */
115         "cccc", /* Y */
116         NULL    /* Z */
117 };
118
119 void CtdlMsgSetCM_Fields(struct CtdlMessage *Msg, const char which, const char *buf, long length)
120 {
121         if (Msg->cm_fields[which] != NULL)
122                 free (Msg->cm_fields[which]);
123         Msg->cm_fields[which] = malloc(length + 1);
124         memcpy(Msg->cm_fields[which], buf, length);
125         Msg->cm_fields[which][length] = '\0';
126 }
127
128 /*
129  * This function is self explanatory.
130  * (What can I say, I'm in a weird mood today...)
131  */
132 void remove_any_whitespace_to_the_left_or_right_of_at_symbol(char *name)
133 {
134         int i;
135
136         for (i = 0; i < strlen(name); ++i) {
137                 if (name[i] == '@') {
138                         while (isspace(name[i - 1]) && i > 0) {
139                                 strcpy(&name[i - 1], &name[i]);
140                                 --i;
141                         }
142                         while (isspace(name[i + 1])) {
143                                 strcpy(&name[i + 1], &name[i + 2]);
144                         }
145                 }
146         }
147 }
148
149
150 /*
151  * Aliasing for network mail.
152  * (Error messages have been commented out, because this is a server.)
153  */
154 int alias(char *name)
155 {                               /* process alias and routing info for mail */
156         struct CitContext *CCC = CC;
157         FILE *fp;
158         int a, i;
159         char aaa[SIZ], bbb[SIZ];
160         char *ignetcfg = NULL;
161         char *ignetmap = NULL;
162         int at = 0;
163         char node[64];
164         char testnode[64];
165         char buf[SIZ];
166
167         char original_name[256];
168         safestrncpy(original_name, name, sizeof original_name);
169
170         striplt(name);
171         remove_any_whitespace_to_the_left_or_right_of_at_symbol(name);
172         stripallbut(name, '<', '>');
173
174         fp = fopen(file_mail_aliases, "r");
175         if (fp == NULL) {
176                 fp = fopen("/dev/null", "r");
177         }
178         if (fp == NULL) {
179                 return (MES_ERROR);
180         }
181         strcpy(aaa, "");
182         strcpy(bbb, "");
183         while (fgets(aaa, sizeof aaa, fp) != NULL) {
184                 while (isspace(name[0]))
185                         strcpy(name, &name[1]);
186                 aaa[strlen(aaa) - 1] = 0;
187                 strcpy(bbb, "");
188                 for (a = 0; a < strlen(aaa); ++a) {
189                         if (aaa[a] == ',') {
190                                 strcpy(bbb, &aaa[a + 1]);
191                                 aaa[a] = 0;
192                         }
193                 }
194                 if (!strcasecmp(name, aaa))
195                         strcpy(name, bbb);
196         }
197         fclose(fp);
198
199         /* Hit the Global Address Book */
200         if (CtdlDirectoryLookup(aaa, name, sizeof aaa) == 0) {
201                 strcpy(name, aaa);
202         }
203
204         if (strcasecmp(original_name, name)) {
205                 MSG_syslog(LOG_INFO, "%s is being forwarded to %s\n", original_name, name);
206         }
207
208         /* Change "user @ xxx" to "user" if xxx is an alias for this host */
209         for (a=0; a<strlen(name); ++a) {
210                 if (name[a] == '@') {
211                         if (CtdlHostAlias(&name[a+1]) == hostalias_localhost) {
212                                 name[a] = 0;
213                                 MSG_syslog(LOG_INFO, "Changed to <%s>\n", name);
214                         }
215                 }
216         }
217
218         /* determine local or remote type, see citadel.h */
219         at = haschar(name, '@');
220         if (at == 0) return(MES_LOCAL);         /* no @'s - local address */
221         if (at > 1) return(MES_ERROR);          /* >1 @'s - invalid address */
222         remove_any_whitespace_to_the_left_or_right_of_at_symbol(name);
223
224         /* figure out the delivery mode */
225         extract_token(node, name, 1, '@', sizeof node);
226
227         /* If there are one or more dots in the nodename, we assume that it
228          * is an FQDN and will attempt SMTP delivery to the Internet.
229          */
230         if (haschar(node, '.') > 0) {
231                 return(MES_INTERNET);
232         }
233
234         /* Otherwise we look in the IGnet maps for a valid Citadel node.
235          * Try directly-connected nodes first...
236          */
237         ignetcfg = CtdlGetSysConfig(IGNETCFG);
238         for (i=0; i<num_tokens(ignetcfg, '\n'); ++i) {
239                 extract_token(buf, ignetcfg, i, '\n', sizeof buf);
240                 extract_token(testnode, buf, 0, '|', sizeof testnode);
241                 if (!strcasecmp(node, testnode)) {
242                         free(ignetcfg);
243                         return(MES_IGNET);
244                 }
245         }
246         free(ignetcfg);
247
248         /*
249          * Then try nodes that are two or more hops away.
250          */
251         ignetmap = CtdlGetSysConfig(IGNETMAP);
252         for (i=0; i<num_tokens(ignetmap, '\n'); ++i) {
253                 extract_token(buf, ignetmap, i, '\n', sizeof buf);
254                 extract_token(testnode, buf, 0, '|', sizeof testnode);
255                 if (!strcasecmp(node, testnode)) {
256                         free(ignetmap);
257                         return(MES_IGNET);
258                 }
259         }
260         free(ignetmap);
261
262         /* If we get to this point it's an invalid node name */
263         return (MES_ERROR);
264 }
265
266
267 /*
268  * Back end for the MSGS command: output message number only.
269  */
270 void simple_listing(long msgnum, void *userdata)
271 {
272         cprintf("%ld\n", msgnum);
273 }
274
275
276
277 /*
278  * Back end for the MSGS command: output header summary.
279  */
280 void headers_listing(long msgnum, void *userdata)
281 {
282         struct CtdlMessage *msg;
283
284         msg = CtdlFetchMessage(msgnum, 0);
285         if (msg == NULL) {
286                 cprintf("%ld|0|||||\n", msgnum);
287                 return;
288         }
289
290         cprintf("%ld|%s|%s|%s|%s|%s|\n",
291                 msgnum,
292                 (msg->cm_fields['T'] ? msg->cm_fields['T'] : "0"),
293                 (msg->cm_fields['A'] ? msg->cm_fields['A'] : ""),
294                 (msg->cm_fields['N'] ? msg->cm_fields['N'] : ""),
295                 (msg->cm_fields['F'] ? msg->cm_fields['F'] : ""),
296                 (msg->cm_fields['U'] ? msg->cm_fields['U'] : "")
297         );
298         CtdlFreeMessage(msg);
299 }
300
301 /*
302  * Back end for the MSGS command: output EUID header.
303  */
304 void headers_euid(long msgnum, void *userdata)
305 {
306         struct CtdlMessage *msg;
307
308         msg = CtdlFetchMessage(msgnum, 0);
309         if (msg == NULL) {
310                 cprintf("%ld||\n", msgnum);
311                 return;
312         }
313
314         cprintf("%ld|%s|%s\n", 
315                 msgnum, 
316                 (msg->cm_fields['E'] ? msg->cm_fields['E'] : ""),
317                 (msg->cm_fields['T'] ? msg->cm_fields['T'] : "0"));
318         CtdlFreeMessage(msg);
319 }
320
321
322
323
324
325 /* Determine if a given message matches the fields in a message template.
326  * Return 0 for a successful match.
327  */
328 int CtdlMsgCmp(struct CtdlMessage *msg, struct CtdlMessage *template) {
329         int i;
330
331         /* If there aren't any fields in the template, all messages will
332          * match.
333          */
334         if (template == NULL) return(0);
335
336         /* Null messages are bogus. */
337         if (msg == NULL) return(1);
338
339         for (i='A'; i<='Z'; ++i) {
340                 if (template->cm_fields[i] != NULL) {
341                         if (msg->cm_fields[i] == NULL) {
342                                 /* Considered equal if temmplate is empty string */
343                                 if (IsEmptyStr(template->cm_fields[i])) continue;
344                                 return 1;
345                         }
346                         if (strcasecmp(msg->cm_fields[i],
347                                 template->cm_fields[i])) return 1;
348                 }
349         }
350
351         /* All compares succeeded: we have a match! */
352         return 0;
353 }
354
355
356
357 /*
358  * Retrieve the "seen" message list for the current room.
359  */
360 void CtdlGetSeen(char *buf, int which_set) {
361         struct CitContext *CCC = CC;
362         visit vbuf;
363
364         /* Learn about the user and room in question */
365         CtdlGetRelationship(&vbuf, &CCC->user, &CCC->room);
366
367         if (which_set == ctdlsetseen_seen)
368                 safestrncpy(buf, vbuf.v_seen, SIZ);
369         if (which_set == ctdlsetseen_answered)
370                 safestrncpy(buf, vbuf.v_answered, SIZ);
371 }
372
373
374
375 /*
376  * Manipulate the "seen msgs" string (or other message set strings)
377  */
378 void CtdlSetSeen(long *target_msgnums, int num_target_msgnums,
379                 int target_setting, int which_set,
380                 struct ctdluser *which_user, struct ctdlroom *which_room) {
381         struct CitContext *CCC = CC;
382         struct cdbdata *cdbfr;
383         int i, k;
384         int is_seen = 0;
385         int was_seen = 0;
386         long lo = (-1L);
387         long hi = (-1L); /// TODO: we just write here. y?
388         visit vbuf;
389         long *msglist;
390         int num_msgs = 0;
391         StrBuf *vset;
392         StrBuf *setstr;
393         StrBuf *lostr;
394         StrBuf *histr;
395         const char *pvset;
396         char *is_set;   /* actually an array of booleans */
397
398         /* Don't bother doing *anything* if we were passed a list of zero messages */
399         if (num_target_msgnums < 1) {
400                 return;
401         }
402
403         /* If no room was specified, we go with the current room. */
404         if (!which_room) {
405                 which_room = &CCC->room;
406         }
407
408         /* If no user was specified, we go with the current user. */
409         if (!which_user) {
410                 which_user = &CCC->user;
411         }
412
413         MSG_syslog(LOG_DEBUG, "CtdlSetSeen(%d msgs starting with %ld, %s, %d) in <%s>\n",
414                    num_target_msgnums, target_msgnums[0],
415                    (target_setting ? "SET" : "CLEAR"),
416                    which_set,
417                    which_room->QRname);
418
419         /* Learn about the user and room in question */
420         CtdlGetRelationship(&vbuf, which_user, which_room);
421
422         /* Load the message list */
423         cdbfr = cdb_fetch(CDB_MSGLISTS, &which_room->QRnumber, sizeof(long));
424         if (cdbfr != NULL) {
425                 msglist = (long *) cdbfr->ptr;
426                 cdbfr->ptr = NULL;      /* CtdlSetSeen() now owns this memory */
427                 num_msgs = cdbfr->len / sizeof(long);
428                 cdb_free(cdbfr);
429         } else {
430                 return; /* No messages at all?  No further action. */
431         }
432
433         is_set = malloc(num_msgs * sizeof(char));
434         memset(is_set, 0, (num_msgs * sizeof(char)) );
435
436         /* Decide which message set we're manipulating */
437         switch(which_set) {
438         case ctdlsetseen_seen:
439                 vset = NewStrBufPlain(vbuf.v_seen, -1);
440                 break;
441         case ctdlsetseen_answered:
442                 vset = NewStrBufPlain(vbuf.v_answered, -1);
443                 break;
444         default:
445                 vset = NewStrBuf();
446         }
447
448
449 #if 0   /* This is a special diagnostic section.  Do not allow it to run during normal operation. */
450         MSG_syslog(LOG_DEBUG, "There are %d messages in the room.\n", num_msgs);
451         for (i=0; i<num_msgs; ++i) {
452                 if ((i > 0) && (msglist[i] <= msglist[i-1])) abort();
453         }
454         MSG_syslog(LOG_DEBUG, "We are twiddling %d of them.\n", num_target_msgnums);
455         for (k=0; k<num_target_msgnums; ++k) {
456                 if ((k > 0) && (target_msgnums[k] <= target_msgnums[k-1])) abort();
457         }
458 #endif
459
460         MSG_syslog(LOG_DEBUG, "before update: %s\n", ChrPtr(vset));
461
462         /* Translate the existing sequence set into an array of booleans */
463         setstr = NewStrBuf();
464         lostr = NewStrBuf();
465         histr = NewStrBuf();
466         pvset = NULL;
467         while (StrBufExtract_NextToken(setstr, vset, &pvset, ',') >= 0) {
468
469                 StrBufExtract_token(lostr, setstr, 0, ':');
470                 if (StrBufNum_tokens(setstr, ':') >= 2) {
471                         StrBufExtract_token(histr, setstr, 1, ':');
472                 }
473                 else {
474                         FlushStrBuf(histr);
475                         StrBufAppendBuf(histr, lostr, 0);
476                 }
477                 lo = StrTol(lostr);
478                 if (!strcmp(ChrPtr(histr), "*")) {
479                         hi = LONG_MAX;
480                 }
481                 else {
482                         hi = StrTol(histr);
483                 }
484
485                 for (i = 0; i < num_msgs; ++i) {
486                         if ((msglist[i] >= lo) && (msglist[i] <= hi)) {
487                                 is_set[i] = 1;
488                         }
489                 }
490         }
491         FreeStrBuf(&setstr);
492         FreeStrBuf(&lostr);
493         FreeStrBuf(&histr);
494
495
496         /* Now translate the array of booleans back into a sequence set */
497         FlushStrBuf(vset);
498         was_seen = 0;
499         lo = (-1);
500         hi = (-1);
501
502         for (i=0; i<num_msgs; ++i) {
503                 is_seen = is_set[i];
504
505                 /* Apply changes */
506                 for (k=0; k<num_target_msgnums; ++k) {
507                         if (msglist[i] == target_msgnums[k]) {
508                                 is_seen = target_setting;
509                         }
510                 }
511
512                 if ((was_seen == 0) && (is_seen == 1)) {
513                         lo = msglist[i];
514                 }
515                 else if ((was_seen == 1) && (is_seen == 0)) {
516                         hi = msglist[i-1];
517
518                         if (StrLength(vset) > 0) {
519                                 StrBufAppendBufPlain(vset, HKEY(","), 0);
520                         }
521                         if (lo == hi) {
522                                 StrBufAppendPrintf(vset, "%ld", hi);
523                         }
524                         else {
525                                 StrBufAppendPrintf(vset, "%ld:%ld", lo, hi);
526                         }
527                 }
528
529                 if ((is_seen) && (i == num_msgs - 1)) {
530                         if (StrLength(vset) > 0) {
531                                 StrBufAppendBufPlain(vset, HKEY(","), 0);
532                         }
533                         if ((i==0) || (was_seen == 0)) {
534                                 StrBufAppendPrintf(vset, "%ld", msglist[i]);
535                         }
536                         else {
537                                 StrBufAppendPrintf(vset, "%ld:%ld", lo, msglist[i]);
538                         }
539                 }
540
541                 was_seen = is_seen;
542         }
543
544         /*
545          * We will have to stuff this string back into a 4096 byte buffer, so if it's
546          * larger than that now, truncate it by removing tokens from the beginning.
547          * The limit of 100 iterations is there to prevent an infinite loop in case
548          * something unexpected happens.
549          */
550         int number_of_truncations = 0;
551         while ( (StrLength(vset) > SIZ) && (number_of_truncations < 100) ) {
552                 StrBufRemove_token(vset, 0, ',');
553                 ++number_of_truncations;
554         }
555
556         /*
557          * If we're truncating the sequence set of messages marked with the 'seen' flag,
558          * we want the earliest messages (the truncated ones) to be marked, not unmarked.
559          * Otherwise messages at the beginning will suddenly appear to be 'unseen'.
560          */
561         if ( (which_set == ctdlsetseen_seen) && (number_of_truncations > 0) ) {
562                 StrBuf *first_tok;
563                 first_tok = NewStrBuf();
564                 StrBufExtract_token(first_tok, vset, 0, ',');
565                 StrBufRemove_token(vset, 0, ',');
566
567                 if (StrBufNum_tokens(first_tok, ':') > 1) {
568                         StrBufRemove_token(first_tok, 0, ':');
569                 }
570                 
571                 StrBuf *new_set;
572                 new_set = NewStrBuf();
573                 StrBufAppendBufPlain(new_set, HKEY("1:"), 0);
574                 StrBufAppendBuf(new_set, first_tok, 0);
575                 StrBufAppendBufPlain(new_set, HKEY(":"), 0);
576                 StrBufAppendBuf(new_set, vset, 0);
577
578                 FreeStrBuf(&vset);
579                 FreeStrBuf(&first_tok);
580                 vset = new_set;
581         }
582
583         MSG_syslog(LOG_DEBUG, " after update: %s\n", ChrPtr(vset));
584
585         /* Decide which message set we're manipulating */
586         switch (which_set) {
587                 case ctdlsetseen_seen:
588                         safestrncpy(vbuf.v_seen, ChrPtr(vset), sizeof vbuf.v_seen);
589                         break;
590                 case ctdlsetseen_answered:
591                         safestrncpy(vbuf.v_answered, ChrPtr(vset), sizeof vbuf.v_answered);
592                         break;
593         }
594
595         free(is_set);
596         free(msglist);
597         CtdlSetRelationship(&vbuf, which_user, which_room);
598         FreeStrBuf(&vset);
599 }
600
601
602 /*
603  * API function to perform an operation for each qualifying message in the
604  * current room.  (Returns the number of messages processed.)
605  */
606 int CtdlForEachMessage(int mode, long ref, char *search_string,
607                         char *content_type,
608                         struct CtdlMessage *compare,
609                         ForEachMsgCallback CallBack,
610                         void *userdata)
611 {
612         struct CitContext *CCC = CC;
613         int a, i, j;
614         visit vbuf;
615         struct cdbdata *cdbfr;
616         long *msglist = NULL;
617         int num_msgs = 0;
618         int num_processed = 0;
619         long thismsg;
620         struct MetaData smi;
621         struct CtdlMessage *msg = NULL;
622         int is_seen = 0;
623         long lastold = 0L;
624         int printed_lastold = 0;
625         int num_search_msgs = 0;
626         long *search_msgs = NULL;
627         regex_t re;
628         int need_to_free_re = 0;
629         regmatch_t pm;
630
631         if ((content_type) && (!IsEmptyStr(content_type))) {
632                 regcomp(&re, content_type, 0);
633                 need_to_free_re = 1;
634         }
635
636         /* Learn about the user and room in question */
637         if (server_shutting_down) {
638                 if (need_to_free_re) regfree(&re);
639                 return -1;
640         }
641         CtdlGetUser(&CCC->user, CCC->curr_user);
642
643         if (server_shutting_down) {
644                 if (need_to_free_re) regfree(&re);
645                 return -1;
646         }
647         CtdlGetRelationship(&vbuf, &CCC->user, &CCC->room);
648
649         if (server_shutting_down) {
650                 if (need_to_free_re) regfree(&re);
651                 return -1;
652         }
653
654         /* Load the message list */
655         cdbfr = cdb_fetch(CDB_MSGLISTS, &CCC->room.QRnumber, sizeof(long));
656         if (cdbfr == NULL) {
657                 if (need_to_free_re) regfree(&re);
658                 return 0;       /* No messages at all?  No further action. */
659         }
660
661         msglist = (long *) cdbfr->ptr;
662         num_msgs = cdbfr->len / sizeof(long);
663
664         cdbfr->ptr = NULL;      /* clear this so that cdb_free() doesn't free it */
665         cdb_free(cdbfr);        /* we own this memory now */
666
667         /*
668          * Now begin the traversal.
669          */
670         if (num_msgs > 0) for (a = 0; a < num_msgs; ++a) {
671
672                 /* If the caller is looking for a specific MIME type, filter
673                  * out all messages which are not of the type requested.
674                  */
675                 if ((content_type != NULL) && (!IsEmptyStr(content_type))) {
676
677                         /* This call to GetMetaData() sits inside this loop
678                          * so that we only do the extra database read per msg
679                          * if we need to.  Doing the extra read all the time
680                          * really kills the server.  If we ever need to use
681                          * metadata for another search criterion, we need to
682                          * move the read somewhere else -- but still be smart
683                          * enough to only do the read if the caller has
684                          * specified something that will need it.
685                          */
686                         if (server_shutting_down) {
687                                 if (need_to_free_re) regfree(&re);
688                                 free(msglist);
689                                 return -1;
690                         }
691                         GetMetaData(&smi, msglist[a]);
692
693                         /* if (strcasecmp(smi.meta_content_type, content_type)) { old non-regex way */
694                         if (regexec(&re, smi.meta_content_type, 1, &pm, 0) != 0) {
695                                 msglist[a] = 0L;
696                         }
697                 }
698         }
699
700         num_msgs = sort_msglist(msglist, num_msgs);
701
702         /* If a template was supplied, filter out the messages which
703          * don't match.  (This could induce some delays!)
704          */
705         if (num_msgs > 0) {
706                 if (compare != NULL) {
707                         for (a = 0; a < num_msgs; ++a) {
708                                 if (server_shutting_down) {
709                                         if (need_to_free_re) regfree(&re);
710                                         free(msglist);
711                                         return -1;
712                                 }
713                                 msg = CtdlFetchMessage(msglist[a], 1);
714                                 if (msg != NULL) {
715                                         if (CtdlMsgCmp(msg, compare)) {
716                                                 msglist[a] = 0L;
717                                         }
718                                         CtdlFreeMessage(msg);
719                                 }
720                         }
721                 }
722         }
723
724         /* If a search string was specified, get a message list from
725          * the full text index and remove messages which aren't on both
726          * lists.
727          *
728          * How this works:
729          * Since the lists are sorted and strictly ascending, and the
730          * output list is guaranteed to be shorter than or equal to the
731          * input list, we overwrite the bottom of the input list.  This
732          * eliminates the need to memmove big chunks of the list over and
733          * over again.
734          */
735         if ( (num_msgs > 0) && (mode == MSGS_SEARCH) && (search_string) ) {
736
737                 /* Call search module via hook mechanism.
738                  * NULL means use any search function available.
739                  * otherwise replace with a char * to name of search routine
740                  */
741                 CtdlModuleDoSearch(&num_search_msgs, &search_msgs, search_string, "fulltext");
742
743                 if (num_search_msgs > 0) {
744         
745                         int orig_num_msgs;
746
747                         orig_num_msgs = num_msgs;
748                         num_msgs = 0;
749                         for (i=0; i<orig_num_msgs; ++i) {
750                                 for (j=0; j<num_search_msgs; ++j) {
751                                         if (msglist[i] == search_msgs[j]) {
752                                                 msglist[num_msgs++] = msglist[i];
753                                         }
754                                 }
755                         }
756                 }
757                 else {
758                         num_msgs = 0;   /* No messages qualify */
759                 }
760                 if (search_msgs != NULL) free(search_msgs);
761
762                 /* Now that we've purged messages which don't contain the search
763                  * string, treat a MSGS_SEARCH just like a MSGS_ALL from this
764                  * point on.
765                  */
766                 mode = MSGS_ALL;
767         }
768
769         /*
770          * Now iterate through the message list, according to the
771          * criteria supplied by the caller.
772          */
773         if (num_msgs > 0)
774                 for (a = 0; a < num_msgs; ++a) {
775                         if (server_shutting_down) {
776                                 if (need_to_free_re) regfree(&re);
777                                 free(msglist);
778                                 return num_processed;
779                         }
780                         thismsg = msglist[a];
781                         if (mode == MSGS_ALL) {
782                                 is_seen = 0;
783                         }
784                         else {
785                                 is_seen = is_msg_in_sequence_set(
786                                                         vbuf.v_seen, thismsg);
787                                 if (is_seen) lastold = thismsg;
788                         }
789                         if ((thismsg > 0L)
790                             && (
791
792                                        (mode == MSGS_ALL)
793                                        || ((mode == MSGS_OLD) && (is_seen))
794                                        || ((mode == MSGS_NEW) && (!is_seen))
795                                        || ((mode == MSGS_LAST) && (a >= (num_msgs - ref)))
796                                    || ((mode == MSGS_FIRST) && (a < ref))
797                                 || ((mode == MSGS_GT) && (thismsg > ref))
798                                 || ((mode == MSGS_LT) && (thismsg < ref))
799                                 || ((mode == MSGS_EQ) && (thismsg == ref))
800                             )
801                             ) {
802                                 if ((mode == MSGS_NEW) && (CCC->user.flags & US_LASTOLD) && (lastold > 0L) && (printed_lastold == 0) && (!is_seen)) {
803                                         if (CallBack)
804                                                 CallBack(lastold, userdata);
805                                         printed_lastold = 1;
806                                         ++num_processed;
807                                 }
808                                 if (CallBack) CallBack(thismsg, userdata);
809                                 ++num_processed;
810                         }
811                 }
812         if (need_to_free_re) regfree(&re);
813
814         /*
815          * We cache the most recent msglist in order to do security checks later
816          */
817         if (CCC->client_socket > 0) {
818                 if (CCC->cached_msglist != NULL) {
819                         free(CCC->cached_msglist);
820                 }
821                 CCC->cached_msglist = msglist;
822                 CCC->cached_num_msgs = num_msgs;
823         }
824         else {
825                 free(msglist);
826         }
827
828         return num_processed;
829 }
830
831
832
833 /*
834  * cmd_msgs()  -  get list of message #'s in this room
835  *              implements the MSGS server command using CtdlForEachMessage()
836  */
837 void cmd_msgs(char *cmdbuf)
838 {
839         int mode = 0;
840         char which[16];
841         char buf[256];
842         char tfield[256];
843         char tvalue[256];
844         int cm_ref = 0;
845         int i;
846         int with_template = 0;
847         struct CtdlMessage *template = NULL;
848         char search_string[1024];
849         ForEachMsgCallback CallBack;
850
851         if (CtdlAccessCheck(ac_logged_in_or_guest)) return;
852
853         extract_token(which, cmdbuf, 0, '|', sizeof which);
854         cm_ref = extract_int(cmdbuf, 1);
855         extract_token(search_string, cmdbuf, 1, '|', sizeof search_string);
856         with_template = extract_int(cmdbuf, 2);
857         switch (extract_int(cmdbuf, 3))
858         {
859         default:
860         case MSG_HDRS_BRIEF:
861                 CallBack = simple_listing;
862                 break;
863         case MSG_HDRS_ALL:
864                 CallBack = headers_listing;
865                 break;
866         case MSG_HDRS_EUID:
867                 CallBack = headers_euid;
868                 break;
869         }
870
871         strcat(which, "   ");
872         if (!strncasecmp(which, "OLD", 3))
873                 mode = MSGS_OLD;
874         else if (!strncasecmp(which, "NEW", 3))
875                 mode = MSGS_NEW;
876         else if (!strncasecmp(which, "FIRST", 5))
877                 mode = MSGS_FIRST;
878         else if (!strncasecmp(which, "LAST", 4))
879                 mode = MSGS_LAST;
880         else if (!strncasecmp(which, "GT", 2))
881                 mode = MSGS_GT;
882         else if (!strncasecmp(which, "LT", 2))
883                 mode = MSGS_LT;
884         else if (!strncasecmp(which, "SEARCH", 6))
885                 mode = MSGS_SEARCH;
886         else
887                 mode = MSGS_ALL;
888
889         if ( (mode == MSGS_SEARCH) && (!config.c_enable_fulltext) ) {
890                 cprintf("%d Full text index is not enabled on this server.\n",
891                         ERROR + CMD_NOT_SUPPORTED);
892                 return;
893         }
894
895         if (with_template) {
896                 unbuffer_output();
897                 cprintf("%d Send template then receive message list\n",
898                         START_CHAT_MODE);
899                 template = (struct CtdlMessage *)
900                         malloc(sizeof(struct CtdlMessage));
901                 memset(template, 0, sizeof(struct CtdlMessage));
902                 template->cm_magic = CTDLMESSAGE_MAGIC;
903                 template->cm_anon_type = MES_NORMAL;
904
905                 while(client_getln(buf, sizeof buf) >= 0 && strcmp(buf,"000")) {
906                         extract_token(tfield, buf, 0, '|', sizeof tfield);
907                         extract_token(tvalue, buf, 1, '|', sizeof tvalue);
908                         for (i='A'; i<='Z'; ++i) if (msgkeys[i]!=NULL) {
909                                 if (!strcasecmp(tfield, msgkeys[i])) {
910                                         template->cm_fields[i] =
911                                                 strdup(tvalue);
912                                 }
913                         }
914                 }
915                 buffer_output();
916         }
917         else {
918                 cprintf("%d  \n", LISTING_FOLLOWS);
919         }
920
921         CtdlForEachMessage(mode,
922                            ( (mode == MSGS_SEARCH) ? 0 : cm_ref ),
923                            ( (mode == MSGS_SEARCH) ? search_string : NULL ),
924                            NULL,
925                            template,
926                            CallBack,
927                            NULL);
928         if (template != NULL) CtdlFreeMessage(template);
929         cprintf("000\n");
930 }
931
932
933
934
935 /* 
936  * help_subst()  -  support routine for help file viewer
937  */
938 void help_subst(char *strbuf, char *source, char *dest)
939 {
940         char workbuf[SIZ];
941         int p;
942
943         while (p = pattern2(strbuf, source), (p >= 0)) {
944                 strcpy(workbuf, &strbuf[p + strlen(source)]);
945                 strcpy(&strbuf[p], dest);
946                 strcat(strbuf, workbuf);
947         }
948 }
949
950
951 void do_help_subst(char *buffer)
952 {
953         char buf2[16];
954
955         help_subst(buffer, "^nodename", config.c_nodename);
956         help_subst(buffer, "^humannode", config.c_humannode);
957         help_subst(buffer, "^fqdn", config.c_fqdn);
958         help_subst(buffer, "^username", CC->user.fullname);
959         snprintf(buf2, sizeof buf2, "%ld", CC->user.usernum);
960         help_subst(buffer, "^usernum", buf2);
961         help_subst(buffer, "^sysadm", config.c_sysadm);
962         help_subst(buffer, "^variantname", CITADEL);
963         snprintf(buf2, sizeof buf2, "%d", config.c_maxsessions);
964         help_subst(buffer, "^maxsessions", buf2);
965         help_subst(buffer, "^bbsdir", ctdl_message_dir);
966 }
967
968
969
970 /*
971  * memfmout()  -  Citadel text formatter and paginator.
972  *           Although the original purpose of this routine was to format
973  *           text to the reader's screen width, all we're really using it
974  *           for here is to format text out to 80 columns before sending it
975  *           to the client.  The client software may reformat it again.
976  */
977 void memfmout(
978         char *mptr,             /* where are we going to get our text from? */
979         const char *nl          /* string to terminate lines with */
980 ) {
981         struct CitContext *CCC = CC;
982         int column = 0;
983         unsigned char ch = 0;
984         char outbuf[1024];
985         int len = 0;
986         int nllen = 0;
987
988         if (!mptr) return;
989         nllen = strlen(nl);
990         while (ch=*(mptr++), ch != 0) {
991
992                 if (ch == '\n') {
993                         if (client_write(outbuf, len) == -1)
994                         {
995                                 MSGM_syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
996                                 return;
997                         }
998                         len = 0;
999                         if (client_write(nl, nllen) == -1)
1000                         {
1001                                 MSGM_syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
1002                                 return;
1003                         }
1004                         column = 0;
1005                 }
1006                 else if (ch == '\r') {
1007                         /* Ignore carriage returns.  Newlines are always LF or CRLF but never CR. */
1008                 }
1009                 else if (isspace(ch)) {
1010                         if (column > 72) {              /* Beyond 72 columns, break on the next space */
1011                                 if (client_write(outbuf, len) == -1)
1012                                 {
1013                                         MSGM_syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
1014                                         return;
1015                                 }
1016                                 len = 0;
1017                                 if (client_write(nl, nllen) == -1)
1018                                 {
1019                                         MSGM_syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
1020                                         return;
1021                                 }
1022                                 column = 0;
1023                         }
1024                         else {
1025                                 outbuf[len++] = ch;
1026                                 ++column;
1027                         }
1028                 }
1029                 else {
1030                         outbuf[len++] = ch;
1031                         ++column;
1032                         if (column > 1000) {            /* Beyond 1000 columns, break anywhere */
1033                                 if (client_write(outbuf, len) == -1)
1034                                 {
1035                                         MSGM_syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
1036                                         return;
1037                                 }
1038                                 len = 0;
1039                                 if (client_write(nl, nllen) == -1)
1040                                 {
1041                                         MSGM_syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
1042                                         return;
1043                                 }
1044                                 column = 0;
1045                         }
1046                 }
1047         }
1048         if (len) {
1049                 if (client_write(outbuf, len) == -1)
1050                 {
1051                         MSGM_syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
1052                         return;
1053                 }
1054                 len = 0;
1055                 client_write(nl, nllen);
1056                 column = 0;
1057         }
1058 }
1059
1060
1061
1062 /*
1063  * Callback function for mime parser that simply lists the part
1064  */
1065 void list_this_part(char *name, char *filename, char *partnum, char *disp,
1066                     void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
1067                     char *cbid, void *cbuserdata)
1068 {
1069         struct ma_info *ma;
1070         
1071         ma = (struct ma_info *)cbuserdata;
1072         if (ma->is_ma == 0) {
1073                 cprintf("part=%s|%s|%s|%s|%s|%ld|%s|%s\n",
1074                         name, 
1075                         filename, 
1076                         partnum, 
1077                         disp, 
1078                         cbtype, 
1079                         (long)length, 
1080                         cbid, 
1081                         cbcharset);
1082         }
1083 }
1084
1085 /* 
1086  * Callback function for multipart prefix
1087  */
1088 void list_this_pref(char *name, char *filename, char *partnum, char *disp,
1089                     void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
1090                     char *cbid, void *cbuserdata)
1091 {
1092         struct ma_info *ma;
1093         
1094         ma = (struct ma_info *)cbuserdata;
1095         if (!strcasecmp(cbtype, "multipart/alternative")) {
1096                 ++ma->is_ma;
1097         }
1098
1099         if (ma->is_ma == 0) {
1100                 cprintf("pref=%s|%s\n", partnum, cbtype);
1101         }
1102 }
1103
1104 /* 
1105  * Callback function for multipart sufffix
1106  */
1107 void list_this_suff(char *name, char *filename, char *partnum, char *disp,
1108                     void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
1109                     char *cbid, void *cbuserdata)
1110 {
1111         struct ma_info *ma;
1112         
1113         ma = (struct ma_info *)cbuserdata;
1114         if (ma->is_ma == 0) {
1115                 cprintf("suff=%s|%s\n", partnum, cbtype);
1116         }
1117         if (!strcasecmp(cbtype, "multipart/alternative")) {
1118                 --ma->is_ma;
1119         }
1120 }
1121
1122
1123 /*
1124  * Callback function for mime parser that opens a section for downloading
1125  */
1126 void mime_download(char *name, char *filename, char *partnum, char *disp,
1127                    void *content, char *cbtype, char *cbcharset, size_t length,
1128                    char *encoding, char *cbid, void *cbuserdata)
1129 {
1130         int rv = 0;
1131         CitContext *CCC = MyContext();
1132
1133         /* Silently go away if there's already a download open. */
1134         if (CCC->download_fp != NULL)
1135                 return;
1136
1137         if (
1138                 (!IsEmptyStr(partnum) && (!strcasecmp(CCC->download_desired_section, partnum)))
1139         ||      (!IsEmptyStr(cbid) && (!strcasecmp(CCC->download_desired_section, cbid)))
1140         ) {
1141                 CCC->download_fp = tmpfile();
1142                 if (CCC->download_fp == NULL) {
1143                         MSG_syslog(LOG_EMERG, "mime_download(): Couldn't write: %s\n",
1144                                     strerror(errno));
1145                         cprintf("%d cannot open temporary file: %s\n",
1146                                 ERROR + INTERNAL_ERROR, strerror(errno));
1147                         return;
1148                 }
1149         
1150                 rv = fwrite(content, length, 1, CCC->download_fp);
1151                 if (rv <= 0) {
1152                         MSG_syslog(LOG_EMERG, "mime_download(): Couldn't write: %s\n",
1153                                    strerror(errno));
1154                         cprintf("%d unable to write tempfile.\n",
1155                                 ERROR + TOO_BIG);
1156                         fclose(CCC->download_fp);
1157                         CCC->download_fp = NULL;
1158                         return;
1159                 }
1160                 fflush(CCC->download_fp);
1161                 rewind(CCC->download_fp);
1162         
1163                 OpenCmdResult(filename, cbtype);
1164         }
1165 }
1166
1167
1168
1169 /*
1170  * Callback function for mime parser that outputs a section all at once.
1171  * We can specify the desired section by part number *or* content-id.
1172  */
1173 void mime_spew_section(char *name, char *filename, char *partnum, char *disp,
1174                    void *content, char *cbtype, char *cbcharset, size_t length,
1175                    char *encoding, char *cbid, void *cbuserdata)
1176 {
1177         int *found_it = (int *)cbuserdata;
1178
1179         if (
1180                 (!IsEmptyStr(partnum) && (!strcasecmp(CC->download_desired_section, partnum)))
1181         ||      (!IsEmptyStr(cbid) && (!strcasecmp(CC->download_desired_section, cbid)))
1182         ) {
1183                 *found_it = 1;
1184                 cprintf("%d %d|-1|%s|%s|%s\n",
1185                         BINARY_FOLLOWS,
1186                         (int)length,
1187                         filename,
1188                         cbtype,
1189                         cbcharset
1190                 );
1191                 client_write(content, length);
1192         }
1193 }
1194
1195
1196 /*
1197  * Load a message from disk into memory.
1198  * This is used by CtdlOutputMsg() and other fetch functions.
1199  *
1200  * NOTE: Caller is responsible for freeing the returned CtdlMessage struct
1201  *       using the CtdlMessageFree() function.
1202  */
1203 struct CtdlMessage *CtdlFetchMessage(long msgnum, int with_body)
1204 {
1205         struct CitContext *CCC = CC;
1206         struct cdbdata *dmsgtext;
1207         struct CtdlMessage *ret = NULL;
1208         char *mptr;
1209         char *upper_bound;
1210         cit_uint8_t ch;
1211         cit_uint8_t field_header;
1212
1213         MSG_syslog(LOG_DEBUG, "CtdlFetchMessage(%ld, %d)\n", msgnum, with_body);
1214         dmsgtext = cdb_fetch(CDB_MSGMAIN, &msgnum, sizeof(long));
1215         if (dmsgtext == NULL) {
1216                 MSG_syslog(LOG_ERR, "CtdlFetchMessage(%ld, %d) Failed!\n", msgnum, with_body);
1217                 return NULL;
1218         }
1219         mptr = dmsgtext->ptr;
1220         upper_bound = mptr + dmsgtext->len;
1221
1222         /* Parse the three bytes that begin EVERY message on disk.
1223          * The first is always 0xFF, the on-disk magic number.
1224          * The second is the anonymous/public type byte.
1225          * The third is the format type byte (vari, fixed, or MIME).
1226          */
1227         ch = *mptr++;
1228         if (ch != 255) {
1229                 MSG_syslog(LOG_ERR, "Message %ld appears to be corrupted.\n", msgnum);
1230                 cdb_free(dmsgtext);
1231                 return NULL;
1232         }
1233         ret = (struct CtdlMessage *) malloc(sizeof(struct CtdlMessage));
1234         memset(ret, 0, sizeof(struct CtdlMessage));
1235
1236         ret->cm_magic = CTDLMESSAGE_MAGIC;
1237         ret->cm_anon_type = *mptr++;    /* Anon type byte */
1238         ret->cm_format_type = *mptr++;  /* Format type byte */
1239
1240         /*
1241          * The rest is zero or more arbitrary fields.  Load them in.
1242          * We're done when we encounter either a zero-length field or
1243          * have just processed the 'M' (message text) field.
1244          */
1245         do {
1246                 if (mptr >= upper_bound) {
1247                         break;
1248                 }
1249                 field_header = *mptr++;
1250                 ret->cm_fields[field_header] = strdup(mptr);
1251
1252                 while (*mptr++ != 0);   /* advance to next field */
1253
1254         } while ((mptr < upper_bound) && (field_header != 'M'));
1255
1256         cdb_free(dmsgtext);
1257
1258         /* Always make sure there's something in the msg text field.  If
1259          * it's NULL, the message text is most likely stored separately,
1260          * so go ahead and fetch that.  Failing that, just set a dummy
1261          * body so other code doesn't barf.
1262          */
1263         if ( (ret->cm_fields['M'] == NULL) && (with_body) ) {
1264                 dmsgtext = cdb_fetch(CDB_BIGMSGS, &msgnum, sizeof(long));
1265                 if (dmsgtext != NULL) {
1266                         ret->cm_fields['M'] = dmsgtext->ptr;
1267                         dmsgtext->ptr = NULL;
1268                         cdb_free(dmsgtext);
1269                 }
1270         }
1271         if (ret->cm_fields['M'] == NULL) {
1272                 ret->cm_fields['M'] = strdup("\r\n\r\n (no text)\r\n");
1273         }
1274
1275         /* Perform "before read" hooks (aborting if any return nonzero) */
1276         if (PerformMessageHooks(ret, EVT_BEFOREREAD) > 0) {
1277                 CtdlFreeMessage(ret);
1278                 return NULL;
1279         }
1280
1281         return (ret);
1282 }
1283
1284
1285 /*
1286  * Returns 1 if the supplied pointer points to a valid Citadel message.
1287  * If the pointer is NULL or the magic number check fails, returns 0.
1288  */
1289 int is_valid_message(struct CtdlMessage *msg) {
1290         if (msg == NULL)
1291                 return 0;
1292         if ((msg->cm_magic) != CTDLMESSAGE_MAGIC) {
1293                 struct CitContext *CCC = CC;
1294                 MSGM_syslog(LOG_WARNING, "is_valid_message() -- self-check failed\n");
1295                 return 0;
1296         }
1297         return 1;
1298 }
1299
1300 void CtdlFreeMessageContents(struct CtdlMessage *msg)
1301 {
1302         int i;
1303
1304         for (i = 0; i < 256; ++i)
1305                 if (msg->cm_fields[i] != NULL) {
1306                         free(msg->cm_fields[i]);
1307                 }
1308
1309         msg->cm_magic = 0;      /* just in case */
1310 }
1311 /*
1312  * 'Destructor' for struct CtdlMessage
1313  */
1314 void CtdlFreeMessage(struct CtdlMessage *msg)
1315 {
1316         if (is_valid_message(msg) == 0) 
1317         {
1318                 if (msg != NULL) free (msg);
1319                 return;
1320         }
1321         CtdlFreeMessageContents(msg);
1322         free(msg);
1323 }
1324
1325 int DupCMField(int i, struct CtdlMessage *OrgMsg, struct CtdlMessage *NewMsg)
1326 {
1327         long len;
1328         len = strlen(OrgMsg->cm_fields[i]);
1329         NewMsg->cm_fields[i] = malloc(len + 1);
1330         if (NewMsg->cm_fields[i] == NULL)
1331                 return 0;
1332         memcpy(NewMsg->cm_fields[i], OrgMsg->cm_fields[i], len);
1333         NewMsg->cm_fields[i][len] = '\0';
1334         return 1;
1335 }
1336
1337 struct CtdlMessage * CtdlDuplicateMessage(struct CtdlMessage *OrgMsg)
1338 {
1339         int i;
1340         struct CtdlMessage *NewMsg;
1341
1342         if (is_valid_message(OrgMsg) == 0) 
1343                 return NULL;
1344         NewMsg = (struct CtdlMessage *)malloc(sizeof(struct CtdlMessage));
1345         if (NewMsg == NULL)
1346                 return NULL;
1347
1348         memcpy(NewMsg, OrgMsg, sizeof(struct CtdlMessage));
1349
1350         memset(&NewMsg->cm_fields, 0, sizeof(char*) * 256);
1351         
1352         for (i = 0; i < 256; ++i)
1353         {
1354                 if (OrgMsg->cm_fields[i] != NULL)
1355                 {
1356                         if (!DupCMField(i, OrgMsg, NewMsg))
1357                         {
1358                                 CtdlFreeMessage(NewMsg);
1359                                 return NULL;
1360                         }
1361                 }
1362         }
1363
1364         return NewMsg;
1365 }
1366
1367
1368
1369 /*
1370  * Pre callback function for multipart/alternative
1371  *
1372  * NOTE: this differs from the standard behavior for a reason.  Normally when
1373  *       displaying multipart/alternative you want to show the _last_ usable
1374  *       format in the message.  Here we show the _first_ one, because it's
1375  *       usually text/plain.  Since this set of functions is designed for text
1376  *       output to non-MIME-aware clients, this is the desired behavior.
1377  *
1378  */
1379 void fixed_output_pre(char *name, char *filename, char *partnum, char *disp,
1380                 void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
1381                 char *cbid, void *cbuserdata)
1382 {
1383         struct CitContext *CCC = CC;
1384         struct ma_info *ma;
1385         
1386         ma = (struct ma_info *)cbuserdata;
1387         MSG_syslog(LOG_DEBUG, "fixed_output_pre() type=<%s>\n", cbtype);        
1388         if (!strcasecmp(cbtype, "multipart/alternative")) {
1389                 ++ma->is_ma;
1390                 ma->did_print = 0;
1391         }
1392         if (!strcasecmp(cbtype, "message/rfc822")) {
1393                 ++ma->freeze;
1394         }
1395 }
1396
1397 /*
1398  * Post callback function for multipart/alternative
1399  */
1400 void fixed_output_post(char *name, char *filename, char *partnum, char *disp,
1401                 void *content, char *cbtype, char *cbcharset, size_t length,
1402                 char *encoding, char *cbid, void *cbuserdata)
1403 {
1404         struct CitContext *CCC = CC;
1405         struct ma_info *ma;
1406         
1407         ma = (struct ma_info *)cbuserdata;
1408         MSG_syslog(LOG_DEBUG, "fixed_output_post() type=<%s>\n", cbtype);       
1409         if (!strcasecmp(cbtype, "multipart/alternative")) {
1410                 --ma->is_ma;
1411                 ma->did_print = 0;
1412         }
1413         if (!strcasecmp(cbtype, "message/rfc822")) {
1414                 --ma->freeze;
1415         }
1416 }
1417
1418 /*
1419  * Inline callback function for mime parser that wants to display text
1420  */
1421 void fixed_output(char *name, char *filename, char *partnum, char *disp,
1422                 void *content, char *cbtype, char *cbcharset, size_t length,
1423                 char *encoding, char *cbid, void *cbuserdata)
1424 {
1425         struct CitContext *CCC = CC;
1426         char *ptr;
1427         char *wptr;
1428         size_t wlen;
1429         struct ma_info *ma;
1430
1431         ma = (struct ma_info *)cbuserdata;
1432
1433         MSG_syslog(LOG_DEBUG,
1434                 "fixed_output() part %s: %s (%s) (%ld bytes)\n",
1435                 partnum, filename, cbtype, (long)length);
1436
1437         /*
1438          * If we're in the middle of a multipart/alternative scope and
1439          * we've already printed another section, skip this one.
1440          */     
1441         if ( (ma->is_ma) && (ma->did_print) ) {
1442                 MSG_syslog(LOG_DEBUG, "Skipping part %s (%s)\n", partnum, cbtype);
1443                 return;
1444         }
1445         ma->did_print = 1;
1446
1447         if ( (!strcasecmp(cbtype, "text/plain")) 
1448            || (IsEmptyStr(cbtype)) ) {
1449                 wptr = content;
1450                 if (length > 0) {
1451                         client_write(wptr, length);
1452                         if (wptr[length-1] != '\n') {
1453                                 cprintf("\n");
1454                         }
1455                 }
1456                 return;
1457         }
1458
1459         if (!strcasecmp(cbtype, "text/html")) {
1460                 ptr = html_to_ascii(content, length, 80, 0);
1461                 wlen = strlen(ptr);
1462                 client_write(ptr, wlen);
1463                 if ((wlen > 0) && (ptr[wlen-1] != '\n')) {
1464                         cprintf("\n");
1465                 }
1466                 free(ptr);
1467                 return;
1468         }
1469
1470         if (ma->use_fo_hooks) {
1471                 if (PerformFixedOutputHooks(cbtype, content, length)) {
1472                 /* above function returns nonzero if it handled the part */
1473                         return;
1474                 }
1475         }
1476
1477         if (strncasecmp(cbtype, "multipart/", 10)) {
1478                 cprintf("Part %s: %s (%s) (%ld bytes)\r\n",
1479                         partnum, filename, cbtype, (long)length);
1480                 return;
1481         }
1482 }
1483
1484 /*
1485  * The client is elegant and sophisticated and wants to be choosy about
1486  * MIME content types, so figure out which multipart/alternative part
1487  * we're going to send.
1488  *
1489  * We use a system of weights.  When we find a part that matches one of the
1490  * MIME types we've declared as preferential, we can store it in ma->chosen_part
1491  * and then set ma->chosen_pref to that MIME type's position in our preference
1492  * list.  If we then hit another match, we only replace the first match if
1493  * the preference value is lower.
1494  */
1495 void choose_preferred(char *name, char *filename, char *partnum, char *disp,
1496                 void *content, char *cbtype, char *cbcharset, size_t length,
1497                 char *encoding, char *cbid, void *cbuserdata)
1498 {
1499         struct CitContext *CCC = CC;
1500         char buf[1024];
1501         int i;
1502         struct ma_info *ma;
1503         
1504         ma = (struct ma_info *)cbuserdata;
1505
1506         // NOTE: REMOVING THIS CONDITIONAL FIXES BUG 220
1507         //       http://bugzilla.citadel.org/show_bug.cgi?id=220
1508         // I don't know if there are any side effects!  Please TEST TEST TEST
1509         //if (ma->is_ma > 0) {
1510
1511         for (i=0; i<num_tokens(CCC->preferred_formats, '|'); ++i) {
1512                 extract_token(buf, CCC->preferred_formats, i, '|', sizeof buf);
1513                 if ( (!strcasecmp(buf, cbtype)) && (!ma->freeze) ) {
1514                         if (i < ma->chosen_pref) {
1515                                 MSG_syslog(LOG_DEBUG, "Setting chosen part: <%s>\n", partnum);
1516                                 safestrncpy(ma->chosen_part, partnum, sizeof ma->chosen_part);
1517                                 ma->chosen_pref = i;
1518                         }
1519                 }
1520         }
1521 }
1522
1523 /*
1524  * Now that we've chosen our preferred part, output it.
1525  */
1526 void output_preferred(char *name, 
1527                       char *filename, 
1528                       char *partnum, 
1529                       char *disp,
1530                       void *content, 
1531                       char *cbtype, 
1532                       char *cbcharset, 
1533                       size_t length,
1534                       char *encoding, 
1535                       char *cbid, 
1536                       void *cbuserdata)
1537 {
1538         struct CitContext *CCC = CC;
1539         int i;
1540         char buf[128];
1541         int add_newline = 0;
1542         char *text_content;
1543         struct ma_info *ma;
1544         char *decoded = NULL;
1545         size_t bytes_decoded;
1546         int rc = 0;
1547
1548         ma = (struct ma_info *)cbuserdata;
1549
1550         /* This is not the MIME part you're looking for... */
1551         if (strcasecmp(partnum, ma->chosen_part)) return;
1552
1553         /* If the content-type of this part is in our preferred formats
1554          * list, we can simply output it verbatim.
1555          */
1556         for (i=0; i<num_tokens(CCC->preferred_formats, '|'); ++i) {
1557                 extract_token(buf, CCC->preferred_formats, i, '|', sizeof buf);
1558                 if (!strcasecmp(buf, cbtype)) {
1559                         /* Yeah!  Go!  W00t!! */
1560                         if (ma->dont_decode == 0) 
1561                                 rc = mime_decode_now (content, 
1562                                                       length,
1563                                                       encoding,
1564                                                       &decoded,
1565                                                       &bytes_decoded);
1566                         if (rc < 0)
1567                                 break; /* Give us the chance, maybe theres another one. */
1568
1569                         if (rc == 0) text_content = (char *)content;
1570                         else {
1571                                 text_content = decoded;
1572                                 length = bytes_decoded;
1573                         }
1574
1575                         if (text_content[length-1] != '\n') {
1576                                 ++add_newline;
1577                         }
1578                         cprintf("Content-type: %s", cbtype);
1579                         if (!IsEmptyStr(cbcharset)) {
1580                                 cprintf("; charset=%s", cbcharset);
1581                         }
1582                         cprintf("\nContent-length: %d\n",
1583                                 (int)(length + add_newline) );
1584                         if (!IsEmptyStr(encoding)) {
1585                                 cprintf("Content-transfer-encoding: %s\n", encoding);
1586                         }
1587                         else {
1588                                 cprintf("Content-transfer-encoding: 7bit\n");
1589                         }
1590                         cprintf("X-Citadel-MSG4-Partnum: %s\n", partnum);
1591                         cprintf("\n");
1592                         if (client_write(text_content, length) == -1)
1593                         {
1594                                 MSGM_syslog(LOG_ERR, "output_preferred(): aborting due to write failure.\n");
1595                                 return;
1596                         }
1597                         if (add_newline) cprintf("\n");
1598                         if (decoded != NULL) free(decoded);
1599                         return;
1600                 }
1601         }
1602
1603         /* No translations required or possible: output as text/plain */
1604         cprintf("Content-type: text/plain\n\n");
1605         rc = 0;
1606         if (ma->dont_decode == 0)
1607                 rc = mime_decode_now (content, 
1608                                       length,
1609                                       encoding,
1610                                       &decoded,
1611                                       &bytes_decoded);
1612         if (rc < 0)
1613                 return; /* Give us the chance, maybe theres another one. */
1614         
1615         if (rc == 0) text_content = (char *)content;
1616         else {
1617                 text_content = decoded;
1618                 length = bytes_decoded;
1619         }
1620
1621         fixed_output(name, filename, partnum, disp, text_content, cbtype, cbcharset,
1622                         length, encoding, cbid, cbuserdata);
1623         if (decoded != NULL) free(decoded);
1624 }
1625
1626
1627 struct encapmsg {
1628         char desired_section[64];
1629         char *msg;
1630         size_t msglen;
1631 };
1632
1633
1634 /*
1635  * Callback function for
1636  */
1637 void extract_encapsulated_message(char *name, char *filename, char *partnum, char *disp,
1638                    void *content, char *cbtype, char *cbcharset, size_t length,
1639                    char *encoding, char *cbid, void *cbuserdata)
1640 {
1641         struct encapmsg *encap;
1642
1643         encap = (struct encapmsg *)cbuserdata;
1644
1645         /* Only proceed if this is the desired section... */
1646         if (!strcasecmp(encap->desired_section, partnum)) {
1647                 encap->msglen = length;
1648                 encap->msg = malloc(length + 2);
1649                 memcpy(encap->msg, content, length);
1650                 return;
1651         }
1652 }
1653
1654
1655 /*
1656  * Determine whether the specified message exists in the cached_msglist
1657  * (This is a security check)
1658  */
1659 int check_cached_msglist(long msgnum) {
1660         struct CitContext *CCC = CC;
1661
1662         /* cases in which we skip the check */
1663         if (!CCC) return om_ok;                                         /* not a session */
1664         if (CCC->client_socket <= 0) return om_ok;                      /* not a client session */
1665         if (CCC->cached_msglist == NULL) return om_access_denied;       /* no msglist fetched */
1666         if (CCC->cached_num_msgs == 0) return om_access_denied;         /* nothing to check */
1667
1668
1669         /* Do a binary search within the cached_msglist for the requested msgnum */
1670         int min = 0;
1671         int max = (CC->cached_num_msgs - 1);
1672
1673         while (max >= min) {
1674                 int middle = min + (max-min) / 2 ;
1675                 if (msgnum == CCC->cached_msglist[middle]) {
1676                         return om_ok;
1677                 }
1678                 if (msgnum > CC->cached_msglist[middle]) {
1679                         min = middle + 1;
1680                 }
1681                 else {
1682                         max = middle - 1;
1683                 }
1684         }
1685
1686         return om_access_denied;
1687 }
1688
1689
1690 /* 
1691  * Determine whether the currently logged in session has permission to read
1692  * messages in the current room.
1693  */
1694 int CtdlDoIHavePermissionToReadMessagesInThisRoom(void) {
1695         if (    (!(CC->logged_in))
1696                 && (!(CC->internal_pgm))
1697                 && (!config.c_guest_logins)
1698         ) {
1699                 return(om_not_logged_in);
1700         }
1701         return(om_ok);
1702 }
1703
1704
1705 /*
1706  * Get a message off disk.  (returns om_* values found in msgbase.h)
1707  * 
1708  */
1709 int CtdlOutputMsg(long msg_num,         /* message number (local) to fetch */
1710                   int mode,             /* how would you like that message? */
1711                   int headers_only,     /* eschew the message body? */
1712                   int do_proto,         /* do Citadel protocol responses? */
1713                   int crlf,             /* Use CRLF newlines instead of LF? */
1714                   char *section,        /* NULL or a message/rfc822 section */
1715                   int flags,            /* various flags; see msgbase.h */
1716                   char **Author,
1717                   char **Address
1718 ) {
1719         struct CitContext *CCC = CC;
1720         struct CtdlMessage *TheMessage = NULL;
1721         int retcode = CIT_OK;
1722         struct encapmsg encap;
1723         int r;
1724
1725         MSG_syslog(LOG_DEBUG, "CtdlOutputMsg(msgnum=%ld, mode=%d, section=%s)\n", 
1726                 msg_num, mode,
1727                 (section ? section : "<>")
1728         );
1729
1730         r = CtdlDoIHavePermissionToReadMessagesInThisRoom();
1731         if (r != om_ok) {
1732                 if (do_proto) {
1733                         if (r == om_not_logged_in) {
1734                                 cprintf("%d Not logged in.\n", ERROR + NOT_LOGGED_IN);
1735                         }
1736                         else {
1737                                 cprintf("%d An unknown error has occurred.\n", ERROR);
1738                         }
1739                 }
1740                 return(r);
1741         }
1742
1743         /*
1744          * Check to make sure the message is actually IN this room
1745          */
1746         r = check_cached_msglist(msg_num);
1747         if (r == om_access_denied) {
1748                 /* Not in the cache?  We get ONE shot to check it again. */
1749                 CtdlForEachMessage(MSGS_ALL, 0L, NULL, NULL, NULL, NULL, NULL);
1750                 r = check_cached_msglist(msg_num);
1751         }
1752         if (r != om_ok) {
1753                 MSG_syslog(LOG_DEBUG, "Security check fail: message %ld is not in %s\n",
1754                            msg_num, CCC->room.QRname
1755                 );
1756                 if (do_proto) {
1757                         if (r == om_access_denied) {
1758                                 cprintf("%d message %ld was not found in this room\n",
1759                                         ERROR + HIGHER_ACCESS_REQUIRED,
1760                                         msg_num
1761                                 );
1762                         }
1763                 }
1764                 return(r);
1765         }
1766
1767         /*
1768          * Fetch the message from disk.  If we're in HEADERS_FAST mode,
1769          * request that we don't even bother loading the body into memory.
1770          */
1771         if (headers_only == HEADERS_FAST) {
1772                 TheMessage = CtdlFetchMessage(msg_num, 0);
1773         }
1774         else {
1775                 TheMessage = CtdlFetchMessage(msg_num, 1);
1776         }
1777
1778         if (TheMessage == NULL) {
1779                 if (do_proto) cprintf("%d Can't locate msg %ld on disk\n",
1780                         ERROR + MESSAGE_NOT_FOUND, msg_num);
1781                 return(om_no_such_msg);
1782         }
1783
1784         /* Here is the weird form of this command, to process only an
1785          * encapsulated message/rfc822 section.
1786          */
1787         if (section) if (!IsEmptyStr(section)) if (strcmp(section, "0")) {
1788                 memset(&encap, 0, sizeof encap);
1789                 safestrncpy(encap.desired_section, section, sizeof encap.desired_section);
1790                 mime_parser(TheMessage->cm_fields['M'],
1791                         NULL,
1792                         *extract_encapsulated_message,
1793                         NULL, NULL, (void *)&encap, 0
1794                 );
1795
1796                 if ((Author != NULL) && (*Author == NULL))
1797                 {
1798                         *Author = TheMessage->cm_fields['A'];
1799                         TheMessage->cm_fields['A'] = NULL;
1800                 }
1801                 if ((Address != NULL) && (*Address == NULL))
1802                 {       
1803                         *Address = TheMessage->cm_fields['F'];
1804                         TheMessage->cm_fields['F'] = NULL;
1805                 }
1806                 CtdlFreeMessage(TheMessage);
1807                 TheMessage = NULL;
1808
1809                 if (encap.msg) {
1810                         encap.msg[encap.msglen] = 0;
1811                         TheMessage = convert_internet_message(encap.msg);
1812                         encap.msg = NULL;       /* no free() here, TheMessage owns it now */
1813
1814                         /* Now we let it fall through to the bottom of this
1815                          * function, because TheMessage now contains the
1816                          * encapsulated message instead of the top-level
1817                          * message.  Isn't that neat?
1818                          */
1819
1820                 }
1821                 else {
1822                         if (do_proto) {
1823                                 cprintf("%d msg %ld has no part %s\n",
1824                                         ERROR + MESSAGE_NOT_FOUND,
1825                                         msg_num,
1826                                         section);
1827                         }
1828                         retcode = om_no_such_msg;
1829                 }
1830
1831         }
1832
1833         /* Ok, output the message now */
1834         if (retcode == CIT_OK)
1835                 retcode = CtdlOutputPreLoadedMsg(TheMessage, mode, headers_only, do_proto, crlf, flags);
1836         if ((Author != NULL) && (*Author == NULL))
1837         {
1838                 *Author = TheMessage->cm_fields['A'];
1839                 TheMessage->cm_fields['A'] = NULL;
1840         }
1841         if ((Address != NULL) && (*Address == NULL))
1842         {       
1843                 *Address = TheMessage->cm_fields['F'];
1844                 TheMessage->cm_fields['F'] = NULL;
1845         }
1846
1847         CtdlFreeMessage(TheMessage);
1848
1849         return(retcode);
1850 }
1851
1852
1853 char *qp_encode_email_addrs(char *source)
1854 {
1855         struct CitContext *CCC = CC;
1856         char *user, *node, *name;
1857         const char headerStr[] = "=?UTF-8?Q?";
1858         char *Encoded;
1859         char *EncodedName;
1860         char *nPtr;
1861         int need_to_encode = 0;
1862         long SourceLen;
1863         long EncodedMaxLen;
1864         long nColons = 0;
1865         long *AddrPtr;
1866         long *AddrUtf8;
1867         long nAddrPtrMax = 50;
1868         long nmax;
1869         int InQuotes = 0;
1870         int i, n;
1871
1872         if (source == NULL) return source;
1873         if (IsEmptyStr(source)) return source;
1874         if (MessageDebugEnabled != 0) cit_backtrace();
1875         MSG_syslog(LOG_DEBUG, "qp_encode_email_addrs: [%s]\n", source);
1876
1877         AddrPtr = malloc (sizeof (long) * nAddrPtrMax);
1878         AddrUtf8 = malloc (sizeof (long) * nAddrPtrMax);
1879         memset(AddrUtf8, 0, sizeof (long) * nAddrPtrMax);
1880         *AddrPtr = 0;
1881         i = 0;
1882         while (!IsEmptyStr (&source[i])) {
1883                 if (nColons >= nAddrPtrMax){
1884                         long *ptr;
1885
1886                         ptr = (long *) malloc(sizeof (long) * nAddrPtrMax * 2);
1887                         memcpy (ptr, AddrPtr, sizeof (long) * nAddrPtrMax);
1888                         free (AddrPtr), AddrPtr = ptr;
1889
1890                         ptr = (long *) malloc(sizeof (long) * nAddrPtrMax * 2);
1891                         memset(&ptr[nAddrPtrMax], 0, 
1892                                sizeof (long) * nAddrPtrMax);
1893
1894                         memcpy (ptr, AddrUtf8, sizeof (long) * nAddrPtrMax);
1895                         free (AddrUtf8), AddrUtf8 = ptr;
1896                         nAddrPtrMax *= 2;                               
1897                 }
1898                 if (((unsigned char) source[i] < 32) || 
1899                     ((unsigned char) source[i] > 126)) {
1900                         need_to_encode = 1;
1901                         AddrUtf8[nColons] = 1;
1902                 }
1903                 if (source[i] == '"')
1904                         InQuotes = !InQuotes;
1905                 if (!InQuotes && source[i] == ',') {
1906                         AddrPtr[nColons] = i;
1907                         nColons++;
1908                 }
1909                 i++;
1910         }
1911         if (need_to_encode == 0) {
1912                 free(AddrPtr);
1913                 free(AddrUtf8);
1914                 return source;
1915         }
1916
1917         SourceLen = i;
1918         EncodedMaxLen = nColons * (sizeof(headerStr) + 3) + SourceLen * 3;
1919         Encoded = (char*) malloc (EncodedMaxLen);
1920
1921         for (i = 0; i < nColons; i++)
1922                 source[AddrPtr[i]++] = '\0';
1923         /* TODO: if libidn, this might get larger*/
1924         user = malloc(SourceLen + 1);
1925         node = malloc(SourceLen + 1);
1926         name = malloc(SourceLen + 1);
1927
1928         nPtr = Encoded;
1929         *nPtr = '\0';
1930         for (i = 0; i < nColons && nPtr != NULL; i++) {
1931                 nmax = EncodedMaxLen - (nPtr - Encoded);
1932                 if (AddrUtf8[i]) {
1933                         process_rfc822_addr(&source[AddrPtr[i]], 
1934                                             user,
1935                                             node,
1936                                             name);
1937                         /* TODO: libIDN here ! */
1938                         if (IsEmptyStr(name)) {
1939                                 n = snprintf(nPtr, nmax, 
1940                                              (i==0)?"%s@%s" : ",%s@%s",
1941                                              user, node);
1942                         }
1943                         else {
1944                                 EncodedName = rfc2047encode(name, strlen(name));                        
1945                                 n = snprintf(nPtr, nmax, 
1946                                              (i==0)?"%s <%s@%s>" : ",%s <%s@%s>",
1947                                              EncodedName, user, node);
1948                                 free(EncodedName);
1949                         }
1950                 }
1951                 else { 
1952                         n = snprintf(nPtr, nmax, 
1953                                      (i==0)?"%s" : ",%s",
1954                                      &source[AddrPtr[i]]);
1955                 }
1956                 if (n > 0 )
1957                         nPtr += n;
1958                 else { 
1959                         char *ptr, *nnPtr;
1960                         ptr = (char*) malloc(EncodedMaxLen * 2);
1961                         memcpy(ptr, Encoded, EncodedMaxLen);
1962                         nnPtr = ptr + (nPtr - Encoded), nPtr = nnPtr;
1963                         free(Encoded), Encoded = ptr;
1964                         EncodedMaxLen *= 2;
1965                         i--; /* do it once more with properly lengthened buffer */
1966                 }
1967         }
1968         for (i = 0; i < nColons; i++)
1969                 source[--AddrPtr[i]] = ',';
1970
1971         free(user);
1972         free(node);
1973         free(name);
1974         free(AddrUtf8);
1975         free(AddrPtr);
1976         return Encoded;
1977 }
1978
1979
1980 /* If the last item in a list of recipients was truncated to a partial address,
1981  * remove it completely in order to avoid choking libSieve
1982  */
1983 void sanitize_truncated_recipient(char *str)
1984 {
1985         if (!str) return;
1986         if (num_tokens(str, ',') < 2) return;
1987
1988         int len = strlen(str);
1989         if (len < 900) return;
1990         if (len > 998) str[998] = 0;
1991
1992         char *cptr = strrchr(str, ',');
1993         if (!cptr) return;
1994
1995         char *lptr = strchr(cptr, '<');
1996         char *rptr = strchr(cptr, '>');
1997
1998         if ( (lptr) && (rptr) && (rptr > lptr) ) return;
1999
2000         *cptr = 0;
2001 }
2002
2003
2004 void OutputCtdlMsgHeaders(
2005         struct CtdlMessage *TheMessage,
2006         int do_proto)           /* do Citadel protocol responses? */
2007 {
2008         char allkeys[30];
2009         int i, k, n;
2010         int suppress_f = 0;
2011         char buf[SIZ];
2012         char display_name[256];
2013
2014         /* begin header processing loop for Citadel message format */
2015         safestrncpy(display_name, "<unknown>", sizeof display_name);
2016         if (TheMessage->cm_fields['A']) {
2017                 strcpy(buf, TheMessage->cm_fields['A']);
2018                 if (TheMessage->cm_anon_type == MES_ANONONLY) {
2019                         safestrncpy(display_name, "****", sizeof display_name);
2020                 }
2021                 else if (TheMessage->cm_anon_type == MES_ANONOPT) {
2022                         safestrncpy(display_name, "anonymous", sizeof display_name);
2023                 }
2024                 else {
2025                         safestrncpy(display_name, buf, sizeof display_name);
2026                 }
2027                 if ((is_room_aide())
2028                     && ((TheMessage->cm_anon_type == MES_ANONONLY)
2029                         || (TheMessage->cm_anon_type == MES_ANONOPT))) {
2030                         size_t tmp = strlen(display_name);
2031                         snprintf(&display_name[tmp],
2032                                  sizeof display_name - tmp,
2033                                  " [%s]", buf);
2034                 }
2035         }
2036
2037         /* Don't show Internet address for users on the
2038          * local Citadel network.
2039          */
2040         suppress_f = 0;
2041         if (TheMessage->cm_fields['N'] != NULL)
2042                 if (!IsEmptyStr(TheMessage->cm_fields['N']))
2043                         if (haschar(TheMessage->cm_fields['N'], '.') == 0) {
2044                                 suppress_f = 1;
2045                         }
2046
2047         /* Now spew the header fields in the order we like them. */
2048         n = safestrncpy(allkeys, FORDER, sizeof allkeys);
2049         for (i=0; i<n; ++i) {
2050                 k = (int) allkeys[i];
2051                 if (k != 'M') {
2052                         if ( (TheMessage->cm_fields[k] != NULL)
2053                              && (msgkeys[k] != NULL) ) {
2054                                 if ((k == 'V') || (k == 'R') || (k == 'Y')) {
2055                                         sanitize_truncated_recipient(TheMessage->cm_fields[k]);
2056                                 }
2057                                 if (k == 'A') {
2058                                         if (do_proto) cprintf("%s=%s\n",
2059                                                               msgkeys[k],
2060                                                               display_name);
2061                                 }
2062                                 else if ((k == 'F') && (suppress_f)) {
2063                                         /* do nothing */
2064                                 }
2065                                 /* Masquerade display name if needed */
2066                                 else {
2067                                         if (do_proto) cprintf("%s=%s\n",
2068                                                               msgkeys[k],
2069                                                               TheMessage->cm_fields[k]
2070                                                 );
2071                                 }
2072                         }
2073                 }
2074         }
2075
2076 }
2077
2078 void OutputRFC822MsgHeaders(
2079         struct CtdlMessage *TheMessage,
2080         int flags,              /* should the bessage be exported clean */
2081         const char *nl,
2082         char *mid, long sizeof_mid,
2083         char *suser, long sizeof_suser,
2084         char *luser, long sizeof_luser,
2085         char *fuser, long sizeof_fuser,
2086         char *snode, long sizeof_snode)
2087 {
2088         char datestamp[100];
2089         int subject_found = 0;
2090         char buf[SIZ];
2091         int i, j, k;
2092         char *mptr = NULL;
2093         char *mpptr = NULL;
2094         char *hptr;
2095
2096         for (i = 0; i < 256; ++i) {
2097                 if (TheMessage->cm_fields[i]) {
2098                         mptr = mpptr = TheMessage->cm_fields[i];
2099                                 
2100                         if (i == 'A') {
2101                                 safestrncpy(luser, mptr, sizeof_luser);
2102                                 safestrncpy(suser, mptr, sizeof_suser);
2103                         }
2104                         else if (i == 'Y') {
2105                                 if ((flags & QP_EADDR) != 0) {
2106                                         mptr = qp_encode_email_addrs(mptr);
2107                                 }
2108                                 sanitize_truncated_recipient(mptr);
2109                                 cprintf("CC: %s%s", mptr, nl);
2110                         }
2111                         else if (i == 'P') {
2112                                 cprintf("Return-Path: %s%s", mptr, nl);
2113                         }
2114                         else if (i == 'L') {
2115                                 cprintf("List-ID: %s%s", mptr, nl);
2116                         }
2117                         else if (i == 'V') {
2118                                 if ((flags & QP_EADDR) != 0) 
2119                                         mptr = qp_encode_email_addrs(mptr);
2120                                 hptr = mptr;
2121                                 while ((*hptr != '\0') && isspace(*hptr))
2122                                         hptr ++;
2123                                 if (!IsEmptyStr(hptr))
2124                                         cprintf("Envelope-To: %s%s", hptr, nl);
2125                         }
2126                         else if (i == 'U') {
2127                                 cprintf("Subject: %s%s", mptr, nl);
2128                                 subject_found = 1;
2129                         }
2130                         else if (i == 'I')
2131                                 safestrncpy(mid, mptr, sizeof_mid); /// TODO: detect @ here and copy @nodename in if not found.
2132                         else if (i == 'F')
2133                                 safestrncpy(fuser, mptr, sizeof_fuser);
2134                         /* else if (i == 'O')
2135                            cprintf("X-Citadel-Room: %s%s",
2136                            mptr, nl); */
2137                         else if (i == 'N')
2138                                 safestrncpy(snode, mptr, sizeof_snode);
2139                         else if (i == 'R')
2140                         {
2141                                 if (haschar(mptr, '@') == 0)
2142                                 {
2143                                         sanitize_truncated_recipient(mptr);
2144                                         cprintf("To: %s@%s", mptr, config.c_fqdn);
2145                                         cprintf("%s", nl);
2146                                 }
2147                                 else
2148                                 {
2149                                         if ((flags & QP_EADDR) != 0) {
2150                                                 mptr = qp_encode_email_addrs(mptr);
2151                                         }
2152                                         sanitize_truncated_recipient(mptr);
2153                                         cprintf("To: %s", mptr);
2154                                         cprintf("%s", nl);
2155                                 }
2156                         }
2157                         else if (i == 'T') {
2158                                 datestring(datestamp, sizeof datestamp,
2159                                            atol(mptr), DATESTRING_RFC822);
2160                                 cprintf("Date: %s%s", datestamp, nl);
2161                         }
2162                         else if (i == 'W') {
2163                                 cprintf("References: ");
2164                                 k = num_tokens(mptr, '|');
2165                                 for (j=0; j<k; ++j) {
2166                                         extract_token(buf, mptr, j, '|', sizeof buf);
2167                                         cprintf("<%s>", buf);
2168                                         if (j == (k-1)) {
2169                                                 cprintf("%s", nl);
2170                                         }
2171                                         else {
2172                                                 cprintf(" ");
2173                                         }
2174                                 }
2175                         }
2176                         else if (i == 'K') {
2177                                 hptr = mptr;
2178                                 while ((*hptr != '\0') && isspace(*hptr))
2179                                         hptr ++;
2180                                 if (!IsEmptyStr(hptr))
2181                                         cprintf("Reply-To: %s%s", mptr, nl);
2182                         }
2183                         if (mptr != mpptr)
2184                                 free (mptr);
2185                 }
2186         }
2187         if (subject_found == 0) {
2188                 cprintf("Subject: (no subject)%s", nl);
2189         }
2190 }
2191
2192
2193 void Dump_RFC822HeadersBody(
2194         struct CtdlMessage *TheMessage,
2195         int headers_only,       /* eschew the message body? */
2196         int flags,              /* should the bessage be exported clean? */
2197
2198         const char *nl)
2199 {
2200         cit_uint8_t prev_ch;
2201         int eoh = 0;
2202         const char *StartOfText = StrBufNOTNULL;
2203         char outbuf[1024];
2204         int outlen = 0;
2205         int nllen = strlen(nl);
2206         char *mptr;
2207
2208         mptr = TheMessage->cm_fields['M'];
2209
2210
2211         prev_ch = '\0';
2212         while (*mptr != '\0') {
2213                 if (*mptr == '\r') {
2214                         /* do nothing */
2215                 }
2216                 else {
2217                         if ((!eoh) &&
2218                             (*mptr == '\n'))
2219                         {
2220                                 eoh = (*(mptr+1) == '\r') && (*(mptr+2) == '\n');
2221                                 if (!eoh)
2222                                         eoh = *(mptr+1) == '\n';
2223                                 if (eoh)
2224                                 {
2225                                         StartOfText = mptr;
2226                                         StartOfText = strchr(StartOfText, '\n');
2227                                         StartOfText = strchr(StartOfText, '\n');
2228                                 }
2229                         }
2230                         if (((headers_only == HEADERS_NONE) && (mptr >= StartOfText)) ||
2231                             ((headers_only == HEADERS_ONLY) && (mptr < StartOfText)) ||
2232                             ((headers_only != HEADERS_NONE) && 
2233                              (headers_only != HEADERS_ONLY))
2234                                 ) {
2235                                 if (*mptr == '\n') {
2236                                         memcpy(&outbuf[outlen], nl, nllen);
2237                                         outlen += nllen;
2238                                         outbuf[outlen] = '\0';
2239                                 }
2240                                 else {
2241                                         outbuf[outlen++] = *mptr;
2242                                 }
2243                         }
2244                 }
2245                 if (flags & ESC_DOT)
2246                 {
2247                         if ((prev_ch == '\n') && 
2248                             (*mptr == '.') && 
2249                             ((*(mptr+1) == '\r') || (*(mptr+1) == '\n')))
2250                         {
2251                                 outbuf[outlen++] = '.';
2252                         }
2253                         prev_ch = *mptr;
2254                 }
2255                 ++mptr;
2256                 if (outlen > 1000) {
2257                         if (client_write(outbuf, outlen) == -1)
2258                         {
2259                                 struct CitContext *CCC = CC;
2260                                 MSGM_syslog(LOG_ERR, "Dump_RFC822HeadersBody(): aborting due to write failure.\n");
2261                                 return;
2262                         }
2263                         outlen = 0;
2264                 }
2265         }
2266         if (outlen > 0) {
2267                 client_write(outbuf, outlen);
2268         }
2269 }
2270
2271
2272
2273 /* If the format type on disk is 1 (fixed-format), then we want
2274  * everything to be output completely literally ... regardless of
2275  * what message transfer format is in use.
2276  */
2277 void DumpFormatFixed(
2278         struct CtdlMessage *TheMessage,
2279         int mode,               /* how would you like that message? */
2280         const char *nl)
2281 {
2282         cit_uint8_t ch;
2283         char buf[SIZ];
2284         int buflen;
2285         int xlline = 0;
2286         int nllen = strlen (nl);
2287         char *mptr;
2288
2289         mptr = TheMessage->cm_fields['M'];
2290         
2291         if (mode == MT_MIME) {
2292                 cprintf("Content-type: text/plain\n\n");
2293         }
2294         *buf = '\0';
2295         buflen = 0;
2296         while (ch = *mptr++, ch > 0) {
2297                 if (ch == '\n')
2298                         ch = '\r';
2299
2300                 if ((buflen > 250) && (!xlline)){
2301                         int tbuflen;
2302                         tbuflen = buflen;
2303
2304                         while ((buflen > 0) && 
2305                                (!isspace(buf[buflen])))
2306                                 buflen --;
2307                         if (buflen == 0) {
2308                                 xlline = 1;
2309                         }
2310                         else {
2311                                 mptr -= tbuflen - buflen;
2312                                 buf[buflen] = '\0';
2313                                 ch = '\r';
2314                         }
2315                 }
2316                 /* if we reach the outer bounds of our buffer, 
2317                    abort without respect what whe purge. */
2318                 if (xlline && 
2319                     ((isspace(ch)) || 
2320                      (buflen > SIZ - nllen - 2)))
2321                         ch = '\r';
2322
2323                 if (ch == '\r') {
2324                         memcpy (&buf[buflen], nl, nllen);
2325                         buflen += nllen;
2326                         buf[buflen] = '\0';
2327
2328                         if (client_write(buf, buflen) == -1)
2329                         {
2330                                 struct CitContext *CCC = CC;
2331                                 MSGM_syslog(LOG_ERR, "DumpFormatFixed(): aborting due to write failure.\n");
2332                                 return;
2333                         }
2334                         *buf = '\0';
2335                         buflen = 0;
2336                         xlline = 0;
2337                 } else {
2338                         buf[buflen] = ch;
2339                         buflen++;
2340                 }
2341         }
2342         buf[buflen] = '\0';
2343         if (!IsEmptyStr(buf))
2344                 cprintf("%s%s", buf, nl);
2345 }
2346
2347 /*
2348  * Get a message off disk.  (returns om_* values found in msgbase.h)
2349  */
2350 int CtdlOutputPreLoadedMsg(
2351                 struct CtdlMessage *TheMessage,
2352                 int mode,               /* how would you like that message? */
2353                 int headers_only,       /* eschew the message body? */
2354                 int do_proto,           /* do Citadel protocol responses? */
2355                 int crlf,               /* Use CRLF newlines instead of LF? */
2356                 int flags               /* should the bessage be exported clean? */
2357 ) {
2358         struct CitContext *CCC = CC;
2359         int i;
2360         char *mptr = NULL;
2361         const char *nl; /* newline string */
2362         struct ma_info ma;
2363
2364         /* Buffers needed for RFC822 translation.  These are all filled
2365          * using functions that are bounds-checked, and therefore we can
2366          * make them substantially smaller than SIZ.
2367          */
2368         char suser[100];
2369         char luser[100];
2370         char fuser[100];
2371         char snode[100];
2372         char mid[100];
2373
2374         MSG_syslog(LOG_DEBUG, "CtdlOutputPreLoadedMsg(TheMessage=%s, %d, %d, %d, %d\n",
2375                    ((TheMessage == NULL) ? "NULL" : "not null"),
2376                    mode, headers_only, do_proto, crlf);
2377
2378         strcpy(mid, "unknown");
2379         nl = (crlf ? "\r\n" : "\n");
2380
2381         if (!is_valid_message(TheMessage)) {
2382                 MSGM_syslog(LOG_ERR,
2383                             "ERROR: invalid preloaded message for output\n");
2384                 cit_backtrace ();
2385                 return(om_no_such_msg);
2386         }
2387
2388         /* Suppress envelope recipients if required to avoid disclosing BCC addresses.
2389          * Pad it with spaces in order to avoid changing the RFC822 length of the message.
2390          */
2391         if ( (flags & SUPPRESS_ENV_TO) && (TheMessage->cm_fields['V'] != NULL) ) {
2392                 memset(TheMessage->cm_fields['V'], ' ', strlen(TheMessage->cm_fields['V']));
2393         }
2394                 
2395         /* Are we downloading a MIME component? */
2396         if (mode == MT_DOWNLOAD) {
2397                 if (TheMessage->cm_format_type != FMT_RFC822) {
2398                         if (do_proto)
2399                                 cprintf("%d This is not a MIME message.\n",
2400                                 ERROR + ILLEGAL_VALUE);
2401                 } else if (CCC->download_fp != NULL) {
2402                         if (do_proto) cprintf(
2403                                 "%d You already have a download open.\n",
2404                                 ERROR + RESOURCE_BUSY);
2405                 } else {
2406                         /* Parse the message text component */
2407                         mptr = TheMessage->cm_fields['M'];
2408                         mime_parser(mptr, NULL, *mime_download, NULL, NULL, NULL, 0);
2409                         /* If there's no file open by this time, the requested
2410                          * section wasn't found, so print an error
2411                          */
2412                         if (CCC->download_fp == NULL) {
2413                                 if (do_proto) cprintf(
2414                                         "%d Section %s not found.\n",
2415                                         ERROR + FILE_NOT_FOUND,
2416                                         CCC->download_desired_section);
2417                         }
2418                 }
2419                 return((CCC->download_fp != NULL) ? om_ok : om_mime_error);
2420         }
2421
2422         /* MT_SPEW_SECTION is like MT_DOWNLOAD except it outputs the whole MIME part
2423          * in a single server operation instead of opening a download file.
2424          */
2425         if (mode == MT_SPEW_SECTION) {
2426                 if (TheMessage->cm_format_type != FMT_RFC822) {
2427                         if (do_proto)
2428                                 cprintf("%d This is not a MIME message.\n",
2429                                 ERROR + ILLEGAL_VALUE);
2430                 } else {
2431                         /* Parse the message text component */
2432                         int found_it = 0;
2433
2434                         mptr = TheMessage->cm_fields['M'];
2435                         mime_parser(mptr, NULL, *mime_spew_section, NULL, NULL, (void *)&found_it, 0);
2436                         /* If section wasn't found, print an error
2437                          */
2438                         if (!found_it) {
2439                                 if (do_proto) cprintf(
2440                                         "%d Section %s not found.\n",
2441                                         ERROR + FILE_NOT_FOUND,
2442                                         CCC->download_desired_section);
2443                         }
2444                 }
2445                 return((CCC->download_fp != NULL) ? om_ok : om_mime_error);
2446         }
2447
2448         /* now for the user-mode message reading loops */
2449         if (do_proto) cprintf("%d msg:\n", LISTING_FOLLOWS);
2450
2451         /* Does the caller want to skip the headers? */
2452         if (headers_only == HEADERS_NONE) goto START_TEXT;
2453
2454         /* Tell the client which format type we're using. */
2455         if ( (mode == MT_CITADEL) && (do_proto) ) {
2456                 cprintf("type=%d\n", TheMessage->cm_format_type);
2457         }
2458
2459         /* nhdr=yes means that we're only displaying headers, no body */
2460         if ( (TheMessage->cm_anon_type == MES_ANONONLY)
2461            && ((mode == MT_CITADEL) || (mode == MT_MIME))
2462            && (do_proto)
2463            ) {
2464                 cprintf("nhdr=yes\n");
2465         }
2466
2467         if ((mode == MT_CITADEL) || (mode == MT_MIME)) 
2468                 OutputCtdlMsgHeaders(TheMessage, do_proto);
2469
2470
2471         /* begin header processing loop for RFC822 transfer format */
2472         strcpy(suser, "");
2473         strcpy(luser, "");
2474         strcpy(fuser, "");
2475         strcpy(snode, NODENAME);
2476         if (mode == MT_RFC822) 
2477                 OutputRFC822MsgHeaders(
2478                         TheMessage,
2479                         flags,
2480                         nl,
2481                         mid, sizeof(mid),
2482                         suser, sizeof(suser),
2483                         luser, sizeof(luser),
2484                         fuser, sizeof(fuser),
2485                         snode, sizeof(snode)
2486                         );
2487
2488
2489         for (i=0; !IsEmptyStr(&suser[i]); ++i) {
2490                 suser[i] = tolower(suser[i]);
2491                 if (!isalnum(suser[i])) suser[i]='_';
2492         }
2493
2494         if (mode == MT_RFC822) {
2495                 if (!strcasecmp(snode, NODENAME)) {
2496                         safestrncpy(snode, FQDN, sizeof snode);
2497                 }
2498
2499                 /* Construct a fun message id */
2500                 cprintf("Message-ID: <%s", mid);/// todo: this possibly breaks threadding mails.
2501                 if (strchr(mid, '@')==NULL) {
2502                         cprintf("@%s", snode);
2503                 }
2504                 cprintf(">%s", nl);
2505
2506                 if (!is_room_aide() && (TheMessage->cm_anon_type == MES_ANONONLY)) {
2507                         cprintf("From: \"----\" <x@x.org>%s", nl);
2508                 }
2509                 else if (!is_room_aide() && (TheMessage->cm_anon_type == MES_ANONOPT)) {
2510                         cprintf("From: \"anonymous\" <x@x.org>%s", nl);
2511                 }
2512                 else if (!IsEmptyStr(fuser)) {
2513                         cprintf("From: \"%s\" <%s>%s", luser, fuser, nl);
2514                 }
2515                 else {
2516                         cprintf("From: \"%s\" <%s@%s>%s", luser, suser, snode, nl);
2517                 }
2518
2519                 /* Blank line signifying RFC822 end-of-headers */
2520                 if (TheMessage->cm_format_type != FMT_RFC822) {
2521                         cprintf("%s", nl);
2522                 }
2523         }
2524
2525         /* end header processing loop ... at this point, we're in the text */
2526 START_TEXT:
2527         if (headers_only == HEADERS_FAST) goto DONE;
2528
2529         /* Tell the client about the MIME parts in this message */
2530         if (TheMessage->cm_format_type == FMT_RFC822) {
2531                 if ( (mode == MT_CITADEL) || (mode == MT_MIME) ) {
2532                         mptr = TheMessage->cm_fields['M'];
2533                         memset(&ma, 0, sizeof(struct ma_info));
2534                         mime_parser(mptr, NULL,
2535                                 (do_proto ? *list_this_part : NULL),
2536                                 (do_proto ? *list_this_pref : NULL),
2537                                 (do_proto ? *list_this_suff : NULL),
2538                                 (void *)&ma, 1);
2539                 }
2540                 else if (mode == MT_RFC822) {   /* unparsed RFC822 dump */
2541                         Dump_RFC822HeadersBody(
2542                                 TheMessage,
2543                                 headers_only,
2544                                 flags,
2545                                 nl);
2546                         goto DONE;
2547                 }
2548         }
2549
2550         if (headers_only == HEADERS_ONLY) {
2551                 goto DONE;
2552         }
2553
2554         /* signify start of msg text */
2555         if ( (mode == MT_CITADEL) || (mode == MT_MIME) ) {
2556                 if (do_proto) cprintf("text\n");
2557         }
2558
2559         if (TheMessage->cm_format_type == FMT_FIXED) 
2560                 DumpFormatFixed(
2561                         TheMessage,
2562                         mode,           /* how would you like that message? */
2563                         nl);
2564
2565         /* If the message on disk is format 0 (Citadel vari-format), we
2566          * output using the formatter at 80 columns.  This is the final output
2567          * form if the transfer format is RFC822, but if the transfer format
2568          * is Citadel proprietary, it'll still work, because the indentation
2569          * for new paragraphs is correct and the client will reformat the
2570          * message to the reader's screen width.
2571          */
2572         if (TheMessage->cm_format_type == FMT_CITADEL) {
2573                 mptr = TheMessage->cm_fields['M'];
2574
2575                 if (mode == MT_MIME) {
2576                         cprintf("Content-type: text/x-citadel-variformat\n\n");
2577                 }
2578                 memfmout(mptr, nl);
2579         }
2580
2581         /* If the message on disk is format 4 (MIME), we've gotta hand it
2582          * off to the MIME parser.  The client has already been told that
2583          * this message is format 1 (fixed format), so the callback function
2584          * we use will display those parts as-is.
2585          */
2586         if (TheMessage->cm_format_type == FMT_RFC822) {
2587                 memset(&ma, 0, sizeof(struct ma_info));
2588
2589                 if (mode == MT_MIME) {
2590                         ma.use_fo_hooks = 0;
2591                         strcpy(ma.chosen_part, "1");
2592                         ma.chosen_pref = 9999;
2593                         ma.dont_decode = CCC->msg4_dont_decode;
2594                         mime_parser(mptr, NULL,
2595                                 *choose_preferred, *fixed_output_pre,
2596                                 *fixed_output_post, (void *)&ma, 1);
2597                         mime_parser(mptr, NULL,
2598                                 *output_preferred, NULL, NULL, (void *)&ma, 1);
2599                 }
2600                 else {
2601                         ma.use_fo_hooks = 1;
2602                         mime_parser(mptr, NULL,
2603                                 *fixed_output, *fixed_output_pre,
2604                                 *fixed_output_post, (void *)&ma, 0);
2605                 }
2606
2607         }
2608
2609 DONE:   /* now we're done */
2610         if (do_proto) cprintf("000\n");
2611         return(om_ok);
2612 }
2613
2614
2615 /*
2616  * display a message (mode 0 - Citadel proprietary)
2617  */
2618 void cmd_msg0(char *cmdbuf)
2619 {
2620         long msgid;
2621         int headers_only = HEADERS_ALL;
2622
2623         msgid = extract_long(cmdbuf, 0);
2624         headers_only = extract_int(cmdbuf, 1);
2625
2626         CtdlOutputMsg(msgid, MT_CITADEL, headers_only, 1, 0, NULL, 0, NULL, NULL);
2627         return;
2628 }
2629
2630
2631 /*
2632  * display a message (mode 2 - RFC822)
2633  */
2634 void cmd_msg2(char *cmdbuf)
2635 {
2636         long msgid;
2637         int headers_only = HEADERS_ALL;
2638
2639         msgid = extract_long(cmdbuf, 0);
2640         headers_only = extract_int(cmdbuf, 1);
2641
2642         CtdlOutputMsg(msgid, MT_RFC822, headers_only, 1, 1, NULL, 0, NULL, NULL);
2643 }
2644
2645
2646
2647 /* 
2648  * display a message (mode 3 - IGnet raw format - internal programs only)
2649  */
2650 void cmd_msg3(char *cmdbuf)
2651 {
2652         long msgnum;
2653         struct CtdlMessage *msg = NULL;
2654         struct ser_ret smr;
2655
2656         if (CC->internal_pgm == 0) {
2657                 cprintf("%d This command is for internal programs only.\n",
2658                         ERROR + HIGHER_ACCESS_REQUIRED);
2659                 return;
2660         }
2661
2662         msgnum = extract_long(cmdbuf, 0);
2663         msg = CtdlFetchMessage(msgnum, 1);
2664         if (msg == NULL) {
2665                 cprintf("%d Message %ld not found.\n", 
2666                         ERROR + MESSAGE_NOT_FOUND, msgnum);
2667                 return;
2668         }
2669
2670         serialize_message(&smr, msg);
2671         CtdlFreeMessage(msg);
2672
2673         if (smr.len == 0) {
2674                 cprintf("%d Unable to serialize message\n",
2675                         ERROR + INTERNAL_ERROR);
2676                 return;
2677         }
2678
2679         cprintf("%d %ld\n", BINARY_FOLLOWS, (long)smr.len);
2680         client_write((char *)smr.ser, (int)smr.len);
2681         free(smr.ser);
2682 }
2683
2684
2685
2686 /* 
2687  * Display a message using MIME content types
2688  */
2689 void cmd_msg4(char *cmdbuf)
2690 {
2691         long msgid;
2692         char section[64];
2693
2694         msgid = extract_long(cmdbuf, 0);
2695         extract_token(section, cmdbuf, 1, '|', sizeof section);
2696         CtdlOutputMsg(msgid, MT_MIME, 0, 1, 0, (section[0] ? section : NULL) , 0, NULL, NULL);
2697 }
2698
2699
2700
2701 /* 
2702  * Client tells us its preferred message format(s)
2703  */
2704 void cmd_msgp(char *cmdbuf)
2705 {
2706         if (!strcasecmp(cmdbuf, "dont_decode")) {
2707                 CC->msg4_dont_decode = 1;
2708                 cprintf("%d MSG4 will not pre-decode messages.\n", CIT_OK);
2709         }
2710         else {
2711                 safestrncpy(CC->preferred_formats, cmdbuf, sizeof(CC->preferred_formats));
2712                 cprintf("%d Preferred MIME formats have been set.\n", CIT_OK);
2713         }
2714 }
2715
2716
2717 /*
2718  * Open a component of a MIME message as a download file 
2719  */
2720 void cmd_opna(char *cmdbuf)
2721 {
2722         long msgid;
2723         char desired_section[128];
2724
2725         msgid = extract_long(cmdbuf, 0);
2726         extract_token(desired_section, cmdbuf, 1, '|', sizeof desired_section);
2727         safestrncpy(CC->download_desired_section, desired_section,
2728                 sizeof CC->download_desired_section);
2729         CtdlOutputMsg(msgid, MT_DOWNLOAD, 0, 1, 1, NULL, 0, NULL, NULL);
2730 }                       
2731
2732
2733 /*
2734  * Open a component of a MIME message and transmit it all at once
2735  */
2736 void cmd_dlat(char *cmdbuf)
2737 {
2738         long msgid;
2739         char desired_section[128];
2740
2741         msgid = extract_long(cmdbuf, 0);
2742         extract_token(desired_section, cmdbuf, 1, '|', sizeof desired_section);
2743         safestrncpy(CC->download_desired_section, desired_section,
2744                 sizeof CC->download_desired_section);
2745         CtdlOutputMsg(msgid, MT_SPEW_SECTION, 0, 1, 1, NULL, 0, NULL, NULL);
2746 }
2747
2748
2749 /*
2750  * Save one or more message pointers into a specified room
2751  * (Returns 0 for success, nonzero for failure)
2752  * roomname may be NULL to use the current room
2753  *
2754  * Note that the 'supplied_msg' field may be set to NULL, in which case
2755  * the message will be fetched from disk, by number, if we need to perform
2756  * replication checks.  This adds an additional database read, so if the
2757  * caller already has the message in memory then it should be supplied.  (Obviously
2758  * this mode of operation only works if we're saving a single message.)
2759  */
2760 int CtdlSaveMsgPointersInRoom(char *roomname, long newmsgidlist[], int num_newmsgs,
2761                         int do_repl_check, struct CtdlMessage *supplied_msg, int suppress_refcount_adj
2762 ) {
2763         struct CitContext *CCC = CC;
2764         int i, j, unique;
2765         char hold_rm[ROOMNAMELEN];
2766         struct cdbdata *cdbfr;
2767         int num_msgs;
2768         long *msglist;
2769         long highest_msg = 0L;
2770
2771         long msgid = 0;
2772         struct CtdlMessage *msg = NULL;
2773
2774         long *msgs_to_be_merged = NULL;
2775         int num_msgs_to_be_merged = 0;
2776
2777         MSG_syslog(LOG_DEBUG,
2778                    "CtdlSaveMsgPointersInRoom(room=%s, num_msgs=%d, repl=%d, suppress_rca=%d)\n",
2779                    roomname, num_newmsgs, do_repl_check, suppress_refcount_adj
2780         );
2781
2782         strcpy(hold_rm, CCC->room.QRname);
2783
2784         /* Sanity checks */
2785         if (newmsgidlist == NULL) return(ERROR + INTERNAL_ERROR);
2786         if (num_newmsgs < 1) return(ERROR + INTERNAL_ERROR);
2787         if (num_newmsgs > 1) supplied_msg = NULL;
2788
2789         /* Now the regular stuff */
2790         if (CtdlGetRoomLock(&CCC->room,
2791            ((roomname != NULL) ? roomname : CCC->room.QRname) )
2792            != 0) {
2793                 MSG_syslog(LOG_ERR, "No such room <%s>\n", roomname);
2794                 return(ERROR + ROOM_NOT_FOUND);
2795         }
2796
2797
2798         msgs_to_be_merged = malloc(sizeof(long) * num_newmsgs);
2799         num_msgs_to_be_merged = 0;
2800
2801
2802         cdbfr = cdb_fetch(CDB_MSGLISTS, &CCC->room.QRnumber, sizeof(long));
2803         if (cdbfr == NULL) {
2804                 msglist = NULL;
2805                 num_msgs = 0;
2806         } else {
2807                 msglist = (long *) cdbfr->ptr;
2808                 cdbfr->ptr = NULL;      /* CtdlSaveMsgPointerInRoom() now owns this memory */
2809                 num_msgs = cdbfr->len / sizeof(long);
2810                 cdb_free(cdbfr);
2811         }
2812
2813
2814         /* Create a list of msgid's which were supplied by the caller, but do
2815          * not already exist in the target room.  It is absolutely taboo to
2816          * have more than one reference to the same message in a room.
2817          */
2818         for (i=0; i<num_newmsgs; ++i) {
2819                 unique = 1;
2820                 if (num_msgs > 0) for (j=0; j<num_msgs; ++j) {
2821                         if (msglist[j] == newmsgidlist[i]) {
2822                                 unique = 0;
2823                         }
2824                 }
2825                 if (unique) {
2826                         msgs_to_be_merged[num_msgs_to_be_merged++] = newmsgidlist[i];
2827                 }
2828         }
2829
2830         MSG_syslog(LOG_DEBUG, "%d unique messages to be merged\n", num_msgs_to_be_merged);
2831
2832         /*
2833          * Now merge the new messages
2834          */
2835         msglist = realloc(msglist, (sizeof(long) * (num_msgs + num_msgs_to_be_merged)) );
2836         if (msglist == NULL) {
2837                 MSGM_syslog(LOG_ALERT, "ERROR: can't realloc message list!\n");
2838                 free(msgs_to_be_merged);
2839                 return (ERROR + INTERNAL_ERROR);
2840         }
2841         memcpy(&msglist[num_msgs], msgs_to_be_merged, (sizeof(long) * num_msgs_to_be_merged) );
2842         num_msgs += num_msgs_to_be_merged;
2843
2844         /* Sort the message list, so all the msgid's are in order */
2845         num_msgs = sort_msglist(msglist, num_msgs);
2846
2847         /* Determine the highest message number */
2848         highest_msg = msglist[num_msgs - 1];
2849
2850         /* Write it back to disk. */
2851         cdb_store(CDB_MSGLISTS, &CCC->room.QRnumber, (int)sizeof(long),
2852                   msglist, (int)(num_msgs * sizeof(long)));
2853
2854         /* Free up the memory we used. */
2855         free(msglist);
2856
2857         /* Update the highest-message pointer and unlock the room. */
2858         CCC->room.QRhighest = highest_msg;
2859         CtdlPutRoomLock(&CCC->room);
2860
2861         /* Perform replication checks if necessary */
2862         if ( (DoesThisRoomNeedEuidIndexing(&CCC->room)) && (do_repl_check) ) {
2863                 MSGM_syslog(LOG_DEBUG, "CtdlSaveMsgPointerInRoom() doing repl checks\n");
2864
2865                 for (i=0; i<num_msgs_to_be_merged; ++i) {
2866                         msgid = msgs_to_be_merged[i];
2867         
2868                         if (supplied_msg != NULL) {
2869                                 msg = supplied_msg;
2870                         }
2871                         else {
2872                                 msg = CtdlFetchMessage(msgid, 0);
2873                         }
2874         
2875                         if (msg != NULL) {
2876                                 ReplicationChecks(msg);
2877                 
2878                                 /* If the message has an Exclusive ID, index that... */
2879                                 if (msg->cm_fields['E'] != NULL) {
2880                                         index_message_by_euid(msg->cm_fields['E'], &CCC->room, msgid);
2881                                 }
2882
2883                                 /* Free up the memory we may have allocated */
2884                                 if (msg != supplied_msg) {
2885                                         CtdlFreeMessage(msg);
2886                                 }
2887                         }
2888         
2889                 }
2890         }
2891
2892         else {
2893                 MSGM_syslog(LOG_DEBUG, "CtdlSaveMsgPointerInRoom() skips repl checks\n");
2894         }
2895
2896         /* Submit this room for processing by hooks */
2897         PerformRoomHooks(&CCC->room);
2898
2899         /* Go back to the room we were in before we wandered here... */
2900         CtdlGetRoom(&CCC->room, hold_rm);
2901
2902         /* Bump the reference count for all messages which were merged */
2903         if (!suppress_refcount_adj) {
2904                 AdjRefCountList(msgs_to_be_merged, num_msgs_to_be_merged, +1);
2905         }
2906
2907         /* Free up memory... */
2908         if (msgs_to_be_merged != NULL) {
2909                 free(msgs_to_be_merged);
2910         }
2911
2912         /* Return success. */
2913         return (0);
2914 }
2915
2916
2917 /*
2918  * This is the same as CtdlSaveMsgPointersInRoom() but it only accepts
2919  * a single message.
2920  */
2921 int CtdlSaveMsgPointerInRoom(char *roomname, long msgid,
2922                              int do_repl_check, struct CtdlMessage *supplied_msg)
2923 {
2924         return CtdlSaveMsgPointersInRoom(roomname, &msgid, 1, do_repl_check, supplied_msg, 0);
2925 }
2926
2927
2928
2929
2930 /*
2931  * Message base operation to save a new message to the message store
2932  * (returns new message number)
2933  *
2934  * This is the back end for CtdlSubmitMsg() and should not be directly
2935  * called by server-side modules.
2936  *
2937  */
2938 long send_message(struct CtdlMessage *msg) {
2939         struct CitContext *CCC = CC;
2940         long newmsgid;
2941         long retval;
2942         char msgidbuf[256];
2943         struct ser_ret smr;
2944         int is_bigmsg = 0;
2945         char *holdM = NULL;
2946
2947         /* Get a new message number */
2948         newmsgid = get_new_message_number();
2949         snprintf(msgidbuf, sizeof msgidbuf, "%08lX-%08lX@%s",
2950                  (long unsigned int) time(NULL),
2951                  (long unsigned int) newmsgid,
2952                  config.c_fqdn
2953                 );
2954
2955         /* Generate an ID if we don't have one already */
2956         if (msg->cm_fields['I']==NULL) {
2957                 msg->cm_fields['I'] = strdup(msgidbuf);
2958         }
2959
2960         /* If the message is big, set its body aside for storage elsewhere */
2961         if (msg->cm_fields['M'] != NULL) {
2962                 if (strlen(msg->cm_fields['M']) > BIGMSG) {
2963                         is_bigmsg = 1;
2964                         holdM = msg->cm_fields['M'];
2965                         msg->cm_fields['M'] = NULL;
2966                 }
2967         }
2968
2969         /* Serialize our data structure for storage in the database */  
2970         serialize_message(&smr, msg);
2971
2972         if (is_bigmsg) {
2973                 msg->cm_fields['M'] = holdM;
2974         }
2975
2976         if (smr.len == 0) {
2977                 cprintf("%d Unable to serialize message\n",
2978                         ERROR + INTERNAL_ERROR);
2979                 return (-1L);
2980         }
2981
2982         /* Write our little bundle of joy into the message base */
2983         if (cdb_store(CDB_MSGMAIN, &newmsgid, (int)sizeof(long),
2984                       smr.ser, smr.len) < 0) {
2985                 MSGM_syslog(LOG_ERR, "Can't store message\n");
2986                 retval = 0L;
2987         } else {
2988                 if (is_bigmsg) {
2989                         cdb_store(CDB_BIGMSGS,
2990                                   &newmsgid,
2991                                   (int)sizeof(long),
2992                                   holdM,
2993                                   (strlen(holdM) + 1)
2994                                 );
2995                 }
2996                 retval = newmsgid;
2997         }
2998
2999         /* Free the memory we used for the serialized message */
3000         free(smr.ser);
3001
3002         /* Return the *local* message ID to the caller
3003          * (even if we're storing an incoming network message)
3004          */
3005         return(retval);
3006 }
3007
3008
3009
3010 /*
3011  * Serialize a struct CtdlMessage into the format used on disk and network.
3012  * 
3013  * This function loads up a "struct ser_ret" (defined in server.h) which
3014  * contains the length of the serialized message and a pointer to the
3015  * serialized message in memory.  THE LATTER MUST BE FREED BY THE CALLER.
3016  */
3017 void serialize_message(struct ser_ret *ret,             /* return values */
3018                        struct CtdlMessage *msg) /* unserialized msg */
3019 {
3020         struct CitContext *CCC = CC;
3021         size_t wlen, fieldlen;
3022         int i;
3023         static char *forder = FORDER;
3024         int n = sizeof(FORDER) - 1;
3025         long lengths[sizeof(FORDER)];
3026         
3027         memset(lengths, 0, sizeof(lengths));
3028
3029         /*
3030          * Check for valid message format
3031          */
3032         if (is_valid_message(msg) == 0) {
3033                 MSGM_syslog(LOG_ERR, "serialize_message() aborting due to invalid message\n");
3034                 ret->len = 0;
3035                 ret->ser = NULL;
3036                 return;
3037         }
3038
3039         ret->len = 3;
3040         for (i=0; i<n; ++i)
3041                 if (msg->cm_fields[(int)forder[i]] != NULL)
3042                 {
3043                         lengths[i] = strlen(msg->cm_fields[(int)forder[i]]);
3044                         ret->len += lengths[i] + 2;
3045                 }
3046
3047         ret->ser = malloc(ret->len);
3048         if (ret->ser == NULL) {
3049                 MSG_syslog(LOG_ERR, "serialize_message() malloc(%ld) failed: %s\n",
3050                            (long)ret->len, strerror(errno));
3051                 ret->len = 0;
3052                 ret->ser = NULL;
3053                 return;
3054         }
3055
3056         ret->ser[0] = 0xFF;
3057         ret->ser[1] = msg->cm_anon_type;
3058         ret->ser[2] = msg->cm_format_type;
3059         wlen = 3;
3060
3061         for (i=0; i<n; ++i)
3062                 if (msg->cm_fields[(int)forder[i]] != NULL)
3063                 {
3064                         fieldlen = lengths[i];
3065                         ret->ser[wlen++] = (char)forder[i];
3066
3067                         memcpy(&ret->ser[wlen],
3068                                msg->cm_fields[(int)forder[i]],
3069                                fieldlen+1);
3070
3071                         wlen = wlen + fieldlen + 1;
3072                 }
3073
3074         if (ret->len != wlen) {
3075                 MSG_syslog(LOG_ERR, "ERROR: len=%ld wlen=%ld\n",
3076                            (long)ret->len, (long)wlen);
3077         }
3078
3079         return;
3080 }
3081
3082
3083 /*
3084  * Check to see if any messages already exist in the current room which
3085  * carry the same Exclusive ID as this one.  If any are found, delete them.
3086  */
3087 void ReplicationChecks(struct CtdlMessage *msg) {
3088         struct CitContext *CCC = CC;
3089         long old_msgnum = (-1L);
3090
3091         if (DoesThisRoomNeedEuidIndexing(&CCC->room) == 0) return;
3092
3093         MSG_syslog(LOG_DEBUG, "Performing replication checks in <%s>\n",
3094                    CCC->room.QRname);
3095
3096         /* No exclusive id?  Don't do anything. */
3097         if (msg == NULL) return;
3098         if (msg->cm_fields['E'] == NULL) return;
3099         if (IsEmptyStr(msg->cm_fields['E'])) return;
3100         /*MSG_syslog(LOG_DEBUG, "Exclusive ID: <%s> for room <%s>\n",
3101           msg->cm_fields['E'], CCC->room.QRname);*/
3102
3103         old_msgnum = CtdlLocateMessageByEuid(msg->cm_fields['E'], &CCC->room);
3104         if (old_msgnum > 0L) {
3105                 MSG_syslog(LOG_DEBUG, "ReplicationChecks() replacing message %ld\n", old_msgnum);
3106                 CtdlDeleteMessages(CCC->room.QRname, &old_msgnum, 1, "");
3107         }
3108 }
3109
3110
3111
3112 /*
3113  * Save a message to disk and submit it into the delivery system.
3114  */
3115 long CtdlSubmitMsg(struct CtdlMessage *msg,     /* message to save */
3116                    struct recptypes *recps,     /* recipients (if mail) */
3117                    const char *force,           /* force a particular room? */
3118                    int flags                    /* should the message be exported clean? */
3119         )
3120 {
3121         char submit_filename[128];
3122         char generated_timestamp[32];
3123         char hold_rm[ROOMNAMELEN];
3124         char actual_rm[ROOMNAMELEN];
3125         char force_room[ROOMNAMELEN];
3126         char content_type[SIZ];                 /* We have to learn this */
3127         char recipient[SIZ];
3128         const char *room;
3129         long newmsgid;
3130         const char *mptr = NULL;
3131         struct ctdluser userbuf;
3132         int a, i;
3133         struct MetaData smi;
3134         FILE *network_fp = NULL;
3135         static int seqnum = 1;
3136         struct CtdlMessage *imsg = NULL;
3137         char *instr = NULL;
3138         size_t instr_alloc = 0;
3139         struct ser_ret smr;
3140         char *hold_R, *hold_D;
3141         char *collected_addresses = NULL;
3142         struct addresses_to_be_filed *aptr = NULL;
3143         StrBuf *saved_rfc822_version = NULL;
3144         int qualified_for_journaling = 0;
3145         CitContext *CCC = MyContext();
3146         char bounce_to[1024] = "";
3147         int rv = 0;
3148
3149         MSGM_syslog(LOG_DEBUG, "CtdlSubmitMsg() called\n");
3150         if (is_valid_message(msg) == 0) return(-1);     /* self check */
3151
3152         /* If this message has no timestamp, we take the liberty of
3153          * giving it one, right now.
3154          */
3155         if (msg->cm_fields['T'] == NULL) {
3156                 snprintf(generated_timestamp, sizeof generated_timestamp, "%ld", (long)time(NULL));
3157                 msg->cm_fields['T'] = strdup(generated_timestamp);
3158         }
3159
3160         /* If this message has no path, we generate one.
3161          */
3162         if (msg->cm_fields['P'] == NULL) {
3163                 if (msg->cm_fields['A'] != NULL) {
3164                         msg->cm_fields['P'] = strdup(msg->cm_fields['A']);
3165                         for (a=0; !IsEmptyStr(&msg->cm_fields['P'][a]); ++a) {
3166                                 if (isspace(msg->cm_fields['P'][a])) {
3167                                         msg->cm_fields['P'][a] = ' ';
3168                                 }
3169                         }
3170                 }
3171                 else {
3172                         msg->cm_fields['P'] = strdup("unknown");
3173                 }
3174         }
3175
3176         if (force == NULL) {
3177                 strcpy(force_room, "");
3178         }
3179         else {
3180                 strcpy(force_room, force);
3181         }
3182
3183         /* Learn about what's inside, because it's what's inside that counts */
3184         if (msg->cm_fields['M'] == NULL) {
3185                 MSGM_syslog(LOG_ERR, "ERROR: attempt to save message with NULL body\n");
3186                 return(-2);
3187         }
3188
3189         switch (msg->cm_format_type) {
3190         case 0:
3191                 strcpy(content_type, "text/x-citadel-variformat");
3192                 break;
3193         case 1:
3194                 strcpy(content_type, "text/plain");
3195                 break;
3196         case 4:
3197                 strcpy(content_type, "text/plain");
3198                 mptr = bmstrcasestr(msg->cm_fields['M'], "Content-type:");
3199                 if (mptr != NULL) {
3200                         char *aptr;
3201                         safestrncpy(content_type, &mptr[13], sizeof content_type);
3202                         striplt(content_type);
3203                         aptr = content_type;
3204                         while (!IsEmptyStr(aptr)) {
3205                                 if ((*aptr == ';')
3206                                     || (*aptr == ' ')
3207                                     || (*aptr == 13)
3208                                     || (*aptr == 10)) {
3209                                         *aptr = 0;
3210                                 }
3211                                 else aptr++;
3212                         }
3213                 }
3214         }
3215
3216         /* Goto the correct room */
3217         room = (recps) ? CCC->room.QRname : SENTITEMS;
3218         MSG_syslog(LOG_DEBUG, "Selected room %s\n", room);
3219         strcpy(hold_rm, CCC->room.QRname);
3220         strcpy(actual_rm, CCC->room.QRname);
3221         if (recps != NULL) {
3222                 strcpy(actual_rm, SENTITEMS);
3223         }
3224
3225         /* If the user is a twit, move to the twit room for posting */
3226         if (TWITDETECT) {
3227                 if (CCC->user.axlevel == AxProbU) {
3228                         strcpy(hold_rm, actual_rm);
3229                         strcpy(actual_rm, config.c_twitroom);
3230                         MSGM_syslog(LOG_DEBUG, "Diverting to twit room\n");
3231                 }
3232         }
3233
3234         /* ...or if this message is destined for Aide> then go there. */
3235         if (!IsEmptyStr(force_room)) {
3236                 strcpy(actual_rm, force_room);
3237         }
3238
3239         MSG_syslog(LOG_INFO, "Final selection: %s (%s)\n", actual_rm, room);
3240         if (strcasecmp(actual_rm, CCC->room.QRname)) {
3241                 /* CtdlGetRoom(&CCC->room, actual_rm); */
3242                 CtdlUserGoto(actual_rm, 0, 1, NULL, NULL);
3243         }
3244
3245         /*
3246          * If this message has no O (room) field, generate one.
3247          */
3248         if (msg->cm_fields['O'] == NULL) {
3249                 msg->cm_fields['O'] = strdup(CCC->room.QRname);
3250         }
3251
3252         /* Perform "before save" hooks (aborting if any return nonzero) */
3253         MSGM_syslog(LOG_DEBUG, "Performing before-save hooks\n");
3254         if (PerformMessageHooks(msg, EVT_BEFORESAVE) > 0) return(-3);
3255
3256         /*
3257          * If this message has an Exclusive ID, and the room is replication
3258          * checking enabled, then do replication checks.
3259          */
3260         if (DoesThisRoomNeedEuidIndexing(&CCC->room)) {
3261                 ReplicationChecks(msg);
3262         }
3263
3264         /* Save it to disk */
3265         MSGM_syslog(LOG_DEBUG, "Saving to disk\n");
3266         newmsgid = send_message(msg);
3267         if (newmsgid <= 0L) return(-5);
3268
3269         /* Write a supplemental message info record.  This doesn't have to
3270          * be a critical section because nobody else knows about this message
3271          * yet.
3272          */
3273         MSGM_syslog(LOG_DEBUG, "Creating MetaData record\n");
3274         memset(&smi, 0, sizeof(struct MetaData));
3275         smi.meta_msgnum = newmsgid;
3276         smi.meta_refcount = 0;
3277         safestrncpy(smi.meta_content_type, content_type,
3278                     sizeof smi.meta_content_type);
3279
3280         /*
3281          * Measure how big this message will be when rendered as RFC822.
3282          * We do this for two reasons:
3283          * 1. We need the RFC822 length for the new metadata record, so the
3284          *    POP and IMAP services don't have to calculate message lengths
3285          *    while the user is waiting (multiplied by potentially hundreds
3286          *    or thousands of messages).
3287          * 2. If journaling is enabled, we will need an RFC822 version of the
3288          *    message to attach to the journalized copy.
3289          */
3290         if (CCC->redirect_buffer != NULL) {
3291                 MSGM_syslog(LOG_ALERT, "CCC->redirect_buffer is not NULL during message submission!\n");
3292                 abort();
3293         }
3294         CCC->redirect_buffer = NewStrBufPlain(NULL, SIZ);
3295         CtdlOutputPreLoadedMsg(msg, MT_RFC822, HEADERS_ALL, 0, 1, QP_EADDR);
3296         smi.meta_rfc822_length = StrLength(CCC->redirect_buffer);
3297         saved_rfc822_version = CCC->redirect_buffer;
3298         CCC->redirect_buffer = NULL;
3299
3300         PutMetaData(&smi);
3301
3302         /* Now figure out where to store the pointers */
3303         MSGM_syslog(LOG_DEBUG, "Storing pointers\n");
3304
3305         /* If this is being done by the networker delivering a private
3306          * message, we want to BYPASS saving the sender's copy (because there
3307          * is no local sender; it would otherwise go to the Trashcan).
3308          */
3309         if ((!CCC->internal_pgm) || (recps == NULL)) {
3310                 if (CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 1, msg) != 0) {
3311                         MSGM_syslog(LOG_ERR, "ERROR saving message pointer!\n");
3312                         CtdlSaveMsgPointerInRoom(config.c_aideroom, newmsgid, 0, msg);
3313                 }
3314         }
3315
3316         /* For internet mail, drop a copy in the outbound queue room */
3317         if ((recps != NULL) && (recps->num_internet > 0)) {
3318                 CtdlSaveMsgPointerInRoom(SMTP_SPOOLOUT_ROOM, newmsgid, 0, msg);
3319         }
3320
3321         /* If other rooms are specified, drop them there too. */
3322         if ((recps != NULL) && (recps->num_room > 0))
3323                 for (i=0; i<num_tokens(recps->recp_room, '|'); ++i) {
3324                         extract_token(recipient, recps->recp_room, i,
3325                                       '|', sizeof recipient);
3326                         MSG_syslog(LOG_DEBUG, "Delivering to room <%s>\n", recipient);///// xxxx
3327                         CtdlSaveMsgPointerInRoom(recipient, newmsgid, 0, msg);
3328                 }
3329
3330         /* Bump this user's messages posted counter. */
3331         MSGM_syslog(LOG_DEBUG, "Updating user\n");
3332         CtdlGetUserLock(&CCC->user, CCC->curr_user);
3333         CCC->user.posted = CCC->user.posted + 1;
3334         CtdlPutUserLock(&CCC->user);
3335
3336         /* Decide where bounces need to be delivered */
3337         if ((recps != NULL) && (recps->bounce_to != NULL)) {
3338                 safestrncpy(bounce_to, recps->bounce_to, sizeof bounce_to);