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