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         char *hptr;
1927
1928         for (i = 0; i < 256; ++i) {
1929                 if (TheMessage->cm_fields[i]) {
1930                         mptr = mpptr = TheMessage->cm_fields[i];
1931
1932                         if (i == 'A') {
1933                                 safestrncpy(luser, mptr, sizeof_luser);
1934                                 safestrncpy(suser, mptr, sizeof_suser);
1935                         }
1936                         else if (i == 'Y') {
1937                                 if ((flags & QP_EADDR) != 0) {
1938                                         mptr = qp_encode_email_addrs(mptr);
1939                                 }
1940                                 sanitize_truncated_recipient(mptr);
1941                                 cprintf("CC: %s%s", mptr, nl);
1942                         }
1943                         else if (i == 'P') {
1944                                 cprintf("Return-Path: %s%s", mptr, nl);
1945                         }
1946                         else if (i == 'L') {
1947                                 cprintf("List-ID: %s%s", mptr, nl);
1948                         }
1949                         else if (i == 'V') {
1950                                 if ((flags & QP_EADDR) != 0)
1951                                         mptr = qp_encode_email_addrs(mptr);
1952                                 hptr = mptr;
1953                                 while ((*hptr != '\0') && isspace(*hptr))
1954                                         hptr ++;
1955                                 if (!IsEmptyStr(hptr))
1956                                         cprintf("Envelope-To: %s%s", hptr, nl);
1957                         }
1958                         else if (i == 'U') {
1959                                 cprintf("Subject: %s%s", mptr, nl);
1960                                 subject_found = 1;
1961                         }
1962                         else if (i == 'I')
1963                                 safestrncpy(mid, mptr, sizeof_mid); /// TODO: detect @ here and copy @nodename in if not found.
1964                         else if (i == 'F')
1965                                 safestrncpy(fuser, mptr, sizeof_fuser);
1966                         /* else if (i == 'O')
1967                            cprintf("X-Citadel-Room: %s%s",
1968                            mptr, nl); */
1969                         else if (i == 'N')
1970                                 safestrncpy(snode, mptr, sizeof_snode);
1971                         else if (i == 'R')
1972                         {
1973                                 if (haschar(mptr, '@') == 0)
1974                                 {
1975                                         sanitize_truncated_recipient(mptr);
1976                                         cprintf("To: %s@%s", mptr, config.c_fqdn);
1977                                         cprintf("%s", nl);
1978                                 }
1979                                 else
1980                                 {
1981                                         if ((flags & QP_EADDR) != 0) {
1982                                                 mptr = qp_encode_email_addrs(mptr);
1983                                         }
1984                                         sanitize_truncated_recipient(mptr);
1985                                         cprintf("To: %s", mptr);
1986                                         cprintf("%s", nl);
1987                                 }
1988                         }
1989                         else if (i == 'T') {
1990                                 datestring(datestamp, sizeof datestamp,
1991                                            atol(mptr), DATESTRING_RFC822);
1992                                 cprintf("Date: %s%s", datestamp, nl);
1993                         }
1994                         else if (i == 'W') {
1995                                 cprintf("References: ");
1996                                 k = num_tokens(mptr, '|');
1997                                 for (j=0; j<k; ++j) {
1998                                         extract_token(buf, mptr, j, '|', sizeof buf);
1999                                         cprintf("<%s>", buf);
2000                                         if (j == (k-1)) {
2001                                                 cprintf("%s", nl);
2002                                         }
2003                                         else {
2004                                                 cprintf(" ");
2005                                         }
2006                                 }
2007                         }
2008                         else if (i == 'K') {
2009                                 hptr = mptr;
2010                                 while ((*hptr != '\0') && isspace(*hptr))
2011                                         hptr ++;
2012                                 if (!IsEmptyStr(hptr))
2013                                         cprintf("Reply-To: %s%s", mptr, nl);
2014                         }
2015                         if (mptr != mpptr)
2016                                 free (mptr);
2017                 }
2018         }
2019         if (subject_found == 0) {
2020                 cprintf("Subject: (no subject)%s", nl);
2021         }
2022 }
2023
2024
2025 void Dump_RFC822HeadersBody(
2026         struct CtdlMessage *TheMessage,
2027         int headers_only,       /* eschew the message body? */
2028         int flags,              /* should the bessage be exported clean? */
2029
2030         const char *nl)
2031 {
2032         cit_uint8_t prev_ch;
2033         int eoh = 0;
2034         const char *StartOfText = StrBufNOTNULL;
2035         char outbuf[1024];
2036         int outlen = 0;
2037         int nllen = strlen(nl);
2038         char *mptr;
2039
2040         mptr = TheMessage->cm_fields['M'];
2041
2042
2043         prev_ch = '\0';
2044         while (*mptr != '\0') {
2045                 if (*mptr == '\r') {
2046                         /* do nothing */
2047                 }
2048                 else {
2049                         if ((!eoh) &&
2050                             (*mptr == '\n'))
2051                         {
2052                                 eoh = (*(mptr+1) == '\r') && (*(mptr+2) == '\n');
2053                                 if (!eoh)
2054                                         eoh = *(mptr+1) == '\n';
2055                                 if (eoh)
2056                                 {
2057                                         StartOfText = mptr;
2058                                         StartOfText = strchr(StartOfText, '\n');
2059                                         StartOfText = strchr(StartOfText, '\n');
2060                                 }
2061                         }
2062                         if (((headers_only == HEADERS_NONE) && (mptr >= StartOfText)) ||
2063                             ((headers_only == HEADERS_ONLY) && (mptr < StartOfText)) ||
2064                             ((headers_only != HEADERS_NONE) &&
2065                              (headers_only != HEADERS_ONLY))
2066                                 ) {
2067                                 if (*mptr == '\n') {
2068                                         memcpy(&outbuf[outlen], nl, nllen);
2069                                         outlen += nllen;
2070                                         outbuf[outlen] = '\0';
2071                                 }
2072                                 else {
2073                                         outbuf[outlen++] = *mptr;
2074                                 }
2075                         }
2076                 }
2077                 if (flags & ESC_DOT)
2078                 {
2079                         if ((prev_ch == '\n') &&
2080                             (*mptr == '.') &&
2081                             ((*(mptr+1) == '\r') || (*(mptr+1) == '\n')))
2082                         {
2083                                 outbuf[outlen++] = '.';
2084                         }
2085                         prev_ch = *mptr;
2086                 }
2087                 ++mptr;
2088                 if (outlen > 1000) {
2089                         client_write(outbuf, outlen);
2090                         outlen = 0;
2091                 }
2092         }
2093         if (outlen > 0) {
2094                 client_write(outbuf, outlen);
2095                 outlen = 0;
2096         }
2097 }
2098
2099
2100
2101 /* If the format type on disk is 1 (fixed-format), then we want
2102  * everything to be output completely literally ... regardless of
2103  * what message transfer format is in use.
2104  */
2105 void DumpFormatFixed(
2106         struct CtdlMessage *TheMessage,
2107         int mode,               /* how would you like that message? */
2108         const char *nl)
2109 {
2110         cit_uint8_t ch;
2111         char buf[SIZ];
2112         int buflen;
2113         int xlline = 0;
2114         int nllen = strlen (nl);
2115         char *mptr;
2116
2117         mptr = TheMessage->cm_fields['M'];
2118
2119         if (mode == MT_MIME) {
2120                 cprintf("Content-type: text/plain\n\n");
2121         }
2122         *buf = '\0';
2123         buflen = 0;
2124         while (ch = *mptr++, ch > 0) {
2125                 if (ch == '\n')
2126                         ch = '\r';
2127
2128                 if ((buflen > 250) && (!xlline)){
2129                         int tbuflen;
2130                         tbuflen = buflen;
2131
2132                         while ((buflen > 0) &&
2133                                (!isspace(buf[buflen])))
2134                                 buflen --;
2135                         if (buflen == 0) {
2136                                 xlline = 1;
2137                         }
2138                         else {
2139                                 mptr -= tbuflen - buflen;
2140                                 buf[buflen] = '\0';
2141                                 ch = '\r';
2142                         }
2143                 }
2144                 /* if we reach the outer bounds of our buffer,
2145                    abort without respect what whe purge. */
2146                 if (xlline &&
2147                     ((isspace(ch)) ||
2148                      (buflen > SIZ - nllen - 2)))
2149                         ch = '\r';
2150
2151                 if (ch == '\r') {
2152                         memcpy (&buf[buflen], nl, nllen);
2153                         buflen += nllen;
2154                         buf[buflen] = '\0';
2155
2156                         client_write(buf, buflen);
2157                         *buf = '\0';
2158                         buflen = 0;
2159                         xlline = 0;
2160                 } else {
2161                         buf[buflen] = ch;
2162                         buflen++;
2163                 }
2164         }
2165         buf[buflen] = '\0';
2166         if (!IsEmptyStr(buf))
2167                 cprintf("%s%s", buf, nl);
2168 }
2169
2170 /*
2171  * Get a message off disk.  (returns om_* values found in msgbase.h)
2172  */
2173 int CtdlOutputPreLoadedMsg(
2174                 struct CtdlMessage *TheMessage,
2175                 int mode,               /* how would you like that message? */
2176                 int headers_only,       /* eschew the message body? */
2177                 int do_proto,           /* do Citadel protocol responses? */
2178                 int crlf,               /* Use CRLF newlines instead of LF? */
2179                 int flags               /* should the bessage be exported clean? */
2180 ) {
2181         int i;
2182         char *mptr = NULL;
2183         const char *nl; /* newline string */
2184         struct ma_info ma;
2185
2186         /* Buffers needed for RFC822 translation.  These are all filled
2187          * using functions that are bounds-checked, and therefore we can
2188          * make them substantially smaller than SIZ.
2189          */
2190         char suser[100];
2191         char luser[100];
2192         char fuser[100];
2193         char snode[100];
2194         char mid[100];
2195
2196         syslog(LOG_DEBUG, "CtdlOutputPreLoadedMsg(TheMessage=%s, %d, %d, %d, %d\n",
2197                 ((TheMessage == NULL) ? "NULL" : "not null"),
2198                 mode, headers_only, do_proto, crlf);
2199
2200         strcpy(mid, "unknown");
2201         nl = (crlf ? "\r\n" : "\n");
2202
2203         if (!is_valid_message(TheMessage)) {
2204                 syslog(LOG_ERR,
2205                         "ERROR: invalid preloaded message for output\n");
2206                 cit_backtrace ();
2207                 return(om_no_such_msg);
2208         }
2209
2210         /* Suppress envelope recipients if required to avoid disclosing BCC addresses.
2211          * Pad it with spaces in order to avoid changing the RFC822 length of the message.
2212          */
2213         if ( (flags & SUPPRESS_ENV_TO) && (TheMessage->cm_fields['V'] != NULL) ) {
2214                 memset(TheMessage->cm_fields['V'], ' ', strlen(TheMessage->cm_fields['V']));
2215         }
2216
2217         /* Are we downloading a MIME component? */
2218         if (mode == MT_DOWNLOAD) {
2219                 if (TheMessage->cm_format_type != FMT_RFC822) {
2220                         if (do_proto)
2221                                 cprintf("%d This is not a MIME message.\n",
2222                                 ERROR + ILLEGAL_VALUE);
2223                 } else if (CC->download_fp != NULL) {
2224                         if (do_proto) cprintf(
2225                                 "%d You already have a download open.\n",
2226                                 ERROR + RESOURCE_BUSY);
2227                 } else {
2228                         /* Parse the message text component */
2229                         mptr = TheMessage->cm_fields['M'];
2230                         mime_parser(mptr, NULL, *mime_download, NULL, NULL, NULL, 0);
2231                         /* If there's no file open by this time, the requested
2232                          * section wasn't found, so print an error
2233                          */
2234                         if (CC->download_fp == NULL) {
2235                                 if (do_proto) cprintf(
2236                                         "%d Section %s not found.\n",
2237                                         ERROR + FILE_NOT_FOUND,
2238                                         CC->download_desired_section);
2239                         }
2240                 }
2241                 return((CC->download_fp != NULL) ? om_ok : om_mime_error);
2242         }
2243
2244         /* MT_SPEW_SECTION is like MT_DOWNLOAD except it outputs the whole MIME part
2245          * in a single server operation instead of opening a download file.
2246          */
2247         if (mode == MT_SPEW_SECTION) {
2248                 if (TheMessage->cm_format_type != FMT_RFC822) {
2249                         if (do_proto)
2250                                 cprintf("%d This is not a MIME message.\n",
2251                                 ERROR + ILLEGAL_VALUE);
2252                 } else {
2253                         /* Parse the message text component */
2254                         int found_it = 0;
2255
2256                         mptr = TheMessage->cm_fields['M'];
2257                         mime_parser(mptr, NULL, *mime_spew_section, NULL, NULL, (void *)&found_it, 0);
2258                         /* If section wasn't found, print an error
2259                          */
2260                         if (!found_it) {
2261                                 if (do_proto) cprintf(
2262                                         "%d Section %s not found.\n",
2263                                         ERROR + FILE_NOT_FOUND,
2264                                         CC->download_desired_section);
2265                         }
2266                 }
2267                 return((CC->download_fp != NULL) ? om_ok : om_mime_error);
2268         }
2269
2270         /* now for the user-mode message reading loops */
2271         if (do_proto) cprintf("%d msg:\n", LISTING_FOLLOWS);
2272
2273         /* Does the caller want to skip the headers? */
2274         if (headers_only == HEADERS_NONE) goto START_TEXT;
2275
2276         /* Tell the client which format type we're using. */
2277         if ( (mode == MT_CITADEL) && (do_proto) ) {
2278                 cprintf("type=%d\n", TheMessage->cm_format_type);
2279         }
2280
2281         /* nhdr=yes means that we're only displaying headers, no body */
2282         if ( (TheMessage->cm_anon_type == MES_ANONONLY)
2283            && ((mode == MT_CITADEL) || (mode == MT_MIME))
2284            && (do_proto)
2285            ) {
2286                 cprintf("nhdr=yes\n");
2287         }
2288
2289         if ((mode == MT_CITADEL) || (mode == MT_MIME))
2290                 OutputCtdlMsgHeaders(TheMessage, do_proto);
2291
2292
2293         /* begin header processing loop for RFC822 transfer format */
2294         strcpy(suser, "");
2295         strcpy(luser, "");
2296         strcpy(fuser, "");
2297         strcpy(snode, NODENAME);
2298         if (mode == MT_RFC822)
2299                 OutputRFC822MsgHeaders(
2300                         TheMessage,
2301                         flags,
2302                         nl,
2303                         mid, sizeof(mid),
2304                         suser, sizeof(suser),
2305                         luser, sizeof(luser),
2306                         fuser, sizeof(fuser),
2307                         snode, sizeof(snode)
2308                         );
2309
2310
2311         for (i=0; !IsEmptyStr(&suser[i]); ++i) {
2312                 suser[i] = tolower(suser[i]);
2313                 if (!isalnum(suser[i])) suser[i]='_';
2314         }
2315
2316         if (mode == MT_RFC822) {
2317                 if (!strcasecmp(snode, NODENAME)) {
2318                         safestrncpy(snode, FQDN, sizeof snode);
2319                 }
2320
2321                 /* Construct a fun message id */
2322                 cprintf("Message-ID: <%s", mid);/// todo: this possibly breaks threadding mails.
2323                 if (strchr(mid, '@')==NULL) {
2324                         cprintf("@%s", snode);
2325                 }
2326                 cprintf(">%s", nl);
2327
2328                 if (!is_room_aide() && (TheMessage->cm_anon_type == MES_ANONONLY)) {
2329                         cprintf("From: \"----\" <x@x.org>%s", nl);
2330                 }
2331                 else if (!is_room_aide() && (TheMessage->cm_anon_type == MES_ANONOPT)) {
2332                         cprintf("From: \"anonymous\" <x@x.org>%s", nl);
2333                 }
2334                 else if (!IsEmptyStr(fuser)) {
2335                         cprintf("From: \"%s\" <%s>%s", luser, fuser, nl);
2336                 }
2337                 else {
2338                         cprintf("From: \"%s\" <%s@%s>%s", luser, suser, snode, nl);
2339                 }
2340
2341                 /* Blank line signifying RFC822 end-of-headers */
2342                 if (TheMessage->cm_format_type != FMT_RFC822) {
2343                         cprintf("%s", nl);
2344                 }
2345         }
2346
2347         /* end header processing loop ... at this point, we're in the text */
2348 START_TEXT:
2349         if (headers_only == HEADERS_FAST) goto DONE;
2350
2351         /* Tell the client about the MIME parts in this message */
2352         if (TheMessage->cm_format_type == FMT_RFC822) {
2353                 if ( (mode == MT_CITADEL) || (mode == MT_MIME) ) {
2354                         mptr = TheMessage->cm_fields['M'];
2355                         memset(&ma, 0, sizeof(struct ma_info));
2356                         mime_parser(mptr, NULL,
2357                                 (do_proto ? *list_this_part : NULL),
2358                                 (do_proto ? *list_this_pref : NULL),
2359                                 (do_proto ? *list_this_suff : NULL),
2360                                 (void *)&ma, 1);
2361                 }
2362                 else if (mode == MT_RFC822) {   /* unparsed RFC822 dump */
2363                         Dump_RFC822HeadersBody(
2364                                 TheMessage,
2365                                 headers_only,
2366                                 flags,
2367                                 nl);
2368                         goto DONE;
2369                 }
2370         }
2371
2372         if (headers_only == HEADERS_ONLY) {
2373                 goto DONE;
2374         }
2375
2376         /* signify start of msg text */
2377         if ( (mode == MT_CITADEL) || (mode == MT_MIME) ) {
2378                 if (do_proto) cprintf("text\n");
2379         }
2380
2381         if (TheMessage->cm_format_type == FMT_FIXED)
2382                 DumpFormatFixed(
2383                         TheMessage,
2384                         mode,           /* how would you like that message? */
2385                         nl);
2386
2387         /* If the message on disk is format 0 (Citadel vari-format), we
2388          * output using the formatter at 80 columns.  This is the final output
2389          * form if the transfer format is RFC822, but if the transfer format
2390          * is Citadel proprietary, it'll still work, because the indentation
2391          * for new paragraphs is correct and the client will reformat the
2392          * message to the reader's screen width.
2393          */
2394         if (TheMessage->cm_format_type == FMT_CITADEL) {
2395                 mptr = TheMessage->cm_fields['M'];
2396
2397                 if (mode == MT_MIME) {
2398                         cprintf("Content-type: text/x-citadel-variformat\n\n");
2399                 }
2400                 memfmout(mptr, nl);
2401         }
2402
2403         /* If the message on disk is format 4 (MIME), we've gotta hand it
2404          * off to the MIME parser.  The client has already been told that
2405          * this message is format 1 (fixed format), so the callback function
2406          * we use will display those parts as-is.
2407          */
2408         if (TheMessage->cm_format_type == FMT_RFC822) {
2409                 memset(&ma, 0, sizeof(struct ma_info));
2410
2411                 if (mode == MT_MIME) {
2412                         ma.use_fo_hooks = 0;
2413                         strcpy(ma.chosen_part, "1");
2414                         ma.chosen_pref = 9999;
2415                         ma.dont_decode = CC->msg4_dont_decode;
2416                         mime_parser(mptr, NULL,
2417                                 *choose_preferred, *fixed_output_pre,
2418                                 *fixed_output_post, (void *)&ma, 1);
2419                         mime_parser(mptr, NULL,
2420                                 *output_preferred, NULL, NULL, (void *)&ma, 1);
2421                 }
2422                 else {
2423                         ma.use_fo_hooks = 1;
2424                         mime_parser(mptr, NULL,
2425                                 *fixed_output, *fixed_output_pre,
2426                                 *fixed_output_post, (void *)&ma, 0);
2427                 }
2428
2429         }
2430
2431 DONE:   /* now we're done */
2432         if (do_proto) cprintf("000\n");
2433         return(om_ok);
2434 }
2435
2436
2437 /*
2438  * display a message (mode 0 - Citadel proprietary)
2439  */
2440 void cmd_msg0(char *cmdbuf)
2441 {
2442         long msgid;
2443         int headers_only = HEADERS_ALL;
2444
2445         msgid = extract_long(cmdbuf, 0);
2446         headers_only = extract_int(cmdbuf, 1);
2447
2448         CtdlOutputMsg(msgid, MT_CITADEL, headers_only, 1, 0, NULL, 0);
2449         return;
2450 }
2451
2452
2453 /*
2454  * display a message (mode 2 - RFC822)
2455  */
2456 void cmd_msg2(char *cmdbuf)
2457 {
2458         long msgid;
2459         int headers_only = HEADERS_ALL;
2460
2461         msgid = extract_long(cmdbuf, 0);
2462         headers_only = extract_int(cmdbuf, 1);
2463
2464         CtdlOutputMsg(msgid, MT_RFC822, headers_only, 1, 1, NULL, 0);
2465 }
2466
2467
2468
2469 /*
2470  * display a message (mode 3 - IGnet raw format - internal programs only)
2471  */
2472 void cmd_msg3(char *cmdbuf)
2473 {
2474         long msgnum;
2475         struct CtdlMessage *msg = NULL;
2476         struct ser_ret smr;
2477
2478         if (CC->internal_pgm == 0) {
2479                 cprintf("%d This command is for internal programs only.\n",
2480                         ERROR + HIGHER_ACCESS_REQUIRED);
2481                 return;
2482         }
2483
2484         msgnum = extract_long(cmdbuf, 0);
2485         msg = CtdlFetchMessage(msgnum, 1);
2486         if (msg == NULL) {
2487                 cprintf("%d Message %ld not found.\n",
2488                         ERROR + MESSAGE_NOT_FOUND, msgnum);
2489                 return;
2490         }
2491
2492         serialize_message(&smr, msg);
2493         CtdlFreeMessage(msg);
2494
2495         if (smr.len == 0) {
2496                 cprintf("%d Unable to serialize message\n",
2497                         ERROR + INTERNAL_ERROR);
2498                 return;
2499         }
2500
2501         cprintf("%d %ld\n", BINARY_FOLLOWS, (long)smr.len);
2502         client_write((char *)smr.ser, (int)smr.len);
2503         free(smr.ser);
2504 }
2505
2506
2507
2508 /*
2509  * Display a message using MIME content types
2510  */
2511 void cmd_msg4(char *cmdbuf)
2512 {
2513         long msgid;
2514         char section[64];
2515
2516         msgid = extract_long(cmdbuf, 0);
2517         extract_token(section, cmdbuf, 1, '|', sizeof section);
2518         CtdlOutputMsg(msgid, MT_MIME, 0, 1, 0, (section[0] ? section : NULL) , 0);
2519 }
2520
2521
2522
2523 /*
2524  * Client tells us its preferred message format(s)
2525  */
2526 void cmd_msgp(char *cmdbuf)
2527 {
2528         if (!strcasecmp(cmdbuf, "dont_decode")) {
2529                 CC->msg4_dont_decode = 1;
2530                 cprintf("%d MSG4 will not pre-decode messages.\n", CIT_OK);
2531         }
2532         else {
2533                 safestrncpy(CC->preferred_formats, cmdbuf, sizeof(CC->preferred_formats));
2534                 cprintf("%d Preferred MIME formats have been set.\n", CIT_OK);
2535         }
2536 }
2537
2538
2539 /*
2540  * Open a component of a MIME message as a download file
2541  */
2542 void cmd_opna(char *cmdbuf)
2543 {
2544         long msgid;
2545         char desired_section[128];
2546
2547         msgid = extract_long(cmdbuf, 0);
2548         extract_token(desired_section, cmdbuf, 1, '|', sizeof desired_section);
2549         safestrncpy(CC->download_desired_section, desired_section,
2550                 sizeof CC->download_desired_section);
2551         CtdlOutputMsg(msgid, MT_DOWNLOAD, 0, 1, 1, NULL, 0);
2552 }
2553
2554
2555 /*
2556  * Open a component of a MIME message and transmit it all at once
2557  */
2558 void cmd_dlat(char *cmdbuf)
2559 {
2560         long msgid;
2561         char desired_section[128];
2562
2563         msgid = extract_long(cmdbuf, 0);
2564         extract_token(desired_section, cmdbuf, 1, '|', sizeof desired_section);
2565         safestrncpy(CC->download_desired_section, desired_section,
2566                 sizeof CC->download_desired_section);
2567         CtdlOutputMsg(msgid, MT_SPEW_SECTION, 0, 1, 1, NULL, 0);
2568 }
2569
2570
2571 /*
2572  * Save one or more message pointers into a specified room
2573  * (Returns 0 for success, nonzero for failure)
2574  * roomname may be NULL to use the current room
2575  *
2576  * Note that the 'supplied_msg' field may be set to NULL, in which case
2577  * the message will be fetched from disk, by number, if we need to perform
2578  * replication checks.  This adds an additional database read, so if the
2579  * caller already has the message in memory then it should be supplied.  (Obviously
2580  * this mode of operation only works if we're saving a single message.)
2581  */
2582 int CtdlSaveMsgPointersInRoom(char *roomname, long newmsgidlist[], int num_newmsgs,
2583                         int do_repl_check, struct CtdlMessage *supplied_msg, int suppress_refcount_adj
2584 ) {
2585         int i, j, unique;
2586         char hold_rm[ROOMNAMELEN];
2587         struct cdbdata *cdbfr;
2588         int num_msgs;
2589         long *msglist;
2590         long highest_msg = 0L;
2591
2592         long msgid = 0;
2593         struct CtdlMessage *msg = NULL;
2594
2595         long *msgs_to_be_merged = NULL;
2596         int num_msgs_to_be_merged = 0;
2597
2598         syslog(LOG_DEBUG,
2599                 "CtdlSaveMsgPointersInRoom(room=%s, num_msgs=%d, repl=%d, suppress_rca=%d)\n",
2600                 roomname, num_newmsgs, do_repl_check, suppress_refcount_adj
2601         );
2602
2603         strcpy(hold_rm, CC->room.QRname);
2604
2605         /* Sanity checks */
2606         if (newmsgidlist == NULL) return(ERROR + INTERNAL_ERROR);
2607         if (num_newmsgs < 1) return(ERROR + INTERNAL_ERROR);
2608         if (num_newmsgs > 1) supplied_msg = NULL;
2609
2610         /* Now the regular stuff */
2611         if (CtdlGetRoomLock(&CC->room,
2612            ((roomname != NULL) ? roomname : CC->room.QRname) )
2613            != 0) {
2614                 syslog(LOG_ERR, "No such room <%s>\n", roomname);
2615                 return(ERROR + ROOM_NOT_FOUND);
2616         }
2617
2618
2619         msgs_to_be_merged = malloc(sizeof(long) * num_newmsgs);
2620         num_msgs_to_be_merged = 0;
2621
2622
2623         cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
2624         if (cdbfr == NULL) {
2625                 msglist = NULL;
2626                 num_msgs = 0;
2627         } else {
2628                 msglist = (long *) cdbfr->ptr;
2629                 cdbfr->ptr = NULL;      /* CtdlSaveMsgPointerInRoom() now owns this memory */
2630                 num_msgs = cdbfr->len / sizeof(long);
2631                 cdb_free(cdbfr);
2632         }
2633
2634
2635         /* Create a list of msgid's which were supplied by the caller, but do
2636          * not already exist in the target room.  It is absolutely taboo to
2637          * have more than one reference to the same message in a room.
2638          */
2639         for (i=0; i<num_newmsgs; ++i) {
2640                 unique = 1;
2641                 if (num_msgs > 0) for (j=0; j<num_msgs; ++j) {
2642                         if (msglist[j] == newmsgidlist[i]) {
2643                                 unique = 0;
2644                         }
2645                 }
2646                 if (unique) {
2647                         msgs_to_be_merged[num_msgs_to_be_merged++] = newmsgidlist[i];
2648                 }
2649         }
2650
2651         syslog(LOG_DEBUG, "%d unique messages to be merged\n", num_msgs_to_be_merged);
2652
2653         /*
2654          * Now merge the new messages
2655          */
2656         msglist = realloc(msglist, (sizeof(long) * (num_msgs + num_msgs_to_be_merged)) );
2657         if (msglist == NULL) {
2658                 syslog(LOG_ALERT, "ERROR: can't realloc message list!\n");
2659         }
2660         memcpy(&msglist[num_msgs], msgs_to_be_merged, (sizeof(long) * num_msgs_to_be_merged) );
2661         num_msgs += num_msgs_to_be_merged;
2662
2663         /* Sort the message list, so all the msgid's are in order */
2664         num_msgs = sort_msglist(msglist, num_msgs);
2665
2666         /* Determine the highest message number */
2667         highest_msg = msglist[num_msgs - 1];
2668
2669         /* Write it back to disk. */
2670         cdb_store(CDB_MSGLISTS, &CC->room.QRnumber, (int)sizeof(long),
2671                   msglist, (int)(num_msgs * sizeof(long)));
2672
2673         /* Free up the memory we used. */
2674         free(msglist);
2675
2676         /* Update the highest-message pointer and unlock the room. */
2677         CC->room.QRhighest = highest_msg;
2678         CtdlPutRoomLock(&CC->room);
2679
2680         /* Perform replication checks if necessary */
2681         if ( (DoesThisRoomNeedEuidIndexing(&CC->room)) && (do_repl_check) ) {
2682                 syslog(LOG_DEBUG, "CtdlSaveMsgPointerInRoom() doing repl checks\n");
2683
2684                 for (i=0; i<num_msgs_to_be_merged; ++i) {
2685                         msgid = msgs_to_be_merged[i];
2686
2687                         if (supplied_msg != NULL) {
2688                                 msg = supplied_msg;
2689                         }
2690                         else {
2691                                 msg = CtdlFetchMessage(msgid, 0);
2692                         }
2693
2694                         if (msg != NULL) {
2695                                 ReplicationChecks(msg);
2696
2697                                 /* If the message has an Exclusive ID, index that... */
2698                                 if (msg->cm_fields['E'] != NULL) {
2699                                         index_message_by_euid(msg->cm_fields['E'], &CC->room, msgid);
2700                                 }
2701
2702                                 /* Free up the memory we may have allocated */
2703                                 if (msg != supplied_msg) {
2704                                         CtdlFreeMessage(msg);
2705                                 }
2706                         }
2707
2708                 }
2709         }
2710
2711         else {
2712                 syslog(LOG_DEBUG, "CtdlSaveMsgPointerInRoom() skips repl checks\n");
2713         }
2714
2715         /* Submit this room for processing by hooks */
2716         PerformRoomHooks(&CC->room);
2717
2718         /* Go back to the room we were in before we wandered here... */
2719         CtdlGetRoom(&CC->room, hold_rm);
2720
2721         /* Bump the reference count for all messages which were merged */
2722         if (!suppress_refcount_adj) {
2723                 for (i=0; i<num_msgs_to_be_merged; ++i) {
2724                         AdjRefCount(msgs_to_be_merged[i], +1);
2725                 }
2726         }
2727
2728         /* Free up memory... */
2729         if (msgs_to_be_merged != NULL) {
2730                 free(msgs_to_be_merged);
2731         }
2732
2733         /* Return success. */
2734         return (0);
2735 }
2736
2737
2738 /*
2739  * This is the same as CtdlSaveMsgPointersInRoom() but it only accepts
2740  * a single message.
2741  */
2742 int CtdlSaveMsgPointerInRoom(char *roomname, long msgid,
2743                         int do_repl_check, struct CtdlMessage *supplied_msg)
2744 {
2745         return CtdlSaveMsgPointersInRoom(roomname, &msgid, 1, do_repl_check, supplied_msg, 0);
2746 }
2747
2748
2749
2750
2751 /*
2752  * Message base operation to save a new message to the message store
2753  * (returns new message number)
2754  *
2755  * This is the back end for CtdlSubmitMsg() and should not be directly
2756  * called by server-side modules.
2757  *
2758  */
2759 long send_message(struct CtdlMessage *msg) {
2760         long newmsgid;
2761         long retval;
2762         char msgidbuf[256];
2763         struct ser_ret smr;
2764         int is_bigmsg = 0;
2765         char *holdM = NULL;
2766
2767         /* Get a new message number */
2768         newmsgid = get_new_message_number();
2769         snprintf(msgidbuf, sizeof msgidbuf, "%08lX-%08lX@%s",
2770                 (long unsigned int) time(NULL),
2771                 (long unsigned int) newmsgid,
2772                 config.c_fqdn
2773         );
2774
2775         /* Generate an ID if we don't have one already */
2776         if (msg->cm_fields['I']==NULL) {
2777                 msg->cm_fields['I'] = strdup(msgidbuf);
2778         }
2779
2780         /* If the message is big, set its body aside for storage elsewhere */
2781         if (msg->cm_fields['M'] != NULL) {
2782                 if (strlen(msg->cm_fields['M']) > BIGMSG) {
2783                         is_bigmsg = 1;
2784                         holdM = msg->cm_fields['M'];
2785                         msg->cm_fields['M'] = NULL;
2786                 }
2787         }
2788
2789         /* Serialize our data structure for storage in the database */
2790         serialize_message(&smr, msg);
2791
2792         if (is_bigmsg) {
2793                 msg->cm_fields['M'] = holdM;
2794         }
2795
2796         if (smr.len == 0) {
2797                 cprintf("%d Unable to serialize message\n",
2798                         ERROR + INTERNAL_ERROR);
2799                 return (-1L);
2800         }
2801
2802         /* Write our little bundle of joy into the message base */
2803         if (cdb_store(CDB_MSGMAIN, &newmsgid, (int)sizeof(long),
2804                       smr.ser, smr.len) < 0) {
2805                 syslog(LOG_ERR, "Can't store message\n");
2806                 retval = 0L;
2807         } else {
2808                 if (is_bigmsg) {
2809                         cdb_store(CDB_BIGMSGS,
2810                                 &newmsgid,
2811                                 (int)sizeof(long),
2812                                 holdM,
2813                                 (strlen(holdM) + 1)
2814                         );
2815                 }
2816                 retval = newmsgid;
2817         }
2818
2819         /* Free the memory we used for the serialized message */
2820         free(smr.ser);
2821
2822         /* Return the *local* message ID to the caller
2823          * (even if we're storing an incoming network message)
2824          */
2825         return(retval);
2826 }
2827
2828
2829
2830 /*
2831  * Serialize a struct CtdlMessage into the format used on disk and network.
2832  *
2833  * This function loads up a "struct ser_ret" (defined in server.h) which
2834  * contains the length of the serialized message and a pointer to the
2835  * serialized message in memory.  THE LATTER MUST BE FREED BY THE CALLER.
2836  */
2837 void serialize_message(struct ser_ret *ret,             /* return values */
2838                         struct CtdlMessage *msg)        /* unserialized msg */
2839 {
2840         size_t wlen, fieldlen;
2841         int i;
2842         static char *forder = FORDER;
2843
2844         /*
2845          * Check for valid message format
2846          */
2847         if (is_valid_message(msg) == 0) {
2848                 syslog(LOG_ERR, "serialize_message() aborting due to invalid message\n");
2849                 ret->len = 0;
2850                 ret->ser = NULL;
2851                 return;
2852         }
2853
2854         ret->len = 3;
2855         for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL)
2856                 ret->len = ret->len +
2857                         strlen(msg->cm_fields[(int)forder[i]]) + 2;
2858
2859         ret->ser = malloc(ret->len);
2860         if (ret->ser == NULL) {
2861                 syslog(LOG_ERR, "serialize_message() malloc(%ld) failed: %s\n",
2862                         (long)ret->len, strerror(errno));
2863                 ret->len = 0;
2864                 ret->ser = NULL;
2865                 return;
2866         }
2867
2868         ret->ser[0] = 0xFF;
2869         ret->ser[1] = msg->cm_anon_type;
2870         ret->ser[2] = msg->cm_format_type;
2871         wlen = 3;
2872
2873         for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL) {
2874                 fieldlen = strlen(msg->cm_fields[(int)forder[i]]);
2875                 ret->ser[wlen++] = (char)forder[i];
2876                 safestrncpy((char *)&ret->ser[wlen], msg->cm_fields[(int)forder[i]], fieldlen+1);
2877                 wlen = wlen + fieldlen + 1;
2878         }
2879         if (ret->len != wlen) syslog(LOG_ERR, "ERROR: len=%ld wlen=%ld\n",
2880                 (long)ret->len, (long)wlen);
2881
2882         return;
2883 }
2884
2885
2886 /*
2887  * Serialize a struct CtdlMessage into the format used on disk and network.
2888  *
2889  * This function loads up a "struct ser_ret" (defined in server.h) which
2890  * contains the length of the serialized message and a pointer to the
2891  * serialized message in memory.  THE LATTER MUST BE FREED BY THE CALLER.
2892  */
2893 void dump_message(struct CtdlMessage *msg,      /* unserialized msg */
2894                   long Siz)                     /* how many chars ? */
2895 {
2896         size_t wlen;
2897         int i;
2898         static char *forder = FORDER;
2899         char *buf;
2900
2901         /*
2902          * Check for valid message format
2903          */
2904         if (is_valid_message(msg) == 0) {
2905                 syslog(LOG_ERR, "dump_message() aborting due to invalid message\n");
2906                 return;
2907         }
2908
2909         buf = (char*) malloc (Siz + 1);
2910
2911         wlen = 3;
2912
2913         for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL) {
2914                         snprintf (buf, Siz, " msg[%c] = %s ...\n", (char) forder[i],
2915                                    msg->cm_fields[(int)forder[i]]);
2916                         client_write (buf, strlen(buf));
2917                 }
2918
2919         return;
2920 }
2921
2922
2923
2924 /*
2925  * Check to see if any messages already exist in the current room which
2926  * carry the same Exclusive ID as this one.  If any are found, delete them.
2927  */
2928 void ReplicationChecks(struct CtdlMessage *msg) {
2929         long old_msgnum = (-1L);
2930
2931         if (DoesThisRoomNeedEuidIndexing(&CC->room) == 0) return;
2932
2933         syslog(LOG_DEBUG, "Performing replication checks in <%s>\n",
2934                 CC->room.QRname);
2935
2936         /* No exclusive id?  Don't do anything. */
2937         if (msg == NULL) return;
2938         if (msg->cm_fields['E'] == NULL) return;
2939         if (IsEmptyStr(msg->cm_fields['E'])) return;
2940         /*syslog(LOG_DEBUG, "Exclusive ID: <%s> for room <%s>\n",
2941                 msg->cm_fields['E'], CC->room.QRname);*/
2942
2943         old_msgnum = CtdlLocateMessageByEuid(msg->cm_fields['E'], &CC->room);
2944         if (old_msgnum > 0L) {
2945                 syslog(LOG_DEBUG, "ReplicationChecks() replacing message %ld\n", old_msgnum);
2946                 CtdlDeleteMessages(CC->room.QRname, &old_msgnum, 1, "");
2947         }
2948 }
2949
2950
2951
2952 /*
2953  * Save a message to disk and submit it into the delivery system.
2954  */
2955 long CtdlSubmitMsg(struct CtdlMessage *msg,     /* message to save */
2956                    struct recptypes *recps,     /* recipients (if mail) */
2957                    char *force,                 /* force a particular room? */
2958                    int flags                    /* should the message be exported clean? */
2959 ) {
2960         char submit_filename[128];
2961         char generated_timestamp[32];
2962         char hold_rm[ROOMNAMELEN];
2963         char actual_rm[ROOMNAMELEN];
2964         char force_room[ROOMNAMELEN];
2965         char content_type[SIZ];                 /* We have to learn this */
2966         char recipient[SIZ];
2967         long newmsgid;
2968         const char *mptr = NULL;
2969         struct ctdluser userbuf;
2970         int a, i;
2971         struct MetaData smi;
2972         FILE *network_fp = NULL;
2973         static int seqnum = 1;
2974         struct CtdlMessage *imsg = NULL;
2975         char *instr = NULL;
2976         size_t instr_alloc = 0;
2977         struct ser_ret smr;
2978         char *hold_R, *hold_D;
2979         char *collected_addresses = NULL;
2980         struct addresses_to_be_filed *aptr = NULL;
2981         StrBuf *saved_rfc822_version = NULL;
2982         int qualified_for_journaling = 0;
2983         CitContext *CCC = MyContext();
2984         char bounce_to[1024] = "";
2985         size_t tmp = 0;
2986         int rv = 0;
2987
2988         syslog(LOG_DEBUG, "CtdlSubmitMsg() called\n");
2989         if (is_valid_message(msg) == 0) return(-1);     /* self check */
2990
2991         /* If this message has no timestamp, we take the liberty of
2992          * giving it one, right now.
2993          */
2994         if (msg->cm_fields['T'] == NULL) {
2995                 snprintf(generated_timestamp, sizeof generated_timestamp, "%ld", (long)time(NULL));
2996                 msg->cm_fields['T'] = strdup(generated_timestamp);
2997         }
2998
2999         /* If this message has no path, we generate one.
3000          */
3001         if (msg->cm_fields['P'] == NULL) {
3002                 if (msg->cm_fields['A'] != NULL) {
3003                         msg->cm_fields['P'] = strdup(msg->cm_fields['A']);
3004                         for (a=0; !IsEmptyStr(&msg->cm_fields['P'][a]); ++a) {
3005                                 if (isspace(msg->cm_fields['P'][a])) {
3006                                         msg->cm_fields['P'][a] = ' ';
3007                                 }
3008                         }
3009                 }
3010                 else {
3011                         msg->cm_fields['P'] = strdup("unknown");
3012                 }
3013         }
3014
3015         if (force == NULL) {
3016                 strcpy(force_room, "");
3017         }
3018         else {
3019                 strcpy(force_room, force);
3020         }
3021
3022         /* Learn about what's inside, because it's what's inside that counts */
3023         if (msg->cm_fields['M'] == NULL) {
3024                 syslog(LOG_ERR, "ERROR: attempt to save message with NULL body\n");
3025                 return(-2);
3026         }
3027
3028         switch (msg->cm_format_type) {
3029         case 0:
3030                 strcpy(content_type, "text/x-citadel-variformat");
3031                 break;
3032         case 1:
3033                 strcpy(content_type, "text/plain");
3034                 break;
3035         case 4:
3036                 strcpy(content_type, "text/plain");
3037                 mptr = bmstrcasestr(msg->cm_fields['M'], "Content-type:");
3038                 if (mptr != NULL) {
3039                         char *aptr;
3040                         safestrncpy(content_type, &mptr[13], sizeof content_type);
3041                         striplt(content_type);
3042                         aptr = content_type;
3043                         while (!IsEmptyStr(aptr)) {
3044                                 if ((*aptr == ';')
3045                                     || (*aptr == ' ')
3046                                     || (*aptr == 13)
3047                                     || (*aptr == 10)) {
3048                                         *aptr = 0;
3049                                 }
3050                                 else aptr++;
3051                         }
3052                 }
3053         }
3054
3055         /* Goto the correct room */
3056         syslog(LOG_DEBUG, "Selected room %s\n", (recps) ? CCC->room.QRname : SENTITEMS);
3057         strcpy(hold_rm, CCC->room.QRname);
3058         strcpy(actual_rm, CCC->room.QRname);
3059         if (recps != NULL) {
3060                 strcpy(actual_rm, SENTITEMS);
3061         }
3062
3063         /* If the user is a twit, move to the twit room for posting */
3064         if (TWITDETECT) {
3065                 if (CCC->user.axlevel == AxProbU) {
3066                         strcpy(hold_rm, actual_rm);
3067                         strcpy(actual_rm, config.c_twitroom);
3068                         syslog(LOG_DEBUG, "Diverting to twit room\n");
3069                 }
3070         }
3071
3072         /* ...or if this message is destined for Aide> then go there. */
3073         if (!IsEmptyStr(force_room)) {
3074                 strcpy(actual_rm, force_room);
3075         }
3076
3077         syslog(LOG_DEBUG, "Final selection: %s\n", actual_rm);
3078         if (strcasecmp(actual_rm, CCC->room.QRname)) {
3079                 /* CtdlGetRoom(&CCC->room, actual_rm); */
3080                 CtdlUserGoto(actual_rm, 0, 1, NULL, NULL);
3081         }
3082
3083         /*
3084          * If this message has no O (room) field, generate one.
3085          */
3086         if (msg->cm_fields['O'] == NULL) {
3087                 msg->cm_fields['O'] = strdup(CCC->room.QRname);
3088         }
3089
3090         /* Perform "before save" hooks (aborting if any return nonzero) */
3091         syslog(LOG_DEBUG, "Performing before-save hooks\n");
3092         if (PerformMessageHooks(msg, EVT_BEFORESAVE) > 0) return(-3);
3093
3094         /*
3095          * If this message has an Exclusive ID, and the room is replication
3096          * checking enabled, then do replication checks.
3097          */
3098         if (DoesThisRoomNeedEuidIndexing(&CCC->room)) {
3099                 ReplicationChecks(msg);
3100         }
3101
3102         /* Save it to disk */
3103         syslog(LOG_DEBUG, "Saving to disk\n");
3104         newmsgid = send_message(msg);
3105         if (newmsgid <= 0L) return(-5);
3106
3107         /* Write a supplemental message info record.  This doesn't have to
3108          * be a critical section because nobody else knows about this message
3109          * yet.
3110          */
3111         syslog(LOG_DEBUG, "Creating MetaData record\n");
3112         memset(&smi, 0, sizeof(struct MetaData));
3113         smi.meta_msgnum = newmsgid;
3114         smi.meta_refcount = 0;
3115         safestrncpy(smi.meta_content_type, content_type,
3116                         sizeof smi.meta_content_type);
3117
3118         /*
3119          * Measure how big this message will be when rendered as RFC822.
3120          * We do this for two reasons:
3121          * 1. We need the RFC822 length for the new metadata record, so the
3122          *    POP and IMAP services don't have to calculate message lengths
3123          *    while the user is waiting (multiplied by potentially hundreds
3124          *    or thousands of messages).
3125          * 2. If journaling is enabled, we will need an RFC822 version of the
3126          *    message to attach to the journalized copy.
3127          */
3128         if (CCC->redirect_buffer != NULL) {
3129                 syslog(LOG_ALERT, "CCC->redirect_buffer is not NULL during message submission!\n");
3130                 abort();
3131         }
3132         CCC->redirect_buffer = NewStrBufPlain(NULL, SIZ);
3133         CtdlOutputPreLoadedMsg(msg, MT_RFC822, HEADERS_ALL, 0, 1, QP_EADDR);
3134         smi.meta_rfc822_length = StrLength(CCC->redirect_buffer);
3135         saved_rfc822_version = CCC->redirect_buffer;
3136         CCC->redirect_buffer = NULL;
3137
3138         PutMetaData(&smi);
3139
3140         /* Now figure out where to store the pointers */
3141         syslog(LOG_DEBUG, "Storing pointers\n");
3142
3143         /* If this is being done by the networker delivering a private
3144          * message, we want to BYPASS saving the sender's copy (because there
3145          * is no local sender; it would otherwise go to the Trashcan).
3146          */
3147         if ((!CCC->internal_pgm) || (recps == NULL)) {
3148                 if (CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 1, msg) != 0) {
3149                         syslog(LOG_ERR, "ERROR saving message pointer!\n");
3150                         CtdlSaveMsgPointerInRoom(config.c_aideroom, newmsgid, 0, msg);
3151                 }
3152         }
3153
3154         /* For internet mail, drop a copy in the outbound queue room */
3155         if ((recps != NULL) && (recps->num_internet > 0)) {
3156                 CtdlSaveMsgPointerInRoom(SMTP_SPOOLOUT_ROOM, newmsgid, 0, msg);
3157         }
3158
3159         /* If other rooms are specified, drop them there too. */
3160         if ((recps != NULL) && (recps->num_room > 0))
3161           for (i=0; i<num_tokens(recps->recp_room, '|'); ++i) {
3162                 extract_token(recipient, recps->recp_room, i,
3163                                         '|', sizeof recipient);
3164                 syslog(LOG_DEBUG, "Delivering to room <%s>\n", recipient);
3165                 CtdlSaveMsgPointerInRoom(recipient, newmsgid, 0, msg);
3166         }
3167
3168         /* Bump this user's messages posted counter. */
3169         syslog(LOG_DEBUG, "Updating user\n");
3170         CtdlGetUserLock(&CCC->user, CCC->curr_user);
3171         CCC->user.posted = CCC->user.posted + 1;
3172         CtdlPutUserLock(&CCC->user);
3173
3174         /* Decide where bounces need to be delivered */
3175         if ((recps != NULL) && (recps->bounce_to != NULL)) {
3176                 safestrncpy(bounce_to, recps->bounce_to, sizeof bounce_to);
3177         }
3178         else if (CCC->logged_in) {
3179                 snprintf(bounce_to, sizeof bounce_to, "%s@%s", CCC->user.fullname, config.c_nodename);
3180         }
3181         else {
3182                 snprintf(bounce_to, sizeof bounce_to, "%s@%s", msg->cm_fields['A'], msg->cm_fields['N']);
3183         }
3184
3185         /* If this is private, local mail, make a copy in the
3186          * recipient's mailbox and bump the reference count.
3187          */
3188         if ((recps != NULL) && (recps->num_local > 0))
3189           for (i=0; i<num_tokens(recps->recp_local, '|'); ++i) {
3190                 extract_token(recipient, recps->recp_local, i,
3191                                         '|', sizeof recipient);
3192                 syslog(LOG_DEBUG, "Delivering private local mail to <%s>\n",
3193                         recipient);
3194                 if (CtdlGetUser(&userbuf, recipient) == 0) {
3195                         // Add a flag so the Funambol module knows its mail
3196                         msg->cm_fields['W'] = strdup(recipient);
3197                         CtdlMailboxName(actual_rm, sizeof actual_rm, &userbuf, MAILROOM);
3198                         CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0, msg);
3199                         CtdlBumpNewMailCounter(userbuf.usernum);
3200                         if (!IsEmptyStr(config.c_funambol_host) || !IsEmptyStr(config.c_pager_program)) {
3201                         /* Generate a instruction message for the Funambol notification
3202                          * server, in the same style as the SMTP queue
3203                          */
3204                            instr_alloc = 1024;
3205                            instr = malloc(instr_alloc);
3206                            snprintf(instr, instr_alloc,
3207                         "Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
3208                         "bounceto|%s\n",
3209                         SPOOLMIME, newmsgid, (long)time(NULL),
3210                         bounce_to
3211                         );
3212
3213                            imsg = malloc(sizeof(struct CtdlMessage));
3214                            memset(imsg, 0, sizeof(struct CtdlMessage));
3215                            imsg->cm_magic = CTDLMESSAGE_MAGIC;
3216                            imsg->cm_anon_type = MES_NORMAL;
3217                            imsg->cm_format_type = FMT_RFC822;
3218                            imsg->cm_fields['A'] = strdup("Citadel");
3219                            imsg->cm_fields['J'] = strdup("do not journal");
3220                            imsg->cm_fields['M'] = instr;        /* imsg owns this memory now */
3221                            imsg->cm_fields['W'] = strdup(recipient);
3222                            CtdlSubmitMsg(imsg, NULL, FNBL_QUEUE_ROOM, 0);
3223                            CtdlFreeMessage(imsg);
3224                         }
3225                 }
3226                 else {
3227                         syslog(LOG_DEBUG, "No user <%s>\n", recipient);
3228                         CtdlSaveMsgPointerInRoom(config.c_aideroom,
3229                                 newmsgid, 0, msg);
3230                 }
3231         }
3232
3233         /* Perform "after save" hooks */
3234         syslog(LOG_DEBUG, "Performing after-save hooks\n");
3235         PerformMessageHooks(msg, EVT_AFTERSAVE);
3236
3237         /* For IGnet mail, we have to save a new copy into the spooler for
3238          * each recipient, with the R and D fields set to the recipient and
3239          * destination-node.  This has two ugly side effects: all other
3240          * recipients end up being unlisted in this recipient's copy of the
3241          * message, and it has to deliver multiple messages to the same
3242          * node.  We'll revisit this again in a year or so when everyone has
3243          * a network spool receiver that can handle the new style messages.
3244          */
3245         if ((recps != NULL) && (recps->num_ignet > 0))
3246           for (i=0; i<num_tokens(recps->recp_ignet, '|'); ++i) {
3247                 extract_token(recipient, recps->recp_ignet, i,
3248                                 '|', sizeof recipient);
3249
3250                 hold_R = msg->cm_fields['R'];
3251                 hold_D = msg->cm_fields['D'];
3252                 msg->cm_fields['R'] = malloc(SIZ);
3253                 msg->cm_fields['D'] = malloc(128);
3254                 extract_token(msg->cm_fields['R'], recipient, 0, '@', SIZ);
3255                 extract_token(msg->cm_fields['D'], recipient, 1, '@', 128);
3256
3257                 serialize_message(&smr, msg);
3258                 if (smr.len > 0) {
3259                         snprintf(submit_filename, sizeof submit_filename,
3260                                          "%s/netmail.%04lx.%04x.%04x",
3261                                          ctdl_netin_dir,
3262                                          (long) getpid(), CCC->cs_pid, ++seqnum);
3263                         network_fp = fopen(submit_filename, "wb+");
3264                         if (network_fp != NULL) {
3265                                 rv = fwrite(smr.ser, smr.len, 1, network_fp);
3266                                 fclose(network_fp);
3267                         }
3268                         free(smr.ser);
3269                 }
3270
3271                 free(msg->cm_fields['R']);
3272                 free(msg->cm_fields['D']);
3273                 msg->cm_fields['R'] = hold_R;
3274                 msg->cm_fields['D'] = hold_D;
3275         }
3276
3277         /* Go back to the room we started from */
3278         syslog(LOG_DEBUG, "Returning to original room %s\n", hold_rm);
3279         if (strcasecmp(hold_rm, CCC->room.QRname))
3280                 CtdlUserGoto(hold_rm, 0, 1, NULL, NULL);
3281
3282         /* For internet mail, generate delivery instructions.
3283          * Yes, this is recursive.  Deal with it.  Infinite recursion does
3284          * not happen because the delivery instructions message does not
3285          * contain a recipient.
3286          */
3287         if ((recps != NULL) && (recps->num_internet > 0)) {
3288                 syslog(LOG_DEBUG, "Generating delivery instructions\n");
3289                 instr_alloc = 1024;
3290                 instr = malloc(instr_alloc);
3291                 snprintf(instr, instr_alloc,
3292                         "Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
3293                         "bounceto|%s\n",
3294                         SPOOLMIME, newmsgid, (long)time(NULL),
3295                         bounce_to
3296                 );
3297
3298                 if (recps->envelope_from != NULL) {
3299                         tmp = strlen(instr);
3300                         snprintf(&instr[tmp], instr_alloc-tmp, "envelope_from|%s\n", recps->envelope_from);
3301                 }
3302
3303                 for (i=0; i<num_tokens(recps->recp_internet, '|'); ++i) {
3304                         tmp = strlen(instr);
3305                         extract_token(recipient, recps->recp_internet, i, '|', sizeof recipient);
3306                         if ((tmp + strlen(recipient) + 32) > instr_alloc) {
3307                                 instr_alloc = instr_alloc * 2;
3308                                 instr = realloc(instr, instr_alloc);
3309                         }
3310                         snprintf(&instr[tmp], instr_alloc - tmp, "remote|%s|0||\n", recipient);
3311                 }
3312
3313                 imsg = malloc(sizeof(struct CtdlMessage));
3314                 memset(imsg, 0, sizeof(struct CtdlMessage));
3315                 imsg->cm_magic = CTDLMESSAGE_MAGIC;
3316                 imsg->cm_anon_type = MES_NORMAL;
3317                 imsg->cm_format_type = FMT_RFC822;
3318                 imsg->cm_fields['A'] = strdup("Citadel");
3319                 imsg->cm_fields['J'] = strdup("do not journal");
3320                 imsg->cm_fields['M'] = instr;   /* imsg owns this memory now */
3321                 CtdlSubmitMsg(imsg, NULL, SMTP_SPOOLOUT_ROOM, QP_EADDR);
3322                 CtdlFreeMessage(imsg);
3323         }
3324
3325         /*
3326          * Any addresses to harvest for someone's address book?
3327          */
3328         if ( (CCC->logged_in) && (recps != NULL) ) {
3329                 collected_addresses = harvest_collected_addresses(msg);
3330         }
3331
3332         if (collected_addresses != NULL) {
3333                 aptr = (struct addresses_to_be_filed *)
3334                         malloc(sizeof(struct addresses_to_be_filed));
3335                 CtdlMailboxName(actual_rm, sizeof actual_rm,
3336                         &CCC->user, USERCONTACTSROOM);
3337                 aptr->roomname = strdup(actual_rm);
3338                 aptr->collected_addresses = collected_addresses;
3339                 begin_critical_section(S_ATBF);
3340                 aptr->next = atbf;
3341                 atbf = aptr;
3342                 end_critical_section(S_ATBF);
3343         }
3344
3345         /*
3346          * Determine whether this message qualifies for journaling.
3347          */
3348         if (msg->cm_fields['J'] != NULL) {
3349                 qualified_for_journaling = 0;
3350         }
3351         else {
3352                 if (recps == NULL) {
3353                         qualified_for_journaling = config.c_journal_pubmsgs;
3354                 }
3355                 else if (recps->num_local + recps->num_ignet + recps->num_internet > 0) {
3356                         qualified_for_journaling = config.c_journal_email;
3357                 }
3358                 else {
3359                         qualified_for_journaling = config.c_journal_pubmsgs;
3360                 }
3361         }
3362
3363         /*
3364          * Do we have to perform journaling?  If so, hand off the saved
3365          * RFC822 version will be handed off to the journaler for background
3366          * submit.  Otherwise, we have to free the memory ourselves.
3367          */
3368         if (saved_rfc822_version != NULL) {
3369                 if (qualified_for_journaling) {
3370                         JournalBackgroundSubmit(msg, saved_rfc822_version, recps);
3371                 }
3372                 else {
3373                         FreeStrBuf(&saved_rfc822_version);
3374                 }
3375         }
3376
3377         /* Done. */
3378         return(newmsgid);
3379 }
3380
3381
3382
3383 void aide_message (char *text, char *subject)
3384 {
3385         quickie_message("Citadel",NULL,NULL,AIDEROOM,text,FMT_CITADEL,subject);
3386 }
3387
3388
3389 /*
3390  * Convenience function for generating small administrative messages.
3391  */
3392 void quickie_message(const char *from, const char *fromaddr, char *to, char *room, const char *text,
3393                         int format_type, const char *subject)
3394 {
3395         struct CtdlMessage *msg;
3396         struct recptypes *recp = NULL;
3397
3398         msg = malloc(sizeof(struct CtdlMessage));
3399         memset(msg, 0, sizeof(struct CtdlMessage));
3400         msg->cm_magic = CTDLMESSAGE_MAGIC;
3401         msg->cm_anon_type = MES_NORMAL;
3402         msg->cm_format_type = format_type;
3403
3404         if (from != NULL) {
3405                 msg->cm_fields['A'] = strdup(from);
3406         }
3407         else if (fromaddr != NULL) {
3408                 msg->cm_fields['A'] = strdup(fromaddr);
3409                 if (strchr(msg->cm_fields['A'], '@')) {
3410                         *strchr(msg->cm_fields['A'], '@') = 0;
3411                 }
3412         }
3413         else {
3414                 msg->cm_fields['A'] = strdup("Citadel");
3415         }
3416
3417         if (fromaddr != NULL) msg->cm_fields['F'] = strdup(fromaddr);
3418         if (room != NULL) msg->cm_fields['O'] = strdup(room);
3419         msg->cm_fields['N'] = strdup(NODENAME);
3420         if (to != NULL) {
3421                 msg->cm_fields['R'] = strdup(to);
3422                 recp = validate_recipients(to, NULL, 0);
3423         }
3424         if (subject != NULL) {
3425                 msg->cm_fields['U'] = strdup(subject);
3426         }
3427         msg->cm_fields['M'] = strdup(text);
3428
3429         CtdlSubmitMsg(msg, recp, room, 0);
3430         CtdlFreeMessage(msg);
3431         if (recp != NULL) free_recipients(recp);
3432 }
3433
3434
3435
3436 /*
3437  * Back end function used by CtdlMakeMessage() and similar functions
3438  */
3439 StrBuf *CtdlReadMessageBodyBuf(char *terminator,        /* token signalling EOT */
3440                                long tlen,
3441                                size_t maxlen,           /* maximum message length */
3442                                char *exist,             /* if non-null, append to it;
3443                                                            exist is ALWAYS freed  */
3444                                int crlf,                /* CRLF newlines instead of LF */
3445                                int *sock                /* socket handle or 0 for this session's client socket */
3446                         )
3447 {
3448         StrBuf *Message;
3449         StrBuf *LineBuf;
3450         int flushing = 0;
3451         int finished = 0;
3452         int dotdot = 0;
3453
3454         LineBuf = NewStrBufPlain(NULL, SIZ);
3455         if (exist == NULL) {
3456                 Message = NewStrBufPlain(NULL, 4 * SIZ);
3457         }
3458         else {
3459                 Message = NewStrBufPlain(exist, -1);
3460                 free(exist);
3461         }
3462
3463         /* Do we need to change leading ".." to "." for SMTP escaping? */
3464         if ((tlen == 1) && (*terminator == '.')) {
3465                 dotdot = 1;
3466         }
3467
3468         /* read in the lines of message text one by one */
3469         do {
3470                 if (sock != NULL) {
3471                         if ((CtdlSockGetLine(sock, LineBuf, 5) < 0) ||
3472                             (*sock == -1))
3473                                 finished = 1;
3474                 }
3475                 else {
3476                         if (CtdlClientGetLine(LineBuf) < 0) finished = 1;
3477                 }
3478                 if ((StrLength(LineBuf) == tlen) &&
3479                     (!strcmp(ChrPtr(LineBuf), terminator)))
3480                         finished = 1;
3481
3482                 if ( (!flushing) && (!finished) ) {
3483                         if (crlf) {
3484                                 StrBufAppendBufPlain(LineBuf, HKEY("\r\n"), 0);
3485                         }
3486                         else {
3487                                 StrBufAppendBufPlain(LineBuf, HKEY("\n"), 0);
3488                         }
3489
3490                         /* Unescape SMTP-style input of two dots at the beginning of the line */
3491                         if ((dotdot) &&
3492                             (StrLength(LineBuf) == 2) &&
3493                             (!strcmp(ChrPtr(LineBuf), "..")))
3494                         {
3495                                 StrBufCutLeft(LineBuf, 1);
3496                         }
3497
3498                         StrBufAppendBuf(Message, LineBuf, 0);
3499                 }
3500
3501                 /* if we've hit the max msg length, flush the rest */
3502                 if (StrLength(Message) >= maxlen) flushing = 1;
3503
3504         } while (!finished);
3505         FreeStrBuf(&LineBuf);
3506         return Message;
3507 }
3508
3509
3510 /*
3511  * Back end function used by CtdlMakeMessage() and similar functions
3512  */
3513 char *CtdlReadMessageBody(char *terminator,     /* token signalling EOT */
3514                           long tlen,
3515                           size_t maxlen,                /* maximum message length */
3516                           char *exist,          /* if non-null, append to it;
3517                                                    exist is ALWAYS freed  */
3518                           int crlf,             /* CRLF newlines instead of LF */
3519                           int *sock             /* socket handle or 0 for this session's client socket */
3520         )
3521 {
3522         StrBuf *Message;
3523
3524         Message = CtdlReadMessageBodyBuf(terminator,
3525                                          tlen,
3526                                          maxlen,
3527                                          exist,
3528                                          crlf,
3529                                          sock);
3530         if (Message == NULL)
3531                 return NULL;
3532         else
3533                 return SmashStrBuf(&Message);
3534 }
3535
3536
3537 /*
3538  * Build a binary message to be saved on disk.
3539  * (NOTE: if you supply 'preformatted_text', the buffer you give it
3540  * will become part of the message.  This means you are no longer
3541  * responsible for managing that memory -- it will be freed along with
3542  * the rest of the fields when CtdlFreeMessage() is called.)
3543  */
3544
3545 struct CtdlMessage *CtdlMakeMessage(
3546         struct ctdluser *author,        /* author's user structure */
3547         char *recipient,                /* NULL if it's not mail */
3548         char *recp_cc,                  /* NULL if it's not mail */
3549         char *room,                     /* room where it's going */
3550         int type,                       /* see MES_ types in header file */
3551         int format_type,                /* variformat, plain text, MIME... */
3552         char *fake_name,                /* who we're masquerading as */
3553         char *my_email,                 /* which of my email addresses to use (empty is ok) */
3554         char *subject,                  /* Subject (optional) */
3555         char *supplied_euid,            /* ...or NULL if this is irrelevant */
3556         char *preformatted_text,        /* ...or NULL to read text from client */
3557         char *references                /* Thread references */
3558 ) {
3559         char dest_node[256];
3560         char buf[1024];
3561         struct CtdlMessage *msg;
3562         StrBuf *FakeAuthor;
3563         StrBuf *FakeEncAuthor = NULL;
3564
3565         msg = malloc(sizeof(struct CtdlMessage));
3566         memset(msg, 0, sizeof(struct CtdlMessage));
3567         msg->cm_magic = CTDLMESSAGE_MAGIC;
3568         msg->cm_anon_type = type;
3569         msg->cm_format_type = format_type;
3570
3571         /* Don't confuse the poor folks if it's not routed mail. */
3572         strcpy(dest_node, "");
3573
3574         if (recipient != NULL) striplt(recipient);
3575         if (recp_cc != NULL) striplt(recp_cc);
3576
3577         /* Path or Return-Path */
3578         if (my_email == NULL) my_email = "";
3579
3580         if (!IsEmptyStr(my_email)) {
3581                 msg->cm_fields['P'] = strdup(my_email);
3582         }
3583         else {
3584                 snprintf(buf, sizeof buf, "%s", author->fullname);
3585                 msg->cm_fields['P'] = strdup(buf);
3586         }
3587         convert_spaces_to_underscores(msg->cm_fields['P']);
3588
3589         snprintf(buf, sizeof buf, "%ld", (long)time(NULL));     /* timestamp */
3590         msg->cm_fields['T'] = strdup(buf);
3591
3592         if ((fake_name != NULL) && (fake_name[0])) {            /* author */
3593                 FakeAuthor = NewStrBufPlain (fake_name, -1);
3594         }
3595         else {
3596                 FakeAuthor = NewStrBufPlain (author->fullname, -1);
3597         }
3598         StrBufRFC2047encode(&FakeEncAuthor, FakeAuthor);
3599         msg->cm_fields['A'] = SmashStrBuf(&FakeEncAuthor);
3600         FreeStrBuf(&FakeAuthor);
3601
3602         if (CC->room.QRflags & QR_MAILBOX) {            /* room */
3603                 msg->cm_fields['O'] = strdup(&CC->room.QRname[11]);
3604         }
3605         else {
3606                 msg->cm_fields['O'] = strdup(CC->room.QRname);
3607         }
3608
3609         msg->cm_fields['N'] = strdup(NODENAME);         /* nodename */
3610         msg->cm_fields['H'] = strdup(HUMANNODE);                /* hnodename */
3611
3612         if ((recipient != NULL) && (recipient[0] != 0)) {
3613                 msg->cm_fields['R'] = strdup(recipient);
3614         }
3615         if ((recp_cc != NULL) && (recp_cc[0] != 0)) {
3616                 msg->cm_fields['Y'] = strdup(recp_cc);
3617         }
3618         if (dest_node[0] != 0) {
3619                 msg->cm_fields['D'] = strdup(dest_node);
3620         }
3621
3622         if (!IsEmptyStr(my_email)) {
3623                 msg->cm_fields['F'] = strdup(my_email);
3624         }
3625         else if ( (author == &CC->user) && (!IsEmptyStr(CC->cs_inet_email)) ) {
3626                 msg->cm_fields['F'] = strdup(CC->cs_inet_email);
3627         }
3628
3629         if (subject != NULL) {
3630                 long length;
3631                 striplt(subject);
3632                 length = strlen(subject);
3633                 if (length > 0) {
3634                         long i;
3635                         long IsAscii;
3636                         IsAscii = -1;
3637                         i = 0;
3638                         while ((subject[i] != '\0') &&
3639                                (IsAscii = isascii(subject[i]) != 0 ))
3640                                 i++;
3641                         if (IsAscii != 0)
3642                                 msg->cm_fields['U'] = strdup(subject);
3643                         else /* ok, we've got utf8 in the string. */
3644                         {
3645                                 msg->cm_fields['U'] = rfc2047encode(subject, length);
3646                         }
3647
3648                 }
3649         }
3650
3651         if (supplied_euid != NULL) {
3652                 msg->cm_fields['E'] = strdup(supplied_euid);
3653         }
3654
3655         if (references != NULL) {
3656                 if (!IsEmptyStr(references)) {
3657                         msg->cm_fields['W'] = strdup(references);
3658                 }
3659         }
3660
3661         if (preformatted_text != NULL) {
3662                 msg->cm_fields['M'] = preformatted_text;
3663         }
3664         else {
3665                 msg->cm_fields['M'] = CtdlReadMessageBody(HKEY("000"), config.c_maxmsglen, NULL, 0, 0);
3666         }
3667
3668         return(msg);
3669 }
3670
3671
3672 /*
3673  * Check to see whether we have permission to post a message in the current
3674  * room.  Returns a *CITADEL ERROR CODE* and puts a message in errmsgbuf, or
3675  * returns 0 on success.
3676  */
3677 int CtdlDoIHavePermissionToPostInThisRoom(
3678         char *errmsgbuf,
3679         size_t n,
3680         const char* RemoteIdentifier,
3681         int PostPublic,
3682         int is_reply
3683 ) {
3684         int ra;
3685
3686         if (!(CC->logged_in) &&
3687             (PostPublic == POST_LOGGED_IN)) {
3688                 snprintf(errmsgbuf, n, "Not logged in.");
3689                 return (ERROR + NOT_LOGGED_IN);
3690         }
3691         else if (PostPublic == CHECK_EXISTANCE) {
3692                 return (0); // We're Evaling whether a recipient exists
3693         }
3694         else if (!(CC->logged_in)) {
3695
3696                 if ((CC->room.QRflags & QR_READONLY)) {
3697                         snprintf(errmsgbuf, n, "Not logged in.");
3698                         return (ERROR + NOT_LOGGED_IN);
3699                 }
3700                 if (CC->room.QRflags2 & QR2_MODERATED) {
3701                         snprintf(errmsgbuf, n, "Not logged in Moderation feature not yet implemented!");
3702                         return (ERROR + NOT_LOGGED_IN);
3703                 }
3704                 if ((PostPublic!=POST_LMTP) &&(CC->room.QRflags2 & QR2_SMTP_PUBLIC) == 0) {
3705                         SpoolControl *sc;
3706                         char filename[SIZ];
3707                         int found;
3708
3709                         if (RemoteIdentifier == NULL)
3710                         {
3711                                 snprintf(errmsgbuf, n, "Need sender to permit access.");
3712                                 return (ERROR + USERNAME_REQUIRED);
3713                         }
3714
3715                         assoc_file_name(filename, sizeof filename, &CC->room, ctdl_netcfg_dir);
3716                         begin_critical_section(S_NETCONFIGS);
3717                         if (!read_spoolcontrol_file(&sc, filename))
3718                         {
3719                                 end_critical_section(S_NETCONFIGS);
3720                                 snprintf(errmsgbuf, n,
3721                                         "This mailing list only accepts posts from subscribers.");
3722                                 return (ERROR + NO_SUCH_USER);
3723                         }
3724                         end_critical_section(S_NETCONFIGS);
3725                         found = is_recipient (sc, RemoteIdentifier);
3726                         free_spoolcontrol_struct(&sc);
3727                         if (found) {
3728                                 return (0);
3729                         }
3730                         else {
3731                                 snprintf(errmsgbuf, n,
3732                                         "This mailing list only accepts posts from subscribers.");
3733                                 return (ERROR + NO_SUCH_USER);
3734                         }
3735                 }
3736                 return (0);
3737
3738         }
3739
3740         if ((CC->user.axlevel < AxProbU)
3741             && ((CC->room.QRflags & QR_MAILBOX) == 0)) {
3742                 snprintf(errmsgbuf, n, "Need to be validated to enter (except in %s> to sysop)", MAILROOM);
3743                 return (ERROR + HIGHER_ACCESS_REQUIRED);
3744         }
3745
3746         CtdlRoomAccess(&CC->room, &CC->user, &ra, NULL);
3747
3748         if (ra & UA_POSTALLOWED) {
3749                 strcpy(errmsgbuf, "OK to post or reply here");
3750                 return(0);
3751         }
3752
3753         if ( (ra & UA_REPLYALLOWED) && (is_reply) ) {
3754                 /*
3755                  * To be thorough, we ought to check to see if the message they are
3756                  * replying to is actually a valid one in this room, but unless this
3757                  * actually becomes a problem we'll go with high performance instead.
3758                  */
3759                 strcpy(errmsgbuf, "OK to reply here");
3760                 return(0);
3761         }
3762
3763         if ( (ra & UA_REPLYALLOWED) && (!is_reply) ) {
3764                 /* Clarify what happened with a better error message */
3765                 snprintf(errmsgbuf, n, "You may only reply to existing messages here.");
3766                 return (ERROR + HIGHER_ACCESS_REQUIRED);
3767         }
3768
3769         snprintf(errmsgbuf, n, "Higher access is required to post in this room.");
3770         return (ERROR + HIGHER_ACCESS_REQUIRED);
3771
3772 }
3773
3774
3775 /*
3776  * Check to see if the specified user has Internet mail permission
3777  * (returns nonzero if permission is granted)
3778  */
3779 int CtdlCheckInternetMailPermission(struct ctdluser *who) {
3780
3781         /* Do not allow twits to send Internet mail */
3782         if (who->axlevel <= AxProbU) return(0);
3783
3784         /* Globally enabled? */
3785         if (config.c_restrict == 0) return(1);
3786
3787         /* User flagged ok? */
3788         if (who->flags & US_INTERNET) return(2);
3789
3790         /* Aide level access? */
3791         if (who->axlevel >= AxAideU) return(3);
3792
3793         /* No mail for you! */
3794         return(0);
3795 }
3796
3797
3798 /*
3799  * Validate recipients, count delivery types and errors, and handle aliasing
3800  * FIXME check for dupes!!!!!
3801  *
3802  * Returns 0 if all addresses are ok, ret->num_error = -1 if no addresses
3803  * were specified, or the number of addresses found invalid.
3804  *
3805  * Caller needs to free the result using free_recipients()
3806  */
3807 struct recptypes *validate_recipients(const char *supplied_recipients,
3808                                       const char *RemoteIdentifier,
3809                                       int Flags) {
3810         struct recptypes *ret;
3811         char *recipients = NULL;
3812         char this_recp[256];
3813         char this_recp_cooked[256];
3814         char append[SIZ];
3815         int num_recps = 0;
3816         int i, j;
3817         int mailtype;
3818         int invalid;
3819         struct ctdluser tempUS;
3820         struct ctdlroom tempQR;
3821         struct ctdlroom tempQR2;
3822         int err = 0;
3823         char errmsg[SIZ];
3824         int in_quotes = 0;
3825
3826         /* Initialize */
3827         ret = (struct recptypes *) malloc(sizeof(struct recptypes));
3828         if (ret == NULL) return(NULL);
3829
3830         /* Set all strings to null and numeric values to zero */
3831         memset(ret, 0, sizeof(struct recptypes));
3832
3833         if (supplied_recipients == NULL) {
3834                 recipients = strdup("");
3835         }
3836         else {
3837                 recipients = strdup(supplied_recipients);
3838         }
3839
3840         /* Allocate some memory.  Yes, this allocates 500% more memory than we will
3841          * actually need, but it's healthier for the heap than doing lots of tiny
3842          * realloc() calls instead.
3843          */
3844
3845         ret->errormsg = malloc(strlen(recipients) + 1024);
3846         ret->recp_local = malloc(strlen(recipients) + 1024);
3847         ret->recp_internet = malloc(strlen(recipients) + 1024);
3848         ret->recp_ignet = malloc(strlen(recipients) + 1024);
3849         ret->recp_room = malloc(strlen(recipients) + 1024);
3850         ret->display_recp = malloc(strlen(recipients) + 1024);
3851
3852         ret->errormsg[0] = 0;
3853         ret->recp_local[0] = 0;
3854         ret->recp_internet[0] = 0;
3855         ret->recp_ignet[0] = 0;
3856         ret->recp_room[0] = 0;
3857         ret->display_recp[0] = 0;
3858
3859         ret->recptypes_magic = RECPTYPES_MAGIC;
3860
3861         /* Change all valid separator characters to commas */
3862         for (i=0; !IsEmptyStr(&recipients[i]); ++i) {
3863                 if ((recipients[i] == ';') || (recipients[i] == '|')) {
3864                         recipients[i] = ',';
3865                 }
3866         }
3867
3868         /* Now start extracting recipients... */
3869
3870         while (!IsEmptyStr(recipients)) {
3871
3872                 for (i=0; i<=strlen(recipients); ++i) {
3873                         if (recipients[i] == '\"') in_quotes = 1 - in_quotes;
3874                         if ( ( (recipients[i] == ',') && (!in_quotes) ) || (recipients[i] == 0) ) {
3875                                 safestrncpy(this_recp, recipients, i+1);
3876                                 this_recp[i] = 0;
3877                                 if (recipients[i] == ',') {
3878                                         strcpy(recipients, &recipients[i+1]);
3879                                 }
3880                                 else {
3881                                         strcpy(recipients, "");
3882                                 }
3883                                 break;
3884                         }
3885                 }
3886
3887                 striplt(this_recp);
3888                 if (IsEmptyStr(this_recp))
3889                         break;
3890                 syslog(LOG_DEBUG, "Evaluating recipient #%d: %s\n", num_recps, this_recp);
3891                 ++num_recps;
3892                 mailtype = alias(this_recp);
3893                 mailtype = alias(this_recp);
3894                 mailtype = alias(this_recp);
3895                 j = 0;
3896                 for (j=0; !IsEmptyStr(&this_recp[j]); ++j) {
3897                         if (this_recp[j]=='_') {
3898                                 this_recp_cooked[j] = ' ';
3899                         }
3900                         else {
3901                                 this_recp_cooked[j] = this_recp[j];
3902                         }
3903                 }
3904                 this_recp_cooked[j] = '\0';
3905                 invalid = 0;
3906                 errmsg[0] = 0;
3907                 switch(mailtype) {
3908                         case MES_LOCAL:
3909                                 if (!strcasecmp(this_recp, "sysop")) {
3910                                         ++ret->num_room;
3911                                         strcpy(this_recp, config.c_aideroom);
3912                                         if (!IsEmptyStr(ret->recp_room)) {
3913                                                 strcat(ret->recp_room, "|");
3914                                         }
3915                                         strcat(ret->recp_room, this_recp);
3916                                 }
3917                                 else if ( (!strncasecmp(this_recp, "room_", 5))
3918                                       && (!CtdlGetRoom(&tempQR, &this_recp_cooked[5])) ) {
3919
3920                                         /* Save room so we can restore it later */
3921                                         tempQR2 = CC->room;
3922                                         CC->room = tempQR;
3923
3924                                         /* Check permissions to send mail to this room */
3925                                         err = CtdlDoIHavePermissionToPostInThisRoom(
3926                                                 errmsg,
3927                                                 sizeof errmsg,
3928                                                 RemoteIdentifier,
3929                                                 Flags,
3930                                                 0                       /* 0 = not a reply */
3931                                         );
3932                                         if (err)
3933                                         {
3934                                                 ++ret->num_error;
3935                                                 invalid = 1;
3936                                         }
3937                                         else {
3938                                                 ++ret->num_room;
3939                                                 if (!IsEmptyStr(ret->recp_room)) {
3940                                                         strcat(ret->recp_room, "|");
3941                                                 }
3942                                                 strcat(ret->recp_room, &this_recp_cooked[5]);
3943                                         }
3944
3945                                         /* Restore room in case something needs it */
3946                                         CC->room = tempQR2;
3947
3948                                 }
3949                                 else if (CtdlGetUser(&tempUS, this_recp) == 0) {
3950                                         ++ret->num_local;
3951                                         strcpy(this_recp, tempUS.fullname);
3952                                         if (!IsEmptyStr(ret->recp_local)) {
3953                                                 strcat(ret->recp_local, "|");
3954                                         }
3955                                         strcat(ret->recp_local, this_recp);
3956                                 }
3957                                 else if (CtdlGetUser(&tempUS, this_recp_cooked) == 0) {
3958                                         ++ret->num_local;
3959                                         strcpy(this_recp, tempUS.fullname);
3960                                         if (!IsEmptyStr(ret->recp_local)) {
3961                                                 strcat(ret->recp_local, "|");
3962                                         }
3963                                         strcat(ret->recp_local, this_recp);
3964                                 }
3965                                 else {
3966                                         ++ret->num_error;
3967                                         invalid = 1;
3968                                 }
3969                                 break;
3970                         case MES_INTERNET:
3971                                 /* Yes, you're reading this correctly: if the target
3972                                  * domain points back to the local system or an attached
3973                                  * Citadel directory, the address is invalid.  That's
3974                                  * because if the address were valid, we would have
3975                                  * already translated it to a local address by now.
3976                                  */
3977                                 if (IsDirectory(this_recp, 0)) {
3978                                         ++ret->num_error;
3979                                         invalid = 1;
3980                                 }
3981                                 else {
3982                                         ++ret->num_internet;
3983                                         if (!IsEmptyStr(ret->recp_internet)) {
3984                                                 strcat(ret->recp_internet, "|");
3985                                         }
3986                                         strcat(ret->recp_internet, this_recp);
3987                                 }
3988                                 break;
3989                         case MES_IGNET:
3990                                 ++ret->num_ignet;
3991                                 if (!IsEmptyStr(ret->recp_ignet)) {
3992                                         strcat(ret->recp_ignet, "|");
3993                                 }
3994                                 strcat(ret->recp_ignet, this_recp);
3995                                 break;
3996                         case MES_ERROR:
3997                                 ++ret->num_error;
3998                                 invalid = 1;
3999                                 break;
4000                 }
4001                 if (invalid) {
4002                         if (IsEmptyStr(errmsg)) {
4003                                 snprintf(append, sizeof append, "Invalid recipient: %s", this_recp);
4004                         }
4005                         else {
4006                                 snprintf(append, sizeof append, "%s", errmsg);
4007                         }
4008                         if ( (strlen(ret->errormsg) + strlen(append) + 3) < SIZ) {
4009                                 if (!IsEmptyStr(ret->errormsg)) {
4010                                         strcat(ret->errormsg, "; ");
4011                                 }
4012                                 strcat(ret->errormsg, append);
4013                         }
4014                 }
4015                 else {
4016                         if (IsEmptyStr(ret->display_recp)) {
4017                                 strcpy(append, this_recp);
4018                         }
4019                         else {
4020                                 snprintf(append, sizeof append, ", %s", this_recp);
4021                         }
4022                         if ( (strlen(ret->display_recp)+strlen(append)) < SIZ) {
4023                                 strcat(ret->display_recp, append);
4024                         }
4025                 }
4026         }
4027
4028         if ((ret->num_local + ret->num_internet + ret->num_ignet +
4029            ret->num_room + ret->num_error) == 0) {
4030                 ret->num_error = (-1);
4031                 strcpy(ret->errormsg, "No recipients specified.");
4032         }
4033
4034         syslog(LOG_DEBUG, "validate_recipients()\n");
4035         syslog(LOG_DEBUG, " local: %d <%s>\n", ret->num_local, ret->recp_local);
4036         syslog(LOG_DEBUG, "  room: %d <%s>\n", ret->num_room, ret->recp_room);
4037         syslog(LOG_DEBUG, "  inet: %d <%s>\n", ret->num_internet, ret->recp_internet);
4038         syslog(LOG_DEBUG, " ignet: %d <%s>\n", ret->num_ignet, ret->recp_ignet);
4039         syslog(LOG_DEBUG, " error: %d <%s>\n", ret->num_error, ret->errormsg);
4040
4041         free(recipients);
4042         return(ret);
4043 }
4044
4045
4046 /*
4047  * Destructor for struct recptypes
4048  */
4049 void free_recipients(struct recptypes *valid) {
4050
4051         if (valid == NULL) {
4052                 return;
4053         }
4054
4055         if (valid->recptypes_magic != RECPTYPES_MAGIC) {
4056                 syslog(LOG_EMERG, "Attempt to call free_recipients() on some other data type!\n");
4057                 abort();
4058         }
4059
4060         if (valid->errormsg != NULL)            free(valid->errormsg);
4061         if (valid->recp_local != NULL)          free(valid->recp_local);
4062         if (valid->recp_internet != NULL)       free(valid->recp_internet);
4063         if (valid->recp_ignet != NULL)          free(valid->recp_ignet);
4064         if (valid->recp_room != NULL)           free(valid->recp_room);
4065         if (valid->display_recp != NULL)        free(valid->display_recp);
4066         if (valid->bounce_to != NULL)           free(valid->bounce_to);
4067         if (valid->envelope_from != NULL)       free(valid->envelope_from);
4068         free(valid);
4069 }
4070
4071
4072
4073 /*
4074  * message entry  -  mode 0 (normal)
4075  */
4076 void cmd_ent0(char *entargs)
4077 {
4078         int post = 0;
4079         char recp[SIZ];
4080         char cc[SIZ];
4081         char bcc[SIZ];
4082         char supplied_euid[128];
4083         int anon_flag = 0;
4084         int format_type = 0;
4085         char newusername[256];
4086         char newuseremail[256];
4087         struct CtdlMessage *msg;
4088         int anonymous = 0;
4089         char errmsg[SIZ];
4090         int err = 0;
4091         struct recptypes *valid = NULL;
4092         struct recptypes *valid_to = NULL;
4093         struct recptypes *valid_cc = NULL;
4094         struct recptypes *valid_bcc = NULL;
4095         char subject[SIZ];
4096         int subject_required = 0;
4097         int do_confirm = 0;
4098         long msgnum;
4099         int i, j;
4100         char buf[256];
4101         int newuseremail_ok = 0;
4102         char references[SIZ];
4103         char *ptr;
4104
4105         unbuffer_output();
4106
4107         post = extract_int(entargs, 0);
4108         extract_token(recp, entargs, 1, '|', sizeof recp);
4109         anon_flag = extract_int(entargs, 2);
4110         format_type = extract_int(entargs, 3);
4111         extract_token(subject, entargs, 4, '|', sizeof subject);
4112         extract_token(newusername, entargs, 5, '|', sizeof newusername);
4113         do_confirm = extract_int(entargs, 6);
4114         extract_token(cc, entargs, 7, '|', sizeof cc);
4115         extract_token(bcc, entargs, 8, '|', sizeof bcc);
4116         switch(CC->room.QRdefaultview) {
4117                 case VIEW_NOTES:
4118                 case VIEW_WIKI:
4119                         extract_token(supplied_euid, entargs, 9, '|', sizeof supplied_euid);
4120                         break;
4121                 default:
4122                         supplied_euid[0] = 0;
4123                         break;
4124         }
4125         extract_token(newuseremail, entargs, 10, '|', sizeof newuseremail);
4126         extract_token(references, entargs, 11, '|', sizeof references);
4127         for (ptr=references; *ptr != 0; ++ptr) {
4128                 if (*ptr == '!') *ptr = '|';
4129         }
4130
4131         /* first check to make sure the request is valid. */
4132
4133         err = CtdlDoIHavePermissionToPostInThisRoom(
4134                 errmsg,
4135                 sizeof errmsg,
4136                 NULL,
4137                 POST_LOGGED_IN,
4138                 (!IsEmptyStr(references))               /* is this a reply?  or a top-level post? */
4139         );
4140         if (err)
4141         {
4142                 cprintf("%d %s\n", err, errmsg);
4143                 return;
4144         }
4145
4146         /* Check some other permission type things. */
4147
4148         if (IsEmptyStr(newusername)) {
4149                 strcpy(newusername, CC->user.fullname);
4150         }
4151         if (  (CC->user.axlevel < AxAideU)
4152            && (strcasecmp(newusername, CC->user.fullname))
4153            && (strcasecmp(newusername, CC->cs_inet_fn))
4154         ) {
4155                 cprintf("%d You don't have permission to author messages as '%s'.\n",
4156                         ERROR + HIGHER_ACCESS_REQUIRED,
4157                         newusername
4158                 );
4159                 return;
4160         }
4161
4162
4163         if (IsEmptyStr(newuseremail)) {
4164                 newuseremail_ok = 1;
4165         }
4166
4167         if (!IsEmptyStr(newuseremail)) {
4168                 if (!strcasecmp(newuseremail, CC->cs_inet_email)) {
4169                         newuseremail_ok = 1;
4170                 }
4171                 else if (!IsEmptyStr(CC->cs_inet_other_emails)) {
4172                         j = num_tokens(CC->cs_inet_other_emails, '|');
4173                         for (i=0; i<j; ++i) {
4174                                 extract_token(buf, CC->cs_inet_other_emails, i, '|', sizeof buf);
4175                                 if (!strcasecmp(newuseremail, buf)) {
4176                                         newuseremail_ok = 1;
4177                                 }
4178                         }
4179                 }
4180         }
4181
4182         if (!newuseremail_ok) {
4183                 cprintf("%d You don't have permission to author messages as '%s'.\n",
4184                         ERROR + HIGHER_ACCESS_REQUIRED,
4185                         newuseremail
4186                 );
4187                 return;
4188         }
4189
4190         CC->cs_flags |= CS_POSTING;
4191
4192         /* In mailbox rooms we have to behave a little differently --
4193          * make sure the user has specified at least one recipient.  Then
4194          * validate the recipient(s).  We do this for the Mail> room, as
4195          * well as any room which has the "Mailbox" view set - unless it
4196          * is the DRAFTS room which does not require recipients
4197          */
4198
4199         if ( (  ( (CC->room.QRflags & QR_MAILBOX) && (!strcasecmp(&CC->room.QRname[11], MAILROOM)) )
4200              || ( (CC->room.QRflags & QR_MAILBOX) && (CC->curr_view == VIEW_MAILBOX) )
4201         ) && (strcasecmp(&CC->room.QRname[11], USERDRAFTROOM)) !=0 ) {
4202                 if (CC->user.axlevel < AxProbU) {
4203                         strcpy(recp, "sysop");
4204                         strcpy(cc, "");
4205                         strcpy(bcc, "");
4206                 }
4207
4208                 valid_to = validate_recipients(recp, NULL, 0);
4209                 if (valid_to->num_error > 0) {
4210                         cprintf("%d %s\n", ERROR + NO_SUCH_USER, valid_to->errormsg);
4211                         free_recipients(valid_to);
4212                         return;
4213                 }
4214
4215                 valid_cc = validate_recipients(cc, NULL, 0);
4216                 if (valid_cc->num_error > 0) {
4217                         cprintf("%d %s\n", ERROR + NO_SUCH_USER, valid_cc->errormsg);
4218                         free_recipients(valid_to);
4219                         free_recipients(valid_cc);
4220                         return;
4221                 }
4222
4223                 valid_bcc = validate_recipients(bcc, NULL, 0);
4224                 if (valid_bcc->num_error > 0) {
4225                         cprintf("%d %s\n", ERROR + NO_SUCH_USER, valid_bcc->errormsg);
4226                         free_recipients(valid_to);
4227                         free_recipients(valid_cc);
4228                         free_recipients(valid_bcc);
4229                         return;
4230                 }
4231
4232                 /* Recipient required, but none were specified */
4233                 if ( (valid_to->num_error < 0) && (valid_cc->num_error < 0) && (valid_bcc->num_error < 0) ) {
4234                         free_recipients(valid_to);
4235                         free_recipients(valid_cc);
4236                         free_recipients(valid_bcc);
4237                         cprintf("%d At least one recipient is required.\n", ERROR + NO_SUCH_USER);
4238                         return;
4239                 }
4240
4241                 if (valid_to->num_internet + valid_cc->num_internet + valid_bcc->num_internet > 0) {
4242                         if (CtdlCheckInternetMailPermission(&CC->user)==0) {
4243                                 cprintf("%d You do not have permission "
4244                                         "to send Internet mail.\n",
4245                                         ERROR + HIGHER_ACCESS_REQUIRED);
4246                                 free_recipients(valid_to);
4247                                 free_recipients(valid_cc);
4248                                 free_recipients(valid_bcc);
4249                                 return;
4250                         }
4251                 }
4252
4253                 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)
4254                    && (CC->user.axlevel < AxNetU) ) {
4255                         cprintf("%d Higher access required for network mail.\n",
4256                                 ERROR + HIGHER_ACCESS_REQUIRED);
4257                         free_recipients(valid_to);
4258                         free_recipients(valid_cc);
4259                         free_recipients(valid_bcc);
4260                         return;
4261                 }
4262
4263                 if ((RESTRICT_INTERNET == 1)
4264                     && (valid_to->num_internet + valid_cc->num_internet + valid_bcc->num_internet > 0)
4265                     && ((CC->user.flags & US_INTERNET) == 0)
4266                     && (!CC->internal_pgm)) {
4267                         cprintf("%d You don't have access to Internet mail.\n",
4268                                 ERROR + HIGHER_ACCESS_REQUIRED);
4269                         free_recipients(valid_to);
4270                         free_recipients(valid_cc);
4271                         free_recipients(valid_bcc);
4272                         return;
4273                 }
4274
4275         }
4276
4277         /* Is this a room which has anonymous-only or anonymous-option? */
4278         anonymous = MES_NORMAL;
4279         if (CC->room.QRflags & QR_ANONONLY) {
4280                 anonymous = MES_ANONONLY;
4281         }
4282         if (CC->room.QRflags & QR_ANONOPT) {
4283                 if (anon_flag == 1) {   /* only if the user requested it */
4284                         anonymous = MES_ANONOPT;
4285                 }
4286         }
4287
4288         if ((CC->room.QRflags & QR_MAILBOX) == 0) {
4289                 recp[0] = 0;
4290         }
4291
4292         /* Recommend to the client that the use of a message subject is
4293          * strongly recommended in this room, if either the SUBJECTREQ flag
4294          * is set, or if there is one or more Internet email recipients.
4295          */
4296         if (CC->room.QRflags2 & QR2_SUBJECTREQ) subject_required = 1;
4297         if ((valid_to)  && (valid_to->num_internet > 0))        subject_required = 1;
4298         if ((valid_cc)  && (valid_cc->num_internet > 0))        subject_required = 1;
4299         if ((valid_bcc) && (valid_bcc->num_internet > 0))       subject_required = 1;
4300
4301         /* If we're only checking the validity of the request, return
4302          * success without creating the message.
4303          */
4304         if (post == 0) {
4305                 cprintf("%d %s|%d\n", CIT_OK,
4306                         ((valid_to != NULL) ? valid_to->display_recp : ""),
4307                         subject_required);
4308                 free_recipients(valid_to);
4309                 free_recipients(valid_cc);
4310                 free_recipients(valid_bcc);
4311                 return;
4312         }
4313
4314         /* We don't need these anymore because we'll do it differently below */
4315         free_recipients(valid_to);
4316         free_recipients(valid_cc);
4317         free_recipients(valid_bcc);
4318
4319         /* Read in the message from the client. */
4320         if (do_confirm) {
4321                 cprintf("%d send message\n", START_CHAT_MODE);
4322         } else {
4323                 cprintf("%d send message\n", SEND_LISTING);
4324         }
4325
4326         msg = CtdlMakeMessage(&CC->user, recp, cc,
4327                 CC->room.QRname, anonymous, format_type,
4328                 newusername, newuseremail, subject,
4329                 ((!IsEmptyStr(supplied_euid)) ? supplied_euid : NULL),
4330                 NULL, references);
4331
4332         /* Put together one big recipients struct containing to/cc/bcc all in
4333          * one.  This is for the envelope.
4334          */
4335         char *all_recps = malloc(SIZ * 3);
4336         strcpy(all_recps, recp);
4337         if (!IsEmptyStr(cc)) {
4338                 if (!IsEmptyStr(all_recps)) {
4339                         strcat(all_recps, ",");
4340                 }
4341                 strcat(all_recps, cc);
4342         }
4343         if (!IsEmptyStr(bcc)) {
4344                 if (!IsEmptyStr(all_recps)) {
4345                         strcat(all_recps, ",");
4346                 }
4347                 strcat(all_recps, bcc);
4348         }
4349         if (!IsEmptyStr(all_recps)) {
4350                 valid = validate_recipients(all_recps, NULL, 0);
4351         }
4352         else {
4353                 valid = NULL;
4354         }
4355         free(all_recps);
4356
4357         if (msg != NULL) {
4358                 msgnum = CtdlSubmitMsg(msg, valid, "", QP_EADDR);
4359
4360                 if (do_confirm) {
4361                         cprintf("%ld\n", msgnum);
4362                         if (msgnum >= 0L) {
4363                                 cprintf("Message accepted.\n");
4364                         }
4365                         else {
4366                                 cprintf("Internal error.\n");
4367                         }
4368                         if (msg->cm_fields['E'] != NULL) {
4369                                 cprintf("%s\n", msg->cm_fields['E']);
4370                         } else {
4371                                 cprintf("\n");
4372                         }
4373                         cprintf("000\n");
4374                 }
4375
4376                 CtdlFreeMessage(msg);
4377         }
4378         if (valid != NULL) {
4379                 free_recipients(valid);
4380         }
4381         return;
4382 }
4383
4384
4385
4386 /*
4387  * API function to delete messages which match a set of criteria
4388  * (returns the actual number of messages deleted)
4389  */
4390 int CtdlDeleteMessages(char *room_name,         /* which room */
4391                         long *dmsgnums,         /* array of msg numbers to be deleted */
4392                         int num_dmsgnums,       /* number of msgs to be deleted, or 0 for "any" */
4393                         char *content_type      /* or "" for any.  regular expressions expected. */
4394 )
4395 {
4396         struct ctdlroom qrbuf;
4397         struct cdbdata *cdbfr;
4398         long *msglist = NULL;
4399         long *dellist = NULL;
4400         int num_msgs = 0;
4401         int i, j;
4402         int num_deleted = 0;
4403         int delete_this;
4404         struct MetaData smi;
4405         regex_t re;
4406         regmatch_t pm;
4407         int need_to_free_re = 0;
4408
4409         if (content_type) if (!IsEmptyStr(content_type)) {
4410                 regcomp(&re, content_type, 0);
4411                 need_to_free_re = 1;
4412         }
4413         syslog(LOG_DEBUG, "CtdlDeleteMessages(%s, %d msgs, %s)\n",
4414                 room_name, num_dmsgnums, content_type);
4415
4416         /* get room record, obtaining a lock... */
4417         if (CtdlGetRoomLock(&qrbuf, room_name) != 0) {
4418                 syslog(LOG_ERR, "CtdlDeleteMessages(): Room <%s> not found\n",
4419                         room_name);
4420                 if (need_to_free_re) regfree(&re);
4421                 return (0);     /* room not found */
4422         }
4423         cdbfr = cdb_fetch(CDB_MSGLISTS, &qrbuf.QRnumber, sizeof(long));
4424
4425         if (cdbfr != NULL) {
4426                 dellist = malloc(cdbfr->len);
4427                 msglist = (long *) cdbfr->ptr;
4428                 cdbfr->ptr = NULL;      /* CtdlDeleteMessages() now owns this memory */
4429                 num_msgs = cdbfr->len / sizeof(long);
4430                 cdb_free(cdbfr);
4431         }
4432         if (num_msgs > 0) {
4433                 for (i = 0; i < num_msgs; ++i) {
4434                         delete_this = 0x00;
4435
4436                         /* Set/clear a bit for each criterion */
4437
4438                         /* 0 messages in the list or a null list means that we are
4439                          * interested in deleting any messages which meet the other criteria.
4440                          */
4441                         if ((num_dmsgnums == 0) || (dmsgnums == NULL)) {
4442                                 delete_this |= 0x01;
4443                         }
4444                         else {
4445                                 for (j=0; j<num_dmsgnums; ++j) {
4446                                         if (msglist[i] == dmsgnums[j]) {
4447                                                 delete_this |= 0x01;
4448                                         }
4449                                 }
4450                         }
4451
4452                         if (IsEmptyStr(content_type)) {
4453                                 delete_this |= 0x02;
4454                         } else {
4455                                 GetMetaData(&smi, msglist[i]);
4456                                 if (regexec(&re, smi.meta_content_type, 1, &pm, 0) == 0) {
4457                                         delete_this |= 0x02;
4458                                 }
4459                         }
4460
4461                         /* Delete message only if all bits are set */
4462                         if (delete_this == 0x03) {
4463                                 dellist[num_deleted++] = msglist[i];
4464                                 msglist[i] = 0L;
4465                         }
4466                 }
4467
4468                 num_msgs = sort_msglist(msglist, num_msgs);
4469                 cdb_store(CDB_MSGLISTS, &qrbuf.QRnumber, (int)sizeof(long),
4470                           msglist, (int)(num_msgs * sizeof(long)));
4471
4472                 if (num_msgs > 0)
4473                         qrbuf.QRhighest = msglist[num_msgs - 1];
4474                 else
4475                         qrbuf.QRhighest = 0;
4476         }
4477         CtdlPutRoomLock(&qrbuf);
4478
4479         /* Go through the messages we pulled out of the index, and decrement
4480          * their reference counts by 1.  If this is the only room the message
4481          * was in, the reference count will reach zero and the message will
4482          * automatically be deleted from the database.  We do this in a
4483          * separate pass because there might be plug-in hooks getting called,
4484          * and we don't want that happening during an S_ROOMS critical
4485          * section.
4486          */
4487         if (num_deleted) for (i=0; i<num_deleted; ++i) {
4488                 PerformDeleteHooks(qrbuf.QRname, dellist[i]);
4489                 AdjRefCount(dellist[i], -1);
4490         }
4491
4492         /* Now free the memory we used, and go away. */
4493         if (msglist != NULL) free(msglist);
4494         if (dellist != NULL) free(dellist);
4495         syslog(LOG_DEBUG, "%d message(s) deleted.\n", num_deleted);
4496         if (need_to_free_re) regfree(&re);
4497         return (num_deleted);
4498 }
4499
4500
4501
4502 /*
4503  * Check whether the current user has permission to delete messages from
4504  * the current room (returns 1 for yes, 0 for no)
4505  */
4506 int CtdlDoIHavePermissionToDeleteMessagesFromThisRoom(void) {
4507         int ra;
4508         CtdlRoomAccess(&CC->room, &CC->user, &ra, NULL);
4509         if (ra & UA_DELETEALLOWED) return(1);
4510         return(0);
4511 }
4512
4513
4514
4515
4516 /*
4517  * Delete message from current room
4518  */
4519 void cmd_dele(char *args)
4520 {
4521         int num_deleted;
4522         int i;
4523         char msgset[SIZ];
4524         char msgtok[32];
4525         long *msgs;
4526         int num_msgs = 0;
4527
4528         extract_token(msgset, args, 0, '|', sizeof msgset);
4529         num_msgs = num_tokens(msgset, ',');
4530         if (num_msgs < 1) {
4531                 cprintf("%d Nothing to do.\n", CIT_OK);
4532                 return;
4533         }
4534
4535         if (CtdlDoIHavePermissionToDeleteMessagesFromThisRoom() == 0) {
4536                 cprintf("%d Higher access required.\n",
4537                         ERROR + HIGHER_ACCESS_REQUIRED);
4538                 return;
4539         }
4540
4541         /*
4542          * Build our message set to be moved/copied
4543          */
4544         msgs = malloc(num_msgs * sizeof(long));
4545         for (i=0; i<num_msgs; ++i) {
4546                 extract_token(msgtok, msgset, i, ',', sizeof msgtok);
4547                 msgs[i] = atol(msgtok);
4548         }
4549
4550         num_deleted = CtdlDeleteMessages(CC->room.QRname, msgs, num_msgs, "");
4551         free(msgs);
4552
4553         if (num_deleted) {
4554                 cprintf("%d %d message%s deleted.\n", CIT_OK,
4555                         num_deleted, ((num_deleted != 1) ? "s" : ""));
4556         } else {
4557                 cprintf("%d Message not found.\n", ERROR + MESSAGE_NOT_FOUND);
4558         }
4559 }
4560
4561
4562
4563
4564 /*
4565  * move or copy a message to another room
4566  */
4567 void cmd_move(char *args)
4568 {
4569         char msgset[SIZ];
4570         char msgtok[32];
4571         long *msgs;
4572         int num_msgs = 0;
4573
4574         char targ[ROOMNAMELEN];
4575         struct ctdlroom qtemp;
4576         int err;
4577         int is_copy = 0;
4578         int ra;
4579         int permit = 0;
4580         int i;
4581
4582         extract_token(msgset, args, 0, '|', sizeof msgset);
4583         num_msgs = num_tokens(msgset, ',');
4584         if (num_msgs < 1) {
4585                 cprintf("%d Nothing to do.\n", CIT_OK);
4586                 return;
4587         }
4588
4589         extract_token(targ, args, 1, '|', sizeof targ);
4590         convert_room_name_macros(targ, sizeof targ);
4591         targ[ROOMNAMELEN - 1] = 0;
4592         is_copy = extract_int(args, 2);
4593
4594         if (CtdlGetRoom(&qtemp, targ) != 0) {
4595                 cprintf("%d '%s' does not exist.\n", ERROR + ROOM_NOT_FOUND, targ);
4596                 return;
4597         }
4598
4599         if (!strcasecmp(qtemp.QRname, CC->room.QRname)) {
4600                 cprintf("%d Source and target rooms are the same.\n", ERROR + ALREADY_EXISTS);
4601                 return;
4602         }
4603
4604         CtdlGetUser(&CC->user, CC->curr_user);
4605         CtdlRoomAccess(&qtemp, &CC->user, &ra, NULL);
4606
4607         /* Check for permission to perform this operation.
4608          * Remember: "CC->room" is source, "qtemp" is target.
4609          */
4610         permit = 0;
4611
4612         /* Aides can move/copy */
4613         if (CC->user.axlevel >= AxAideU) permit = 1;
4614
4615         /* Room aides can move/copy */
4616         if (CC->user.usernum == CC->room.QRroomaide) permit = 1;
4617
4618         /* Permit move/copy from personal rooms */
4619         if ((CC->room.QRflags & QR_MAILBOX)
4620            && (qtemp.QRflags & QR_MAILBOX)) permit = 1;
4621
4622         /* Permit only copy from public to personal room */
4623         if ( (is_copy)
4624            && (!(CC->room.QRflags & QR_MAILBOX))
4625            && (qtemp.QRflags & QR_MAILBOX)) permit = 1;
4626
4627         /* Permit message removal from collaborative delete rooms */
4628         if (CC->room.QRflags2 & QR2_COLLABDEL) permit = 1;
4629
4630         /* Users allowed to post into the target room may move into it too. */
4631         if ((CC->room.QRflags & QR_MAILBOX) &&
4632             (qtemp.QRflags & UA_POSTALLOWED))  permit = 1;
4633
4634         /* User must have access to target room */
4635         if (!(ra & UA_KNOWN))  permit = 0;
4636
4637         if (!permit) {
4638                 cprintf("%d Higher access required.\n",
4639                         ERROR + HIGHER_ACCESS_REQUIRED);
4640                 return;
4641         }
4642
4643         /*
4644          * Build our message set to be moved/copied
4645          */
4646         msgs = malloc(num_msgs * sizeof(long));
4647         for (i=0; i<num_msgs; ++i) {
4648                 extract_token(msgtok, msgset, i, ',', sizeof msgtok);
4649                 msgs[i] = atol(msgtok);
4650         }
4651
4652         /*
4653          * Do the copy
4654          */
4655         err = CtdlSaveMsgPointersInRoom(targ, msgs, num_msgs, 1, NULL, 0);
4656         if (err != 0) {
4657                 cprintf("%d Cannot store message(s) in %s: error %d\n",
4658                         err, targ, err);
4659                 free(msgs);
4660                 return;
4661         }
4662
4663         /* Now delete the message from the source room,
4664          * if this is a 'move' rather than a 'copy' operation.
4665          */
4666         if (is_copy == 0) {
4667                 CtdlDeleteMessages(CC->room.QRname, msgs, num_msgs, "");
4668         }
4669         free(msgs);
4670
4671         cprintf("%d Message(s) %s.\n", CIT_OK, (is_copy ? "copied" : "moved") );
4672 }
4673
4674
4675
4676 /*
4677  * GetMetaData()  -  Get the supplementary record for a message
4678  */
4679 void GetMetaData(struct MetaData *smibuf, long msgnum)
4680 {
4681
4682         struct cdbdata *cdbsmi;
4683         long TheIndex;
4684
4685         memset(smibuf, 0, sizeof(struct MetaData));
4686         smibuf->meta_msgnum = msgnum;
4687         smibuf->meta_refcount = 1;      /* Default reference count is 1 */
4688
4689         /* Use the negative of the message number for its supp record index */
4690         TheIndex = (0L - msgnum);
4691
4692         cdbsmi = cdb_fetch(CDB_MSGMAIN, &TheIndex, sizeof(long));
4693         if (cdbsmi == NULL) {
4694                 return;         /* record not found; go with defaults */
4695         }
4696         memcpy(smibuf, cdbsmi->ptr,
4697                ((cdbsmi->len > sizeof(struct MetaData)) ?
4698                 sizeof(struct MetaData) : cdbsmi->len));
4699         cdb_free(cdbsmi);
4700         return;
4701 }
4702
4703
4704 /*
4705  * PutMetaData()  -  (re)write supplementary record for a message
4706  */
4707 void PutMetaData(struct MetaData *smibuf)
4708 {
4709         long TheIndex;
4710
4711         /* Use the negative of the message number for the metadata db index */
4712         TheIndex = (0L - smibuf->meta_msgnum);
4713
4714         cdb_store(CDB_MSGMAIN,
4715                   &TheIndex, (int)sizeof(long),
4716                   smibuf, (int)sizeof(struct MetaData));
4717
4718 }
4719
4720 /*
4721  * AdjRefCount  -  submit an adjustment to the reference count for a message.
4722  *                 (These are just queued -- we actually process them later.)
4723  */
4724 void AdjRefCount(long msgnum, int incr)
4725 {
4726         struct arcq new_arcq;
4727         int rv = 0;
4728
4729         syslog(LOG_DEBUG, "AdjRefCount() msg %ld ref count delta %+d\n",
4730                 msgnum, incr
4731         );
4732
4733         begin_critical_section(S_SUPPMSGMAIN);
4734         if (arcfp == NULL) {
4735                 arcfp = fopen(file_arcq, "ab+");
4736         }
4737         end_critical_section(S_SUPPMSGMAIN);
4738
4739         /* msgnum < 0 means that we're trying to close the file */
4740         if (msgnum < 0) {
4741                 syslog(LOG_DEBUG, "Closing the AdjRefCount queue file\n");
4742                 begin_critical_section(S_SUPPMSGMAIN);
4743                 if (arcfp != NULL) {
4744                         fclose(arcfp);
4745                         arcfp = NULL;
4746                 }
4747                 end_critical_section(S_SUPPMSGMAIN);
4748                 return;
4749         }
4750
4751         /*
4752          * If we can't open the queue, perform the operation synchronously.
4753          */
4754         if (arcfp == NULL) {
4755                 TDAP_AdjRefCount(msgnum, incr);
4756                 return;
4757         }
4758
4759         new_arcq.arcq_msgnum = msgnum;
4760         new_arcq.arcq_delta = incr;
4761         rv = fwrite(&new_arcq, sizeof(struct arcq), 1, arcfp);
4762         fflush(arcfp);
4763
4764         return;
4765 }
4766
4767
4768 /*
4769  * TDAP_ProcessAdjRefCountQueue()
4770  *
4771  * Process the queue of message count adjustments that was created by calls
4772  * to AdjRefCount() ... by reading the queue and calling TDAP_AdjRefCount()
4773  * for each one.  This should be an "off hours" operation.
4774  */
4775 int TDAP_ProcessAdjRefCountQueue(void)
4776 {
4777         char file_arcq_temp[PATH_MAX];
4778         int r;
4779         FILE *fp;
4780         struct arcq arcq_rec;
4781         int num_records_processed = 0;
4782
4783         snprintf(file_arcq_temp, sizeof file_arcq_temp, "%s.%04x", file_arcq, rand());
4784
4785         begin_critical_section(S_SUPPMSGMAIN);
4786         if (arcfp != NULL) {
4787                 fclose(arcfp);
4788                 arcfp = NULL;
4789         }
4790
4791         r = link(file_arcq, file_arcq_temp);
4792         if (r != 0) {
4793                 syslog(LOG_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
4794                 end_critical_section(S_SUPPMSGMAIN);
4795                 return(num_records_processed);
4796         }
4797
4798         unlink(file_arcq);
4799         end_critical_section(S_SUPPMSGMAIN);
4800
4801         fp = fopen(file_arcq_temp, "rb");
4802         if (fp == NULL) {
4803                 syslog(LOG_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
4804                 return(num_records_processed);
4805         }
4806
4807         while (fread(&arcq_rec, sizeof(struct arcq), 1, fp) == 1) {
4808                 TDAP_AdjRefCount(arcq_rec.arcq_msgnum, arcq_rec.arcq_delta);
4809                 ++num_records_processed;
4810         }
4811
4812         fclose(fp);
4813         r = unlink(file_arcq_temp);
4814         if (r != 0) {
4815                 syslog(LOG_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
4816         }
4817
4818         return(num_records_processed);
4819 }
4820
4821
4822
4823 /*
4824  * TDAP_AdjRefCount  -  adjust the reference count for a message.
4825  *                      This one does it "for real" because it's called by
4826  *                      the autopurger function that processes the queue
4827  *                      created by AdjRefCount().   If a message's reference
4828  *                      count becomes zero, we also delete the message from
4829  *                      disk and de-index it.
4830  */
4831 void TDAP_AdjRefCount(long msgnum, int incr)
4832 {
4833
4834         struct MetaData smi;
4835         long delnum;
4836
4837         /* This is a *tight* critical section; please keep it that way, as
4838          * it may get called while nested in other critical sections.
4839          * Complicating this any further will surely cause deadlock!
4840          */
4841         begin_critical_section(S_SUPPMSGMAIN);
4842         GetMetaData(&smi, msgnum);
4843         smi.meta_refcount += incr;
4844         PutMetaData(&smi);
4845         end_critical_section(S_SUPPMSGMAIN);
4846         syslog(LOG_DEBUG, "TDAP_AdjRefCount() msg %ld ref count delta %+d, is now %d\n",
4847                 msgnum, incr, smi.meta_refcount
4848         );
4849
4850         /* If the reference count is now zero, delete the message
4851          * (and its supplementary record as well).
4852          */
4853         if (smi.meta_refcount == 0) {
4854                 syslog(LOG_DEBUG, "Deleting message <%ld>\n", msgnum);
4855
4856                 /* Call delete hooks with NULL room to show it has gone altogether */
4857                 PerformDeleteHooks(NULL, msgnum);
4858
4859                 /* Remove from message base */
4860                 delnum = msgnum;
4861                 cdb_delete(CDB_MSGMAIN, &delnum, (int)sizeof(long));
4862                 cdb_delete(CDB_BIGMSGS, &delnum, (int)sizeof(long));
4863
4864                 /* Remove metadata record */
4865                 delnum = (0L - msgnum);
4866                 cdb_delete(CDB_MSGMAIN, &delnum, (int)sizeof(long));
4867         }
4868
4869 }
4870
4871 /*
4872  * Write a generic object to this room
4873  *
4874  * Note: this could be much more efficient.  Right now we use two temporary
4875  * files, and still pull the message into memory as with all others.
4876  */
4877 void CtdlWriteObject(char *req_room,                    /* Room to stuff it in */
4878                         char *content_type,             /* MIME type of this object */
4879                         char *raw_message,              /* Data to be written */
4880                         off_t raw_length,               /* Size of raw_message */
4881                         struct ctdluser *is_mailbox,    /* Mailbox room? */
4882                         int is_binary,                  /* Is encoding necessary? */
4883                         int is_unique,                  /* Del others of this type? */
4884                         unsigned int flags              /* Internal save flags */
4885                         )
4886 {
4887
4888         struct ctdlroom qrbuf;
4889         char roomname[ROOMNAMELEN];
4890         struct CtdlMessage *msg;
4891         char *encoded_message = NULL;
4892
4893         if (is_mailbox != NULL) {
4894                 CtdlMailboxName(roomname, sizeof roomname, is_mailbox, req_room);
4895         }
4896         else {
4897                 safestrncpy(roomname, req_room, sizeof(roomname));
4898         }
4899
4900         syslog(LOG_DEBUG, "Raw length is %ld\n", (long)raw_length);
4901
4902         if (is_binary) {
4903                 encoded_message = malloc((size_t) (((raw_length * 134) / 100) + 4096 ) );
4904         }
4905         else {
4906                 encoded_message = malloc((size_t)(raw_length + 4096));
4907         }
4908
4909         sprintf(encoded_message, "Content-type: %s\n", content_type);
4910
4911         if (is_binary) {
4912                 sprintf(&encoded_message[strlen(encoded_message)],
4913                         "Content-transfer-encoding: base64\n\n"
4914                 );
4915         }
4916         else {
4917                 sprintf(&encoded_message[strlen(encoded_message)],
4918                         "Content-transfer-encoding: 7bit\n\n"
4919                 );
4920         }
4921
4922         if (is_binary) {
4923                 CtdlEncodeBase64(
4924                         &encoded_message[strlen(encoded_message)],
4925                         raw_message,
4926                         (int)raw_length,
4927                         0
4928                 );
4929         }
4930         else {
4931                 memcpy(
4932                         &encoded_message[strlen(encoded_message)],
4933                         raw_message,
4934                         (int)(raw_length+1)
4935                 );
4936         }
4937
4938         syslog(LOG_DEBUG, "Allocating\n");
4939         msg = malloc(sizeof(struct CtdlMessage));
4940         memset(msg, 0, sizeof(struct CtdlMessage));
4941         msg->cm_magic = CTDLMESSAGE_MAGIC;
4942         msg->cm_anon_type = MES_NORMAL;
4943         msg->cm_format_type = 4;
4944         msg->cm_fields['A'] = strdup(CC->user.fullname);
4945         msg->cm_fields['O'] = strdup(req_room);
4946         msg->cm_fields['N'] = strdup(config.c_nodename);
4947         msg->cm_fields['H'] = strdup(config.c_humannode);
4948         msg->cm_flags = flags;
4949
4950         msg->cm_fields['M'] = encoded_message;
4951
4952         /* Create the requested room if we have to. */
4953         if (CtdlGetRoom(&qrbuf, roomname) != 0) {
4954                 CtdlCreateRoom(roomname,
4955                         ( (is_mailbox != NULL) ? 5 : 3 ),
4956                         "", 0, 1, 0, VIEW_BBS);
4957         }
4958         /* If the caller specified this object as unique, delete all
4959          * other objects of this type that are currently in the room.
4960          */
4961         if (is_unique) {
4962                 syslog(LOG_DEBUG, "Deleted %d other msgs of this type\n",
4963                         CtdlDeleteMessages(roomname, NULL, 0, content_type)
4964                 );
4965         }
4966         /* Now write the data */
4967         CtdlSubmitMsg(msg, NULL, roomname, 0);
4968         CtdlFreeMessage(msg);
4969 }
4970
4971
4972
4973
4974
4975
4976 void CtdlGetSysConfigBackend(long msgnum, void *userdata) {
4977         config_msgnum = msgnum;
4978 }
4979
4980
4981 char *CtdlGetSysConfig(char *sysconfname) {
4982         char hold_rm[ROOMNAMELEN];
4983         long msgnum;
4984         char *conf;
4985         struct CtdlMessage *msg;
4986         char buf[SIZ];
4987
4988         strcpy(hold_rm, CC->room.QRname);
4989         if (CtdlGetRoom(&CC->room, SYSCONFIGROOM) != 0) {
4990                 CtdlGetRoom(&CC->room, hold_rm);
4991                 return NULL;
4992         }
4993
4994
4995         /* We want the last (and probably only) config in this room */
4996         begin_critical_section(S_CONFIG);
4997         config_msgnum = (-1L);
4998         CtdlForEachMessage(MSGS_LAST, 1, NULL, sysconfname, NULL,
4999                 CtdlGetSysConfigBackend, NULL);
5000         msgnum = config_msgnum;
5001         end_critical_section(S_CONFIG);
5002
5003         if (msgnum < 0L) {
5004                 conf = NULL;
5005         }
5006         else {
5007                 msg = CtdlFetchMessage(msgnum, 1);
5008                 if (msg != NULL) {
5009                         conf = strdup(msg->cm_fields['M']);
5010                         CtdlFreeMessage(msg);
5011                 }
5012                 else {
5013                         conf = NULL;
5014                 }
5015         }
5016
5017         CtdlGetRoom(&CC->room, hold_rm);
5018
5019         if (conf != NULL) do {
5020                 extract_token(buf, conf, 0, '\n', sizeof buf);
5021                 strcpy(conf, &conf[strlen(buf)+1]);
5022         } while ( (!IsEmptyStr(conf)) && (!IsEmptyStr(buf)) );
5023
5024         return(conf);
5025 }
5026
5027
5028 void CtdlPutSysConfig(char *sysconfname, char *sysconfdata) {
5029         CtdlWriteObject(SYSCONFIGROOM, sysconfname, sysconfdata, (strlen(sysconfdata)+1), NULL, 0, 1, 0);
5030 }
5031
5032
5033 /*
5034  * Determine whether a given Internet address belongs to the current user
5035  */
5036 int CtdlIsMe(char *addr, int addr_buf_len)
5037 {
5038         struct recptypes *recp;
5039         int i;
5040
5041         recp = validate_recipients(addr, NULL, 0);
5042         if (recp == NULL) return(0);
5043
5044         if (recp->num_local == 0) {
5045                 free_recipients(recp);
5046                 return(0);
5047         }
5048
5049         for (i=0; i<recp->num_local; ++i) {
5050                 extract_token(addr, recp->recp_local, i, '|', addr_buf_len);
5051                 if (!strcasecmp(addr, CC->user.fullname)) {
5052                         free_recipients(recp);
5053                         return(1);
5054                 }
5055         }
5056
5057         free_recipients(recp);
5058         return(0);
5059 }
5060
5061
5062 /*
5063  * Citadel protocol command to do the same
5064  */
5065 void cmd_isme(char *argbuf) {
5066         char addr[256];
5067
5068         if (CtdlAccessCheck(ac_logged_in)) return;
5069         extract_token(addr, argbuf, 0, '|', sizeof addr);
5070
5071         if (CtdlIsMe(addr, sizeof addr)) {
5072                 cprintf("%d %s\n", CIT_OK, addr);
5073         }
5074         else {
5075                 cprintf("%d Not you.\n", ERROR + ILLEGAL_VALUE);
5076         }
5077
5078 }
5079
5080
5081 /*****************************************************************************/
5082 /*                      MODULE INITIALIZATION STUFF                          */
5083 /*****************************************************************************/
5084
5085 CTDL_MODULE_INIT(msgbase)
5086 {
5087         if (!threading) {
5088                 CtdlRegisterProtoHook(cmd_msgs, "MSGS", "Output a list of messages in the current room");
5089                 CtdlRegisterProtoHook(cmd_msg0, "MSG0", "Output a message in plain text format");
5090                 CtdlRegisterProtoHook(cmd_msg2, "MSG2", "Output a message in RFC822 format");
5091                 CtdlRegisterProtoHook(cmd_msg3, "MSG3", "Output a message in raw format (deprecated)");
5092                 CtdlRegisterProtoHook(cmd_msg4, "MSG4", "Output a message in the client's preferred format");
5093                 CtdlRegisterProtoHook(cmd_msgp, "MSGP", "Select preferred format for MSG4 output");
5094                 CtdlRegisterProtoHook(cmd_opna, "OPNA", "Open an attachment for download");
5095                 CtdlRegisterProtoHook(cmd_dlat, "DLAT", "Download an attachment");
5096                 CtdlRegisterProtoHook(cmd_ent0, "ENT0", "Enter a message");
5097                 CtdlRegisterProtoHook(cmd_dele, "DELE", "Delete a message");
5098                 CtdlRegisterProtoHook(cmd_move, "MOVE", "Move or copy a message to another room");
5099                 CtdlRegisterProtoHook(cmd_isme, "ISME", "Determine whether an email address belongs to a user");
5100         }
5101
5102         /* return our Subversion id for the Log */
5103         return "msgbase";
5104 }