citadel/msgbase.c

   1 /*
   2  * Implements the message store.
   3  *
   4  * Copyright (c) 1987-2011 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 as published by
   8  * the Free Software Foundation; either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19  */
  20
  21 #include "sysdep.h"
  22 #include <stdlib.h>
  23 #include <unistd.h>
  24 #include <stdio.h>
  25 #include <fcntl.h>
  26
  27 #if TIME_WITH_SYS_TIME
  28 # include <sys/time.h>
  29 # include <time.h>
  30 #else
  31 # if HAVE_SYS_TIME_H
  32 #  include <sys/time.h>
  33 # else
  34 #  include <time.h>
  35 # endif
  36 #endif
  37
  38
  39 #include <ctype.h>
  40 #include <string.h>
  41 #include <limits.h>
  42 #include <errno.h>
  43 #include <stdarg.h>
  44 #include <sys/stat.h>
  45 #include <sys/types.h>
  46 #include <regex.h>
  47 #include <libcitadel.h>
  48 #include "citadel.h"
  49 #include "server.h"
  50 #include "serv_extensions.h"
  51 #include "database.h"
  52 #include "msgbase.h"
  53 #include "support.h"
  54 #include "sysdep_decls.h"
  55 #include "citserver.h"
  56 #include "room_ops.h"
  57 #include "user_ops.h"
  58 #include "file_ops.h"
  59 #include "config.h"
  60 #include "control.h"
  61 #include "genstamp.h"
  62 #include "internet_addressing.h"
  63 #include "euidindex.h"
  64 #include "journaling.h"
  65 #include "citadel_dirs.h"
  66 #include "clientsocket.h"
  67 #include "serv_network.h"
  68 #include "threads.h"
  69
  70 #include "ctdl_module.h"
  71
  72 long config_msgnum;
  73 struct addresses_to_be_filed *atbf = NULL;
  74
  75 /* This temp file holds the queue of operations for AdjRefCount() */
  76 static FILE *arcfp = NULL;
  77
  78 /*
  79  * This really belongs in serv_network.c, but I don't know how to export
  80  * symbols between modules.
  81  */
  82 struct FilterList *filterlist = NULL;
  83
  84
  85 /*
  86  * These are the four-character field headers we use when outputting
  87  * messages in Citadel format (as opposed to RFC822 format).
  88  */
  89 char *msgkeys[] = {
  90         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  91         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  92         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  93         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  94         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  95         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  96         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  97         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  98         NULL,
  99         "from",
 100         NULL, NULL, NULL,
 101         "exti",
 102         "rfca",
 103         NULL,
 104         "hnod",
 105         "msgn",
 106         "jrnl",
 107         NULL,
 108         "list",
 109         "text",
 110         "node",
 111         "room",
 112         "path",
 113         NULL,
 114         "rcpt",
 115         "spec",
 116         "time",
 117         "subj",
 118         NULL,
 119         "wefw",
 120         NULL,
 121         "cccc",
 122         NULL
 123 };
 124
 125 /*
 126  * This function is self explanatory.
 127  * (What can I say, I'm in a weird mood today...)
 128  */
 129 void remove_any_whitespace_to_the_left_or_right_of_at_symbol(char *name)
 130 {
 131         int i;
 132
 133         for (i = 0; i < strlen(name); ++i) {
 134                 if (name[i] == '@') {
 135                         while (isspace(name[i - 1]) && i > 0) {
 136                                 strcpy(&name[i - 1], &name[i]);
 137                                 --i;
 138                         }
 139                         while (isspace(name[i + 1])) {
 140                                 strcpy(&name[i + 1], &name[i + 2]);
 141                         }
 142                 }
 143         }
 144 }
 145
 146
 147 /*
 148  * Aliasing for network mail.
 149  * (Error messages have been commented out, because this is a server.)
 150  */
 151 int alias(char *name)
 152 {                               /* process alias and routing info for mail */
 153         FILE *fp;
 154         int a, i;
 155         char aaa[SIZ], bbb[SIZ];
 156         char *ignetcfg = NULL;
 157         char *ignetmap = NULL;
 158         int at = 0;
 159         char node[64];
 160         char testnode[64];
 161         char buf[SIZ];
 162
 163         char original_name[256];
 164         safestrncpy(original_name, name, sizeof original_name);
 165
 166         striplt(name);
 167         remove_any_whitespace_to_the_left_or_right_of_at_symbol(name);
 168         stripallbut(name, '<', '>');
 169
 170         fp = fopen(file_mail_aliases, "r");
 171         if (fp == NULL) {
 172                 fp = fopen("/dev/null", "r");
 173         }
 174         if (fp == NULL) {
 175                 return (MES_ERROR);
 176         }
 177         strcpy(aaa, "");
 178         strcpy(bbb, "");
 179         while (fgets(aaa, sizeof aaa, fp) != NULL) {
 180                 while (isspace(name[0]))
 181                         strcpy(name, &name[1]);
 182                 aaa[strlen(aaa) - 1] = 0;
 183                 strcpy(bbb, "");
 184                 for (a = 0; a < strlen(aaa); ++a) {
 185                         if (aaa[a] == ',') {
 186                                 strcpy(bbb, &aaa[a + 1]);
 187                                 aaa[a] = 0;
 188                         }
 189                 }
 190                 if (!strcasecmp(name, aaa))
 191                         strcpy(name, bbb);
 192         }
 193         fclose(fp);
 194
 195         /* Hit the Global Address Book */
 196         if (CtdlDirectoryLookup(aaa, name, sizeof aaa) == 0) {
 197                 strcpy(name, aaa);
 198         }
 199
 200         if (strcasecmp(original_name, name)) {
 201                 syslog(LOG_INFO, "%s is being forwarded to %s\n", original_name, name);
 202         }
 203
 204         /* Change "user @ xxx" to "user" if xxx is an alias for this host */
 205         for (a=0; a<strlen(name); ++a) {
 206                 if (name[a] == '@') {
 207                         if (CtdlHostAlias(&name[a+1]) == hostalias_localhost) {
 208                                 name[a] = 0;
 209                                 syslog(LOG_INFO, "Changed to <%s>\n", name);
 210                         }
 211                 }
 212         }
 213
 214         /* determine local or remote type, see citadel.h */
 215         at = haschar(name, '@');
 216         if (at == 0) return(MES_LOCAL);         /* no @'s - local address */
 217         if (at > 1) return(MES_ERROR);          /* >1 @'s - invalid address */
 218         remove_any_whitespace_to_the_left_or_right_of_at_symbol(name);
 219
 220         /* figure out the delivery mode */
 221         extract_token(node, name, 1, '@', sizeof node);
 222
 223         /* If there are one or more dots in the nodename, we assume that it
 224          * is an FQDN and will attempt SMTP delivery to the Internet.
 225          */
 226         if (haschar(node, '.') > 0) {
 227                 return(MES_INTERNET);
 228         }
 229
 230         /* Otherwise we look in the IGnet maps for a valid Citadel node.
 231          * Try directly-connected nodes first...
 232          */
 233         ignetcfg = CtdlGetSysConfig(IGNETCFG);
 234         for (i=0; i<num_tokens(ignetcfg, '\n'); ++i) {
 235                 extract_token(buf, ignetcfg, i, '\n', sizeof buf);
 236                 extract_token(testnode, buf, 0, '|', sizeof testnode);
 237                 if (!strcasecmp(node, testnode)) {
 238                         free(ignetcfg);
 239                         return(MES_IGNET);
 240                 }
 241         }
 242         free(ignetcfg);
 243
 244         /*
 245          * Then try nodes that are two or more hops away.
 246          */
 247         ignetmap = CtdlGetSysConfig(IGNETMAP);
 248         for (i=0; i<num_tokens(ignetmap, '\n'); ++i) {
 249                 extract_token(buf, ignetmap, i, '\n', sizeof buf);
 250                 extract_token(testnode, buf, 0, '|', sizeof testnode);
 251                 if (!strcasecmp(node, testnode)) {
 252                         free(ignetmap);
 253                         return(MES_IGNET);
 254                 }
 255         }
 256         free(ignetmap);
 257
 258         /* If we get to this point it's an invalid node name */
 259         return (MES_ERROR);
 260 }
 261
 262
 263 /*
 264  * Back end for the MSGS command: output message number only.
 265  */
 266 void simple_listing(long msgnum, void *userdata)
 267 {
 268         cprintf("%ld\n", msgnum);
 269 }
 270
 271
 272
 273 /*
 274  * Back end for the MSGS command: output header summary.
 275  */
 276 void headers_listing(long msgnum, void *userdata)
 277 {
 278         struct CtdlMessage *msg;
 279
 280         msg = CtdlFetchMessage(msgnum, 0);
 281         if (msg == NULL) {
 282                 cprintf("%ld|0|||||\n", msgnum);
 283                 return;
 284         }
 285
 286         cprintf("%ld|%s|%s|%s|%s|%s|\n",
 287                 msgnum,
 288                 (msg->cm_fields['T'] ? msg->cm_fields['T'] : "0"),
 289                 (msg->cm_fields['A'] ? msg->cm_fields['A'] : ""),
 290                 (msg->cm_fields['N'] ? msg->cm_fields['N'] : ""),
 291                 (msg->cm_fields['F'] ? msg->cm_fields['F'] : ""),
 292                 (msg->cm_fields['U'] ? msg->cm_fields['U'] : "")
 293         );
 294         CtdlFreeMessage(msg);
 295 }
 296
 297 /*
 298  * Back end for the MSGS command: output EUID header.
 299  */
 300 void headers_euid(long msgnum, void *userdata)
 301 {
 302         struct CtdlMessage *msg;
 303
 304         msg = CtdlFetchMessage(msgnum, 0);
 305         if (msg == NULL) {
 306                 cprintf("%ld||\n", msgnum);
 307                 return;
 308         }
 309
 310         cprintf("%ld|%s|%s\n",
 311                 msgnum,
 312                 (msg->cm_fields['E'] ? msg->cm_fields['E'] : ""),
 313                 (msg->cm_fields['T'] ? msg->cm_fields['T'] : "0"));
 314         CtdlFreeMessage(msg);
 315 }
 316
 317
 318
 319
 320
 321 /* Determine if a given message matches the fields in a message template.
 322  * Return 0 for a successful match.
 323  */
 324 int CtdlMsgCmp(struct CtdlMessage *msg, struct CtdlMessage *template) {
 325         int i;
 326
 327         /* If there aren't any fields in the template, all messages will
 328          * match.
 329          */
 330         if (template == NULL) return(0);
 331
 332         /* Null messages are bogus. */
 333         if (msg == NULL) return(1);
 334
 335         for (i='A'; i<='Z'; ++i) {
 336                 if (template->cm_fields[i] != NULL) {
 337                         if (msg->cm_fields[i] == NULL) {
 338                                 /* Considered equal if temmplate is empty string */
 339                                 if (IsEmptyStr(template->cm_fields[i])) continue;
 340                                 return 1;
 341                         }
 342                         if (strcasecmp(msg->cm_fields[i],
 343                                 template->cm_fields[i])) return 1;
 344                 }
 345         }
 346
 347         /* All compares succeeded: we have a match! */
 348         return 0;
 349 }
 350
 351
 352
 353 /*
 354  * Retrieve the "seen" message list for the current room.
 355  */
 356 void CtdlGetSeen(char *buf, int which_set) {
 357         visit vbuf;
 358
 359         /* Learn about the user and room in question */
 360         CtdlGetRelationship(&vbuf, &CC->user, &CC->room);
 361
 362         if (which_set == ctdlsetseen_seen)
 363                 safestrncpy(buf, vbuf.v_seen, SIZ);
 364         if (which_set == ctdlsetseen_answered)
 365                 safestrncpy(buf, vbuf.v_answered, SIZ);
 366 }
 367
 368
 369
 370 /*
 371  * Manipulate the "seen msgs" string (or other message set strings)
 372  */
 373 void CtdlSetSeen(long *target_msgnums, int num_target_msgnums,
 374                 int target_setting, int which_set,
 375                 struct ctdluser *which_user, struct ctdlroom *which_room) {
 376         struct cdbdata *cdbfr;
 377         int i, k;
 378         int is_seen = 0;
 379         int was_seen = 0;
 380         long lo = (-1L);
 381         long hi = (-1L);
 382         visit vbuf;
 383         long *msglist;
 384         int num_msgs = 0;
 385         StrBuf *vset;
 386         StrBuf *setstr;
 387         StrBuf *lostr;
 388         StrBuf *histr;
 389         const char *pvset;
 390         char *is_set;   /* actually an array of booleans */
 391
 392         /* Don't bother doing *anything* if we were passed a list of zero messages */
 393         if (num_target_msgnums < 1) {
 394                 return;
 395         }
 396
 397         /* If no room was specified, we go with the current room. */
 398         if (!which_room) {
 399                 which_room = &CC->room;
 400         }
 401
 402         /* If no user was specified, we go with the current user. */
 403         if (!which_user) {
 404                 which_user = &CC->user;
 405         }
 406
 407         syslog(LOG_DEBUG, "CtdlSetSeen(%d msgs starting with %ld, %s, %d) in <%s>\n",
 408                 num_target_msgnums, target_msgnums[0],
 409                 (target_setting ? "SET" : "CLEAR"),
 410                 which_set,
 411                 which_room->QRname);
 412
 413         /* Learn about the user and room in question */
 414         CtdlGetRelationship(&vbuf, which_user, which_room);
 415
 416         /* Load the message list */
 417         cdbfr = cdb_fetch(CDB_MSGLISTS, &which_room->QRnumber, sizeof(long));
 418         if (cdbfr != NULL) {
 419                 msglist = (long *) cdbfr->ptr;
 420                 cdbfr->ptr = NULL;      /* CtdlSetSeen() now owns this memory */
 421                 num_msgs = cdbfr->len / sizeof(long);
 422                 cdb_free(cdbfr);
 423         } else {
 424                 return; /* No messages at all?  No further action. */
 425         }
 426
 427         is_set = malloc(num_msgs * sizeof(char));
 428         memset(is_set, 0, (num_msgs * sizeof(char)) );
 429
 430         /* Decide which message set we're manipulating */
 431         switch(which_set) {
 432         case ctdlsetseen_seen:
 433                 vset = NewStrBufPlain(vbuf.v_seen, -1);
 434                 break;
 435         case ctdlsetseen_answered:
 436                 vset = NewStrBufPlain(vbuf.v_answered, -1);
 437                 break;
 438         default:
 439                 vset = NewStrBuf();
 440         }
 441
 442
 443 #if 0   /* This is a special diagnostic section.  Do not allow it to run during normal operation. */
 444         syslog(LOG_DEBUG, "There are %d messages in the room.\n", num_msgs);
 445         for (i=0; i<num_msgs; ++i) {
 446                 if ((i > 0) && (msglist[i] <= msglist[i-1])) abort();
 447         }
 448         syslog(LOG_DEBUG, "We are twiddling %d of them.\n", num_target_msgnums);
 449         for (k=0; k<num_target_msgnums; ++k) {
 450                 if ((k > 0) && (target_msgnums[k] <= target_msgnums[k-1])) abort();
 451         }
 452 #endif
 453
 454         syslog(LOG_DEBUG, "before update: %s\n", ChrPtr(vset));
 455
 456         /* Translate the existing sequence set into an array of booleans */
 457         setstr = NewStrBuf();
 458         lostr = NewStrBuf();
 459         histr = NewStrBuf();
 460         pvset = NULL;
 461         while (StrBufExtract_NextToken(setstr, vset, &pvset, ',') >= 0) {
 462
 463                 StrBufExtract_token(lostr, setstr, 0, ':');
 464                 if (StrBufNum_tokens(setstr, ':') >= 2) {
 465                         StrBufExtract_token(histr, setstr, 1, ':');
 466                 }
 467                 else {
 468                         FlushStrBuf(histr);
 469                         StrBufAppendBuf(histr, lostr, 0);
 470                 }
 471                 lo = StrTol(lostr);
 472                 if (!strcmp(ChrPtr(histr), "*")) {
 473                         hi = LONG_MAX;
 474                 }
 475                 else {
 476                         hi = StrTol(histr);
 477                 }
 478
 479                 for (i = 0; i < num_msgs; ++i) {
 480                         if ((msglist[i] >= lo) && (msglist[i] <= hi)) {
 481                                 is_set[i] = 1;
 482                         }
 483                 }
 484         }
 485         FreeStrBuf(&setstr);
 486         FreeStrBuf(&lostr);
 487         FreeStrBuf(&histr);
 488
 489
 490         /* Now translate the array of booleans back into a sequence set */
 491         FlushStrBuf(vset);
 492         was_seen = 0;
 493         lo = (-1);
 494         hi = (-1);
 495
 496         for (i=0; i<num_msgs; ++i) {
 497                 is_seen = is_set[i];
 498
 499                 /* Apply changes */
 500                 for (k=0; k<num_target_msgnums; ++k) {
 501                         if (msglist[i] == target_msgnums[k]) {
 502                                 is_seen = target_setting;
 503                         }
 504                 }
 505
 506                 if ((was_seen == 0) && (is_seen == 1)) {
 507                         lo = msglist[i];
 508                 }
 509                 else if ((was_seen == 1) && (is_seen == 0)) {
 510                         hi = msglist[i-1];
 511
 512                         if (StrLength(vset) > 0) {
 513                                 StrBufAppendBufPlain(vset, HKEY(","), 0);
 514                         }
 515                         if (lo == hi) {
 516                                 StrBufAppendPrintf(vset, "%ld", hi);
 517                         }
 518                         else {
 519                                 StrBufAppendPrintf(vset, "%ld:%ld", lo, hi);
 520                         }
 521                 }
 522
 523                 if ((is_seen) && (i == num_msgs - 1)) {
 524                         if (StrLength(vset) > 0) {
 525                                 StrBufAppendBufPlain(vset, HKEY(","), 0);
 526                         }
 527                         if ((i==0) || (was_seen == 0)) {
 528                                 StrBufAppendPrintf(vset, "%ld", msglist[i]);
 529                         }
 530                         else {
 531                                 StrBufAppendPrintf(vset, "%ld:%ld", lo, msglist[i]);
 532                         }
 533                 }
 534
 535                 was_seen = is_seen;
 536         }
 537
 538         /*
 539          * We will have to stuff this string back into a 4096 byte buffer, so if it's
 540          * larger than that now, truncate it by removing tokens from the beginning.
 541          * The limit of 100 iterations is there to prevent an infinite loop in case
 542          * something unexpected happens.
 543          */
 544         int number_of_truncations = 0;
 545         while ( (StrLength(vset) > SIZ) && (number_of_truncations < 100) ) {
 546                 StrBufRemove_token(vset, 0, ',');
 547                 ++number_of_truncations;
 548         }
 549
 550         /*
 551          * If we're truncating the sequence set of messages marked with the 'seen' flag,
 552          * we want the earliest messages (the truncated ones) to be marked, not unmarked.
 553          * Otherwise messages at the beginning will suddenly appear to be 'unseen'.
 554          */
 555         if ( (which_set == ctdlsetseen_seen) && (number_of_truncations > 0) ) {
 556                 StrBuf *first_tok;
 557                 first_tok = NewStrBuf();
 558                 StrBufExtract_token(first_tok, vset, 0, ',');
 559                 StrBufRemove_token(vset, 0, ',');
 560
 561                 if (StrBufNum_tokens(first_tok, ':') > 1) {
 562                         StrBufRemove_token(first_tok, 0, ':');
 563                 }
 564
 565                 StrBuf *new_set;
 566                 new_set = NewStrBuf();
 567                 StrBufAppendBufPlain(new_set, HKEY("1:"), 0);
 568                 StrBufAppendBuf(new_set, first_tok, 0);
 569                 StrBufAppendBufPlain(new_set, HKEY(":"), 0);
 570                 StrBufAppendBuf(new_set, vset, 0);
 571
 572                 FreeStrBuf(&vset);
 573                 FreeStrBuf(&first_tok);
 574                 vset = new_set;
 575         }
 576
 577         syslog(LOG_DEBUG, " after update: %s\n", ChrPtr(vset));
 578
 579         /* Decide which message set we're manipulating */
 580         switch (which_set) {
 581                 case ctdlsetseen_seen:
 582                         safestrncpy(vbuf.v_seen, ChrPtr(vset), sizeof vbuf.v_seen);
 583                         break;
 584                 case ctdlsetseen_answered:
 585                         safestrncpy(vbuf.v_answered, ChrPtr(vset), sizeof vbuf.v_answered);
 586                         break;
 587         }
 588
 589         free(is_set);
 590         free(msglist);
 591         CtdlSetRelationship(&vbuf, which_user, which_room);
 592         FreeStrBuf(&vset);
 593 }
 594
 595
 596 /*
 597  * API function to perform an operation for each qualifying message in the
 598  * current room.  (Returns the number of messages processed.)
 599  */
 600 int CtdlForEachMessage(int mode, long ref, char *search_string,
 601                         char *content_type,
 602                         struct CtdlMessage *compare,
 603                         ForEachMsgCallback CallBack,
 604                         void *userdata)
 605 {
 606
 607         int a, i, j;
 608         visit vbuf;
 609         struct cdbdata *cdbfr;
 610         long *msglist = NULL;
 611         int num_msgs = 0;
 612         int num_processed = 0;
 613         long thismsg;
 614         struct MetaData smi;
 615         struct CtdlMessage *msg = NULL;
 616         int is_seen = 0;
 617         long lastold = 0L;
 618         int printed_lastold = 0;
 619         int num_search_msgs = 0;
 620         long *search_msgs = NULL;
 621         regex_t re;
 622         int need_to_free_re = 0;
 623         regmatch_t pm;
 624
 625         if ((content_type) && (!IsEmptyStr(content_type))) {
 626                 regcomp(&re, content_type, 0);
 627                 need_to_free_re = 1;
 628         }
 629
 630         /* Learn about the user and room in question */
 631         CtdlGetUser(&CC->user, CC->curr_user);
 632         CtdlGetRelationship(&vbuf, &CC->user, &CC->room);
 633
 634         /* Load the message list */
 635         cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
 636         if (cdbfr == NULL) {
 637                 if (need_to_free_re) regfree(&re);
 638                 return 0;       /* No messages at all?  No further action. */
 639         }
 640
 641         msglist = (long *) cdbfr->ptr;
 642         num_msgs = cdbfr->len / sizeof(long);
 643
 644         cdbfr->ptr = NULL;      /* clear this so that cdb_free() doesn't free it */
 645         cdb_free(cdbfr);        /* we own this memory now */
 646
 647         /*
 648          * Now begin the traversal.
 649          */
 650         if (num_msgs > 0) for (a = 0; a < num_msgs; ++a) {
 651
 652                 /* If the caller is looking for a specific MIME type, filter
 653                  * out all messages which are not of the type requested.
 654                  */
 655                 if ((content_type != NULL) && (!IsEmptyStr(content_type))) {
 656
 657                         /* This call to GetMetaData() sits inside this loop
 658                          * so that we only do the extra database read per msg
 659                          * if we need to.  Doing the extra read all the time
 660                          * really kills the server.  If we ever need to use
 661                          * metadata for another search criterion, we need to
 662                          * move the read somewhere else -- but still be smart
 663                          * enough to only do the read if the caller has
 664                          * specified something that will need it.
 665                          */
 666                         GetMetaData(&smi, msglist[a]);
 667
 668                         /* if (strcasecmp(smi.meta_content_type, content_type)) { old non-regex way */
 669                         if (regexec(&re, smi.meta_content_type, 1, &pm, 0) != 0) {
 670                                 msglist[a] = 0L;
 671                         }
 672                 }
 673         }
 674
 675         num_msgs = sort_msglist(msglist, num_msgs);
 676
 677         /* If a template was supplied, filter out the messages which
 678          * don't match.  (This could induce some delays!)
 679          */
 680         if (num_msgs > 0) {
 681                 if (compare != NULL) {
 682                         for (a = 0; a < num_msgs; ++a) {
 683                                 msg = CtdlFetchMessage(msglist[a], 1);
 684                                 if (msg != NULL) {
 685                                         if (CtdlMsgCmp(msg, compare)) {
 686                                                 msglist[a] = 0L;
 687                                         }
 688                                         CtdlFreeMessage(msg);
 689                                 }
 690                         }
 691                 }
 692         }
 693
 694         /* If a search string was specified, get a message list from
 695          * the full text index and remove messages which aren't on both
 696          * lists.
 697          *
 698          * How this works:
 699          * Since the lists are sorted and strictly ascending, and the
 700          * output list is guaranteed to be shorter than or equal to the
 701          * input list, we overwrite the bottom of the input list.  This
 702          * eliminates the need to memmove big chunks of the list over and
 703          * over again.
 704          */
 705         if ( (num_msgs > 0) && (mode == MSGS_SEARCH) && (search_string) ) {
 706
 707                 /* Call search module via hook mechanism.
 708                  * NULL means use any search function available.
 709                  * otherwise replace with a char * to name of search routine
 710                  */
 711                 CtdlModuleDoSearch(&num_search_msgs, &search_msgs, search_string, "fulltext");
 712
 713                 if (num_search_msgs > 0) {
 714
 715                         int orig_num_msgs;
 716
 717                         orig_num_msgs = num_msgs;
 718                         num_msgs = 0;
 719                         for (i=0; i<orig_num_msgs; ++i) {
 720                                 for (j=0; j<num_search_msgs; ++j) {
 721                                         if (msglist[i] == search_msgs[j]) {
 722                                                 msglist[num_msgs++] = msglist[i];
 723                                         }
 724                                 }
 725                         }
 726                 }
 727                 else {
 728                         num_msgs = 0;   /* No messages qualify */
 729                 }
 730                 if (search_msgs != NULL) free(search_msgs);
 731
 732                 /* Now that we've purged messages which don't contain the search
 733                  * string, treat a MSGS_SEARCH just like a MSGS_ALL from this
 734                  * point on.
 735                  */
 736                 mode = MSGS_ALL;
 737         }
 738
 739         /*
 740          * Now iterate through the message list, according to the
 741          * criteria supplied by the caller.
 742          */
 743         if (num_msgs > 0)
 744                 for (a = 0; a < num_msgs; ++a) {
 745                         thismsg = msglist[a];
 746                         if (mode == MSGS_ALL) {
 747                                 is_seen = 0;
 748                         }
 749                         else {
 750                                 is_seen = is_msg_in_sequence_set(
 751                                                         vbuf.v_seen, thismsg);
 752                                 if (is_seen) lastold = thismsg;
 753                         }
 754                         if ((thismsg > 0L)
 755                             && (
 756
 757                                        (mode == MSGS_ALL)
 758                                        || ((mode == MSGS_OLD) && (is_seen))
 759                                        || ((mode == MSGS_NEW) && (!is_seen))
 760                                        || ((mode == MSGS_LAST) && (a >= (num_msgs - ref)))
 761                                    || ((mode == MSGS_FIRST) && (a < ref))
 762                                 || ((mode == MSGS_GT) && (thismsg > ref))
 763                                 || ((mode == MSGS_LT) && (thismsg < ref))
 764                                 || ((mode == MSGS_EQ) && (thismsg == ref))
 765                             )
 766                             ) {
 767                                 if ((mode == MSGS_NEW) && (CC->user.flags & US_LASTOLD) && (lastold > 0L) && (printed_lastold == 0) && (!is_seen)) {
 768                                         if (CallBack)
 769                                                 CallBack(lastold, userdata);
 770                                         printed_lastold = 1;
 771                                         ++num_processed;
 772                                 }
 773                                 if (CallBack) CallBack(thismsg, userdata);
 774                                 ++num_processed;
 775                         }
 776                 }
 777         if (need_to_free_re) regfree(&re);
 778
 779         /*
 780          * We cache the most recent msglist in order to do security checks later
 781          */
 782         if (CC->client_socket > 0) {
 783                 if (CC->cached_msglist != NULL) {
 784                         free(CC->cached_msglist);
 785                 }
 786                 CC->cached_msglist = msglist;
 787                 CC->cached_num_msgs = num_msgs;
 788         }
 789         else {
 790                 free(msglist);
 791         }
 792
 793         return num_processed;
 794 }
 795
 796
 797
 798 /*
 799  * cmd_msgs()  -  get list of message #'s in this room
 800  *              implements the MSGS server command using CtdlForEachMessage()
 801  */
 802 void cmd_msgs(char *cmdbuf)
 803 {
 804         int mode = 0;
 805         char which[16];
 806         char buf[256];
 807         char tfield[256];
 808         char tvalue[256];
 809         int cm_ref = 0;
 810         int i;
 811         int with_template = 0;
 812         struct CtdlMessage *template = NULL;
 813         char search_string[1024];
 814         ForEachMsgCallback CallBack;
 815
 816         if (CtdlAccessCheck(ac_logged_in_or_guest)) return;
 817
 818         extract_token(which, cmdbuf, 0, '|', sizeof which);
 819         cm_ref = extract_int(cmdbuf, 1);
 820         extract_token(search_string, cmdbuf, 1, '|', sizeof search_string);
 821         with_template = extract_int(cmdbuf, 2);
 822         switch (extract_int(cmdbuf, 3))
 823         {
 824         default:
 825         case MSG_HDRS_BRIEF:
 826                 CallBack = simple_listing;
 827                 break;
 828         case MSG_HDRS_ALL:
 829                 CallBack = headers_listing;
 830                 break;
 831         case MSG_HDRS_EUID:
 832                 CallBack = headers_euid;
 833                 break;
 834         }
 835
 836         strcat(which, "   ");
 837         if (!strncasecmp(which, "OLD", 3))
 838                 mode = MSGS_OLD;
 839         else if (!strncasecmp(which, "NEW", 3))
 840                 mode = MSGS_NEW;
 841         else if (!strncasecmp(which, "FIRST", 5))
 842                 mode = MSGS_FIRST;
 843         else if (!strncasecmp(which, "LAST", 4))
 844                 mode = MSGS_LAST;
 845         else if (!strncasecmp(which, "GT", 2))
 846                 mode = MSGS_GT;
 847         else if (!strncasecmp(which, "LT", 2))
 848                 mode = MSGS_LT;
 849         else if (!strncasecmp(which, "SEARCH", 6))
 850                 mode = MSGS_SEARCH;
 851         else
 852                 mode = MSGS_ALL;
 853
 854         if ( (mode == MSGS_SEARCH) && (!config.c_enable_fulltext) ) {
 855                 cprintf("%d Full text index is not enabled on this server.\n",
 856                         ERROR + CMD_NOT_SUPPORTED);
 857                 return;
 858         }
 859
 860         if (with_template) {
 861                 unbuffer_output();
 862                 cprintf("%d Send template then receive message list\n",
 863                         START_CHAT_MODE);
 864                 template = (struct CtdlMessage *)
 865                         malloc(sizeof(struct CtdlMessage));
 866                 memset(template, 0, sizeof(struct CtdlMessage));
 867                 template->cm_magic = CTDLMESSAGE_MAGIC;
 868                 template->cm_anon_type = MES_NORMAL;
 869
 870                 while(client_getln(buf, sizeof buf) >= 0 && strcmp(buf,"000")) {
 871                         extract_token(tfield, buf, 0, '|', sizeof tfield);
 872                         extract_token(tvalue, buf, 1, '|', sizeof tvalue);
 873                         for (i='A'; i<='Z'; ++i) if (msgkeys[i]!=NULL) {
 874                                 if (!strcasecmp(tfield, msgkeys[i])) {
 875                                         template->cm_fields[i] =
 876                                                 strdup(tvalue);
 877                                 }
 878                         }
 879                 }
 880                 buffer_output();
 881         }
 882         else {
 883                 cprintf("%d  \n", LISTING_FOLLOWS);
 884         }
 885
 886         CtdlForEachMessage(mode,
 887                            ( (mode == MSGS_SEARCH) ? 0 : cm_ref ),
 888                            ( (mode == MSGS_SEARCH) ? search_string : NULL ),
 889                            NULL,
 890                            template,
 891                            CallBack,
 892                            NULL);
 893         if (template != NULL) CtdlFreeMessage(template);
 894         cprintf("000\n");
 895 }
 896
 897
 898
 899
 900 /*
 901  * help_subst()  -  support routine for help file viewer
 902  */
 903 void help_subst(char *strbuf, char *source, char *dest)
 904 {
 905         char workbuf[SIZ];
 906         int p;
 907
 908         while (p = pattern2(strbuf, source), (p >= 0)) {
 909                 strcpy(workbuf, &strbuf[p + strlen(source)]);
 910                 strcpy(&strbuf[p], dest);
 911                 strcat(strbuf, workbuf);
 912         }
 913 }
 914
 915
 916 void do_help_subst(char *buffer)
 917 {
 918         char buf2[16];
 919
 920         help_subst(buffer, "^nodename", config.c_nodename);
 921         help_subst(buffer, "^humannode", config.c_humannode);
 922         help_subst(buffer, "^fqdn", config.c_fqdn);
 923         help_subst(buffer, "^username", CC->user.fullname);
 924         snprintf(buf2, sizeof buf2, "%ld", CC->user.usernum);
 925         help_subst(buffer, "^usernum", buf2);
 926         help_subst(buffer, "^sysadm", config.c_sysadm);
 927         help_subst(buffer, "^variantname", CITADEL);
 928         snprintf(buf2, sizeof buf2, "%d", config.c_maxsessions);
 929         help_subst(buffer, "^maxsessions", buf2);
 930         help_subst(buffer, "^bbsdir", ctdl_message_dir);
 931 }
 932
 933
 934
 935 /*
 936  * memfmout()  -  Citadel text formatter and paginator.
 937  *           Although the original purpose of this routine was to format
 938  *           text to the reader's screen width, all we're really using it
 939  *           for here is to format text out to 80 columns before sending it
 940  *           to the client.  The client software may reformat it again.
 941  */
 942 void memfmout(
 943         char *mptr,             /* where are we going to get our text from? */
 944         const char *nl          /* string to terminate lines with */
 945 ) {
 946         int column = 0;
 947         unsigned char ch = 0;
 948         char outbuf[1024];
 949         int len = 0;
 950         int nllen = 0;
 951
 952         if (!mptr) return;
 953         nllen = strlen(nl);
 954         while (ch=*(mptr++), ch != 0) {
 955
 956                 if (ch == '\n') {
 957                         client_write(outbuf, len);
 958                         len = 0;
 959                         client_write(nl, nllen);
 960                         column = 0;
 961                 }
 962                 else if (ch == '\r') {
 963                         /* Ignore carriage returns.  Newlines are always LF or CRLF but never CR. */
 964                 }
 965                 else if (isspace(ch)) {
 966                         if (column > 72) {              /* Beyond 72 columns, break on the next space */
 967                                 client_write(outbuf, len);
 968                                 len = 0;
 969                                 client_write(nl, nllen);
 970                                 column = 0;
 971                         }
 972                         else {
 973                                 outbuf[len++] = ch;
 974                                 ++column;
 975                         }
 976                 }
 977                 else {
 978                         outbuf[len++] = ch;
 979                         ++column;
 980                         if (column > 1000) {            /* Beyond 1000 columns, break anywhere */
 981                                 client_write(outbuf, len);
 982                                 len = 0;
 983                                 client_write(nl, nllen);
 984                                 column = 0;
 985                         }
 986                 }
 987         }
 988         if (len) {
 989                 client_write(outbuf, len);
 990                 len = 0;
 991                 client_write(nl, nllen);
 992                 column = 0;
 993         }
 994 }
 995
 996
 997
 998 /*
 999  * Callback function for mime parser that simply lists the part
1000  */
1001 void list_this_part(char *name, char *filename, char *partnum, char *disp,
1002                     void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
1003                     char *cbid, void *cbuserdata)
1004 {
1005         struct ma_info *ma;
1006
1007         ma = (struct ma_info *)cbuserdata;
1008         if (ma->is_ma == 0) {
1009                 cprintf("part=%s|%s|%s|%s|%s|%ld|%s|%s\n",
1010                         name,
1011                         filename,
1012                         partnum,
1013                         disp,
1014                         cbtype,
1015                         (long)length,
1016                         cbid,
1017                         cbcharset);
1018         }
1019 }
1020
1021 /*
1022  * Callback function for multipart prefix
1023  */
1024 void list_this_pref(char *name, char *filename, char *partnum, char *disp,
1025                     void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
1026                     char *cbid, void *cbuserdata)
1027 {
1028         struct ma_info *ma;
1029
1030         ma = (struct ma_info *)cbuserdata;
1031         if (!strcasecmp(cbtype, "multipart/alternative")) {
1032                 ++ma->is_ma;
1033         }
1034
1035         if (ma->is_ma == 0) {
1036                 cprintf("pref=%s|%s\n", partnum, cbtype);
1037         }
1038 }
1039
1040 /*
1041  * Callback function for multipart sufffix
1042  */
1043 void list_this_suff(char *name, char *filename, char *partnum, char *disp,
1044                     void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
1045                     char *cbid, void *cbuserdata)
1046 {
1047         struct ma_info *ma;
1048
1049         ma = (struct ma_info *)cbuserdata;
1050         if (ma->is_ma == 0) {
1051                 cprintf("suff=%s|%s\n", partnum, cbtype);
1052         }
1053         if (!strcasecmp(cbtype, "multipart/alternative")) {
1054                 --ma->is_ma;
1055         }
1056 }
1057
1058
1059 /*
1060  * Callback function for mime parser that opens a section for downloading
1061  */
1062 void mime_download(char *name, char *filename, char *partnum, char *disp,
1063                    void *content, char *cbtype, char *cbcharset, size_t length,
1064                    char *encoding, char *cbid, void *cbuserdata)
1065 {
1066         int rv = 0;
1067
1068         /* Silently go away if there's already a download open. */
1069         if (CC->download_fp != NULL)
1070                 return;
1071
1072         if (
1073                 (!IsEmptyStr(partnum) && (!strcasecmp(CC->download_desired_section, partnum)))
1074         ||      (!IsEmptyStr(cbid) && (!strcasecmp(CC->download_desired_section, cbid)))
1075         ) {
1076                 CC->download_fp = tmpfile();
1077                 if (CC->download_fp == NULL)
1078                         return;
1079
1080                 rv = fwrite(content, length, 1, CC->download_fp);
1081                 fflush(CC->download_fp);
1082                 rewind(CC->download_fp);
1083
1084                 OpenCmdResult(filename, cbtype);
1085         }
1086 }
1087
1088
1089
1090 /*
1091  * Callback function for mime parser that outputs a section all at once.
1092  * We can specify the desired section by part number *or* content-id.
1093  */
1094 void mime_spew_section(char *name, char *filename, char *partnum, char *disp,
1095                    void *content, char *cbtype, char *cbcharset, size_t length,
1096                    char *encoding, char *cbid, void *cbuserdata)
1097 {
1098         int *found_it = (int *)cbuserdata;
1099
1100         if (
1101                 (!IsEmptyStr(partnum) && (!strcasecmp(CC->download_desired_section, partnum)))
1102         ||      (!IsEmptyStr(cbid) && (!strcasecmp(CC->download_desired_section, cbid)))
1103         ) {
1104                 *found_it = 1;
1105                 cprintf("%d %d|-1|%s|%s|%s\n",
1106                         BINARY_FOLLOWS,
1107                         (int)length,
1108                         filename,
1109                         cbtype,
1110                         cbcharset
1111                 );
1112                 client_write(content, length);
1113         }
1114 }
1115
1116
1117 /*
1118  * Load a message from disk into memory.
1119  * This is used by CtdlOutputMsg() and other fetch functions.
1120  *
1121  * NOTE: Caller is responsible for freeing the returned CtdlMessage struct
1122  *       using the CtdlMessageFree() function.
1123  */
1124 struct CtdlMessage *CtdlFetchMessage(long msgnum, int with_body)
1125 {
1126         struct cdbdata *dmsgtext;
1127         struct CtdlMessage *ret = NULL;
1128         char *mptr;
1129         char *upper_bound;
1130         cit_uint8_t ch;
1131         cit_uint8_t field_header;
1132
1133         syslog(LOG_DEBUG, "CtdlFetchMessage(%ld, %d)\n", msgnum, with_body);
1134         dmsgtext = cdb_fetch(CDB_MSGMAIN, &msgnum, sizeof(long));
1135         if (dmsgtext == NULL) {
1136                 return NULL;
1137         }
1138         mptr = dmsgtext->ptr;
1139         upper_bound = mptr + dmsgtext->len;
1140
1141         /* Parse the three bytes that begin EVERY message on disk.
1142          * The first is always 0xFF, the on-disk magic number.
1143          * The second is the anonymous/public type byte.
1144          * The third is the format type byte (vari, fixed, or MIME).
1145          */
1146         ch = *mptr++;
1147         if (ch != 255) {
1148                 syslog(LOG_ERR, "Message %ld appears to be corrupted.\n", msgnum);
1149                 cdb_free(dmsgtext);
1150                 return NULL;
1151         }
1152         ret = (struct CtdlMessage *) malloc(sizeof(struct CtdlMessage));
1153         memset(ret, 0, sizeof(struct CtdlMessage));
1154
1155         ret->cm_magic = CTDLMESSAGE_MAGIC;
1156         ret->cm_anon_type = *mptr++;    /* Anon type byte */
1157         ret->cm_format_type = *mptr++;  /* Format type byte */
1158
1159         /*
1160          * The rest is zero or more arbitrary fields.  Load them in.
1161          * We're done when we encounter either a zero-length field or
1162          * have just processed the 'M' (message text) field.
1163          */
1164         do {
1165                 if (mptr >= upper_bound) {
1166                         break;
1167                 }
1168                 field_header = *mptr++;
1169                 ret->cm_fields[field_header] = strdup(mptr);
1170
1171                 while (*mptr++ != 0);   /* advance to next field */
1172
1173         } while ((mptr < upper_bound) && (field_header != 'M'));
1174
1175         cdb_free(dmsgtext);
1176
1177         /* Always make sure there's something in the msg text field.  If
1178          * it's NULL, the message text is most likely stored separately,
1179          * so go ahead and fetch that.  Failing that, just set a dummy
1180          * body so other code doesn't barf.
1181          */
1182         if ( (ret->cm_fields['M'] == NULL) && (with_body) ) {
1183                 dmsgtext = cdb_fetch(CDB_BIGMSGS, &msgnum, sizeof(long));
1184                 if (dmsgtext != NULL) {
1185                         ret->cm_fields['M'] = dmsgtext->ptr;
1186                         dmsgtext->ptr = NULL;
1187                         cdb_free(dmsgtext);
1188                 }
1189         }
1190         if (ret->cm_fields['M'] == NULL) {
1191                 ret->cm_fields['M'] = strdup("\r\n\r\n (no text)\r\n");
1192         }
1193
1194         /* Perform "before read" hooks (aborting if any return nonzero) */
1195         if (PerformMessageHooks(ret, EVT_BEFOREREAD) > 0) {
1196                 CtdlFreeMessage(ret);
1197                 return NULL;
1198         }
1199
1200         return (ret);
1201 }
1202
1203
1204 /*
1205  * Returns 1 if the supplied pointer points to a valid Citadel message.
1206  * If the pointer is NULL or the magic number check fails, returns 0.
1207  */
1208 int is_valid_message(struct CtdlMessage *msg) {
1209         if (msg == NULL)
1210                 return 0;
1211         if ((msg->cm_magic) != CTDLMESSAGE_MAGIC) {
1212                 syslog(LOG_WARNING, "is_valid_message() -- self-check failed\n");
1213                 return 0;
1214         }
1215         return 1;
1216 }
1217
1218
1219 /*
1220  * 'Destructor' for struct CtdlMessage
1221  */
1222 void CtdlFreeMessage(struct CtdlMessage *msg)
1223 {
1224         int i;
1225
1226         if (is_valid_message(msg) == 0)
1227         {
1228                 if (msg != NULL) free (msg);
1229                 return;
1230         }
1231
1232         for (i = 0; i < 256; ++i)
1233                 if (msg->cm_fields[i] != NULL) {
1234                         free(msg->cm_fields[i]);
1235                 }
1236
1237         msg->cm_magic = 0;      /* just in case */
1238         free(msg);
1239 }
1240
1241
1242 /*
1243  * Pre callback function for multipart/alternative
1244  *
1245  * NOTE: this differs from the standard behavior for a reason.  Normally when
1246  *       displaying multipart/alternative you want to show the _last_ usable
1247  *       format in the message.  Here we show the _first_ one, because it's
1248  *       usually text/plain.  Since this set of functions is designed for text
1249  *       output to non-MIME-aware clients, this is the desired behavior.
1250  *
1251  */
1252 void fixed_output_pre(char *name, char *filename, char *partnum, char *disp,
1253                 void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
1254                 char *cbid, void *cbuserdata)
1255 {
1256         struct ma_info *ma;
1257
1258         ma = (struct ma_info *)cbuserdata;
1259         syslog(LOG_DEBUG, "fixed_output_pre() type=<%s>\n", cbtype);
1260         if (!strcasecmp(cbtype, "multipart/alternative")) {
1261                 ++ma->is_ma;
1262                 ma->did_print = 0;
1263         }
1264         if (!strcasecmp(cbtype, "message/rfc822")) {
1265                 ++ma->freeze;
1266         }
1267 }
1268
1269 /*
1270  * Post callback function for multipart/alternative
1271  */
1272 void fixed_output_post(char *name, char *filename, char *partnum, char *disp,
1273                 void *content, char *cbtype, char *cbcharset, size_t length,
1274                 char *encoding, char *cbid, void *cbuserdata)
1275 {
1276         struct ma_info *ma;
1277
1278         ma = (struct ma_info *)cbuserdata;
1279         syslog(LOG_DEBUG, "fixed_output_post() type=<%s>\n", cbtype);
1280         if (!strcasecmp(cbtype, "multipart/alternative")) {
1281                 --ma->is_ma;
1282                 ma->did_print = 0;
1283         }
1284         if (!strcasecmp(cbtype, "message/rfc822")) {
1285                 --ma->freeze;
1286         }
1287 }
1288
1289 /*
1290  * Inline callback function for mime parser that wants to display text
1291  */
1292 void fixed_output(char *name, char *filename, char *partnum, char *disp,
1293                 void *content, char *cbtype, char *cbcharset, size_t length,
1294                 char *encoding, char *cbid, void *cbuserdata)
1295 {
1296         char *ptr;
1297         char *wptr;
1298         size_t wlen;
1299         struct ma_info *ma;
1300
1301         ma = (struct ma_info *)cbuserdata;
1302
1303         syslog(LOG_DEBUG,
1304                 "fixed_output() part %s: %s (%s) (%ld bytes)\n",
1305                 partnum, filename, cbtype, (long)length);
1306
1307         /*
1308          * If we're in the middle of a multipart/alternative scope and
1309          * we've already printed another section, skip this one.
1310          */
1311         if ( (ma->is_ma) && (ma->did_print) ) {
1312                 syslog(LOG_DEBUG, "Skipping part %s (%s)\n", partnum, cbtype);
1313                 return;
1314         }
1315         ma->did_print = 1;
1316
1317         if ( (!strcasecmp(cbtype, "text/plain"))
1318            || (IsEmptyStr(cbtype)) ) {
1319                 wptr = content;
1320                 if (length > 0) {
1321                         client_write(wptr, length);
1322                         if (wptr[length-1] != '\n') {
1323                                 cprintf("\n");
1324                         }
1325                 }
1326                 return;
1327         }
1328
1329         if (!strcasecmp(cbtype, "text/html")) {
1330                 ptr = html_to_ascii(content, length, 80, 0);
1331                 wlen = strlen(ptr);
1332                 client_write(ptr, wlen);
1333                 if (ptr[wlen-1] != '\n') {
1334                         cprintf("\n");
1335                 }
1336                 free(ptr);
1337                 return;
1338         }
1339
1340         if (ma->use_fo_hooks) {
1341                 if (PerformFixedOutputHooks(cbtype, content, length)) {
1342                 /* above function returns nonzero if it handled the part */
1343                         return;
1344                 }
1345         }
1346
1347         if (strncasecmp(cbtype, "multipart/", 10)) {
1348                 cprintf("Part %s: %s (%s) (%ld bytes)\r\n",
1349                         partnum, filename, cbtype, (long)length);
1350                 return;
1351         }
1352 }
1353
1354 /*
1355  * The client is elegant and sophisticated and wants to be choosy about
1356  * MIME content types, so figure out which multipart/alternative part
1357  * we're going to send.
1358  *
1359  * We use a system of weights.  When we find a part that matches one of the
1360  * MIME types we've declared as preferential, we can store it in ma->chosen_part
1361  * and then set ma->chosen_pref to that MIME type's position in our preference
1362  * list.  If we then hit another match, we only replace the first match if
1363  * the preference value is lower.
1364  */
1365 void choose_preferred(char *name, char *filename, char *partnum, char *disp,
1366                 void *content, char *cbtype, char *cbcharset, size_t length,
1367                 char *encoding, char *cbid, void *cbuserdata)
1368 {
1369         char buf[1024];
1370         int i;
1371         struct ma_info *ma;
1372
1373         ma = (struct ma_info *)cbuserdata;
1374
1375         // NOTE: REMOVING THIS CONDITIONAL FIXES BUG 220
1376         //       http://bugzilla.citadel.org/show_bug.cgi?id=220
1377         // I don't know if there are any side effects!  Please TEST TEST TEST
1378         //if (ma->is_ma > 0) {
1379
1380         for (i=0; i<num_tokens(CC->preferred_formats, '|'); ++i) {
1381                 extract_token(buf, CC->preferred_formats, i, '|', sizeof buf);
1382                 if ( (!strcasecmp(buf, cbtype)) && (!ma->freeze) ) {
1383                         if (i < ma->chosen_pref) {
1384                                 syslog(LOG_DEBUG, "Setting chosen part: <%s>\n", partnum);
1385                                 safestrncpy(ma->chosen_part, partnum, sizeof ma->chosen_part);
1386                                 ma->chosen_pref = i;
1387                         }
1388                 }
1389         }
1390 }
1391
1392 /*
1393  * Now that we've chosen our preferred part, output it.
1394  */
1395 void output_preferred(char *name,
1396                       char *filename,
1397                       char *partnum,
1398                       char *disp,
1399                       void *content,
1400                       char *cbtype,
1401                       char *cbcharset,
1402                       size_t length,
1403                       char *encoding,
1404                       char *cbid,
1405                       void *cbuserdata)
1406 {
1407         int i;
1408         char buf[128];
1409         int add_newline = 0;
1410         char *text_content;
1411         struct ma_info *ma;
1412         char *decoded = NULL;
1413         size_t bytes_decoded;
1414         int rc = 0;
1415
1416         ma = (struct ma_info *)cbuserdata;
1417
1418         /* This is not the MIME part you're looking for... */
1419         if (strcasecmp(partnum, ma->chosen_part)) return;
1420
1421         /* If the content-type of this part is in our preferred formats
1422          * list, we can simply output it verbatim.
1423          */
1424         for (i=0; i<num_tokens(CC->preferred_formats, '|'); ++i) {
1425                 extract_token(buf, CC->preferred_formats, i, '|', sizeof buf);
1426                 if (!strcasecmp(buf, cbtype)) {
1427                         /* Yeah!  Go!  W00t!! */
1428                         if (ma->dont_decode == 0)
1429                                 rc = mime_decode_now (content,
1430                                                       length,
1431                                                       encoding,
1432                                                       &decoded,
1433                                                       &bytes_decoded);
1434                         if (rc < 0)
1435                                 break; /* Give us the chance, maybe theres another one. */
1436
1437                         if (rc == 0) text_content = (char *)content;
1438                         else {
1439                                 text_content = decoded;
1440                                 length = bytes_decoded;
1441                         }
1442
1443                         if (text_content[length-1] != '\n') {
1444                                 ++add_newline;
1445                         }
1446                         cprintf("Content-type: %s", cbtype);
1447                         if (!IsEmptyStr(cbcharset)) {
1448                                 cprintf("; charset=%s", cbcharset);
1449                         }
1450                         cprintf("\nContent-length: %d\n",
1451                                 (int)(length + add_newline) );
1452                         if (!IsEmptyStr(encoding)) {
1453                                 cprintf("Content-transfer-encoding: %s\n", encoding);
1454                         }
1455                         else {
1456                                 cprintf("Content-transfer-encoding: 7bit\n");
1457                         }
1458                         cprintf("X-Citadel-MSG4-Partnum: %s\n", partnum);
1459                         cprintf("\n");
1460                         client_write(text_content, length);
1461                         if (add_newline) cprintf("\n");
1462                         if (decoded != NULL) free(decoded);
1463                         return;
1464                 }
1465         }
1466
1467         /* No translations required or possible: output as text/plain */
1468         cprintf("Content-type: text/plain\n\n");
1469         rc = 0;
1470         if (ma->dont_decode == 0)
1471                 rc = mime_decode_now (content,
1472                                       length,
1473                                       encoding,
1474                                       &decoded,
1475                                       &bytes_decoded);
1476         if (rc < 0)
1477                 return; /* Give us the chance, maybe theres another one. */
1478
1479         if (rc == 0) text_content = (char *)content;
1480         else {
1481                 text_content = decoded;
1482                 length = bytes_decoded;
1483         }
1484
1485         fixed_output(name, filename, partnum, disp, text_content, cbtype, cbcharset,
1486                         length, encoding, cbid, cbuserdata);
1487         if (decoded != NULL) free(decoded);
1488 }
1489
1490
1491 struct encapmsg {
1492         char desired_section[64];
1493         char *msg;
1494         size_t msglen;
1495 };
1496
1497
1498 /*
1499  * Callback function for
1500  */
1501 void extract_encapsulated_message(char *name, char *filename, char *partnum, char *disp,
1502                    void *content, char *cbtype, char *cbcharset, size_t length,
1503                    char *encoding, char *cbid, void *cbuserdata)
1504 {
1505         struct encapmsg *encap;
1506
1507         encap = (struct encapmsg *)cbuserdata;
1508
1509         /* Only proceed if this is the desired section... */
1510         if (!strcasecmp(encap->desired_section, partnum)) {
1511                 encap->msglen = length;
1512                 encap->msg = malloc(length + 2);
1513                 memcpy(encap->msg, content, length);
1514                 return;
1515         }
1516 }
1517
1518
1519 /*
1520  * Determine whether the specified message exists in the cached_msglist
1521  * (This is a security check)
1522  */
1523 int check_cached_msglist(long msgnum) {
1524
1525         /* cases in which we skip the check */
1526         if (!CC) return om_ok;                                          /* not a session */
1527         if (CC->client_socket <= 0) return om_ok;                       /* not a client session */
1528         if (CC->cached_msglist == NULL) return om_access_denied;        /* no msglist fetched */
1529         if (CC->cached_num_msgs == 0) return om_access_denied;          /* nothing to check */
1530
1531
1532         /* Do a binary search within the cached_msglist for the requested msgnum */
1533         int min = 0;
1534         int max = (CC->cached_num_msgs - 1);
1535
1536         while (max >= min) {
1537                 int middle = min + (max-min) / 2 ;
1538                 if (msgnum == CC->cached_msglist[middle]) {
1539                         return om_ok;
1540                 }
1541                 if (msgnum > CC->cached_msglist[middle]) {
1542                         min = middle + 1;
1543                 }
1544                 else {
1545                         max = middle - 1;
1546                 }
1547         }
1548
1549         return om_access_denied;
1550 }
1551
1552
1553 /*
1554  * Determine whether the currently logged in session has permission to read
1555  * messages in the current room.
1556  */
1557 int CtdlDoIHavePermissionToReadMessagesInThisRoom(void) {
1558         if (    (!(CC->logged_in))
1559                 && (!(CC->internal_pgm))
1560                 && (!config.c_guest_logins)
1561         ) {
1562                 return(om_not_logged_in);
1563         }
1564         return(om_ok);
1565 }
1566
1567
1568 /*
1569  * Get a message off disk.  (returns om_* values found in msgbase.h)
1570  *
1571  */
1572 int CtdlOutputMsg(long msg_num,         /* message number (local) to fetch */
1573                   int mode,             /* how would you like that message? */
1574                   int headers_only,     /* eschew the message body? */
1575                   int do_proto,         /* do Citadel protocol responses? */
1576                   int crlf,             /* Use CRLF newlines instead of LF? */
1577                   char *section,        /* NULL or a message/rfc822 section */
1578                   int flags             /* various flags; see msgbase.h */
1579 ) {
1580         struct CtdlMessage *TheMessage = NULL;
1581         int retcode = om_no_such_msg;
1582         struct encapmsg encap;
1583         int r;
1584
1585         syslog(LOG_DEBUG, "CtdlOutputMsg(msgnum=%ld, mode=%d, section=%s)\n",
1586                 msg_num, mode,
1587                 (section ? section : "<>")
1588         );
1589
1590         r = CtdlDoIHavePermissionToReadMessagesInThisRoom();
1591         if (r != om_ok) {
1592                 if (do_proto) {
1593                         if (r == om_not_logged_in) {
1594                                 cprintf("%d Not logged in.\n", ERROR + NOT_LOGGED_IN);
1595                         }
1596                         else {
1597                                 cprintf("%d An unknown error has occurred.\n", ERROR);
1598                         }
1599                 }
1600                 return(r);
1601         }
1602
1603         /*
1604          * Check to make sure the message is actually IN this room
1605          */
1606         r = check_cached_msglist(msg_num);
1607         if (r == om_access_denied) {
1608                 /* Not in the cache?  We get ONE shot to check it again. */
1609                 CtdlForEachMessage(MSGS_ALL, 0L, NULL, NULL, NULL, NULL, NULL);
1610                 r = check_cached_msglist(msg_num);
1611         }
1612         if (r != om_ok) {
1613                 syslog(LOG_DEBUG, "Security check fail: message %ld is not in %s\n",
1614                         msg_num, CC->room.QRname
1615                 );
1616                 if (do_proto) {
1617                         if (r == om_access_denied) {
1618                                 cprintf("%d message %ld was not found in this room\n",
1619                                         ERROR + HIGHER_ACCESS_REQUIRED,
1620                                         msg_num
1621                                 );
1622                         }
1623                 }
1624                 return(r);
1625         }
1626
1627         /*
1628          * Fetch the message from disk.  If we're in HEADERS_FAST mode,
1629          * request that we don't even bother loading the body into memory.
1630          */
1631         if (headers_only == HEADERS_FAST) {
1632                 TheMessage = CtdlFetchMessage(msg_num, 0);
1633         }
1634         else {
1635                 TheMessage = CtdlFetchMessage(msg_num, 1);
1636         }
1637
1638         if (TheMessage == NULL) {
1639                 if (do_proto) cprintf("%d Can't locate msg %ld on disk\n",
1640                         ERROR + MESSAGE_NOT_FOUND, msg_num);
1641                 return(om_no_such_msg);
1642         }
1643
1644         /* Here is the weird form of this command, to process only an
1645          * encapsulated message/rfc822 section.
1646          */
1647         if (section) if (!IsEmptyStr(section)) if (strcmp(section, "0")) {
1648                 memset(&encap, 0, sizeof encap);
1649                 safestrncpy(encap.desired_section, section, sizeof encap.desired_section);
1650                 mime_parser(TheMessage->cm_fields['M'],
1651                         NULL,
1652                         *extract_encapsulated_message,
1653                         NULL, NULL, (void *)&encap, 0
1654                 );
1655                 CtdlFreeMessage(TheMessage);
1656                 TheMessage = NULL;
1657
1658                 if (encap.msg) {
1659                         encap.msg[encap.msglen] = 0;
1660                         TheMessage = convert_internet_message(encap.msg);
1661                         encap.msg = NULL;       /* no free() here, TheMessage owns it now */
1662
1663                         /* Now we let it fall through to the bottom of this
1664                          * function, because TheMessage now contains the
1665                          * encapsulated message instead of the top-level
1666                          * message.  Isn't that neat?
1667                          */
1668
1669                 }
1670                 else {
1671                         if (do_proto) cprintf("%d msg %ld has no part %s\n",
1672                                 ERROR + MESSAGE_NOT_FOUND, msg_num, section);
1673                         retcode = om_no_such_msg;
1674                 }
1675
1676         }
1677
1678         /* Ok, output the message now */
1679         retcode = CtdlOutputPreLoadedMsg(TheMessage, mode, headers_only, do_proto, crlf, flags);
1680         CtdlFreeMessage(TheMessage);
1681
1682         return(retcode);
1683 }
1684
1685
1686 char *qp_encode_email_addrs(char *source)
1687 {
1688         char *user, *node, *name;
1689         const char headerStr[] = "=?UTF-8?Q?";
1690         char *Encoded;
1691         char *EncodedName;
1692         char *nPtr;
1693         int need_to_encode = 0;
1694         long SourceLen;
1695         long EncodedMaxLen;
1696         long nColons = 0;
1697         long *AddrPtr;
1698         long *AddrUtf8;
1699         long nAddrPtrMax = 50;
1700         long nmax;
1701         int InQuotes = 0;
1702         int i, n;
1703
1704         if (source == NULL) return source;
1705         if (IsEmptyStr(source)) return source;
1706         cit_backtrace();
1707         syslog(LOG_DEBUG, "qp_encode_email_addrs: [%s]\n", source);
1708
1709         AddrPtr = malloc (sizeof (long) * nAddrPtrMax);
1710         AddrUtf8 = malloc (sizeof (long) * nAddrPtrMax);
1711         memset(AddrUtf8, 0, sizeof (long) * nAddrPtrMax);
1712         *AddrPtr = 0;
1713         i = 0;
1714         while (!IsEmptyStr (&source[i])) {
1715                 if (nColons >= nAddrPtrMax){
1716                         long *ptr;
1717
1718                         ptr = (long *) malloc(sizeof (long) * nAddrPtrMax * 2);
1719                         memcpy (ptr, AddrPtr, sizeof (long) * nAddrPtrMax);
1720                         free (AddrPtr), AddrPtr = ptr;
1721
1722                         ptr = (long *) malloc(sizeof (long) * nAddrPtrMax * 2);
1723                         memset(&ptr[nAddrPtrMax], 0,
1724                                sizeof (long) * nAddrPtrMax);
1725
1726                         memcpy (ptr, AddrUtf8, sizeof (long) * nAddrPtrMax);
1727                         free (AddrUtf8), AddrUtf8 = ptr;
1728                         nAddrPtrMax *= 2;
1729                 }
1730                 if (((unsigned char) source[i] < 32) ||
1731                     ((unsigned char) source[i] > 126)) {
1732                         need_to_encode = 1;
1733                         AddrUtf8[nColons] = 1;
1734                 }
1735                 if (source[i] == '"')
1736                         InQuotes = !InQuotes;
1737                 if (!InQuotes && source[i] == ',') {
1738                         AddrPtr[nColons] = i;
1739                         nColons++;
1740                 }
1741                 i++;
1742         }
1743         if (need_to_encode == 0) {
1744                 free(AddrPtr);
1745                 free(AddrUtf8);
1746                 return source;
1747         }
1748
1749         SourceLen = i;
1750         EncodedMaxLen = nColons * (sizeof(headerStr) + 3) + SourceLen * 3;
1751         Encoded = (char*) malloc (EncodedMaxLen);
1752
1753         for (i = 0; i < nColons; i++)
1754                 source[AddrPtr[i]++] = '\0';
1755         /* TODO: if libidn, this might get larger*/
1756         user = malloc(SourceLen + 1);
1757         node = malloc(SourceLen + 1);
1758         name = malloc(SourceLen + 1);
1759
1760         nPtr = Encoded;
1761         *nPtr = '\0';
1762         for (i = 0; i < nColons && nPtr != NULL; i++) {
1763                 nmax = EncodedMaxLen - (nPtr - Encoded);
1764                 if (AddrUtf8[i]) {
1765                         process_rfc822_addr(&source[AddrPtr[i]],
1766                                             user,
1767                                             node,
1768                                             name);
1769                         /* TODO: libIDN here ! */
1770                         if (IsEmptyStr(name)) {
1771                                 n = snprintf(nPtr, nmax,
1772                                              (i==0)?"%s@%s" : ",%s@%s",
1773                                              user, node);
1774                         }
1775                         else {
1776                                 EncodedName = rfc2047encode(name, strlen(name));
1777                                 n = snprintf(nPtr, nmax,
1778                                              (i==0)?"%s <%s@%s>" : ",%s <%s@%s>",
1779                                              EncodedName, user, node);
1780                                 free(EncodedName);
1781                         }
1782                 }
1783                 else {
1784                         n = snprintf(nPtr, nmax,
1785                                      (i==0)?"%s" : ",%s",
1786                                      &source[AddrPtr[i]]);
1787                 }
1788                 if (n > 0 )
1789                         nPtr += n;
1790                 else {
1791                         char *ptr, *nnPtr;
1792                         ptr = (char*) malloc(EncodedMaxLen * 2);
1793                         memcpy(ptr, Encoded, EncodedMaxLen);
1794                         nnPtr = ptr + (nPtr - Encoded), nPtr = nnPtr;
1795                         free(Encoded), Encoded = ptr;
1796                         EncodedMaxLen *= 2;
1797                         i--; /* do it once more with properly lengthened buffer */
1798                 }
1799         }
1800         for (i = 0; i < nColons; i++)
1801                 source[--AddrPtr[i]] = ',';
1802
1803         free(user);
1804         free(node);
1805         free(name);
1806         free(AddrUtf8);
1807         free(AddrPtr);
1808         return Encoded;
1809 }
1810
1811
1812 /* If the last item in a list of recipients was truncated to a partial address,
1813  * remove it completely in order to avoid choking libSieve
1814  */
1815 void sanitize_truncated_recipient(char *str)
1816 {
1817         if (!str) return;
1818         if (num_tokens(str, ',') < 2) return;
1819
1820         int len = strlen(str);
1821         if (len < 900) return;
1822         if (len > 998) str[998] = 0;
1823
1824         char *cptr = strrchr(str, ',');
1825         if (!cptr) return;
1826
1827         char *lptr = strchr(cptr, '<');
1828         char *rptr = strchr(cptr, '>');
1829
1830         if ( (lptr) && (rptr) && (rptr > lptr) ) return;
1831
1832         *cptr = 0;
1833 }
1834
1835
1836 void OutputCtdlMsgHeaders(
1837         struct CtdlMessage *TheMessage,
1838         int do_proto)           /* do Citadel protocol responses? */
1839 {
1840         char allkeys[30];
1841         int i, k, n;
1842         int suppress_f = 0;
1843         char buf[SIZ];
1844         char display_name[256];
1845
1846         /* begin header processing loop for Citadel message format */
1847         safestrncpy(display_name, "<unknown>", sizeof display_name);
1848         if (TheMessage->cm_fields['A']) {
1849                 strcpy(buf, TheMessage->cm_fields['A']);
1850                 if (TheMessage->cm_anon_type == MES_ANONONLY) {
1851                         safestrncpy(display_name, "****", sizeof display_name);
1852                 }
1853                 else if (TheMessage->cm_anon_type == MES_ANONOPT) {
1854                         safestrncpy(display_name, "anonymous", sizeof display_name);
1855                 }
1856                 else {
1857                         safestrncpy(display_name, buf, sizeof display_name);
1858                 }
1859                 if ((is_room_aide())
1860                     && ((TheMessage->cm_anon_type == MES_ANONONLY)
1861                         || (TheMessage->cm_anon_type == MES_ANONOPT))) {
1862                         size_t tmp = strlen(display_name);
1863                         snprintf(&display_name[tmp],
1864                                  sizeof display_name - tmp,
1865                                  " [%s]", buf);
1866                 }
1867         }
1868
1869         /* Don't show Internet address for users on the
1870          * local Citadel network.
1871          */
1872         suppress_f = 0;
1873         if (TheMessage->cm_fields['N'] != NULL)
1874                 if (!IsEmptyStr(TheMessage->cm_fields['N']))
1875                         if (haschar(TheMessage->cm_fields['N'], '.') == 0) {
1876                                 suppress_f = 1;
1877                         }
1878
1879         /* Now spew the header fields in the order we like them. */
1880         n = safestrncpy(allkeys, FORDER, sizeof allkeys);
1881         for (i=0; i<n; ++i) {
1882                 k = (int) allkeys[i];
1883                 if (k != 'M') {
1884                         if ( (TheMessage->cm_fields[k] != NULL)
1885                              && (msgkeys[k] != NULL) ) {
1886                                 if ((k == 'V') || (k == 'R') || (k == 'Y')) {
1887                                         sanitize_truncated_recipient(TheMessage->cm_fields[k]);
1888                                 }
1889                                 if (k == 'A') {
1890                                         if (do_proto) cprintf("%s=%s\n",
1891                                                               msgkeys[k],
1892                                                               display_name);
1893                                 }
1894                                 else if ((k == 'F') && (suppress_f)) {
1895                                         /* do nothing */
1896                                 }
1897                                 /* Masquerade display name if needed */
1898                                 else {
1899                                         if (do_proto) cprintf("%s=%s\n",
1900                                                               msgkeys[k],
1901                                                               TheMessage->cm_fields[k]
1902                                                 );
1903                                 }
1904                         }
1905                 }
1906         }
1907
1908 }
1909
1910 void OutputRFC822MsgHeaders(
1911         struct CtdlMessage *TheMessage,
1912         int flags,              /* should the bessage be exported clean */
1913         const char *nl,
1914         char *mid, long sizeof_mid,
1915         char *suser, long sizeof_suser,
1916         char *luser, long sizeof_luser,
1917         char *fuser, long sizeof_fuser,
1918         char *snode, long sizeof_snode)
1919 {
1920         char datestamp[100];
1921         int subject_found = 0;
1922         char buf[SIZ];
1923         int i, j, k;
1924         char *mptr = NULL;
1925         char *mpptr = NULL;
1926
1927         for (i = 0; i < 256; ++i) {
1928                 if (TheMessage->cm_fields[i]) {
1929                         mptr = mpptr = TheMessage->cm_fields[i];
1930
1931                         if (i == 'A') {
1932                                 safestrncpy(luser, mptr, sizeof_luser);
1933                                 safestrncpy(suser, mptr, sizeof_suser);
1934                         }
1935                         else if (i == 'Y') {
1936                                 if ((flags & QP_EADDR) != 0) {
1937                                         mptr = qp_encode_email_addrs(mptr);
1938                                 }
1939                                 sanitize_truncated_recipient(mptr);
1940                                 cprintf("CC: %s%s", mptr, nl);
1941                         }
1942                         else if (i == 'P') {
1943                                 cprintf("Return-Path: %s%s", mptr, nl);
1944                         }
1945                         else if (i == 'L') {
1946                                 cprintf("List-ID: %s%s", mptr, nl);
1947                         }
1948                         else if (i == 'V') {
1949                                 if ((flags & QP_EADDR) != 0)
1950                                         mptr = qp_encode_email_addrs(mptr);
1951                                 cprintf("Envelope-To: %s%s", mptr, nl);
1952                         }
1953                         else if (i == 'U') {
1954                                 cprintf("Subject: %s%s", mptr, nl);
1955                                 subject_found = 1;
1956                         }
1957                         else if (i == 'I')
1958                                 safestrncpy(mid, mptr, sizeof_mid); /// TODO: detect @ here and copy @nodename in if not found.
1959                         else if (i == 'F')
1960                                 safestrncpy(fuser, mptr, sizeof_fuser);
1961                         /* else if (i == 'O')
1962                            cprintf("X-Citadel-Room: %s%s",
1963                            mptr, nl); */
1964                         else if (i == 'N')
1965                                 safestrncpy(snode, mptr, sizeof_snode);
1966                         else if (i == 'R')
1967                         {
1968                                 if (haschar(mptr, '@') == 0)
1969                                 {
1970                                         sanitize_truncated_recipient(mptr);
1971                                         cprintf("To: %s@%s", mptr, config.c_fqdn);
1972                                         cprintf("%s", nl);
1973                                 }
1974                                 else
1975                                 {
1976                                         if ((flags & QP_EADDR) != 0) {
1977                                                 mptr = qp_encode_email_addrs(mptr);
1978                                         }
1979                                         sanitize_truncated_recipient(mptr);
1980                                         cprintf("To: %s", mptr);
1981                                         cprintf("%s", nl);
1982                                 }
1983                         }
1984                         else if (i == 'T') {
1985                                 datestring(datestamp, sizeof datestamp,
1986                                            atol(mptr), DATESTRING_RFC822);
1987                                 cprintf("Date: %s%s", datestamp, nl);
1988                         }
1989                         else if (i == 'W') {
1990                                 cprintf("References: ");
1991                                 k = num_tokens(mptr, '|');
1992                                 for (j=0; j<k; ++j) {
1993                                         extract_token(buf, mptr, j, '|', sizeof buf);
1994                                         cprintf("<%s>", buf);
1995                                         if (j == (k-1)) {
1996                                                 cprintf("%s", nl);
1997                                         }
1998                                         else {
1999                                                 cprintf(" ");
2000                                         }
2001                                 }
2002                         }
2003                         else if (i == 'K') {
2004                                 cprintf("Reply-To: <%s>%s", mptr, nl);
2005                         }
2006                         if (mptr != mpptr)
2007                                 free (mptr);
2008                 }
2009         }
2010         if (subject_found == 0) {
2011                 cprintf("Subject: (no subject)%s", nl);
2012         }
2013 }
2014
2015
2016 void Dump_RFC822HeadersBody(
2017         struct CtdlMessage *TheMessage,
2018         int headers_only,       /* eschew the message body? */
2019         int flags,              /* should the bessage be exported clean? */
2020
2021         const char *nl)
2022 {
2023         cit_uint8_t prev_ch;
2024         int eoh = 0;
2025         const char *StartOfText = StrBufNOTNULL;
2026         char outbuf[1024];
2027         int outlen = 0;
2028         int nllen = strlen(nl);
2029         char *mptr;
2030
2031         mptr = TheMessage->cm_fields['M'];
2032
2033
2034         prev_ch = '\0';
2035         while (*mptr != '\0') {
2036                 if (*mptr == '\r') {
2037                         /* do nothing */
2038                 }
2039                 else {
2040                         if ((!eoh) &&
2041                             (*mptr == '\n'))
2042                         {
2043                                 eoh = (*(mptr+1) == '\r') && (*(mptr+2) == '\n');
2044                                 if (!eoh)
2045                                         eoh = *(mptr+1) == '\n';
2046                                 if (eoh)
2047                                 {
2048                                         StartOfText = mptr;
2049                                         StartOfText = strchr(StartOfText, '\n');
2050                                         StartOfText = strchr(StartOfText, '\n');
2051                                 }
2052                         }
2053                         if (((headers_only == HEADERS_NONE) && (mptr >= StartOfText)) ||
2054                             ((headers_only == HEADERS_ONLY) && (mptr < StartOfText)) ||
2055                             ((headers_only != HEADERS_NONE) &&
2056                              (headers_only != HEADERS_ONLY))
2057                                 ) {
2058                                 if (*mptr == '\n') {
2059                                         memcpy(&outbuf[outlen], nl, nllen);
2060                                         outlen += nllen;
2061                                         outbuf[outlen] = '\0';
2062                                 }
2063                                 else {
2064                                         outbuf[outlen++] = *mptr;
2065                                 }
2066                         }
2067                 }
2068                 if (flags & ESC_DOT)
2069                 {
2070                         if ((prev_ch == '\n') &&
2071                             (*mptr == '.') &&
2072                             ((*(mptr+1) == '\r') || (*(mptr+1) == '\n')))
2073                         {
2074                                 outbuf[outlen++] = '.';
2075                         }
2076                         prev_ch = *mptr;
2077                 }
2078                 ++mptr;
2079                 if (outlen > 1000) {
2080                         client_write(outbuf, outlen);
2081                         outlen = 0;
2082                 }
2083         }
2084         if (outlen > 0) {
2085                 client_write(outbuf, outlen);
2086                 outlen = 0;
2087         }
2088 }
2089
2090
2091
2092 /* If the format type on disk is 1 (fixed-format), then we want
2093  * everything to be output completely literally ... regardless of
2094  * what message transfer format is in use.
2095  */
2096 void DumpFormatFixed(
2097         struct CtdlMessage *TheMessage,
2098         int mode,               /* how would you like that message? */
2099         const char *nl)
2100 {
2101         cit_uint8_t ch;
2102         char buf[SIZ];
2103         int buflen;
2104         int xlline = 0;
2105         int nllen = strlen (nl);
2106         char *mptr;
2107
2108         mptr = TheMessage->cm_fields['M'];
2109
2110         if (mode == MT_MIME) {
2111                 cprintf("Content-type: text/plain\n\n");
2112         }
2113         *buf = '\0';
2114         buflen = 0;
2115         while (ch = *mptr++, ch > 0) {
2116                 if (ch == '\n')
2117                         ch = '\r';
2118
2119                 if ((buflen > 250) && (!xlline)){
2120                         int tbuflen;
2121                         tbuflen = buflen;
2122
2123                         while ((buflen > 0) &&
2124                                (!isspace(buf[buflen])))
2125                                 buflen --;
2126                         if (buflen == 0) {
2127                                 xlline = 1;
2128                         }
2129                         else {
2130                                 mptr -= tbuflen - buflen;
2131                                 buf[buflen] = '\0';
2132                                 ch = '\r';
2133                         }
2134                 }
2135                 /* if we reach the outer bounds of our buffer,
2136                    abort without respect what whe purge. */
2137                 if (xlline &&
2138                     ((isspace(ch)) ||
2139                      (buflen > SIZ - nllen - 2)))
2140                         ch = '\r';
2141
2142                 if (ch == '\r') {
2143                         memcpy (&buf[buflen], nl, nllen);
2144                         buflen += nllen;
2145                         buf[buflen] = '\0';
2146
2147                         client_write(buf, buflen);
2148                         *buf = '\0';
2149                         buflen = 0;
2150                         xlline = 0;
2151                 } else {
2152                         buf[buflen] = ch;
2153                         buflen++;
2154                 }
2155         }
2156         buf[buflen] = '\0';
2157         if (!IsEmptyStr(buf))
2158                 cprintf("%s%s", buf, nl);
2159 }
2160
2161 /*
2162  * Get a message off disk.  (returns om_* values found in msgbase.h)
2163  */
2164 int CtdlOutputPreLoadedMsg(
2165                 struct CtdlMessage *TheMessage,
2166                 int mode,               /* how would you like that message? */
2167                 int headers_only,       /* eschew the message body? */
2168                 int do_proto,           /* do Citadel protocol responses? */
2169                 int crlf,               /* Use CRLF newlines instead of LF? */
2170                 int flags               /* should the bessage be exported clean? */
2171 ) {
2172         int i;
2173         char *mptr = NULL;
2174         const char *nl; /* newline string */
2175         struct ma_info ma;
2176
2177         /* Buffers needed for RFC822 translation.  These are all filled
2178          * using functions that are bounds-checked, and therefore we can
2179          * make them substantially smaller than SIZ.
2180          */
2181         char suser[100];
2182         char luser[100];
2183         char fuser[100];
2184         char snode[100];
2185         char mid[100];
2186
2187         syslog(LOG_DEBUG, "CtdlOutputPreLoadedMsg(TheMessage=%s, %d, %d, %d, %d\n",
2188                 ((TheMessage == NULL) ? "NULL" : "not null"),
2189                 mode, headers_only, do_proto, crlf);
2190
2191         strcpy(mid, "unknown");
2192         nl = (crlf ? "\r\n" : "\n");
2193
2194         if (!is_valid_message(TheMessage)) {
2195                 syslog(LOG_ERR,
2196                         "ERROR: invalid preloaded message for output\n");
2197                 cit_backtrace ();
2198                 return(om_no_such_msg);
2199         }
2200
2201         /* Suppress envelope recipients if required to avoid disclosing BCC addresses.
2202          * Pad it with spaces in order to avoid changing the RFC822 length of the message.
2203          */
2204         if ( (flags & SUPPRESS_ENV_TO) && (TheMessage->cm_fields['V'] != NULL) ) {
2205                 memset(TheMessage->cm_fields['V'], ' ', strlen(TheMessage->cm_fields['V']));
2206         }
2207
2208         /* Are we downloading a MIME component? */
2209         if (mode == MT_DOWNLOAD) {
2210                 if (TheMessage->cm_format_type != FMT_RFC822) {
2211                         if (do_proto)
2212                                 cprintf("%d This is not a MIME message.\n",
2213                                 ERROR + ILLEGAL_VALUE);
2214                 } else if (CC->download_fp != NULL) {
2215                         if (do_proto) cprintf(
2216                                 "%d You already have a download open.\n",
2217                                 ERROR + RESOURCE_BUSY);
2218                 } else {
2219                         /* Parse the message text component */
2220                         mptr = TheMessage->cm_fields['M'];
2221                         mime_parser(mptr, NULL, *mime_download, NULL, NULL, NULL, 0);
2222                         /* If there's no file open by this time, the requested
2223                          * section wasn't found, so print an error
2224                          */
2225                         if (CC->download_fp == NULL) {
2226                                 if (do_proto) cprintf(
2227                                         "%d Section %s not found.\n",
2228                                         ERROR + FILE_NOT_FOUND,
2229                                         CC->download_desired_section);
2230                         }
2231                 }
2232                 return((CC->download_fp != NULL) ? om_ok : om_mime_error);
2233         }
2234
2235         /* MT_SPEW_SECTION is like MT_DOWNLOAD except it outputs the whole MIME part
2236          * in a single server operation instead of opening a download file.
2237          */
2238         if (mode == MT_SPEW_SECTION) {
2239                 if (TheMessage->cm_format_type != FMT_RFC822) {
2240                         if (do_proto)
2241                                 cprintf("%d This is not a MIME message.\n",
2242                                 ERROR + ILLEGAL_VALUE);
2243                 } else {
2244                         /* Parse the message text component */
2245                         int found_it = 0;
2246
2247                         mptr = TheMessage->cm_fields['M'];
2248                         mime_parser(mptr, NULL, *mime_spew_section, NULL, NULL, (void *)&found_it, 0);
2249                         /* If section wasn't found, print an error
2250                          */
2251                         if (!found_it) {
2252                                 if (do_proto) cprintf(
2253                                         "%d Section %s not found.\n",
2254                                         ERROR + FILE_NOT_FOUND,
2255                                         CC->download_desired_section);
2256                         }
2257                 }
2258                 return((CC->download_fp != NULL) ? om_ok : om_mime_error);
2259         }
2260
2261         /* now for the user-mode message reading loops */
2262         if (do_proto) cprintf("%d msg:\n", LISTING_FOLLOWS);
2263
2264         /* Does the caller want to skip the headers? */
2265         if (headers_only == HEADERS_NONE) goto START_TEXT;
2266
2267         /* Tell the client which format type we're using. */
2268         if ( (mode == MT_CITADEL) && (do_proto) ) {
2269                 cprintf("type=%d\n", TheMessage->cm_format_type);
2270         }
2271
2272         /* nhdr=yes means that we're only displaying headers, no body */
2273         if ( (TheMessage->cm_anon_type == MES_ANONONLY)
2274            && ((mode == MT_CITADEL) || (mode == MT_MIME))
2275            && (do_proto)
2276            ) {
2277                 cprintf("nhdr=yes\n");
2278         }
2279
2280         if ((mode == MT_CITADEL) || (mode == MT_MIME))
2281                 OutputCtdlMsgHeaders(TheMessage, do_proto);
2282
2283
2284         /* begin header processing loop for RFC822 transfer format */
2285         strcpy(suser, "");
2286         strcpy(luser, "");
2287         strcpy(fuser, "");
2288         strcpy(snode, NODENAME);
2289         if (mode == MT_RFC822)
2290                 OutputRFC822MsgHeaders(
2291                         TheMessage,
2292                         flags,
2293                         nl,
2294                         mid, sizeof(mid),
2295                         suser, sizeof(suser),
2296                         luser, sizeof(luser),
2297                         fuser, sizeof(fuser),
2298                         snode, sizeof(snode)
2299                         );
2300
2301
2302         for (i=0; !IsEmptyStr(&suser[i]); ++i) {
2303                 suser[i] = tolower(suser[i]);
2304                 if (!isalnum(suser[i])) suser[i]='_';
2305         }
2306
2307         if (mode == MT_RFC822) {
2308                 if (!strcasecmp(snode, NODENAME)) {
2309                         safestrncpy(snode, FQDN, sizeof snode);
2310                 }
2311
2312                 /* Construct a fun message id */
2313                 cprintf("Message-ID: <%s", mid);/// todo: this possibly breaks threadding mails.
2314                 if (strchr(mid, '@')==NULL) {
2315                         cprintf("@%s", snode);
2316                 }
2317                 cprintf(">%s", nl);
2318
2319                 if (!is_room_aide() && (TheMessage->cm_anon_type == MES_ANONONLY)) {
2320                         cprintf("From: \"----\" <x@x.org>%s", nl);
2321                 }
2322                 else if (!is_room_aide() && (TheMessage->cm_anon_type == MES_ANONOPT)) {
2323                         cprintf("From: \"anonymous\" <x@x.org>%s", nl);
2324                 }
2325                 else if (!IsEmptyStr(fuser)) {
2326                         cprintf("From: \"%s\" <%s>%s", luser, fuser, nl);
2327                 }
2328                 else {
2329                         cprintf("From: \"%s\" <%s@%s>%s", luser, suser, snode, nl);
2330                 }
2331
2332                 /* Blank line signifying RFC822 end-of-headers */
2333                 if (TheMessage->cm_format_type != FMT_RFC822) {
2334                         cprintf("%s", nl);
2335                 }
2336         }
2337
2338         /* end header processing loop ... at this point, we're in the text */
2339 START_TEXT:
2340         if (headers_only == HEADERS_FAST) goto DONE;
2341
2342         /* Tell the client about the MIME parts in this message */
2343         if (TheMessage->cm_format_type == FMT_RFC822) {
2344                 if ( (mode == MT_CITADEL) || (mode == MT_MIME) ) {
2345                         mptr = TheMessage->cm_fields['M'];
2346                         memset(&ma, 0, sizeof(struct ma_info));
2347                         mime_parser(mptr, NULL,
2348                                 (do_proto ? *list_this_part : NULL),
2349                                 (do_proto ? *list_this_pref : NULL),
2350                                 (do_proto ? *list_this_suff : NULL),
2351                                 (void *)&ma, 1);
2352                 }
2353                 else if (mode == MT_RFC822) {   /* unparsed RFC822 dump */
2354                         Dump_RFC822HeadersBody(
2355                                 TheMessage,
2356                                 headers_only,
2357                                 flags,
2358                                 nl);
2359                         goto DONE;
2360                 }
2361         }
2362
2363         if (headers_only == HEADERS_ONLY) {
2364                 goto DONE;
2365         }
2366
2367         /* signify start of msg text */
2368         if ( (mode == MT_CITADEL) || (mode == MT_MIME) ) {
2369                 if (do_proto) cprintf("text\n");
2370         }
2371
2372         if (TheMessage->cm_format_type == FMT_FIXED)
2373                 DumpFormatFixed(
2374                         TheMessage,
2375                         mode,           /* how would you like that message? */
2376                         nl);
2377
2378         /* If the message on disk is format 0 (Citadel vari-format), we
2379          * output using the formatter at 80 columns.  This is the final output
2380          * form if the transfer format is RFC822, but if the transfer format
2381          * is Citadel proprietary, it'll still work, because the indentation
2382          * for new paragraphs is correct and the client will reformat the
2383          * message to the reader's screen width.
2384          */
2385         if (TheMessage->cm_format_type == FMT_CITADEL) {
2386                 mptr = TheMessage->cm_fields['M'];
2387
2388                 if (mode == MT_MIME) {
2389                         cprintf("Content-type: text/x-citadel-variformat\n\n");
2390                 }
2391                 memfmout(mptr, nl);
2392         }
2393
2394         /* If the message on disk is format 4 (MIME), we've gotta hand it
2395          * off to the MIME parser.  The client has already been told that
2396          * this message is format 1 (fixed format), so the callback function
2397          * we use will display those parts as-is.
2398          */
2399         if (TheMessage->cm_format_type == FMT_RFC822) {
2400                 memset(&ma, 0, sizeof(struct ma_info));
2401
2402                 if (mode == MT_MIME) {
2403                         ma.use_fo_hooks = 0;
2404                         strcpy(ma.chosen_part, "1");
2405                         ma.chosen_pref = 9999;
2406                         ma.dont_decode = CC->msg4_dont_decode;
2407                         mime_parser(mptr, NULL,
2408                                 *choose_preferred, *fixed_output_pre,
2409                                 *fixed_output_post, (void *)&ma, 1);
2410                         mime_parser(mptr, NULL,
2411                                 *output_preferred, NULL, NULL, (void *)&ma, 1);
2412                 }
2413                 else {
2414                         ma.use_fo_hooks = 1;
2415                         mime_parser(mptr, NULL,
2416                                 *fixed_output, *fixed_output_pre,
2417                                 *fixed_output_post, (void *)&ma, 0);
2418                 }
2419
2420         }
2421
2422 DONE:   /* now we're done */
2423         if (do_proto) cprintf("000\n");
2424         return(om_ok);
2425 }
2426
2427
2428 /*
2429  * display a message (mode 0 - Citadel proprietary)
2430  */
2431 void cmd_msg0(char *cmdbuf)
2432 {
2433         long msgid;
2434         int headers_only = HEADERS_ALL;
2435
2436         msgid = extract_long(cmdbuf, 0);
2437         headers_only = extract_int(cmdbuf, 1);
2438
2439         CtdlOutputMsg(msgid, MT_CITADEL, headers_only, 1, 0, NULL, 0);
2440         return;
2441 }
2442
2443
2444 /*
2445  * display a message (mode 2 - RFC822)
2446  */
2447 void cmd_msg2(char *cmdbuf)
2448 {
2449         long msgid;
2450         int headers_only = HEADERS_ALL;
2451
2452         msgid = extract_long(cmdbuf, 0);
2453         headers_only = extract_int(cmdbuf, 1);
2454
2455         CtdlOutputMsg(msgid, MT_RFC822, headers_only, 1, 1, NULL, 0);
2456 }
2457
2458
2459
2460 /*
2461  * display a message (mode 3 - IGnet raw format - internal programs only)
2462  */
2463 void cmd_msg3(char *cmdbuf)
2464 {
2465         long msgnum;
2466         struct CtdlMessage *msg = NULL;
2467         struct ser_ret smr;
2468
2469         if (CC->internal_pgm == 0) {
2470                 cprintf("%d This command is for internal programs only.\n",
2471                         ERROR + HIGHER_ACCESS_REQUIRED);
2472                 return;
2473         }
2474
2475         msgnum = extract_long(cmdbuf, 0);
2476         msg = CtdlFetchMessage(msgnum, 1);
2477         if (msg == NULL) {
2478                 cprintf("%d Message %ld not found.\n",
2479                         ERROR + MESSAGE_NOT_FOUND, msgnum);
2480                 return;
2481         }
2482
2483         serialize_message(&smr, msg);
2484         CtdlFreeMessage(msg);
2485
2486         if (smr.len == 0) {
2487                 cprintf("%d Unable to serialize message\n",
2488                         ERROR + INTERNAL_ERROR);
2489                 return;
2490         }
2491
2492         cprintf("%d %ld\n", BINARY_FOLLOWS, (long)smr.len);
2493         client_write((char *)smr.ser, (int)smr.len);
2494         free(smr.ser);
2495 }
2496
2497
2498
2499 /*
2500  * Display a message using MIME content types
2501  */
2502 void cmd_msg4(char *cmdbuf)
2503 {
2504         long msgid;
2505         char section[64];
2506
2507         msgid = extract_long(cmdbuf, 0);
2508         extract_token(section, cmdbuf, 1, '|', sizeof section);
2509         CtdlOutputMsg(msgid, MT_MIME, 0, 1, 0, (section[0] ? section : NULL) , 0);
2510 }
2511
2512
2513
2514 /*
2515  * Client tells us its preferred message format(s)
2516  */
2517 void cmd_msgp(char *cmdbuf)
2518 {
2519         if (!strcasecmp(cmdbuf, "dont_decode")) {
2520                 CC->msg4_dont_decode = 1;
2521                 cprintf("%d MSG4 will not pre-decode messages.\n", CIT_OK);
2522         }
2523         else {
2524                 safestrncpy(CC->preferred_formats, cmdbuf, sizeof(CC->preferred_formats));
2525                 cprintf("%d Preferred MIME formats have been set.\n", CIT_OK);
2526         }
2527 }
2528
2529
2530 /*
2531  * Open a component of a MIME message as a download file
2532  */
2533 void cmd_opna(char *cmdbuf)
2534 {
2535         long msgid;
2536         char desired_section[128];
2537
2538         msgid = extract_long(cmdbuf, 0);
2539         extract_token(desired_section, cmdbuf, 1, '|', sizeof desired_section);
2540         safestrncpy(CC->download_desired_section, desired_section,
2541                 sizeof CC->download_desired_section);
2542         CtdlOutputMsg(msgid, MT_DOWNLOAD, 0, 1, 1, NULL, 0);
2543 }
2544
2545
2546 /*
2547  * Open a component of a MIME message and transmit it all at once
2548  */
2549 void cmd_dlat(char *cmdbuf)
2550 {
2551         long msgid;
2552         char desired_section[128];
2553
2554         msgid = extract_long(cmdbuf, 0);
2555         extract_token(desired_section, cmdbuf, 1, '|', sizeof desired_section);
2556         safestrncpy(CC->download_desired_section, desired_section,
2557                 sizeof CC->download_desired_section);
2558         CtdlOutputMsg(msgid, MT_SPEW_SECTION, 0, 1, 1, NULL, 0);
2559 }
2560
2561
2562 /*
2563  * Save one or more message pointers into a specified room
2564  * (Returns 0 for success, nonzero for failure)
2565  * roomname may be NULL to use the current room
2566  *
2567  * Note that the 'supplied_msg' field may be set to NULL, in which case
2568  * the message will be fetched from disk, by number, if we need to perform
2569  * replication checks.  This adds an additional database read, so if the
2570  * caller already has the message in memory then it should be supplied.  (Obviously
2571  * this mode of operation only works if we're saving a single message.)
2572  */
2573 int CtdlSaveMsgPointersInRoom(char *roomname, long newmsgidlist[], int num_newmsgs,
2574                         int do_repl_check, struct CtdlMessage *supplied_msg, int suppress_refcount_adj
2575 ) {
2576         int i, j, unique;
2577         char hold_rm[ROOMNAMELEN];
2578         struct cdbdata *cdbfr;
2579         int num_msgs;
2580         long *msglist;
2581         long highest_msg = 0L;
2582
2583         long msgid = 0;
2584         struct CtdlMessage *msg = NULL;
2585
2586         long *msgs_to_be_merged = NULL;
2587         int num_msgs_to_be_merged = 0;
2588
2589         syslog(LOG_DEBUG,
2590                 "CtdlSaveMsgPointersInRoom(room=%s, num_msgs=%d, repl=%d, suppress_rca=%d)\n",
2591                 roomname, num_newmsgs, do_repl_check, suppress_refcount_adj
2592         );
2593
2594         strcpy(hold_rm, CC->room.QRname);
2595
2596         /* Sanity checks */
2597         if (newmsgidlist == NULL) return(ERROR + INTERNAL_ERROR);
2598         if (num_newmsgs < 1) return(ERROR + INTERNAL_ERROR);
2599         if (num_newmsgs > 1) supplied_msg = NULL;
2600
2601         /* Now the regular stuff */
2602         if (CtdlGetRoomLock(&CC->room,
2603            ((roomname != NULL) ? roomname : CC->room.QRname) )
2604            != 0) {
2605                 syslog(LOG_ERR, "No such room <%s>\n", roomname);
2606                 return(ERROR + ROOM_NOT_FOUND);
2607         }
2608
2609
2610         msgs_to_be_merged = malloc(sizeof(long) * num_newmsgs);
2611         num_msgs_to_be_merged = 0;
2612
2613
2614         cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
2615         if (cdbfr == NULL) {
2616                 msglist = NULL;
2617                 num_msgs = 0;
2618         } else {
2619                 msglist = (long *) cdbfr->ptr;
2620                 cdbfr->ptr = NULL;      /* CtdlSaveMsgPointerInRoom() now owns this memory */
2621                 num_msgs = cdbfr->len / sizeof(long);
2622                 cdb_free(cdbfr);
2623         }
2624
2625
2626         /* Create a list of msgid's which were supplied by the caller, but do
2627          * not already exist in the target room.  It is absolutely taboo to
2628          * have more than one reference to the same message in a room.
2629          */
2630         for (i=0; i<num_newmsgs; ++i) {
2631                 unique = 1;
2632                 if (num_msgs > 0) for (j=0; j<num_msgs; ++j) {
2633                         if (msglist[j] == newmsgidlist[i]) {
2634                                 unique = 0;
2635                         }
2636                 }
2637                 if (unique) {
2638                         msgs_to_be_merged[num_msgs_to_be_merged++] = newmsgidlist[i];
2639                 }
2640         }
2641
2642         syslog(LOG_DEBUG, "%d unique messages to be merged\n", num_msgs_to_be_merged);
2643
2644         /*
2645          * Now merge the new messages
2646          */
2647         msglist = realloc(msglist, (sizeof(long) * (num_msgs + num_msgs_to_be_merged)) );
2648         if (msglist == NULL) {
2649                 syslog(LOG_ALERT, "ERROR: can't realloc message list!\n");
2650         }
2651         memcpy(&msglist[num_msgs], msgs_to_be_merged, (sizeof(long) * num_msgs_to_be_merged) );
2652         num_msgs += num_msgs_to_be_merged;
2653
2654         /* Sort the message list, so all the msgid's are in order */
2655         num_msgs = sort_msglist(msglist, num_msgs);
2656
2657         /* Determine the highest message number */
2658         highest_msg = msglist[num_msgs - 1];
2659
2660         /* Write it back to disk. */
2661         cdb_store(CDB_MSGLISTS, &CC->room.QRnumber, (int)sizeof(long),
2662                   msglist, (int)(num_msgs * sizeof(long)));
2663
2664         /* Free up the memory we used. */
2665         free(msglist);
2666
2667         /* Update the highest-message pointer and unlock the room. */
2668         CC->room.QRhighest = highest_msg;
2669         CtdlPutRoomLock(&CC->room);
2670
2671         /* Perform replication checks if necessary */
2672         if ( (DoesThisRoomNeedEuidIndexing(&CC->room)) && (do_repl_check) ) {
2673                 syslog(LOG_DEBUG, "CtdlSaveMsgPointerInRoom() doing repl checks\n");
2674
2675                 for (i=0; i<num_msgs_to_be_merged; ++i) {
2676                         msgid = msgs_to_be_merged[i];
2677
2678                         if (supplied_msg != NULL) {
2679                                 msg = supplied_msg;
2680                         }
2681                         else {
2682                                 msg = CtdlFetchMessage(msgid, 0);
2683                         }
2684
2685                         if (msg != NULL) {
2686                                 ReplicationChecks(msg);
2687
2688                                 /* If the message has an Exclusive ID, index that... */
2689                                 if (msg->cm_fields['E'] != NULL) {
2690                                         index_message_by_euid(msg->cm_fields['E'], &CC->room, msgid);
2691                                 }
2692
2693                                 /* Free up the memory we may have allocated */
2694                                 if (msg != supplied_msg) {
2695                                         CtdlFreeMessage(msg);
2696                                 }
2697                         }
2698
2699                 }
2700         }
2701
2702         else {
2703                 syslog(LOG_DEBUG, "CtdlSaveMsgPointerInRoom() skips repl checks\n");
2704         }
2705
2706         /* Submit this room for processing by hooks */
2707         PerformRoomHooks(&CC->room);
2708
2709         /* Go back to the room we were in before we wandered here... */
2710         CtdlGetRoom(&CC->room, hold_rm);
2711
2712         /* Bump the reference count for all messages which were merged */
2713         if (!suppress_refcount_adj) {
2714                 for (i=0; i<num_msgs_to_be_merged; ++i) {
2715                         AdjRefCount(msgs_to_be_merged[i], +1);
2716                 }
2717         }
2718
2719         /* Free up memory... */
2720         if (msgs_to_be_merged != NULL) {
2721                 free(msgs_to_be_merged);
2722         }
2723
2724         /* Return success. */
2725         return (0);
2726 }
2727
2728
2729 /*
2730  * This is the same as CtdlSaveMsgPointersInRoom() but it only accepts
2731  * a single message.
2732  */
2733 int CtdlSaveMsgPointerInRoom(char *roomname, long msgid,
2734                         int do_repl_check, struct CtdlMessage *supplied_msg)
2735 {
2736         return CtdlSaveMsgPointersInRoom(roomname, &msgid, 1, do_repl_check, supplied_msg, 0);
2737 }
2738
2739
2740
2741
2742 /*
2743  * Message base operation to save a new message to the message store
2744  * (returns new message number)
2745  *
2746  * This is the back end for CtdlSubmitMsg() and should not be directly
2747  * called by server-side modules.
2748  *
2749  */
2750 long send_message(struct CtdlMessage *msg) {
2751         long newmsgid;
2752         long retval;
2753         char msgidbuf[256];
2754         struct ser_ret smr;
2755         int is_bigmsg = 0;
2756         char *holdM = NULL;
2757
2758         /* Get a new message number */
2759         newmsgid = get_new_message_number();
2760         snprintf(msgidbuf, sizeof msgidbuf, "%08lX-%08lX@%s",
2761                 (long unsigned int) time(NULL),
2762                 (long unsigned int) newmsgid,
2763                 config.c_fqdn
2764         );
2765
2766         /* Generate an ID if we don't have one already */
2767         if (msg->cm_fields['I']==NULL) {
2768                 msg->cm_fields['I'] = strdup(msgidbuf);
2769         }
2770
2771         /* If the message is big, set its body aside for storage elsewhere */
2772         if (msg->cm_fields['M'] != NULL) {
2773                 if (strlen(msg->cm_fields['M']) > BIGMSG) {
2774                         is_bigmsg = 1;
2775                         holdM = msg->cm_fields['M'];
2776                         msg->cm_fields['M'] = NULL;
2777                 }
2778         }
2779
2780         /* Serialize our data structure for storage in the database */
2781         serialize_message(&smr, msg);
2782
2783         if (is_bigmsg) {
2784                 msg->cm_fields['M'] = holdM;
2785         }
2786
2787         if (smr.len == 0) {
2788                 cprintf("%d Unable to serialize message\n",
2789                         ERROR + INTERNAL_ERROR);
2790                 return (-1L);
2791         }
2792
2793         /* Write our little bundle of joy into the message base */
2794         if (cdb_store(CDB_MSGMAIN, &newmsgid, (int)sizeof(long),
2795                       smr.ser, smr.len) < 0) {
2796                 syslog(LOG_ERR, "Can't store message\n");
2797                 retval = 0L;
2798         } else {
2799                 if (is_bigmsg) {
2800                         cdb_store(CDB_BIGMSGS,
2801                                 &newmsgid,
2802                                 (int)sizeof(long),
2803                                 holdM,
2804                                 (strlen(holdM) + 1)
2805                         );
2806                 }
2807                 retval = newmsgid;
2808         }
2809
2810         /* Free the memory we used for the serialized message */
2811         free(smr.ser);
2812
2813         /* Return the *local* message ID to the caller
2814          * (even if we're storing an incoming network message)
2815          */
2816         return(retval);
2817 }
2818
2819
2820
2821 /*
2822  * Serialize a struct CtdlMessage into the format used on disk and network.
2823  *
2824  * This function loads up a "struct ser_ret" (defined in server.h) which
2825  * contains the length of the serialized message and a pointer to the
2826  * serialized message in memory.  THE LATTER MUST BE FREED BY THE CALLER.
2827  */
2828 void serialize_message(struct ser_ret *ret,             /* return values */
2829                         struct CtdlMessage *msg)        /* unserialized msg */
2830 {
2831         size_t wlen, fieldlen;
2832         int i;
2833         static char *forder = FORDER;
2834
2835         /*
2836          * Check for valid message format
2837          */
2838         if (is_valid_message(msg) == 0) {
2839                 syslog(LOG_ERR, "serialize_message() aborting due to invalid message\n");
2840                 ret->len = 0;
2841                 ret->ser = NULL;
2842                 return;
2843         }
2844
2845         ret->len = 3;
2846         for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL)
2847                 ret->len = ret->len +
2848                         strlen(msg->cm_fields[(int)forder[i]]) + 2;
2849
2850         ret->ser = malloc(ret->len);
2851         if (ret->ser == NULL) {
2852                 syslog(LOG_ERR, "serialize_message() malloc(%ld) failed: %s\n",
2853                         (long)ret->len, strerror(errno));
2854                 ret->len = 0;
2855                 ret->ser = NULL;
2856                 return;
2857         }
2858
2859         ret->ser[0] = 0xFF;
2860         ret->ser[1] = msg->cm_anon_type;
2861         ret->ser[2] = msg->cm_format_type;
2862         wlen = 3;
2863
2864         for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL) {
2865                 fieldlen = strlen(msg->cm_fields[(int)forder[i]]);
2866                 ret->ser[wlen++] = (char)forder[i];
2867                 safestrncpy((char *)&ret->ser[wlen], msg->cm_fields[(int)forder[i]], fieldlen+1);
2868                 wlen = wlen + fieldlen + 1;
2869         }
2870         if (ret->len != wlen) syslog(LOG_ERR, "ERROR: len=%ld wlen=%ld\n",
2871                 (long)ret->len, (long)wlen);
2872
2873         return;
2874 }
2875
2876
2877 /*
2878  * Serialize a struct CtdlMessage into the format used on disk and network.
2879  *
2880  * This function loads up a "struct ser_ret" (defined in server.h) which
2881  * contains the length of the serialized message and a pointer to the
2882  * serialized message in memory.  THE LATTER MUST BE FREED BY THE CALLER.
2883  */
2884 void dump_message(struct CtdlMessage *msg,      /* unserialized msg */
2885                   long Siz)                     /* how many chars ? */
2886 {
2887         size_t wlen;
2888         int i;
2889         static char *forder = FORDER;
2890         char *buf;
2891
2892         /*
2893          * Check for valid message format
2894          */
2895         if (is_valid_message(msg) == 0) {
2896                 syslog(LOG_ERR, "dump_message() aborting due to invalid message\n");
2897                 return;
2898         }
2899
2900         buf = (char*) malloc (Siz + 1);
2901
2902         wlen = 3;
2903
2904         for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL) {
2905                         snprintf (buf, Siz, " msg[%c] = %s ...\n", (char) forder[i],
2906                                    msg->cm_fields[(int)forder[i]]);
2907                         client_write (buf, strlen(buf));
2908                 }
2909
2910         return;
2911 }
2912
2913
2914
2915 /*
2916  * Check to see if any messages already exist in the current room which
2917  * carry the same Exclusive ID as this one.  If any are found, delete them.
2918  */
2919 void ReplicationChecks(struct CtdlMessage *msg) {
2920         long old_msgnum = (-1L);
2921
2922         if (DoesThisRoomNeedEuidIndexing(&CC->room) == 0) return;
2923
2924         syslog(LOG_DEBUG, "Performing replication checks in <%s>\n",
2925                 CC->room.QRname);
2926
2927         /* No exclusive id?  Don't do anything. */
2928         if (msg == NULL) return;
2929         if (msg->cm_fields['E'] == NULL) return;
2930         if (IsEmptyStr(msg->cm_fields['E'])) return;
2931         /*syslog(LOG_DEBUG, "Exclusive ID: <%s> for room <%s>\n",
2932                 msg->cm_fields['E'], CC->room.QRname);*/
2933
2934         old_msgnum = CtdlLocateMessageByEuid(msg->cm_fields['E'], &CC->room);
2935         if (old_msgnum > 0L) {
2936                 syslog(LOG_DEBUG, "ReplicationChecks() replacing message %ld\n", old_msgnum);
2937                 CtdlDeleteMessages(CC->room.QRname, &old_msgnum, 1, "");
2938         }
2939 }
2940
2941
2942
2943 /*
2944  * Save a message to disk and submit it into the delivery system.
2945  */
2946 long CtdlSubmitMsg(struct CtdlMessage *msg,     /* message to save */
2947                    struct recptypes *recps,     /* recipients (if mail) */
2948                    char *force,                 /* force a particular room? */
2949                    int flags                    /* should the message be exported clean? */
2950 ) {
2951         char submit_filename[128];
2952         char generated_timestamp[32];
2953         char hold_rm[ROOMNAMELEN];
2954         char actual_rm[ROOMNAMELEN];
2955         char force_room[ROOMNAMELEN];
2956         char content_type[SIZ];                 /* We have to learn this */
2957         char recipient[SIZ];
2958         long newmsgid;
2959         const char *mptr = NULL;
2960         struct ctdluser userbuf;
2961         int a, i;
2962         struct MetaData smi;
2963         FILE *network_fp = NULL;
2964         static int seqnum = 1;
2965         struct CtdlMessage *imsg = NULL;
2966         char *instr = NULL;
2967         size_t instr_alloc = 0;
2968         struct ser_ret smr;
2969         char *hold_R, *hold_D;
2970         char *collected_addresses = NULL;
2971         struct addresses_to_be_filed *aptr = NULL;
2972         StrBuf *saved_rfc822_version = NULL;
2973         int qualified_for_journaling = 0;
2974         CitContext *CCC = MyContext();
2975         char bounce_to[1024] = "";
2976         size_t tmp = 0;
2977         int rv = 0;
2978
2979         syslog(LOG_DEBUG, "CtdlSubmitMsg() called\n");
2980         if (is_valid_message(msg) == 0) return(-1);     /* self check */
2981
2982         /* If this message has no timestamp, we take the liberty of
2983          * giving it one, right now.
2984          */
2985         if (msg->cm_fields['T'] == NULL) {
2986                 snprintf(generated_timestamp, sizeof generated_timestamp, "%ld", (long)time(NULL));
2987                 msg->cm_fields['T'] = strdup(generated_timestamp);
2988         }
2989
2990         /* If this message has no path, we generate one.
2991          */
2992         if (msg->cm_fields['P'] == NULL) {
2993                 if (msg->cm_fields['A'] != NULL) {
2994                         msg->cm_fields['P'] = strdup(msg->cm_fields['A']);
2995                         for (a=0; !IsEmptyStr(&msg->cm_fields['P'][a]); ++a) {
2996                                 if (isspace(msg->cm_fields['P'][a])) {
2997                                         msg->cm_fields['P'][a] = ' ';
2998                                 }
2999                         }
3000                 }
3001                 else {
3002                         msg->cm_fields['P'] = strdup("unknown");
3003                 }
3004         }
3005
3006         if (force == NULL) {
3007                 strcpy(force_room, "");
3008         }
3009         else {
3010                 strcpy(force_room, force);
3011         }
3012
3013         /* Learn about what's inside, because it's what's inside that counts */
3014         if (msg->cm_fields['M'] == NULL) {
3015                 syslog(LOG_ERR, "ERROR: attempt to save message with NULL body\n");
3016                 return(-2);
3017         }
3018
3019         switch (msg->cm_format_type) {
3020         case 0:
3021                 strcpy(content_type, "text/x-citadel-variformat");
3022                 break;
3023         case 1:
3024                 strcpy(content_type, "text/plain");
3025                 break;
3026         case 4:
3027                 strcpy(content_type, "text/plain");
3028                 mptr = bmstrcasestr(msg->cm_fields['M'], "Content-type:");
3029                 if (mptr != NULL) {
3030                         char *aptr;
3031                         safestrncpy(content_type, &mptr[13], sizeof content_type);
3032                         striplt(content_type);
3033                         aptr = content_type;
3034                         while (!IsEmptyStr(aptr)) {
3035                                 if ((*aptr == ';')
3036                                     || (*aptr == ' ')
3037                                     || (*aptr == 13)
3038                                     || (*aptr == 10)) {
3039                                         *aptr = 0;
3040                                 }
3041                                 else aptr++;
3042                         }
3043                 }
3044         }
3045
3046         /* Goto the correct room */
3047         syslog(LOG_DEBUG, "Selected room %s\n", (recps) ? CCC->room.QRname : SENTITEMS);
3048         strcpy(hold_rm, CCC->room.QRname);
3049         strcpy(actual_rm, CCC->room.QRname);
3050         if (recps != NULL) {
3051                 strcpy(actual_rm, SENTITEMS);
3052         }
3053
3054         /* If the user is a twit, move to the twit room for posting */
3055         if (TWITDETECT) {
3056                 if (CCC->user.axlevel == AxProbU) {
3057                         strcpy(hold_rm, actual_rm);
3058                         strcpy(actual_rm, config.c_twitroom);
3059                         syslog(LOG_DEBUG, "Diverting to twit room\n");
3060                 }
3061         }
3062
3063         /* ...or if this message is destined for Aide> then go there. */
3064         if (!IsEmptyStr(force_room)) {
3065                 strcpy(actual_rm, force_room);
3066         }
3067
3068         syslog(LOG_DEBUG, "Final selection: %s\n", actual_rm);
3069         if (strcasecmp(actual_rm, CCC->room.QRname)) {
3070                 /* CtdlGetRoom(&CCC->room, actual_rm); */
3071                 CtdlUserGoto(actual_rm, 0, 1, NULL, NULL);
3072         }
3073
3074         /*
3075          * If this message has no O (room) field, generate one.
3076          */
3077         if (msg->cm_fields['O'] == NULL) {
3078                 msg->cm_fields['O'] = strdup(CCC->room.QRname);
3079         }
3080
3081         /* Perform "before save" hooks (aborting if any return nonzero) */
3082         syslog(LOG_DEBUG, "Performing before-save hooks\n");
3083         if (PerformMessageHooks(msg, EVT_BEFORESAVE) > 0) return(-3);
3084
3085         /*
3086          * If this message has an Exclusive ID, and the room is replication
3087          * checking enabled, then do replication checks.
3088          */
3089         if (DoesThisRoomNeedEuidIndexing(&CCC->room)) {
3090                 ReplicationChecks(msg);
3091         }
3092
3093         /* Save it to disk */
3094         syslog(LOG_DEBUG, "Saving to disk\n");
3095         newmsgid = send_message(msg);
3096         if (newmsgid <= 0L) return(-5);
3097
3098         /* Write a supplemental message info record.  This doesn't have to
3099          * be a critical section because nobody else knows about this message
3100          * yet.
3101          */
3102         syslog(LOG_DEBUG, "Creating MetaData record\n");
3103         memset(&smi, 0, sizeof(struct MetaData));
3104         smi.meta_msgnum = newmsgid;
3105         smi.meta_refcount = 0;
3106         safestrncpy(smi.meta_content_type, content_type,
3107                         sizeof smi.meta_content_type);
3108
3109         /*
3110          * Measure how big this message will be when rendered as RFC822.
3111          * We do this for two reasons:
3112          * 1. We need the RFC822 length for the new metadata record, so the
3113          *    POP and IMAP services don't have to calculate message lengths
3114          *    while the user is waiting (multiplied by potentially hundreds
3115          *    or thousands of messages).
3116          * 2. If journaling is enabled, we will need an RFC822 version of the
3117          *    message to attach to the journalized copy.
3118          */
3119         if (CCC->redirect_buffer != NULL) {
3120                 syslog(LOG_ALERT, "CCC->redirect_buffer is not NULL during message submission!\n");
3121                 abort();
3122         }
3123         CCC->redirect_buffer = NewStrBufPlain(NULL, SIZ);
3124         CtdlOutputPreLoadedMsg(msg, MT_RFC822, HEADERS_ALL, 0, 1, QP_EADDR);
3125         smi.meta_rfc822_length = StrLength(CCC->redirect_buffer);
3126         saved_rfc822_version = CCC->redirect_buffer;
3127         CCC->redirect_buffer = NULL;
3128
3129         PutMetaData(&smi);
3130
3131         /* Now figure out where to store the pointers */
3132         syslog(LOG_DEBUG, "Storing pointers\n");
3133
3134         /* If this is being done by the networker delivering a private
3135          * message, we want to BYPASS saving the sender's copy (because there
3136          * is no local sender; it would otherwise go to the Trashcan).
3137          */
3138         if ((!CCC->internal_pgm) || (recps == NULL)) {
3139                 if (CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 1, msg) != 0) {
3140                         syslog(LOG_ERR, "ERROR saving message pointer!\n");
3141                         CtdlSaveMsgPointerInRoom(config.c_aideroom, newmsgid, 0, msg);
3142                 }
3143         }
3144
3145         /* For internet mail, drop a copy in the outbound queue room */
3146         if ((recps != NULL) && (recps->num_internet > 0)) {
3147                 CtdlSaveMsgPointerInRoom(SMTP_SPOOLOUT_ROOM, newmsgid, 0, msg);
3148         }
3149
3150         /* If other rooms are specified, drop them there too. */
3151         if ((recps != NULL) && (recps->num_room > 0))
3152           for (i=0; i<num_tokens(recps->recp_room, '|'); ++i) {
3153                 extract_token(recipient, recps->recp_room, i,
3154                                         '|', sizeof recipient);
3155                 syslog(LOG_DEBUG, "Delivering to room <%s>\n", recipient);
3156                 CtdlSaveMsgPointerInRoom(recipient, newmsgid, 0, msg);
3157         }
3158
3159         /* Bump this user's messages posted counter. */
3160         syslog(LOG_DEBUG, "Updating user\n");
3161         CtdlGetUserLock(&CCC->user, CCC->curr_user);
3162         CCC->user.posted = CCC->user.posted + 1;
3163         CtdlPutUserLock(&CCC->user);
3164
3165         /* Decide where bounces need to be delivered */
3166         if ((recps != NULL) && (recps->bounce_to != NULL)) {
3167                 safestrncpy(bounce_to, recps->bounce_to, sizeof bounce_to);
3168         }
3169         else if (CCC->logged_in) {
3170                 snprintf(bounce_to, sizeof bounce_to, "%s@%s", CCC->user.fullname, config.c_nodename);
3171         }
3172         else {
3173                 snprintf(bounce_to, sizeof bounce_to, "%s@%s", msg->cm_fields['A'], msg->cm_fields['N']);
3174         }
3175
3176         /* If this is private, local mail, make a copy in the
3177          * recipient's mailbox and bump the reference count.
3178          */
3179         if ((recps != NULL) && (recps->num_local > 0))
3180           for (i=0; i<num_tokens(recps->recp_local, '|'); ++i) {
3181                 extract_token(recipient, recps->recp_local, i,
3182                                         '|', sizeof recipient);
3183                 syslog(LOG_DEBUG, "Delivering private local mail to <%s>\n",
3184                         recipient);
3185                 if (CtdlGetUser(&userbuf, recipient) == 0) {
3186                         // Add a flag so the Funambol module knows its mail
3187                         msg->cm_fields['W'] = strdup(recipient);
3188                         CtdlMailboxName(actual_rm, sizeof actual_rm, &userbuf, MAILROOM);
3189                         CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0, msg);
3190                         CtdlBumpNewMailCounter(userbuf.usernum);
3191                         if (!IsEmptyStr(config.c_funambol_host) || !IsEmptyStr(config.c_pager_program)) {
3192                         /* Generate a instruction message for the Funambol notification
3193                          * server, in the same style as the SMTP queue
3194                          */
3195                            instr_alloc = 1024;
3196                            instr = malloc(instr_alloc);
3197                            snprintf(instr, instr_alloc,
3198                         "Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
3199                         "bounceto|%s\n",
3200                         SPOOLMIME, newmsgid, (long)time(NULL),
3201                         bounce_to
3202                         );
3203
3204                            imsg = malloc(sizeof(struct CtdlMessage));
3205                            memset(imsg, 0, sizeof(struct CtdlMessage));
3206                            imsg->cm_magic = CTDLMESSAGE_MAGIC;
3207                            imsg->cm_anon_type = MES_NORMAL;
3208                            imsg->cm_format_type = FMT_RFC822;
3209                            imsg->cm_fields['A'] = strdup("Citadel");
3210                            imsg->cm_fields['J'] = strdup("do not journal");
3211                            imsg->cm_fields['M'] = instr;        /* imsg owns this memory now */
3212                            imsg->cm_fields['W'] = strdup(recipient);
3213                            CtdlSubmitMsg(imsg, NULL, FNBL_QUEUE_ROOM, 0);
3214                            CtdlFreeMessage(imsg);
3215                         }
3216                 }
3217                 else {
3218                         syslog(LOG_DEBUG, "No user <%s>\n", recipient);
3219                         CtdlSaveMsgPointerInRoom(config.c_aideroom,
3220                                 newmsgid, 0, msg);
3221                 }
3222         }
3223
3224         /* Perform "after save" hooks */
3225         syslog(LOG_DEBUG, "Performing after-save hooks\n");
3226         PerformMessageHooks(msg, EVT_AFTERSAVE);
3227
3228         /* For IGnet mail, we have to save a new copy into the spooler for
3229          * each recipient, with the R and D fields set to the recipient and
3230          * destination-node.  This has two ugly side effects: all other
3231          * recipients end up being unlisted in this recipient's copy of the
3232          * message, and it has to deliver multiple messages to the same
3233          * node.  We'll revisit this again in a year or so when everyone has
3234          * a network spool receiver that can handle the new style messages.
3235          */
3236         if ((recps != NULL) && (recps->num_ignet > 0))
3237           for (i=0; i<num_tokens(recps->recp_ignet, '|'); ++i) {
3238                 extract_token(recipient, recps->recp_ignet, i,
3239                                 '|', sizeof recipient);
3240
3241                 hold_R = msg->cm_fields['R'];
3242                 hold_D = msg->cm_fields['D'];
3243                 msg->cm_fields['R'] = malloc(SIZ);
3244                 msg->cm_fields['D'] = malloc(128);
3245                 extract_token(msg->cm_fields['R'], recipient, 0, '@', SIZ);
3246                 extract_token(msg->cm_fields['D'], recipient, 1, '@', 128);
3247
3248                 serialize_message(&smr, msg);
3249                 if (smr.len > 0) {
3250                         snprintf(submit_filename, sizeof submit_filename,
3251                                          "%s/netmail.%04lx.%04x.%04x",
3252                                          ctdl_netin_dir,
3253                                          (long) getpid(), CCC->cs_pid, ++seqnum);
3254                         network_fp = fopen(submit_filename, "wb+");
3255                         if (network_fp != NULL) {
3256                                 rv = fwrite(smr.ser, smr.len, 1, network_fp);
3257                                 fclose(network_fp);
3258                         }
3259                         free(smr.ser);
3260                 }
3261
3262                 free(msg->cm_fields['R']);
3263                 free(msg->cm_fields['D']);
3264                 msg->cm_fields['R'] = hold_R;
3265                 msg->cm_fields['D'] = hold_D;
3266         }
3267
3268         /* Go back to the room we started from */
3269         syslog(LOG_DEBUG, "Returning to original room %s\n", hold_rm);
3270         if (strcasecmp(hold_rm, CCC->room.QRname))
3271                 CtdlUserGoto(hold_rm, 0, 1, NULL, NULL);
3272
3273         /* For internet mail, generate delivery instructions.
3274          * Yes, this is recursive.  Deal with it.  Infinite recursion does
3275          * not happen because the delivery instructions message does not
3276          * contain a recipient.
3277          */
3278         if ((recps != NULL) && (recps->num_internet > 0)) {
3279                 syslog(LOG_DEBUG, "Generating delivery instructions\n");
3280                 instr_alloc = 1024;
3281                 instr = malloc(instr_alloc);
3282                 snprintf(instr, instr_alloc,
3283                         "Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
3284                         "bounceto|%s\n",
3285                         SPOOLMIME, newmsgid, (long)time(NULL),
3286                         bounce_to
3287                 );
3288
3289                 if (recps->envelope_from != NULL) {
3290                         tmp = strlen(instr);
3291                         snprintf(&instr[tmp], instr_alloc-tmp, "envelope_from|%s\n", recps->envelope_from);
3292                 }
3293
3294                 for (i=0; i<num_tokens(recps->recp_internet, '|'); ++i) {
3295                         tmp = strlen(instr);
3296                         extract_token(recipient, recps->recp_internet, i, '|', sizeof recipient);
3297                         if ((tmp + strlen(recipient) + 32) > instr_alloc) {
3298                                 instr_alloc = instr_alloc * 2;
3299                                 instr = realloc(instr, instr_alloc);
3300                         }
3301                         snprintf(&instr[tmp], instr_alloc - tmp, "remote|%s|0||\n", recipient);
3302                 }
3303
3304                 imsg = malloc(sizeof(struct CtdlMessage));
3305                 memset(imsg, 0, sizeof(struct CtdlMessage));
3306                 imsg->cm_magic = CTDLMESSAGE_MAGIC;
3307                 imsg->cm_anon_type = MES_NORMAL;
3308                 imsg->cm_format_type = FMT_RFC822;
3309                 imsg->cm_fields['A'] = strdup("Citadel");
3310                 imsg->cm_fields['J'] = strdup("do not journal");
3311                 imsg->cm_fields['M'] = instr;   /* imsg owns this memory now */
3312                 CtdlSubmitMsg(imsg, NULL, SMTP_SPOOLOUT_ROOM, QP_EADDR);
3313                 CtdlFreeMessage(imsg);
3314         }
3315
3316         /*
3317          * Any addresses to harvest for someone's address book?
3318          */
3319         if ( (CCC->logged_in) && (recps != NULL) ) {
3320                 collected_addresses = harvest_collected_addresses(msg);
3321         }
3322
3323         if (collected_addresses != NULL) {
3324                 aptr = (struct addresses_to_be_filed *)
3325                         malloc(sizeof(struct addresses_to_be_filed));
3326                 CtdlMailboxName(actual_rm, sizeof actual_rm,
3327                         &CCC->user, USERCONTACTSROOM);
3328                 aptr->roomname = strdup(actual_rm);
3329                 aptr->collected_addresses = collected_addresses;
3330                 begin_critical_section(S_ATBF);
3331                 aptr->next = atbf;
3332                 atbf = aptr;
3333                 end_critical_section(S_ATBF);
3334         }
3335
3336         /*
3337          * Determine whether this message qualifies for journaling.
3338          */
3339         if (msg->cm_fields['J'] != NULL) {
3340                 qualified_for_journaling = 0;
3341         }
3342         else {
3343                 if (recps == NULL) {
3344                         qualified_for_journaling = config.c_journal_pubmsgs;
3345                 }
3346                 else if (recps->num_local + recps->num_ignet + recps->num_internet > 0) {
3347                         qualified_for_journaling = config.c_journal_email;
3348                 }
3349                 else {
3350                         qualified_for_journaling = config.c_journal_pubmsgs;
3351                 }
3352         }
3353
3354         /*
3355          * Do we have to perform journaling?  If so, hand off the saved
3356          * RFC822 version will be handed off to the journaler for background
3357          * submit.  Otherwise, we have to free the memory ourselves.
3358          */
3359         if (saved_rfc822_version != NULL) {
3360                 if (qualified_for_journaling) {
3361                         JournalBackgroundSubmit(msg, saved_rfc822_version, recps);
3362                 }
3363                 else {
3364                         FreeStrBuf(&saved_rfc822_version);
3365                 }
3366         }
3367
3368         /* Done. */
3369         return(newmsgid);
3370 }
3371
3372
3373
3374 void aide_message (char *text, char *subject)
3375 {
3376         quickie_message("Citadel",NULL,NULL,AIDEROOM,text,FMT_CITADEL,subject);
3377 }
3378
3379
3380 /*
3381  * Convenience function for generating small administrative messages.
3382  */
3383 void quickie_message(const char *from, const char *fromaddr, char *to, char *room, const char *text,
3384                         int format_type, const char *subject)
3385 {
3386         struct CtdlMessage *msg;
3387         struct recptypes *recp = NULL;
3388
3389         msg = malloc(sizeof(struct CtdlMessage));
3390         memset(msg, 0, sizeof(struct CtdlMessage));
3391         msg->cm_magic = CTDLMESSAGE_MAGIC;
3392         msg->cm_anon_type = MES_NORMAL;
3393         msg->cm_format_type = format_type;
3394
3395         if (from != NULL) {
3396                 msg->cm_fields['A'] = strdup(from);
3397         }
3398         else if (fromaddr != NULL) {
3399                 msg->cm_fields['A'] = strdup(fromaddr);
3400                 if (strchr(msg->cm_fields['A'], '@')) {
3401                         *strchr(msg->cm_fields['A'], '@') = 0;
3402                 }
3403         }
3404         else {
3405                 msg->cm_fields['A'] = strdup("Citadel");
3406         }
3407
3408         if (fromaddr != NULL) msg->cm_fields['F'] = strdup(fromaddr);
3409         if (room != NULL) msg->cm_fields['O'] = strdup(room);
3410         msg->cm_fields['N'] = strdup(NODENAME);
3411         if (to != NULL) {
3412                 msg->cm_fields['R'] = strdup(to);
3413                 recp = validate_recipients(to, NULL, 0);
3414         }
3415         if (subject != NULL) {
3416                 msg->cm_fields['U'] = strdup(subject);
3417         }
3418         msg->cm_fields['M'] = strdup(text);
3419
3420         CtdlSubmitMsg(msg, recp, room, 0);
3421         CtdlFreeMessage(msg);
3422         if (recp != NULL) free_recipients(recp);
3423 }
3424
3425
3426
3427 /*
3428  * Back end function used by CtdlMakeMessage() and similar functions
3429  */
3430 StrBuf *CtdlReadMessageBodyBuf(char *terminator,        /* token signalling EOT */
3431                                long tlen,
3432                                size_t maxlen,           /* maximum message length */
3433                                char *exist,             /* if non-null, append to it;
3434                                                            exist is ALWAYS freed  */
3435                                int crlf,                /* CRLF newlines instead of LF */
3436                                int *sock                /* socket handle or 0 for this session's client socket */
3437                         )
3438 {
3439         StrBuf *Message;
3440         StrBuf *LineBuf;
3441         int flushing = 0;
3442         int finished = 0;
3443         int dotdot = 0;
3444
3445         LineBuf = NewStrBufPlain(NULL, SIZ);
3446         if (exist == NULL) {
3447                 Message = NewStrBufPlain(NULL, 4 * SIZ);
3448         }
3449         else {
3450                 Message = NewStrBufPlain(exist, -1);
3451                 free(exist);
3452         }
3453
3454         /* Do we need to change leading ".." to "." for SMTP escaping? */
3455         if ((tlen == 1) && (*terminator == '.')) {
3456                 dotdot = 1;
3457         }
3458
3459         /* read in the lines of message text one by one */
3460         do {
3461                 if (sock != NULL) {
3462                         if ((CtdlSockGetLine(sock, LineBuf, 5) < 0) ||
3463                             (*sock == -1))
3464                                 finished = 1;
3465                 }
3466                 else {
3467                         if (CtdlClientGetLine(LineBuf) < 0) finished = 1;
3468                 }
3469                 if ((StrLength(LineBuf) == tlen) &&
3470                     (!strcmp(ChrPtr(LineBuf), terminator)))
3471                         finished = 1;
3472
3473                 if ( (!flushing) && (!finished) ) {
3474                         if (crlf) {
3475                                 StrBufAppendBufPlain(LineBuf, HKEY("\r\n"), 0);
3476                         }
3477                         else {
3478                                 StrBufAppendBufPlain(LineBuf, HKEY("\n"), 0);
3479                         }
3480
3481                         /* Unescape SMTP-style input of two dots at the beginning of the line */
3482                         if ((dotdot) &&
3483                             (StrLength(LineBuf) == 2) &&
3484                             (!strcmp(ChrPtr(LineBuf), "..")))
3485                         {
3486                                 StrBufCutLeft(LineBuf, 1);
3487                         }
3488
3489                         StrBufAppendBuf(Message, LineBuf, 0);
3490                 }
3491
3492                 /* if we've hit the max msg length, flush the rest */
3493                 if (StrLength(Message) >= maxlen) flushing = 1;
3494
3495         } while (!finished);
3496         FreeStrBuf(&LineBuf);
3497         return Message;
3498 }
3499
3500
3501 /*
3502  * Back end function used by CtdlMakeMessage() and similar functions
3503  */
3504 char *CtdlReadMessageBody(char *terminator,     /* token signalling EOT */
3505                           long tlen,
3506                           size_t maxlen,                /* maximum message length */
3507                           char *exist,          /* if non-null, append to it;
3508                                                    exist is ALWAYS freed  */
3509                           int crlf,             /* CRLF newlines instead of LF */
3510                           int *sock             /* socket handle or 0 for this session's client socket */
3511         )
3512 {
3513         StrBuf *Message;
3514
3515         Message = CtdlReadMessageBodyBuf(terminator,
3516                                          tlen,
3517                                          maxlen,
3518                                          exist,
3519                                          crlf,
3520                                          sock);
3521         if (Message == NULL)
3522                 return NULL;
3523         else
3524                 return SmashStrBuf(&Message);
3525 }
3526
3527
3528 /*
3529  * Build a binary message to be saved on disk.
3530  * (NOTE: if you supply 'preformatted_text', the buffer you give it
3531  * will become part of the message.  This means you are no longer
3532  * responsible for managing that memory -- it will be freed along with
3533  * the rest of the fields when CtdlFreeMessage() is called.)
3534  */
3535
3536 struct CtdlMessage *CtdlMakeMessage(
3537         struct ctdluser *author,        /* author's user structure */
3538         char *recipient,                /* NULL if it's not mail */
3539         char *recp_cc,                  /* NULL if it's not mail */
3540         char *room,                     /* room where it's going */
3541         int type,                       /* see MES_ types in header file */
3542         int format_type,                /* variformat, plain text, MIME... */
3543         char *fake_name,                /* who we're masquerading as */
3544         char *my_email,                 /* which of my email addresses to use (empty is ok) */
3545         char *subject,                  /* Subject (optional) */
3546         char *supplied_euid,            /* ...or NULL if this is irrelevant */
3547         char *preformatted_text,        /* ...or NULL to read text from client */
3548         char *references                /* Thread references */
3549 ) {
3550         char dest_node[256];
3551         char buf[1024];
3552         struct CtdlMessage *msg;
3553         StrBuf *FakeAuthor;
3554         StrBuf *FakeEncAuthor = NULL;
3555
3556         msg = malloc(sizeof(struct CtdlMessage));
3557         memset(msg, 0, sizeof(struct CtdlMessage));
3558         msg->cm_magic = CTDLMESSAGE_MAGIC;
3559         msg->cm_anon_type = type;
3560         msg->cm_format_type = format_type;
3561
3562         /* Don't confuse the poor folks if it's not routed mail. */
3563         strcpy(dest_node, "");
3564
3565         if (recipient != NULL) striplt(recipient);
3566         if (recp_cc != NULL) striplt(recp_cc);
3567
3568         /* Path or Return-Path */
3569         if (my_email == NULL) my_email = "";
3570
3571         if (!IsEmptyStr(my_email)) {
3572                 msg->cm_fields['P'] = strdup(my_email);
3573         }
3574         else {
3575                 snprintf(buf, sizeof buf, "%s", author->fullname);
3576                 msg->cm_fields['P'] = strdup(buf);
3577         }
3578         convert_spaces_to_underscores(msg->cm_fields['P']);
3579
3580         snprintf(buf, sizeof buf, "%ld", (long)time(NULL));     /* timestamp */
3581         msg->cm_fields['T'] = strdup(buf);
3582
3583         if ((fake_name != NULL) && (fake_name[0])) {            /* author */
3584                 FakeAuthor = NewStrBufPlain (fake_name, -1);
3585         }
3586         else {
3587                 FakeAuthor = NewStrBufPlain (author->fullname, -1);
3588         }
3589         StrBufRFC2047encode(&FakeEncAuthor, FakeAuthor);
3590         msg->cm_fields['A'] = SmashStrBuf(&FakeEncAuthor);
3591         FreeStrBuf(&FakeAuthor);
3592
3593         if (CC->room.QRflags & QR_MAILBOX) {            /* room */
3594                 msg->cm_fields['O'] = strdup(&CC->room.QRname[11]);
3595         }
3596         else {
3597                 msg->cm_fields['O'] = strdup(CC->room.QRname);
3598         }
3599
3600         msg->cm_fields['N'] = strdup(NODENAME);         /* nodename */
3601         msg->cm_fields['H'] = strdup(HUMANNODE);                /* hnodename */
3602
3603         if ((recipient != NULL) && (recipient[0] != 0)) {
3604                 msg->cm_fields['R'] = strdup(recipient);
3605         }
3606         if ((recp_cc != NULL) && (recp_cc[0] != 0)) {
3607                 msg->cm_fields['Y'] = strdup(recp_cc);
3608         }
3609         if (dest_node[0] != 0) {
3610                 msg->cm_fields['D'] = strdup(dest_node);
3611         }
3612
3613         if (!IsEmptyStr(my_email)) {
3614                 msg->cm_fields['F'] = strdup(my_email);
3615         }
3616         else if ( (author == &CC->user) && (!IsEmptyStr(CC->cs_inet_email)) ) {
3617                 msg->cm_fields['F'] = strdup(CC->cs_inet_email);
3618         }
3619
3620         if (subject != NULL) {
3621                 long length;
3622                 striplt(subject);
3623                 length = strlen(subject);
3624                 if (length > 0) {
3625                         long i;
3626                         long IsAscii;
3627                         IsAscii = -1;
3628                         i = 0;
3629                         while ((subject[i] != '\0') &&
3630                                (IsAscii = isascii(subject[i]) != 0 ))
3631                                 i++;
3632                         if (IsAscii != 0)
3633                                 msg->cm_fields['U'] = strdup(subject);
3634                         else /* ok, we've got utf8 in the string. */
3635                         {
3636                                 msg->cm_fields['U'] = rfc2047encode(subject, length);
3637                         }
3638
3639                 }
3640         }
3641
3642         if (supplied_euid != NULL) {
3643                 msg->cm_fields['E'] = strdup(supplied_euid);
3644         }
3645
3646         if (references != NULL) {
3647                 if (!IsEmptyStr(references)) {
3648                         msg->cm_fields['W'] = strdup(references);
3649                 }
3650         }
3651
3652         if (preformatted_text != NULL) {
3653                 msg->cm_fields['M'] = preformatted_text;
3654         }
3655         else {
3656                 msg->cm_fields['M'] = CtdlReadMessageBody(HKEY("000"), config.c_maxmsglen, NULL, 0, 0);
3657         }
3658
3659         return(msg);
3660 }
3661
3662
3663 /*
3664  * Check to see whether we have permission to post a message in the current
3665  * room.  Returns a *CITADEL ERROR CODE* and puts a message in errmsgbuf, or
3666  * returns 0 on success.
3667  */
3668 int CtdlDoIHavePermissionToPostInThisRoom(
3669         char *errmsgbuf,
3670         size_t n,
3671         const char* RemoteIdentifier,
3672         int PostPublic,
3673         int is_reply
3674 ) {
3675         int ra;
3676
3677         if (!(CC->logged_in) &&
3678             (PostPublic == POST_LOGGED_IN)) {
3679                 snprintf(errmsgbuf, n, "Not logged in.");
3680                 return (ERROR + NOT_LOGGED_IN);
3681         }
3682         else if (PostPublic == CHECK_EXISTANCE) {
3683                 return (0); // We're Evaling whether a recipient exists
3684         }
3685         else if (!(CC->logged_in)) {
3686
3687                 if ((CC->room.QRflags & QR_READONLY)) {
3688                         snprintf(errmsgbuf, n, "Not logged in.");
3689                         return (ERROR + NOT_LOGGED_IN);
3690                 }
3691                 if (CC->room.QRflags2 & QR2_MODERATED) {
3692                         snprintf(errmsgbuf, n, "Not logged in Moderation feature not yet implemented!");
3693                         return (ERROR + NOT_LOGGED_IN);
3694                 }
3695                 if ((PostPublic!=POST_LMTP) &&(CC->room.QRflags2 & QR2_SMTP_PUBLIC) == 0) {
3696                         SpoolControl *sc;
3697                         char filename[SIZ];
3698                         int found;
3699
3700                         if (RemoteIdentifier == NULL)
3701                         {
3702                                 snprintf(errmsgbuf, n, "Need sender to permit access.");
3703                                 return (ERROR + USERNAME_REQUIRED);
3704                         }
3705
3706                         assoc_file_name(filename, sizeof filename, &CC->room, ctdl_netcfg_dir);
3707                         begin_critical_section(S_NETCONFIGS);
3708                         if (!read_spoolcontrol_file(&sc, filename))
3709                         {
3710                                 end_critical_section(S_NETCONFIGS);
3711                                 snprintf(errmsgbuf, n,
3712                                         "This mailing list only accepts posts from subscribers.");
3713                                 return (ERROR + NO_SUCH_USER);
3714                         }
3715                         end_critical_section(S_NETCONFIGS);
3716                         found = is_recipient (sc, RemoteIdentifier);
3717                         free_spoolcontrol_struct(&sc);
3718                         if (found) {
3719                                 return (0);
3720                         }
3721                         else {
3722                                 snprintf(errmsgbuf, n,
3723                                         "This mailing list only accepts posts from subscribers.");
3724                                 return (ERROR + NO_SUCH_USER);
3725                         }
3726                 }
3727                 return (0);
3728
3729         }
3730
3731         if ((CC->user.axlevel < AxProbU)
3732             && ((CC->room.QRflags & QR_MAILBOX) == 0)) {
3733                 snprintf(errmsgbuf, n, "Need to be validated to enter (except in %s> to sysop)", MAILROOM);
3734                 return (ERROR + HIGHER_ACCESS_REQUIRED);
3735         }
3736
3737         CtdlRoomAccess(&CC->room, &CC->user, &ra, NULL);
3738
3739         if (ra & UA_POSTALLOWED) {
3740                 strcpy(errmsgbuf, "OK to post or reply here");
3741                 return(0);
3742         }
3743
3744         if ( (ra & UA_REPLYALLOWED) && (is_reply) ) {
3745                 /*
3746                  * To be thorough, we ought to check to see if the message they are
3747                  * replying to is actually a valid one in this room, but unless this
3748                  * actually becomes a problem we'll go with high performance instead.
3749                  */
3750                 strcpy(errmsgbuf, "OK to reply here");
3751                 return(0);
3752         }
3753
3754         if ( (ra & UA_REPLYALLOWED) && (!is_reply) ) {
3755                 /* Clarify what happened with a better error message */
3756                 snprintf(errmsgbuf, n, "You may only reply to existing messages here.");
3757                 return (ERROR + HIGHER_ACCESS_REQUIRED);
3758         }
3759
3760         snprintf(errmsgbuf, n, "Higher access is required to post in this room.");
3761         return (ERROR + HIGHER_ACCESS_REQUIRED);
3762
3763 }
3764
3765
3766 /*
3767  * Check to see if the specified user has Internet mail permission
3768  * (returns nonzero if permission is granted)
3769  */
3770 int CtdlCheckInternetMailPermission(struct ctdluser *who) {
3771
3772         /* Do not allow twits to send Internet mail */
3773         if (who->axlevel <= AxProbU) return(0);
3774
3775         /* Globally enabled? */
3776         if (config.c_restrict == 0) return(1);
3777
3778         /* User flagged ok? */
3779         if (who->flags & US_INTERNET) return(2);
3780
3781         /* Aide level access? */
3782         if (who->axlevel >= AxAideU) return(3);
3783
3784         /* No mail for you! */
3785         return(0);
3786 }
3787
3788
3789 /*
3790  * Validate recipients, count delivery types and errors, and handle aliasing
3791  * FIXME check for dupes!!!!!
3792  *
3793  * Returns 0 if all addresses are ok, ret->num_error = -1 if no addresses
3794  * were specified, or the number of addresses found invalid.
3795  *
3796  * Caller needs to free the result using free_recipients()
3797  */
3798 struct recptypes *validate_recipients(const char *supplied_recipients,
3799                                       const char *RemoteIdentifier,
3800                                       int Flags) {
3801         struct recptypes *ret;
3802         char *recipients = NULL;
3803         char this_recp[256];
3804         char this_recp_cooked[256];
3805         char append[SIZ];
3806         int num_recps = 0;
3807         int i, j;
3808         int mailtype;
3809         int invalid;
3810         struct ctdluser tempUS;
3811         struct ctdlroom tempQR;
3812         struct ctdlroom tempQR2;
3813         int err = 0;
3814         char errmsg[SIZ];
3815         int in_quotes = 0;
3816
3817         /* Initialize */
3818         ret = (struct recptypes *) malloc(sizeof(struct recptypes));
3819         if (ret == NULL) return(NULL);
3820
3821         /* Set all strings to null and numeric values to zero */
3822         memset(ret, 0, sizeof(struct recptypes));
3823
3824         if (supplied_recipients == NULL) {
3825                 recipients = strdup("");
3826         }
3827         else {
3828                 recipients = strdup(supplied_recipients);
3829         }
3830
3831         /* Allocate some memory.  Yes, this allocates 500% more memory than we will
3832          * actually need, but it's healthier for the heap than doing lots of tiny
3833          * realloc() calls instead.
3834          */
3835
3836         ret->errormsg = malloc(strlen(recipients) + 1024);
3837         ret->recp_local = malloc(strlen(recipients) + 1024);
3838         ret->recp_internet = malloc(strlen(recipients) + 1024);
3839         ret->recp_ignet = malloc(strlen(recipients) + 1024);
3840         ret->recp_room = malloc(strlen(recipients) + 1024);
3841         ret->display_recp = malloc(strlen(recipients) + 1024);
3842
3843         ret->errormsg[0] = 0;
3844         ret->recp_local[0] = 0;
3845         ret->recp_internet[0] = 0;
3846         ret->recp_ignet[0] = 0;
3847         ret->recp_room[0] = 0;
3848         ret->display_recp[0] = 0;
3849
3850         ret->recptypes_magic = RECPTYPES_MAGIC;
3851
3852         /* Change all valid separator characters to commas */
3853         for (i=0; !IsEmptyStr(&recipients[i]); ++i) {
3854                 if ((recipients[i] == ';') || (recipients[i] == '|')) {
3855                         recipients[i] = ',';
3856                 }
3857         }
3858
3859         /* Now start extracting recipients... */
3860
3861         while (!IsEmptyStr(recipients)) {
3862
3863                 for (i=0; i<=strlen(recipients); ++i) {
3864                         if (recipients[i] == '\"') in_quotes = 1 - in_quotes;
3865                         if ( ( (recipients[i] == ',') && (!in_quotes) ) || (recipients[i] == 0) ) {
3866                                 safestrncpy(this_recp, recipients, i+1);
3867                                 this_recp[i] = 0;
3868                                 if (recipients[i] == ',') {
3869                                         strcpy(recipients, &recipients[i+1]);
3870                                 }
3871                                 else {
3872                                         strcpy(recipients, "");
3873                                 }
3874                                 break;
3875                         }
3876                 }
3877
3878                 striplt(this_recp);
3879                 if (IsEmptyStr(this_recp))
3880                         break;
3881                 syslog(LOG_DEBUG, "Evaluating recipient #%d: %s\n", num_recps, this_recp);
3882                 ++num_recps;
3883                 mailtype = alias(this_recp);
3884                 mailtype = alias(this_recp);
3885                 mailtype = alias(this_recp);
3886                 j = 0;
3887                 for (j=0; !IsEmptyStr(&this_recp[j]); ++j) {
3888                         if (this_recp[j]=='_') {
3889                                 this_recp_cooked[j] = ' ';
3890                         }
3891                         else {
3892                                 this_recp_cooked[j] = this_recp[j];
3893                         }
3894                 }
3895                 this_recp_cooked[j] = '\0';
3896                 invalid = 0;
3897                 errmsg[0] = 0;
3898                 switch(mailtype) {
3899                         case MES_LOCAL:
3900                                 if (!strcasecmp(this_recp, "sysop")) {
3901                                         ++ret->num_room;
3902                                         strcpy(this_recp, config.c_aideroom);
3903                                         if (!IsEmptyStr(ret->recp_room)) {
3904                                                 strcat(ret->recp_room, "|");
3905                                         }
3906                                         strcat(ret->recp_room, this_recp);
3907                                 }
3908                                 else if ( (!strncasecmp(this_recp, "room_", 5))
3909                                       && (!CtdlGetRoom(&tempQR, &this_recp_cooked[5])) ) {
3910
3911                                         /* Save room so we can restore it later */
3912                                         tempQR2 = CC->room;
3913                                         CC->room = tempQR;
3914
3915                                         /* Check permissions to send mail to this room */
3916                                         err = CtdlDoIHavePermissionToPostInThisRoom(
3917                                                 errmsg,
3918                                                 sizeof errmsg,
3919                                                 RemoteIdentifier,
3920                                                 Flags,
3921                                                 0                       /* 0 = not a reply */
3922                                         );
3923                                         if (err)
3924                                         {
3925                                                 ++ret->num_error;
3926                                                 invalid = 1;
3927                                         }
3928                                         else {
3929                                                 ++ret->num_room;
3930                                                 if (!IsEmptyStr(ret->recp_room)) {
3931                                                         strcat(ret->recp_room, "|");
3932                                                 }
3933                                                 strcat(ret->recp_room, &this_recp_cooked[5]);
3934                                         }
3935
3936                                         /* Restore room in case something needs it */
3937                                         CC->room = tempQR2;
3938
3939                                 }
3940                                 else if (CtdlGetUser(&tempUS, this_recp) == 0) {
3941                                         ++ret->num_local;
3942                                         strcpy(this_recp, tempUS.fullname);
3943                                         if (!IsEmptyStr(ret->recp_local)) {
3944                                                 strcat(ret->recp_local, "|");
3945                                         }
3946                                         strcat(ret->recp_local, this_recp);
3947                                 }
3948                                 else if (CtdlGetUser(&tempUS, this_recp_cooked) == 0) {
3949                                         ++ret->num_local;
3950                                         strcpy(this_recp, tempUS.fullname);
3951                                         if (!IsEmptyStr(ret->recp_local)) {
3952                                                 strcat(ret->recp_local, "|");
3953                                         }
3954                                         strcat(ret->recp_local, this_recp);
3955                                 }
3956                                 else {
3957                                         ++ret->num_error;
3958                                         invalid = 1;
3959                                 }
3960                                 break;
3961                         case MES_INTERNET:
3962                                 /* Yes, you're reading this correctly: if the target
3963                                  * domain points back to the local system or an attached
3964                                  * Citadel directory, the address is invalid.  That's
3965                                  * because if the address were valid, we would have
3966                                  * already translated it to a local address by now.
3967                                  */
3968                                 if (IsDirectory(this_recp, 0)) {
3969                                         ++ret->num_error;
3970                                         invalid = 1;
3971                                 }
3972                                 else {
3973                                         ++ret->num_internet;
3974                                         if (!IsEmptyStr(ret->recp_internet)) {
3975                                                 strcat(ret->recp_internet, "|");
3976                                         }
3977                                         strcat(ret->recp_internet, this_recp);
3978                                 }
3979                                 break;
3980                         case MES_IGNET:
3981                                 ++ret->num_ignet;
3982                                 if (!IsEmptyStr(ret->recp_ignet)) {
3983                                         strcat(ret->recp_ignet, "|");
3984                                 }
3985                                 strcat(ret->recp_ignet, this_recp);
3986                                 break;
3987                         case MES_ERROR:
3988                                 ++ret->num_error;
3989                                 invalid = 1;
3990                                 break;
3991                 }
3992                 if (invalid) {
3993                         if (IsEmptyStr(errmsg)) {
3994                                 snprintf(append, sizeof append, "Invalid recipient: %s", this_recp);
3995                         }
3996                         else {
3997                                 snprintf(append, sizeof append, "%s", errmsg);
3998                         }
3999                         if ( (strlen(ret->errormsg) + strlen(append) + 3) < SIZ) {
4000                                 if (!IsEmptyStr(ret->errormsg)) {
4001                                         strcat(ret->errormsg, "; ");
4002                                 }
4003                                 strcat(ret->errormsg, append);
4004                         }
4005                 }
4006                 else {
4007                         if (IsEmptyStr(ret->display_recp)) {
4008                                 strcpy(append, this_recp);
4009                         }
4010                         else {
4011                                 snprintf(append, sizeof append, ", %s", this_recp);
4012                         }
4013                         if ( (strlen(ret->display_recp)+strlen(append)) < SIZ) {
4014                                 strcat(ret->display_recp, append);
4015                         }
4016                 }
4017         }
4018
4019         if ((ret->num_local + ret->num_internet + ret->num_ignet +
4020            ret->num_room + ret->num_error) == 0) {
4021                 ret->num_error = (-1);
4022                 strcpy(ret->errormsg, "No recipients specified.");
4023         }
4024
4025         syslog(LOG_DEBUG, "validate_recipients()\n");
4026         syslog(LOG_DEBUG, " local: %d <%s>\n", ret->num_local, ret->recp_local);
4027         syslog(LOG_DEBUG, "  room: %d <%s>\n", ret->num_room, ret->recp_room);
4028         syslog(LOG_DEBUG, "  inet: %d <%s>\n", ret->num_internet, ret->recp_internet);
4029         syslog(LOG_DEBUG, " ignet: %d <%s>\n", ret->num_ignet, ret->recp_ignet);
4030         syslog(LOG_DEBUG, " error: %d <%s>\n", ret->num_error, ret->errormsg);
4031
4032         free(recipients);
4033         return(ret);
4034 }
4035
4036
4037 /*
4038  * Destructor for struct recptypes
4039  */
4040 void free_recipients(struct recptypes *valid) {
4041
4042         if (valid == NULL) {
4043                 return;
4044         }
4045
4046         if (valid->recptypes_magic != RECPTYPES_MAGIC) {
4047                 syslog(LOG_EMERG, "Attempt to call free_recipients() on some other data type!\n");
4048                 abort();
4049         }
4050
4051         if (valid->errormsg != NULL)            free(valid->errormsg);
4052         if (valid->recp_local != NULL)          free(valid->recp_local);
4053         if (valid->recp_internet != NULL)       free(valid->recp_internet);
4054         if (valid->recp_ignet != NULL)          free(valid->recp_ignet);
4055         if (valid->recp_room != NULL)           free(valid->recp_room);
4056         if (valid->display_recp != NULL)        free(valid->display_recp);
4057         if (valid->bounce_to != NULL)           free(valid->bounce_to);
4058         if (valid->envelope_from != NULL)       free(valid->envelope_from);
4059         free(valid);
4060 }
4061
4062
4063
4064 /*
4065  * message entry  -  mode 0 (normal)
4066  */
4067 void cmd_ent0(char *entargs)
4068 {
4069         int post = 0;
4070         char recp[SIZ];
4071         char cc[SIZ];
4072         char bcc[SIZ];
4073         char supplied_euid[128];
4074         int anon_flag = 0;
4075         int format_type = 0;
4076         char newusername[256];
4077         char newuseremail[256];
4078         struct CtdlMessage *msg;
4079         int anonymous = 0;
4080         char errmsg[SIZ];
4081         int err = 0;
4082         struct recptypes *valid = NULL;
4083         struct recptypes *valid_to = NULL;
4084         struct recptypes *valid_cc = NULL;
4085         struct recptypes *valid_bcc = NULL;
4086         char subject[SIZ];
4087         int subject_required = 0;
4088         int do_confirm = 0;
4089         long msgnum;
4090         int i, j;
4091         char buf[256];
4092         int newuseremail_ok = 0;
4093         char references[SIZ];
4094         char *ptr;
4095
4096         unbuffer_output();
4097
4098         post = extract_int(entargs, 0);
4099         extract_token(recp, entargs, 1, '|', sizeof recp);
4100         anon_flag = extract_int(entargs, 2);
4101         format_type = extract_int(entargs, 3);
4102         extract_token(subject, entargs, 4, '|', sizeof subject);
4103         extract_token(newusername, entargs, 5, '|', sizeof newusername);
4104         do_confirm = extract_int(entargs, 6);
4105         extract_token(cc, entargs, 7, '|', sizeof cc);
4106         extract_token(bcc, entargs, 8, '|', sizeof bcc);
4107         switch(CC->room.QRdefaultview) {
4108                 case VIEW_NOTES:
4109                 case VIEW_WIKI:
4110                         extract_token(supplied_euid, entargs, 9, '|', sizeof supplied_euid);
4111                         break;
4112                 default:
4113                         supplied_euid[0] = 0;
4114                         break;
4115         }
4116         extract_token(newuseremail, entargs, 10, '|', sizeof newuseremail);
4117         extract_token(references, entargs, 11, '|', sizeof references);
4118         for (ptr=references; *ptr != 0; ++ptr) {
4119                 if (*ptr == '!') *ptr = '|';
4120         }
4121
4122         /* first check to make sure the request is valid. */
4123
4124         err = CtdlDoIHavePermissionToPostInThisRoom(
4125                 errmsg,
4126                 sizeof errmsg,
4127                 NULL,
4128                 POST_LOGGED_IN,
4129                 (!IsEmptyStr(references))               /* is this a reply?  or a top-level post? */
4130         );
4131         if (err)
4132         {
4133                 cprintf("%d %s\n", err, errmsg);
4134                 return;
4135         }
4136
4137         /* Check some other permission type things. */
4138
4139         if (IsEmptyStr(newusername)) {
4140                 strcpy(newusername, CC->user.fullname);
4141         }
4142         if (  (CC->user.axlevel < AxAideU)
4143            && (strcasecmp(newusername, CC->user.fullname))
4144            && (strcasecmp(newusername, CC->cs_inet_fn))
4145         ) {
4146                 cprintf("%d You don't have permission to author messages as '%s'.\n",
4147                         ERROR + HIGHER_ACCESS_REQUIRED,
4148                         newusername
4149                 );
4150                 return;
4151         }
4152
4153
4154         if (IsEmptyStr(newuseremail)) {
4155                 newuseremail_ok = 1;
4156         }
4157
4158         if (!IsEmptyStr(newuseremail)) {
4159                 if (!strcasecmp(newuseremail, CC->cs_inet_email)) {
4160                         newuseremail_ok = 1;
4161                 }
4162                 else if (!IsEmptyStr(CC->cs_inet_other_emails)) {
4163                         j = num_tokens(CC->cs_inet_other_emails, '|');
4164                         for (i=0; i<j; ++i) {
4165                                 extract_token(buf, CC->cs_inet_other_emails, i, '|', sizeof buf);
4166                                 if (!strcasecmp(newuseremail, buf)) {
4167                                         newuseremail_ok = 1;
4168                                 }
4169                         }
4170                 }
4171         }
4172
4173         if (!newuseremail_ok) {
4174                 cprintf("%d You don't have permission to author messages as '%s'.\n",
4175                         ERROR + HIGHER_ACCESS_REQUIRED,
4176                         newuseremail
4177                 );
4178                 return;
4179         }
4180
4181         CC->cs_flags |= CS_POSTING;
4182
4183         /* In mailbox rooms we have to behave a little differently --
4184          * make sure the user has specified at least one recipient.  Then
4185          * validate the recipient(s).  We do this for the Mail> room, as
4186          * well as any room which has the "Mailbox" view set - unless it
4187          * is the DRAFTS room which does not require recipients
4188          */
4189
4190         if ( (  ( (CC->room.QRflags & QR_MAILBOX) && (!strcasecmp(&CC->room.QRname[11], MAILROOM)) )
4191              || ( (CC->room.QRflags & QR_MAILBOX) && (CC->curr_view == VIEW_MAILBOX) )
4192         ) && (strcasecmp(&CC->room.QRname[11], USERDRAFTROOM)) !=0 ) {
4193                 if (CC->user.axlevel < AxProbU) {
4194                         strcpy(recp, "sysop");
4195                         strcpy(cc, "");
4196                         strcpy(bcc, "");
4197                 }
4198
4199                 valid_to = validate_recipients(recp, NULL, 0);
4200                 if (valid_to->num_error > 0) {
4201                         cprintf("%d %s\n", ERROR + NO_SUCH_USER, valid_to->errormsg);
4202                         free_recipients(valid_to);
4203                         return;
4204                 }
4205
4206                 valid_cc = validate_recipients(cc, NULL, 0);
4207                 if (valid_cc->num_error > 0) {
4208                         cprintf("%d %s\n", ERROR + NO_SUCH_USER, valid_cc->errormsg);
4209                         free_recipients(valid_to);
4210                         free_recipients(valid_cc);
4211                         return;
4212                 }
4213
4214                 valid_bcc = validate_recipients(bcc, NULL, 0);
4215                 if (valid_bcc->num_error > 0) {
4216                         cprintf("%d %s\n", ERROR + NO_SUCH_USER, valid_bcc->errormsg);
4217                         free_recipients(valid_to);
4218                         free_recipients(valid_cc);
4219                         free_recipients(valid_bcc);
4220                         return;
4221                 }
4222
4223                 /* Recipient required, but none were specified */
4224                 if ( (valid_to->num_error < 0) && (valid_cc->num_error < 0) && (valid_bcc->num_error < 0) ) {
4225                         free_recipients(valid_to);
4226                         free_recipients(valid_cc);
4227                         free_recipients(valid_bcc);
4228                         cprintf("%d At least one recipient is required.\n", ERROR + NO_SUCH_USER);
4229                         return;
4230                 }
4231
4232                 if (valid_to->num_internet + valid_cc->num_internet + valid_bcc->num_internet > 0) {
4233                         if (CtdlCheckInternetMailPermission(&CC->user)==0) {
4234                                 cprintf("%d You do not have permission "
4235                                         "to send Internet mail.\n",
4236                                         ERROR + HIGHER_ACCESS_REQUIRED);
4237                                 free_recipients(valid_to);
4238                                 free_recipients(valid_cc);
4239                                 free_recipients(valid_bcc);
4240                                 return;
4241                         }
4242                 }
4243
4244                 if ( ( (valid_to->num_internet + valid_to->num_ignet + valid_cc->num_internet + valid_cc->num_ignet + valid_bcc->num_internet + valid_bcc->num_ignet) > 0)
4245                    && (CC->user.axlevel < AxNetU) ) {
4246                         cprintf("%d Higher access required for network mail.\n",
4247                                 ERROR + HIGHER_ACCESS_REQUIRED);
4248                         free_recipients(valid_to);
4249                         free_recipients(valid_cc);
4250                         free_recipients(valid_bcc);
4251                         return;
4252                 }
4253
4254                 if ((RESTRICT_INTERNET == 1)
4255                     && (valid_to->num_internet + valid_cc->num_internet + valid_bcc->num_internet > 0)
4256                     && ((CC->user.flags & US_INTERNET) == 0)
4257                     && (!CC->internal_pgm)) {
4258                         cprintf("%d You don't have access to Internet mail.\n",
4259                                 ERROR + HIGHER_ACCESS_REQUIRED);
4260                         free_recipients(valid_to);
4261                         free_recipients(valid_cc);
4262                         free_recipients(valid_bcc);
4263                         return;
4264                 }
4265
4266         }
4267
4268         /* Is this a room which has anonymous-only or anonymous-option? */
4269         anonymous = MES_NORMAL;
4270         if (CC->room.QRflags & QR_ANONONLY) {
4271                 anonymous = MES_ANONONLY;
4272         }
4273         if (CC->room.QRflags & QR_ANONOPT) {
4274                 if (anon_flag == 1) {   /* only if the user requested it */
4275                         anonymous = MES_ANONOPT;
4276                 }
4277         }
4278
4279         if ((CC->room.QRflags & QR_MAILBOX) == 0) {
4280                 recp[0] = 0;
4281         }
4282
4283         /* Recommend to the client that the use of a message subject is
4284          * strongly recommended in this room, if either the SUBJECTREQ flag
4285          * is set, or if there is one or more Internet email recipients.
4286          */
4287         if (CC->room.QRflags2 & QR2_SUBJECTREQ) subject_required = 1;
4288         if ((valid_to)  && (valid_to->num_internet > 0))        subject_required = 1;
4289         if ((valid_cc)  && (valid_cc->num_internet > 0))        subject_required = 1;
4290         if ((valid_bcc) && (valid_bcc->num_internet > 0))       subject_required = 1;
4291
4292         /* If we're only checking the validity of the request, return
4293          * success without creating the message.
4294          */
4295         if (post == 0) {
4296                 cprintf("%d %s|%d\n", CIT_OK,
4297                         ((valid_to != NULL) ? valid_to->display_recp : ""),
4298                         subject_required);
4299                 free_recipients(valid_to);
4300                 free_recipients(valid_cc);
4301                 free_recipients(valid_bcc);
4302                 return;
4303         }
4304
4305         /* We don't need these anymore because we'll do it differently below */
4306         free_recipients(valid_to);
4307         free_recipients(valid_cc);
4308         free_recipients(valid_bcc);
4309
4310         /* Read in the message from the client. */
4311         if (do_confirm) {
4312                 cprintf("%d send message\n", START_CHAT_MODE);
4313         } else {
4314                 cprintf("%d send message\n", SEND_LISTING);
4315         }
4316
4317         msg = CtdlMakeMessage(&CC->user, recp, cc,
4318                 CC->room.QRname, anonymous, format_type,
4319                 newusername, newuseremail, subject,
4320                 ((!IsEmptyStr(supplied_euid)) ? supplied_euid : NULL),
4321                 NULL, references);
4322
4323         /* Put together one big recipients struct containing to/cc/bcc all in
4324          * one.  This is for the envelope.
4325          */
4326         char *all_recps = malloc(SIZ * 3);
4327         strcpy(all_recps, recp);
4328         if (!IsEmptyStr(cc)) {
4329                 if (!IsEmptyStr(all_recps)) {
4330                         strcat(all_recps, ",");
4331                 }
4332                 strcat(all_recps, cc);
4333         }
4334         if (!IsEmptyStr(bcc)) {
4335                 if (!IsEmptyStr(all_recps)) {
4336                         strcat(all_recps, ",");
4337                 }
4338                 strcat(all_recps, bcc);
4339         }
4340         if (!IsEmptyStr(all_recps)) {
4341                 valid = validate_recipients(all_recps, NULL, 0);
4342         }
4343         else {
4344                 valid = NULL;
4345         }
4346         free(all_recps);
4347
4348         if (msg != NULL) {
4349                 msgnum = CtdlSubmitMsg(msg, valid, "", QP_EADDR);
4350
4351                 if (do_confirm) {
4352                         cprintf("%ld\n", msgnum);
4353                         if (msgnum >= 0L) {
4354                                 cprintf("Message accepted.\n");
4355                         }
4356                         else {
4357                                 cprintf("Internal error.\n");
4358                         }
4359                         if (msg->cm_fields['E'] != NULL) {
4360                                 cprintf("%s\n", msg->cm_fields['E']);
4361                         } else {
4362                                 cprintf("\n");
4363                         }
4364                         cprintf("000\n");
4365                 }
4366
4367                 CtdlFreeMessage(msg);
4368         }
4369         if (valid != NULL) {
4370                 free_recipients(valid);
4371         }
4372         return;
4373 }
4374
4375
4376
4377 /*
4378  * API function to delete messages which match a set of criteria
4379  * (returns the actual number of messages deleted)
4380  */
4381 int CtdlDeleteMessages(char *room_name,         /* which room */
4382                         long *dmsgnums,         /* array of msg numbers to be deleted */
4383                         int num_dmsgnums,       /* number of msgs to be deleted, or 0 for "any" */
4384                         char *content_type      /* or "" for any.  regular expressions expected. */
4385 )
4386 {
4387         struct ctdlroom qrbuf;
4388         struct cdbdata *cdbfr;
4389         long *msglist = NULL;
4390         long *dellist = NULL;
4391         int num_msgs = 0;
4392         int i, j;
4393         int num_deleted = 0;
4394         int delete_this;
4395         struct MetaData smi;
4396         regex_t re;
4397         regmatch_t pm;
4398         int need_to_free_re = 0;
4399
4400         if (content_type) if (!IsEmptyStr(content_type)) {
4401                 regcomp(&re, content_type, 0);
4402                 need_to_free_re = 1;
4403         }
4404         syslog(LOG_DEBUG, "CtdlDeleteMessages(%s, %d msgs, %s)\n",
4405                 room_name, num_dmsgnums, content_type);
4406
4407         /* get room record, obtaining a lock... */
4408         if (CtdlGetRoomLock(&qrbuf, room_name) != 0) {
4409                 syslog(LOG_ERR, "CtdlDeleteMessages(): Room <%s> not found\n",
4410                         room_name);
4411                 if (need_to_free_re) regfree(&re);
4412                 return (0);     /* room not found */
4413         }
4414         cdbfr = cdb_fetch(CDB_MSGLISTS, &qrbuf.QRnumber, sizeof(long));
4415
4416         if (cdbfr != NULL) {
4417                 dellist = malloc(cdbfr->len);
4418                 msglist = (long *) cdbfr->ptr;
4419                 cdbfr->ptr = NULL;      /* CtdlDeleteMessages() now owns this memory */
4420                 num_msgs = cdbfr->len / sizeof(long);
4421                 cdb_free(cdbfr);
4422         }
4423         if (num_msgs > 0) {
4424                 for (i = 0; i < num_msgs; ++i) {
4425                         delete_this = 0x00;
4426
4427                         /* Set/clear a bit for each criterion */
4428
4429                         /* 0 messages in the list or a null list means that we are
4430                          * interested in deleting any messages which meet the other criteria.
4431                          */
4432                         if ((num_dmsgnums == 0) || (dmsgnums == NULL)) {
4433                                 delete_this |= 0x01;
4434                         }
4435                         else {
4436                                 for (j=0; j<num_dmsgnums; ++j) {
4437                                         if (msglist[i] == dmsgnums[j]) {
4438                                                 delete_this |= 0x01;
4439                                         }
4440                                 }
4441                         }
4442
4443                         if (IsEmptyStr(content_type)) {
4444                                 delete_this |= 0x02;
4445                         } else {
4446                                 GetMetaData(&smi, msglist[i]);
4447                                 if (regexec(&re, smi.meta_content_type, 1, &pm, 0) == 0) {
4448                                         delete_this |= 0x02;
4449                                 }
4450                         }
4451
4452                         /* Delete message only if all bits are set */
4453                         if (delete_this == 0x03) {
4454                                 dellist[num_deleted++] = msglist[i];
4455                                 msglist[i] = 0L;
4456                         }
4457                 }
4458
4459                 num_msgs = sort_msglist(msglist, num_msgs);
4460                 cdb_store(CDB_MSGLISTS, &qrbuf.QRnumber, (int)sizeof(long),
4461                           msglist, (int)(num_msgs * sizeof(long)));
4462
4463                 if (num_msgs > 0)
4464                         qrbuf.QRhighest = msglist[num_msgs - 1];
4465                 else
4466                         qrbuf.QRhighest = 0;
4467         }
4468         CtdlPutRoomLock(&qrbuf);
4469
4470         /* Go through the messages we pulled out of the index, and decrement
4471          * their reference counts by 1.  If this is the only room the message
4472          * was in, the reference count will reach zero and the message will
4473          * automatically be deleted from the database.  We do this in a
4474          * separate pass because there might be plug-in hooks getting called,
4475          * and we don't want that happening during an S_ROOMS critical
4476          * section.
4477          */
4478         if (num_deleted) for (i=0; i<num_deleted; ++i) {
4479                 PerformDeleteHooks(qrbuf.QRname, dellist[i]);
4480                 AdjRefCount(dellist[i], -1);
4481         }
4482
4483         /* Now free the memory we used, and go away. */
4484         if (msglist != NULL) free(msglist);
4485         if (dellist != NULL) free(dellist);
4486         syslog(LOG_DEBUG, "%d message(s) deleted.\n", num_deleted);
4487         if (need_to_free_re) regfree(&re);
4488         return (num_deleted);
4489 }
4490
4491
4492
4493 /*
4494  * Check whether the current user has permission to delete messages from
4495  * the current room (returns 1 for yes, 0 for no)
4496  */
4497 int CtdlDoIHavePermissionToDeleteMessagesFromThisRoom(void) {
4498         int ra;
4499         CtdlRoomAccess(&CC->room, &CC->user, &ra, NULL);
4500         if (ra & UA_DELETEALLOWED) return(1);
4501         return(0);
4502 }
4503
4504
4505
4506
4507 /*
4508  * Delete message from current room
4509  */
4510 void cmd_dele(char *args)
4511 {
4512         int num_deleted;
4513         int i;
4514         char msgset[SIZ];
4515         char msgtok[32];
4516         long *msgs;
4517         int num_msgs = 0;
4518
4519         extract_token(msgset, args, 0, '|', sizeof msgset);
4520         num_msgs = num_tokens(msgset, ',');
4521         if (num_msgs < 1) {
4522                 cprintf("%d Nothing to do.\n", CIT_OK);
4523                 return;
4524         }
4525
4526         if (CtdlDoIHavePermissionToDeleteMessagesFromThisRoom() == 0) {
4527                 cprintf("%d Higher access required.\n",
4528                         ERROR + HIGHER_ACCESS_REQUIRED);
4529                 return;
4530         }
4531
4532         /*
4533          * Build our message set to be moved/copied
4534          */
4535         msgs = malloc(num_msgs * sizeof(long));
4536         for (i=0; i<num_msgs; ++i) {
4537                 extract_token(msgtok, msgset, i, ',', sizeof msgtok);
4538                 msgs[i] = atol(msgtok);
4539         }
4540
4541         num_deleted = CtdlDeleteMessages(CC->room.QRname, msgs, num_msgs, "");
4542         free(msgs);
4543
4544         if (num_deleted) {
4545                 cprintf("%d %d message%s deleted.\n", CIT_OK,
4546                         num_deleted, ((num_deleted != 1) ? "s" : ""));
4547         } else {
4548                 cprintf("%d Message not found.\n", ERROR + MESSAGE_NOT_FOUND);
4549         }
4550 }
4551
4552
4553
4554
4555 /*
4556  * move or copy a message to another room
4557  */
4558 void cmd_move(char *args)
4559 {
4560         char msgset[SIZ];
4561         char msgtok[32];
4562         long *msgs;
4563         int num_msgs = 0;
4564
4565         char targ[ROOMNAMELEN];
4566         struct ctdlroom qtemp;
4567         int err;
4568         int is_copy = 0;
4569         int ra;
4570         int permit = 0;
4571         int i;
4572
4573         extract_token(msgset, args, 0, '|', sizeof msgset);
4574         num_msgs = num_tokens(msgset, ',');
4575         if (num_msgs < 1) {
4576                 cprintf("%d Nothing to do.\n", CIT_OK);
4577                 return;
4578         }
4579
4580         extract_token(targ, args, 1, '|', sizeof targ);
4581         convert_room_name_macros(targ, sizeof targ);
4582         targ[ROOMNAMELEN - 1] = 0;
4583         is_copy = extract_int(args, 2);
4584
4585         if (CtdlGetRoom(&qtemp, targ) != 0) {
4586                 cprintf("%d '%s' does not exist.\n", ERROR + ROOM_NOT_FOUND, targ);
4587                 return;
4588         }
4589
4590         if (!strcasecmp(qtemp.QRname, CC->room.QRname)) {
4591                 cprintf("%d Source and target rooms are the same.\n", ERROR + ALREADY_EXISTS);
4592                 return;
4593         }
4594
4595         CtdlGetUser(&CC->user, CC->curr_user);
4596         CtdlRoomAccess(&qtemp, &CC->user, &ra, NULL);
4597
4598         /* Check for permission to perform this operation.
4599          * Remember: "CC->room" is source, "qtemp" is target.
4600          */
4601         permit = 0;
4602
4603         /* Aides can move/copy */
4604         if (CC->user.axlevel >= AxAideU) permit = 1;
4605
4606         /* Room aides can move/copy */
4607         if (CC->user.usernum == CC->room.QRroomaide) permit = 1;
4608
4609         /* Permit move/copy from personal rooms */
4610         if ((CC->room.QRflags & QR_MAILBOX)
4611            && (qtemp.QRflags & QR_MAILBOX)) permit = 1;
4612
4613         /* Permit only copy from public to personal room */
4614         if ( (is_copy)
4615            && (!(CC->room.QRflags & QR_MAILBOX))
4616            && (qtemp.QRflags & QR_MAILBOX)) permit = 1;
4617
4618         /* Permit message removal from collaborative delete rooms */
4619         if (CC->room.QRflags2 & QR2_COLLABDEL) permit = 1;
4620
4621         /* Users allowed to post into the target room may move into it too. */
4622         if ((CC->room.QRflags & QR_MAILBOX) &&
4623             (qtemp.QRflags & UA_POSTALLOWED))  permit = 1;
4624
4625         /* User must have access to target room */
4626         if (!(ra & UA_KNOWN))  permit = 0;
4627
4628         if (!permit) {
4629                 cprintf("%d Higher access required.\n",
4630                         ERROR + HIGHER_ACCESS_REQUIRED);
4631                 return;
4632         }
4633
4634         /*
4635          * Build our message set to be moved/copied
4636          */
4637         msgs = malloc(num_msgs * sizeof(long));
4638         for (i=0; i<num_msgs; ++i) {
4639                 extract_token(msgtok, msgset, i, ',', sizeof msgtok);
4640                 msgs[i] = atol(msgtok);
4641         }
4642
4643         /*
4644          * Do the copy
4645          */
4646         err = CtdlSaveMsgPointersInRoom(targ, msgs, num_msgs, 1, NULL, 0);
4647         if (err != 0) {
4648                 cprintf("%d Cannot store message(s) in %s: error %d\n",
4649                         err, targ, err);
4650                 free(msgs);
4651                 return;
4652         }
4653
4654         /* Now delete the message from the source room,
4655          * if this is a 'move' rather than a 'copy' operation.
4656          */
4657         if (is_copy == 0) {
4658                 CtdlDeleteMessages(CC->room.QRname, msgs, num_msgs, "");
4659         }
4660         free(msgs);
4661
4662         cprintf("%d Message(s) %s.\n", CIT_OK, (is_copy ? "copied" : "moved") );
4663 }
4664
4665
4666
4667 /*
4668  * GetMetaData()  -  Get the supplementary record for a message
4669  */
4670 void GetMetaData(struct MetaData *smibuf, long msgnum)
4671 {
4672
4673         struct cdbdata *cdbsmi;
4674         long TheIndex;
4675
4676         memset(smibuf, 0, sizeof(struct MetaData));
4677         smibuf->meta_msgnum = msgnum;
4678         smibuf->meta_refcount = 1;      /* Default reference count is 1 */
4679
4680         /* Use the negative of the message number for its supp record index */
4681         TheIndex = (0L - msgnum);
4682
4683         cdbsmi = cdb_fetch(CDB_MSGMAIN, &TheIndex, sizeof(long));
4684         if (cdbsmi == NULL) {
4685                 return;         /* record not found; go with defaults */
4686         }
4687         memcpy(smibuf, cdbsmi->ptr,
4688                ((cdbsmi->len > sizeof(struct MetaData)) ?
4689                 sizeof(struct MetaData) : cdbsmi->len));
4690         cdb_free(cdbsmi);
4691         return;
4692 }
4693
4694
4695 /*
4696  * PutMetaData()  -  (re)write supplementary record for a message
4697  */
4698 void PutMetaData(struct MetaData *smibuf)
4699 {
4700         long TheIndex;
4701
4702         /* Use the negative of the message number for the metadata db index */
4703         TheIndex = (0L - smibuf->meta_msgnum);
4704
4705         cdb_store(CDB_MSGMAIN,
4706                   &TheIndex, (int)sizeof(long),
4707                   smibuf, (int)sizeof(struct MetaData));
4708
4709 }
4710
4711 /*
4712  * AdjRefCount  -  submit an adjustment to the reference count for a message.
4713  *                 (These are just queued -- we actually process them later.)
4714  */
4715 void AdjRefCount(long msgnum, int incr)
4716 {
4717         struct arcq new_arcq;
4718         int rv = 0;
4719
4720         syslog(LOG_DEBUG, "AdjRefCount() msg %ld ref count delta %+d\n",
4721                 msgnum, incr
4722         );
4723
4724         begin_critical_section(S_SUPPMSGMAIN);
4725         if (arcfp == NULL) {
4726                 arcfp = fopen(file_arcq, "ab+");
4727         }
4728         end_critical_section(S_SUPPMSGMAIN);
4729
4730         /* msgnum < 0 means that we're trying to close the file */
4731         if (msgnum < 0) {
4732                 syslog(LOG_DEBUG, "Closing the AdjRefCount queue file\n");
4733                 begin_critical_section(S_SUPPMSGMAIN);
4734                 if (arcfp != NULL) {
4735                         fclose(arcfp);
4736                         arcfp = NULL;
4737                 }
4738                 end_critical_section(S_SUPPMSGMAIN);
4739                 return;
4740         }
4741
4742         /*
4743          * If we can't open the queue, perform the operation synchronously.
4744          */
4745         if (arcfp == NULL) {
4746                 TDAP_AdjRefCount(msgnum, incr);
4747                 return;
4748         }
4749
4750         new_arcq.arcq_msgnum = msgnum;
4751         new_arcq.arcq_delta = incr;
4752         rv = fwrite(&new_arcq, sizeof(struct arcq), 1, arcfp);
4753         fflush(arcfp);
4754
4755         return;
4756 }
4757
4758
4759 /*
4760  * TDAP_ProcessAdjRefCountQueue()
4761  *
4762  * Process the queue of message count adjustments that was created by calls
4763  * to AdjRefCount() ... by reading the queue and calling TDAP_AdjRefCount()
4764  * for each one.  This should be an "off hours" operation.
4765  */
4766 int TDAP_ProcessAdjRefCountQueue(void)
4767 {
4768         char file_arcq_temp[PATH_MAX];
4769         int r;
4770         FILE *fp;
4771         struct arcq arcq_rec;
4772         int num_records_processed = 0;
4773
4774         snprintf(file_arcq_temp, sizeof file_arcq_temp, "%s.%04x", file_arcq, rand());
4775
4776         begin_critical_section(S_SUPPMSGMAIN);
4777         if (arcfp != NULL) {
4778                 fclose(arcfp);
4779                 arcfp = NULL;
4780         }
4781
4782         r = link(file_arcq, file_arcq_temp);
4783         if (r != 0) {
4784                 syslog(LOG_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
4785                 end_critical_section(S_SUPPMSGMAIN);
4786                 return(num_records_processed);
4787         }
4788
4789         unlink(file_arcq);
4790         end_critical_section(S_SUPPMSGMAIN);
4791
4792         fp = fopen(file_arcq_temp, "rb");
4793         if (fp == NULL) {
4794                 syslog(LOG_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
4795                 return(num_records_processed);
4796         }
4797
4798         while (fread(&arcq_rec, sizeof(struct arcq), 1, fp) == 1) {
4799                 TDAP_AdjRefCount(arcq_rec.arcq_msgnum, arcq_rec.arcq_delta);
4800                 ++num_records_processed;
4801         }
4802
4803         fclose(fp);
4804         r = unlink(file_arcq_temp);
4805         if (r != 0) {
4806                 syslog(LOG_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
4807         }
4808
4809         return(num_records_processed);
4810 }
4811
4812
4813
4814 /*
4815  * TDAP_AdjRefCount  -  adjust the reference count for a message.
4816  *                      This one does it "for real" because it's called by
4817  *                      the autopurger function that processes the queue
4818  *                      created by AdjRefCount().   If a message's reference
4819  *                      count becomes zero, we also delete the message from
4820  *                      disk and de-index it.
4821  */
4822 void TDAP_AdjRefCount(long msgnum, int incr)
4823 {
4824
4825         struct MetaData smi;
4826         long delnum;
4827
4828         /* This is a *tight* critical section; please keep it that way, as
4829          * it may get called while nested in other critical sections.
4830          * Complicating this any further will surely cause deadlock!
4831          */
4832         begin_critical_section(S_SUPPMSGMAIN);
4833         GetMetaData(&smi, msgnum);
4834         smi.meta_refcount += incr;
4835         PutMetaData(&smi);
4836         end_critical_section(S_SUPPMSGMAIN);
4837         syslog(LOG_DEBUG, "TDAP_AdjRefCount() msg %ld ref count delta %+d, is now %d\n",
4838                 msgnum, incr, smi.meta_refcount
4839         );
4840
4841         /* If the reference count is now zero, delete the message
4842          * (and its supplementary record as well).
4843          */
4844         if (smi.meta_refcount == 0) {
4845                 syslog(LOG_DEBUG, "Deleting message <%ld>\n", msgnum);
4846
4847                 /* Call delete hooks with NULL room to show it has gone altogether */
4848                 PerformDeleteHooks(NULL, msgnum);
4849
4850                 /* Remove from message base */
4851                 delnum = msgnum;
4852                 cdb_delete(CDB_MSGMAIN, &delnum, (int)sizeof(long));
4853                 cdb_delete(CDB_BIGMSGS, &delnum, (int)sizeof(long));
4854
4855                 /* Remove metadata record */
4856                 delnum = (0L - msgnum);
4857                 cdb_delete(CDB_MSGMAIN, &delnum, (int)sizeof(long));
4858         }
4859
4860 }
4861
4862 /*
4863  * Write a generic object to this room
4864  *
4865  * Note: this could be much more efficient.  Right now we use two temporary
4866  * files, and still pull the message into memory as with all others.
4867  */
4868 void CtdlWriteObject(char *req_room,                    /* Room to stuff it in */
4869                         char *content_type,             /* MIME type of this object */
4870                         char *raw_message,              /* Data to be written */
4871                         off_t raw_length,               /* Size of raw_message */
4872                         struct ctdluser *is_mailbox,    /* Mailbox room? */
4873                         int is_binary,                  /* Is encoding necessary? */
4874                         int is_unique,                  /* Del others of this type? */
4875                         unsigned int flags              /* Internal save flags */
4876                         )
4877 {
4878
4879         struct ctdlroom qrbuf;
4880         char roomname[ROOMNAMELEN];
4881         struct CtdlMessage *msg;
4882         char *encoded_message = NULL;
4883
4884         if (is_mailbox != NULL) {
4885                 CtdlMailboxName(roomname, sizeof roomname, is_mailbox, req_room);
4886         }
4887         else {
4888                 safestrncpy(roomname, req_room, sizeof(roomname));
4889         }
4890
4891         syslog(LOG_DEBUG, "Raw length is %ld\n", (long)raw_length);
4892
4893         if (is_binary) {
4894                 encoded_message = malloc((size_t) (((raw_length * 134) / 100) + 4096 ) );
4895         }
4896         else {
4897                 encoded_message = malloc((size_t)(raw_length + 4096));
4898         }
4899
4900         sprintf(encoded_message, "Content-type: %s\n", content_type);
4901
4902         if (is_binary) {
4903                 sprintf(&encoded_message[strlen(encoded_message)],
4904                         "Content-transfer-encoding: base64\n\n"
4905                 );
4906         }
4907         else {
4908                 sprintf(&encoded_message[strlen(encoded_message)],
4909                         "Content-transfer-encoding: 7bit\n\n"
4910                 );
4911         }
4912
4913         if (is_binary) {
4914                 CtdlEncodeBase64(
4915                         &encoded_message[strlen(encoded_message)],
4916                         raw_message,
4917                         (int)raw_length,
4918                         0
4919                 );
4920         }
4921         else {
4922                 memcpy(
4923                         &encoded_message[strlen(encoded_message)],
4924                         raw_message,
4925                         (int)(raw_length+1)
4926                 );
4927         }
4928
4929         syslog(LOG_DEBUG, "Allocating\n");
4930         msg = malloc(sizeof(struct CtdlMessage));
4931         memset(msg, 0, sizeof(struct CtdlMessage));
4932         msg->cm_magic = CTDLMESSAGE_MAGIC;
4933         msg->cm_anon_type = MES_NORMAL;
4934         msg->cm_format_type = 4;
4935         msg->cm_fields['A'] = strdup(CC->user.fullname);
4936         msg->cm_fields['O'] = strdup(req_room);
4937         msg->cm_fields['N'] = strdup(config.c_nodename);
4938         msg->cm_fields['H'] = strdup(config.c_humannode);
4939         msg->cm_flags = flags;
4940
4941         msg->cm_fields['M'] = encoded_message;
4942
4943         /* Create the requested room if we have to. */
4944         if (CtdlGetRoom(&qrbuf, roomname) != 0) {
4945                 CtdlCreateRoom(roomname,
4946                         ( (is_mailbox != NULL) ? 5 : 3 ),
4947                         "", 0, 1, 0, VIEW_BBS);
4948         }
4949         /* If the caller specified this object as unique, delete all
4950          * other objects of this type that are currently in the room.
4951          */
4952         if (is_unique) {
4953                 syslog(LOG_DEBUG, "Deleted %d other msgs of this type\n",
4954                         CtdlDeleteMessages(roomname, NULL, 0, content_type)
4955                 );
4956         }
4957         /* Now write the data */
4958         CtdlSubmitMsg(msg, NULL, roomname, 0);
4959         CtdlFreeMessage(msg);
4960 }
4961
4962
4963
4964
4965
4966
4967 void CtdlGetSysConfigBackend(long msgnum, void *userdata) {
4968         config_msgnum = msgnum;
4969 }
4970
4971
4972 char *CtdlGetSysConfig(char *sysconfname) {
4973         char hold_rm[ROOMNAMELEN];
4974         long msgnum;
4975         char *conf;
4976         struct CtdlMessage *msg;
4977         char buf[SIZ];
4978
4979         strcpy(hold_rm, CC->room.QRname);
4980         if (CtdlGetRoom(&CC->room, SYSCONFIGROOM) != 0) {
4981                 CtdlGetRoom(&CC->room, hold_rm);
4982                 return NULL;
4983         }
4984
4985
4986         /* We want the last (and probably only) config in this room */
4987         begin_critical_section(S_CONFIG);
4988         config_msgnum = (-1L);
4989         CtdlForEachMessage(MSGS_LAST, 1, NULL, sysconfname, NULL,
4990                 CtdlGetSysConfigBackend, NULL);
4991         msgnum = config_msgnum;
4992         end_critical_section(S_CONFIG);
4993
4994         if (msgnum < 0L) {
4995                 conf = NULL;
4996         }
4997         else {
4998                 msg = CtdlFetchMessage(msgnum, 1);
4999                 if (msg != NULL) {
5000                         conf = strdup(msg->cm_fields['M']);
5001                         CtdlFreeMessage(msg);
5002                 }
5003                 else {
5004                         conf = NULL;
5005                 }
5006         }
5007
5008         CtdlGetRoom(&CC->room, hold_rm);
5009
5010         if (conf != NULL) do {
5011                 extract_token(buf, conf, 0, '\n', sizeof buf);
5012                 strcpy(conf, &conf[strlen(buf)+1]);
5013         } while ( (!IsEmptyStr(conf)) && (!IsEmptyStr(buf)) );
5014
5015         return(conf);
5016 }
5017
5018
5019 void CtdlPutSysConfig(char *sysconfname, char *sysconfdata) {
5020         CtdlWriteObject(SYSCONFIGROOM, sysconfname, sysconfdata, (strlen(sysconfdata)+1), NULL, 0, 1, 0);
5021 }
5022
5023
5024 /*
5025  * Determine whether a given Internet address belongs to the current user
5026  */
5027 int CtdlIsMe(char *addr, int addr_buf_len)
5028 {
5029         struct recptypes *recp;
5030         int i;
5031
5032         recp = validate_recipients(addr, NULL, 0);
5033         if (recp == NULL) return(0);
5034
5035         if (recp->num_local == 0) {
5036                 free_recipients(recp);
5037                 return(0);
5038         }
5039
5040         for (i=0; i<recp->num_local; ++i) {
5041                 extract_token(addr, recp->recp_local, i, '|', addr_buf_len);
5042                 if (!strcasecmp(addr, CC->user.fullname)) {
5043                         free_recipients(recp);
5044                         return(1);
5045                 }
5046         }
5047
5048         free_recipients(recp);
5049         return(0);
5050 }
5051
5052
5053 /*
5054  * Citadel protocol command to do the same
5055  */
5056 void cmd_isme(char *argbuf) {
5057         char addr[256];
5058
5059         if (CtdlAccessCheck(ac_logged_in)) return;
5060         extract_token(addr, argbuf, 0, '|', sizeof addr);
5061
5062         if (CtdlIsMe(addr, sizeof addr)) {
5063                 cprintf("%d %s\n", CIT_OK, addr);
5064         }
5065         else {
5066                 cprintf("%d Not you.\n", ERROR + ILLEGAL_VALUE);
5067         }
5068
5069 }
5070
5071
5072 /*****************************************************************************/
5073 /*                      MODULE INITIALIZATION STUFF                          */
5074 /*****************************************************************************/
5075
5076 CTDL_MODULE_INIT(msgbase)
5077 {
5078         if (!threading) {
5079                 CtdlRegisterProtoHook(cmd_msgs, "MSGS", "Output a list of messages in the current room");
5080                 CtdlRegisterProtoHook(cmd_msg0, "MSG0", "Output a message in plain text format");
5081                 CtdlRegisterProtoHook(cmd_msg2, "MSG2", "Output a message in RFC822 format");
5082                 CtdlRegisterProtoHook(cmd_msg3, "MSG3", "Output a message in raw format (deprecated)");
5083                 CtdlRegisterProtoHook(cmd_msg4, "MSG4", "Output a message in the client's preferred format");
5084                 CtdlRegisterProtoHook(cmd_msgp, "MSGP", "Select preferred format for MSG4 output");
5085                 CtdlRegisterProtoHook(cmd_opna, "OPNA", "Open an attachment for download");
5086                 CtdlRegisterProtoHook(cmd_dlat, "DLAT", "Download an attachment");
5087                 CtdlRegisterProtoHook(cmd_ent0, "ENT0", "Enter a message");
5088                 CtdlRegisterProtoHook(cmd_dele, "DELE", "Delete a message");
5089                 CtdlRegisterProtoHook(cmd_move, "MOVE", "Move or copy a message to another room");
5090                 CtdlRegisterProtoHook(cmd_isme, "ISME", "Determine whether an email address belongs to a user");
5091         }
5092
5093         /* return our Subversion id for the Log */
5094         return "msgbase";
5095 }