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