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                         if (client_write(outbuf, len) == -1)
 958                         {
 959                                 syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
 960                                 return;
 961                         }
 962                         len = 0;
 963                         if (client_write(nl, nllen) == -1)
 964                         {
 965                                 syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
 966                                 return;
 967                         }
 968                         column = 0;
 969                 }
 970                 else if (ch == '\r') {
 971                         /* Ignore carriage returns.  Newlines are always LF or CRLF but never CR. */
 972                 }
 973                 else if (isspace(ch)) {
 974                         if (column > 72) {              /* Beyond 72 columns, break on the next space */
 975                                 if (client_write(outbuf, len) == -1)
 976                                 {
 977                                         syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
 978                                         return;
 979                                 }
 980                                 len = 0;
 981                                 if (client_write(nl, nllen) == -1)
 982                                 {
 983                                         syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
 984                                         return;
 985                                 }
 986                                 column = 0;
 987                         }
 988                         else {
 989                                 outbuf[len++] = ch;
 990                                 ++column;
 991                         }
 992                 }
 993                 else {
 994                         outbuf[len++] = ch;
 995                         ++column;
 996                         if (column > 1000) {            /* Beyond 1000 columns, break anywhere */
 997                                 if (client_write(outbuf, len) == -1)
 998                                 {
 999                                         syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
1000                                         return;
1001                                 }
1002                                 len = 0;
1003                                 if (client_write(nl, nllen) == -1)
1004                                 {
1005                                         syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
1006                                         return;
1007                                 }
1008                                 column = 0;
1009                         }
1010                 }
1011         }
1012         if (len) {
1013                 if (client_write(outbuf, len) == -1)
1014                 {
1015                         syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
1016                         return;
1017                 }
1018                 len = 0;
1019                 client_write(nl, nllen);
1020                 column = 0;
1021         }
1022 }
1023
1024
1025
1026 /*
1027  * Callback function for mime parser that simply lists the part
1028  */
1029 void list_this_part(char *name, char *filename, char *partnum, char *disp,
1030                     void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
1031                     char *cbid, void *cbuserdata)
1032 {
1033         struct ma_info *ma;
1034
1035         ma = (struct ma_info *)cbuserdata;
1036         if (ma->is_ma == 0) {
1037                 cprintf("part=%s|%s|%s|%s|%s|%ld|%s|%s\n",
1038                         name,
1039                         filename,
1040                         partnum,
1041                         disp,
1042                         cbtype,
1043                         (long)length,
1044                         cbid,
1045                         cbcharset);
1046         }
1047 }
1048
1049 /*
1050  * Callback function for multipart prefix
1051  */
1052 void list_this_pref(char *name, char *filename, char *partnum, char *disp,
1053                     void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
1054                     char *cbid, void *cbuserdata)
1055 {
1056         struct ma_info *ma;
1057
1058         ma = (struct ma_info *)cbuserdata;
1059         if (!strcasecmp(cbtype, "multipart/alternative")) {
1060                 ++ma->is_ma;
1061         }
1062
1063         if (ma->is_ma == 0) {
1064                 cprintf("pref=%s|%s\n", partnum, cbtype);
1065         }
1066 }
1067
1068 /*
1069  * Callback function for multipart sufffix
1070  */
1071 void list_this_suff(char *name, char *filename, char *partnum, char *disp,
1072                     void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
1073                     char *cbid, void *cbuserdata)
1074 {
1075         struct ma_info *ma;
1076
1077         ma = (struct ma_info *)cbuserdata;
1078         if (ma->is_ma == 0) {
1079                 cprintf("suff=%s|%s\n", partnum, cbtype);
1080         }
1081         if (!strcasecmp(cbtype, "multipart/alternative")) {
1082                 --ma->is_ma;
1083         }
1084 }
1085
1086
1087 /*
1088  * Callback function for mime parser that opens a section for downloading
1089  */
1090 void mime_download(char *name, char *filename, char *partnum, char *disp,
1091                    void *content, char *cbtype, char *cbcharset, size_t length,
1092                    char *encoding, char *cbid, void *cbuserdata)
1093 {
1094         int rv = 0;
1095
1096         /* Silently go away if there's already a download open. */
1097         if (CC->download_fp != NULL)
1098                 return;
1099
1100         if (
1101                 (!IsEmptyStr(partnum) && (!strcasecmp(CC->download_desired_section, partnum)))
1102         ||      (!IsEmptyStr(cbid) && (!strcasecmp(CC->download_desired_section, cbid)))
1103         ) {
1104                 CC->download_fp = tmpfile();
1105                 if (CC->download_fp == NULL)
1106                         return;
1107
1108                 rv = fwrite(content, length, 1, CC->download_fp);
1109                 fflush(CC->download_fp);
1110                 rewind(CC->download_fp);
1111
1112                 OpenCmdResult(filename, cbtype);
1113         }
1114 }
1115
1116
1117
1118 /*
1119  * Callback function for mime parser that outputs a section all at once.
1120  * We can specify the desired section by part number *or* content-id.
1121  */
1122 void mime_spew_section(char *name, char *filename, char *partnum, char *disp,
1123                    void *content, char *cbtype, char *cbcharset, size_t length,
1124                    char *encoding, char *cbid, void *cbuserdata)
1125 {
1126         int *found_it = (int *)cbuserdata;
1127
1128         if (
1129                 (!IsEmptyStr(partnum) && (!strcasecmp(CC->download_desired_section, partnum)))
1130         ||      (!IsEmptyStr(cbid) && (!strcasecmp(CC->download_desired_section, cbid)))
1131         ) {
1132                 *found_it = 1;
1133                 cprintf("%d %d|-1|%s|%s|%s\n",
1134                         BINARY_FOLLOWS,
1135                         (int)length,
1136                         filename,
1137                         cbtype,
1138                         cbcharset
1139                 );
1140                 client_write(content, length);
1141         }
1142 }
1143
1144
1145 /*
1146  * Load a message from disk into memory.
1147  * This is used by CtdlOutputMsg() and other fetch functions.
1148  *
1149  * NOTE: Caller is responsible for freeing the returned CtdlMessage struct
1150  *       using the CtdlMessageFree() function.
1151  */
1152 struct CtdlMessage *CtdlFetchMessage(long msgnum, int with_body)
1153 {
1154         struct cdbdata *dmsgtext;
1155         struct CtdlMessage *ret = NULL;
1156         char *mptr;
1157         char *upper_bound;
1158         cit_uint8_t ch;
1159         cit_uint8_t field_header;
1160
1161         syslog(LOG_DEBUG, "CtdlFetchMessage(%ld, %d)\n", msgnum, with_body);
1162         dmsgtext = cdb_fetch(CDB_MSGMAIN, &msgnum, sizeof(long));
1163         if (dmsgtext == NULL) {
1164                 return NULL;
1165         }
1166         mptr = dmsgtext->ptr;
1167         upper_bound = mptr + dmsgtext->len;
1168
1169         /* Parse the three bytes that begin EVERY message on disk.
1170          * The first is always 0xFF, the on-disk magic number.
1171          * The second is the anonymous/public type byte.
1172          * The third is the format type byte (vari, fixed, or MIME).
1173          */
1174         ch = *mptr++;
1175         if (ch != 255) {
1176                 syslog(LOG_ERR, "Message %ld appears to be corrupted.\n", msgnum);
1177                 cdb_free(dmsgtext);
1178                 return NULL;
1179         }
1180         ret = (struct CtdlMessage *) malloc(sizeof(struct CtdlMessage));
1181         memset(ret, 0, sizeof(struct CtdlMessage));
1182
1183         ret->cm_magic = CTDLMESSAGE_MAGIC;
1184         ret->cm_anon_type = *mptr++;    /* Anon type byte */
1185         ret->cm_format_type = *mptr++;  /* Format type byte */
1186
1187         /*
1188          * The rest is zero or more arbitrary fields.  Load them in.
1189          * We're done when we encounter either a zero-length field or
1190          * have just processed the 'M' (message text) field.
1191          */
1192         do {
1193                 if (mptr >= upper_bound) {
1194                         break;
1195                 }
1196                 field_header = *mptr++;
1197                 ret->cm_fields[field_header] = strdup(mptr);
1198
1199                 while (*mptr++ != 0);   /* advance to next field */
1200
1201         } while ((mptr < upper_bound) && (field_header != 'M'));
1202
1203         cdb_free(dmsgtext);
1204
1205         /* Always make sure there's something in the msg text field.  If
1206          * it's NULL, the message text is most likely stored separately,
1207          * so go ahead and fetch that.  Failing that, just set a dummy
1208          * body so other code doesn't barf.
1209          */
1210         if ( (ret->cm_fields['M'] == NULL) && (with_body) ) {
1211                 dmsgtext = cdb_fetch(CDB_BIGMSGS, &msgnum, sizeof(long));
1212                 if (dmsgtext != NULL) {
1213                         ret->cm_fields['M'] = dmsgtext->ptr;
1214                         dmsgtext->ptr = NULL;
1215                         cdb_free(dmsgtext);
1216                 }
1217         }
1218         if (ret->cm_fields['M'] == NULL) {
1219                 ret->cm_fields['M'] = strdup("\r\n\r\n (no text)\r\n");
1220         }
1221
1222         /* Perform "before read" hooks (aborting if any return nonzero) */
1223         if (PerformMessageHooks(ret, EVT_BEFOREREAD) > 0) {
1224                 CtdlFreeMessage(ret);
1225                 return NULL;
1226         }
1227
1228         return (ret);
1229 }
1230
1231
1232 /*
1233  * Returns 1 if the supplied pointer points to a valid Citadel message.
1234  * If the pointer is NULL or the magic number check fails, returns 0.
1235  */
1236 int is_valid_message(struct CtdlMessage *msg) {
1237         if (msg == NULL)
1238                 return 0;
1239         if ((msg->cm_magic) != CTDLMESSAGE_MAGIC) {
1240                 syslog(LOG_WARNING, "is_valid_message() -- self-check failed\n");
1241                 return 0;
1242         }
1243         return 1;
1244 }
1245
1246
1247 /*
1248  * 'Destructor' for struct CtdlMessage
1249  */
1250 void CtdlFreeMessage(struct CtdlMessage *msg)
1251 {
1252         int i;
1253
1254         if (is_valid_message(msg) == 0)
1255         {
1256                 if (msg != NULL) free (msg);
1257                 return;
1258         }
1259
1260         for (i = 0; i < 256; ++i)
1261                 if (msg->cm_fields[i] != NULL) {
1262                         free(msg->cm_fields[i]);
1263                 }
1264
1265         msg->cm_magic = 0;      /* just in case */
1266         free(msg);
1267 }
1268
1269
1270 /*
1271  * Pre callback function for multipart/alternative
1272  *
1273  * NOTE: this differs from the standard behavior for a reason.  Normally when
1274  *       displaying multipart/alternative you want to show the _last_ usable
1275  *       format in the message.  Here we show the _first_ one, because it's
1276  *       usually text/plain.  Since this set of functions is designed for text
1277  *       output to non-MIME-aware clients, this is the desired behavior.
1278  *
1279  */
1280 void fixed_output_pre(char *name, char *filename, char *partnum, char *disp,
1281                 void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
1282                 char *cbid, void *cbuserdata)
1283 {
1284         struct ma_info *ma;
1285
1286         ma = (struct ma_info *)cbuserdata;
1287         syslog(LOG_DEBUG, "fixed_output_pre() type=<%s>\n", cbtype);
1288         if (!strcasecmp(cbtype, "multipart/alternative")) {
1289                 ++ma->is_ma;
1290                 ma->did_print = 0;
1291         }
1292         if (!strcasecmp(cbtype, "message/rfc822")) {
1293                 ++ma->freeze;
1294         }
1295 }
1296
1297 /*
1298  * Post callback function for multipart/alternative
1299  */
1300 void fixed_output_post(char *name, char *filename, char *partnum, char *disp,
1301                 void *content, char *cbtype, char *cbcharset, size_t length,
1302                 char *encoding, char *cbid, void *cbuserdata)
1303 {
1304         struct ma_info *ma;
1305
1306         ma = (struct ma_info *)cbuserdata;
1307         syslog(LOG_DEBUG, "fixed_output_post() type=<%s>\n", cbtype);
1308         if (!strcasecmp(cbtype, "multipart/alternative")) {
1309                 --ma->is_ma;
1310                 ma->did_print = 0;
1311         }
1312         if (!strcasecmp(cbtype, "message/rfc822")) {
1313                 --ma->freeze;
1314         }
1315 }
1316
1317 /*
1318  * Inline callback function for mime parser that wants to display text
1319  */
1320 void fixed_output(char *name, char *filename, char *partnum, char *disp,
1321                 void *content, char *cbtype, char *cbcharset, size_t length,
1322                 char *encoding, char *cbid, void *cbuserdata)
1323 {
1324         char *ptr;
1325         char *wptr;
1326         size_t wlen;
1327         struct ma_info *ma;
1328
1329         ma = (struct ma_info *)cbuserdata;
1330
1331         syslog(LOG_DEBUG,
1332                 "fixed_output() part %s: %s (%s) (%ld bytes)\n",
1333                 partnum, filename, cbtype, (long)length);
1334
1335         /*
1336          * If we're in the middle of a multipart/alternative scope and
1337          * we've already printed another section, skip this one.
1338          */
1339         if ( (ma->is_ma) && (ma->did_print) ) {
1340                 syslog(LOG_DEBUG, "Skipping part %s (%s)\n", partnum, cbtype);
1341                 return;
1342         }
1343         ma->did_print = 1;
1344
1345         if ( (!strcasecmp(cbtype, "text/plain"))
1346            || (IsEmptyStr(cbtype)) ) {
1347                 wptr = content;
1348                 if (length > 0) {
1349                         client_write(wptr, length);
1350                         if (wptr[length-1] != '\n') {
1351                                 cprintf("\n");
1352                         }
1353                 }
1354                 return;
1355         }
1356
1357         if (!strcasecmp(cbtype, "text/html")) {
1358                 ptr = html_to_ascii(content, length, 80, 0);
1359                 wlen = strlen(ptr);
1360                 client_write(ptr, wlen);
1361                 if (ptr[wlen-1] != '\n') {
1362                         cprintf("\n");
1363                 }
1364                 free(ptr);
1365                 return;
1366         }
1367
1368         if (ma->use_fo_hooks) {
1369                 if (PerformFixedOutputHooks(cbtype, content, length)) {
1370                 /* above function returns nonzero if it handled the part */
1371                         return;
1372                 }
1373         }
1374
1375         if (strncasecmp(cbtype, "multipart/", 10)) {
1376                 cprintf("Part %s: %s (%s) (%ld bytes)\r\n",
1377                         partnum, filename, cbtype, (long)length);
1378                 return;
1379         }
1380 }
1381
1382 /*
1383  * The client is elegant and sophisticated and wants to be choosy about
1384  * MIME content types, so figure out which multipart/alternative part
1385  * we're going to send.
1386  *
1387  * We use a system of weights.  When we find a part that matches one of the
1388  * MIME types we've declared as preferential, we can store it in ma->chosen_part
1389  * and then set ma->chosen_pref to that MIME type's position in our preference
1390  * list.  If we then hit another match, we only replace the first match if
1391  * the preference value is lower.
1392  */
1393 void choose_preferred(char *name, char *filename, char *partnum, char *disp,
1394                 void *content, char *cbtype, char *cbcharset, size_t length,
1395                 char *encoding, char *cbid, void *cbuserdata)
1396 {
1397         char buf[1024];
1398         int i;
1399         struct ma_info *ma;
1400
1401         ma = (struct ma_info *)cbuserdata;
1402
1403         // NOTE: REMOVING THIS CONDITIONAL FIXES BUG 220
1404         //       http://bugzilla.citadel.org/show_bug.cgi?id=220
1405         // I don't know if there are any side effects!  Please TEST TEST TEST
1406         //if (ma->is_ma > 0) {
1407
1408         for (i=0; i<num_tokens(CC->preferred_formats, '|'); ++i) {
1409                 extract_token(buf, CC->preferred_formats, i, '|', sizeof buf);
1410                 if ( (!strcasecmp(buf, cbtype)) && (!ma->freeze) ) {
1411                         if (i < ma->chosen_pref) {
1412                                 syslog(LOG_DEBUG, "Setting chosen part: <%s>\n", partnum);
1413                                 safestrncpy(ma->chosen_part, partnum, sizeof ma->chosen_part);
1414                                 ma->chosen_pref = i;
1415                         }
1416                 }
1417         }
1418 }
1419
1420 /*
1421  * Now that we've chosen our preferred part, output it.
1422  */
1423 void output_preferred(char *name,
1424                       char *filename,
1425                       char *partnum,
1426                       char *disp,
1427                       void *content,
1428                       char *cbtype,
1429                       char *cbcharset,
1430                       size_t length,
1431                       char *encoding,
1432                       char *cbid,
1433                       void *cbuserdata)
1434 {
1435         int i;
1436         char buf[128];
1437         int add_newline = 0;
1438         char *text_content;
1439         struct ma_info *ma;
1440         char *decoded = NULL;
1441         size_t bytes_decoded;
1442         int rc = 0;
1443
1444         ma = (struct ma_info *)cbuserdata;
1445
1446         /* This is not the MIME part you're looking for... */
1447         if (strcasecmp(partnum, ma->chosen_part)) return;
1448
1449         /* If the content-type of this part is in our preferred formats
1450          * list, we can simply output it verbatim.
1451          */
1452         for (i=0; i<num_tokens(CC->preferred_formats, '|'); ++i) {
1453                 extract_token(buf, CC->preferred_formats, i, '|', sizeof buf);
1454                 if (!strcasecmp(buf, cbtype)) {
1455                         /* Yeah!  Go!  W00t!! */
1456                         if (ma->dont_decode == 0)
1457                                 rc = mime_decode_now (content,
1458                                                       length,
1459                                                       encoding,
1460                                                       &decoded,
1461                                                       &bytes_decoded);
1462                         if (rc < 0)
1463                                 break; /* Give us the chance, maybe theres another one. */
1464
1465                         if (rc == 0) text_content = (char *)content;
1466                         else {
1467                                 text_content = decoded;
1468                                 length = bytes_decoded;
1469                         }
1470
1471                         if (text_content[length-1] != '\n') {
1472                                 ++add_newline;
1473                         }
1474                         cprintf("Content-type: %s", cbtype);
1475                         if (!IsEmptyStr(cbcharset)) {
1476                                 cprintf("; charset=%s", cbcharset);
1477                         }
1478                         cprintf("\nContent-length: %d\n",
1479                                 (int)(length + add_newline) );
1480                         if (!IsEmptyStr(encoding)) {
1481                                 cprintf("Content-transfer-encoding: %s\n", encoding);
1482                         }
1483                         else {
1484                                 cprintf("Content-transfer-encoding: 7bit\n");
1485                         }
1486                         cprintf("X-Citadel-MSG4-Partnum: %s\n", partnum);
1487                         cprintf("\n");
1488                         if (client_write(text_content, length) == -1)
1489                         {
1490                                 syslog(LOG_ERR, "output_preferred(): aborting due to write failure.\n");
1491                                 return;
1492                         }
1493                         if (add_newline) cprintf("\n");
1494                         if (decoded != NULL) free(decoded);
1495                         return;
1496                 }
1497         }
1498
1499         /* No translations required or possible: output as text/plain */
1500         cprintf("Content-type: text/plain\n\n");
1501         rc = 0;
1502         if (ma->dont_decode == 0)
1503                 rc = mime_decode_now (content,
1504                                       length,
1505                                       encoding,
1506                                       &decoded,
1507                                       &bytes_decoded);
1508         if (rc < 0)
1509                 return; /* Give us the chance, maybe theres another one. */
1510
1511         if (rc == 0) text_content = (char *)content;
1512         else {
1513                 text_content = decoded;
1514                 length = bytes_decoded;
1515         }
1516
1517         fixed_output(name, filename, partnum, disp, text_content, cbtype, cbcharset,
1518                         length, encoding, cbid, cbuserdata);
1519         if (decoded != NULL) free(decoded);
1520 }
1521
1522
1523 struct encapmsg {
1524         char desired_section[64];
1525         char *msg;
1526         size_t msglen;
1527 };
1528
1529
1530 /*
1531  * Callback function for
1532  */
1533 void extract_encapsulated_message(char *name, char *filename, char *partnum, char *disp,
1534                    void *content, char *cbtype, char *cbcharset, size_t length,
1535                    char *encoding, char *cbid, void *cbuserdata)
1536 {
1537         struct encapmsg *encap;
1538
1539         encap = (struct encapmsg *)cbuserdata;
1540
1541         /* Only proceed if this is the desired section... */
1542         if (!strcasecmp(encap->desired_section, partnum)) {
1543                 encap->msglen = length;
1544                 encap->msg = malloc(length + 2);
1545                 memcpy(encap->msg, content, length);
1546                 return;
1547         }
1548 }
1549
1550
1551 /*
1552  * Determine whether the specified message exists in the cached_msglist
1553  * (This is a security check)
1554  */
1555 int check_cached_msglist(long msgnum) {
1556
1557         /* cases in which we skip the check */
1558         if (!CC) return om_ok;                                          /* not a session */
1559         if (CC->client_socket <= 0) return om_ok;                       /* not a client session */
1560         if (CC->cached_msglist == NULL) return om_access_denied;        /* no msglist fetched */
1561         if (CC->cached_num_msgs == 0) return om_access_denied;          /* nothing to check */
1562
1563
1564         /* Do a binary search within the cached_msglist for the requested msgnum */
1565         int min = 0;
1566         int max = (CC->cached_num_msgs - 1);
1567
1568         while (max >= min) {
1569                 int middle = min + (max-min) / 2 ;
1570                 if (msgnum == CC->cached_msglist[middle]) {
1571                         return om_ok;
1572                 }
1573                 if (msgnum > CC->cached_msglist[middle]) {
1574                         min = middle + 1;
1575                 }
1576                 else {
1577                         max = middle - 1;
1578                 }
1579         }
1580
1581         return om_access_denied;
1582 }
1583
1584
1585 /*
1586  * Determine whether the currently logged in session has permission to read
1587  * messages in the current room.
1588  */
1589 int CtdlDoIHavePermissionToReadMessagesInThisRoom(void) {
1590         if (    (!(CC->logged_in))
1591                 && (!(CC->internal_pgm))
1592                 && (!config.c_guest_logins)
1593         ) {
1594                 return(om_not_logged_in);
1595         }
1596         return(om_ok);
1597 }
1598
1599
1600 /*
1601  * Get a message off disk.  (returns om_* values found in msgbase.h)
1602  *
1603  */
1604 int CtdlOutputMsg(long msg_num,         /* message number (local) to fetch */
1605                   int mode,             /* how would you like that message? */
1606                   int headers_only,     /* eschew the message body? */
1607                   int do_proto,         /* do Citadel protocol responses? */
1608                   int crlf,             /* Use CRLF newlines instead of LF? */
1609                   char *section,        /* NULL or a message/rfc822 section */
1610                   int flags             /* various flags; see msgbase.h */
1611 ) {
1612         struct CtdlMessage *TheMessage = NULL;
1613         int retcode = om_no_such_msg;
1614         struct encapmsg encap;
1615         int r;
1616
1617         syslog(LOG_DEBUG, "CtdlOutputMsg(msgnum=%ld, mode=%d, section=%s)\n",
1618                 msg_num, mode,
1619                 (section ? section : "<>")
1620         );
1621
1622         r = CtdlDoIHavePermissionToReadMessagesInThisRoom();
1623         if (r != om_ok) {
1624                 if (do_proto) {
1625                         if (r == om_not_logged_in) {
1626                                 cprintf("%d Not logged in.\n", ERROR + NOT_LOGGED_IN);
1627                         }
1628                         else {
1629                                 cprintf("%d An unknown error has occurred.\n", ERROR);
1630                         }
1631                 }
1632                 return(r);
1633         }
1634
1635         /*
1636          * Check to make sure the message is actually IN this room
1637          */
1638         r = check_cached_msglist(msg_num);
1639         if (r == om_access_denied) {
1640                 /* Not in the cache?  We get ONE shot to check it again. */
1641                 CtdlForEachMessage(MSGS_ALL, 0L, NULL, NULL, NULL, NULL, NULL);
1642                 r = check_cached_msglist(msg_num);
1643         }
1644         if (r != om_ok) {
1645                 syslog(LOG_DEBUG, "Security check fail: message %ld is not in %s\n",
1646                         msg_num, CC->room.QRname
1647                 );
1648                 if (do_proto) {
1649                         if (r == om_access_denied) {
1650                                 cprintf("%d message %ld was not found in this room\n",
1651                                         ERROR + HIGHER_ACCESS_REQUIRED,
1652                                         msg_num
1653                                 );
1654                         }
1655                 }
1656                 return(r);
1657         }
1658
1659         /*
1660          * Fetch the message from disk.  If we're in HEADERS_FAST mode,
1661          * request that we don't even bother loading the body into memory.
1662          */
1663         if (headers_only == HEADERS_FAST) {
1664                 TheMessage = CtdlFetchMessage(msg_num, 0);
1665         }
1666         else {
1667                 TheMessage = CtdlFetchMessage(msg_num, 1);
1668         }
1669
1670         if (TheMessage == NULL) {
1671                 if (do_proto) cprintf("%d Can't locate msg %ld on disk\n",
1672                         ERROR + MESSAGE_NOT_FOUND, msg_num);
1673                 return(om_no_such_msg);
1674         }
1675
1676         /* Here is the weird form of this command, to process only an
1677          * encapsulated message/rfc822 section.
1678          */
1679         if (section) if (!IsEmptyStr(section)) if (strcmp(section, "0")) {
1680                 memset(&encap, 0, sizeof encap);
1681                 safestrncpy(encap.desired_section, section, sizeof encap.desired_section);
1682                 mime_parser(TheMessage->cm_fields['M'],
1683                         NULL,
1684                         *extract_encapsulated_message,
1685                         NULL, NULL, (void *)&encap, 0
1686                 );
1687                 CtdlFreeMessage(TheMessage);
1688                 TheMessage = NULL;
1689
1690                 if (encap.msg) {
1691                         encap.msg[encap.msglen] = 0;
1692                         TheMessage = convert_internet_message(encap.msg);
1693                         encap.msg = NULL;       /* no free() here, TheMessage owns it now */
1694
1695                         /* Now we let it fall through to the bottom of this
1696                          * function, because TheMessage now contains the
1697                          * encapsulated message instead of the top-level
1698                          * message.  Isn't that neat?
1699                          */
1700
1701                 }
1702                 else {
1703                         if (do_proto) cprintf("%d msg %ld has no part %s\n",
1704                                 ERROR + MESSAGE_NOT_FOUND, msg_num, section);
1705                         retcode = om_no_such_msg;
1706                 }
1707
1708         }
1709
1710         /* Ok, output the message now */
1711         retcode = CtdlOutputPreLoadedMsg(TheMessage, mode, headers_only, do_proto, crlf, flags);
1712         CtdlFreeMessage(TheMessage);
1713
1714         return(retcode);
1715 }
1716
1717
1718 char *qp_encode_email_addrs(char *source)
1719 {
1720         char *user, *node, *name;
1721         const char headerStr[] = "=?UTF-8?Q?";
1722         char *Encoded;
1723         char *EncodedName;
1724         char *nPtr;
1725         int need_to_encode = 0;
1726         long SourceLen;
1727         long EncodedMaxLen;
1728         long nColons = 0;
1729         long *AddrPtr;
1730         long *AddrUtf8;
1731         long nAddrPtrMax = 50;
1732         long nmax;
1733         int InQuotes = 0;
1734         int i, n;
1735
1736         if (source == NULL) return source;
1737         if (IsEmptyStr(source)) return source;
1738         cit_backtrace();
1739         syslog(LOG_DEBUG, "qp_encode_email_addrs: [%s]\n", source);
1740
1741         AddrPtr = malloc (sizeof (long) * nAddrPtrMax);
1742         AddrUtf8 = malloc (sizeof (long) * nAddrPtrMax);
1743         memset(AddrUtf8, 0, sizeof (long) * nAddrPtrMax);
1744         *AddrPtr = 0;
1745         i = 0;
1746         while (!IsEmptyStr (&source[i])) {
1747                 if (nColons >= nAddrPtrMax){
1748                         long *ptr;
1749
1750                         ptr = (long *) malloc(sizeof (long) * nAddrPtrMax * 2);
1751                         memcpy (ptr, AddrPtr, sizeof (long) * nAddrPtrMax);
1752                         free (AddrPtr), AddrPtr = ptr;
1753
1754                         ptr = (long *) malloc(sizeof (long) * nAddrPtrMax * 2);
1755                         memset(&ptr[nAddrPtrMax], 0,
1756                                sizeof (long) * nAddrPtrMax);
1757
1758                         memcpy (ptr, AddrUtf8, sizeof (long) * nAddrPtrMax);
1759                         free (AddrUtf8), AddrUtf8 = ptr;
1760                         nAddrPtrMax *= 2;
1761                 }
1762                 if (((unsigned char) source[i] < 32) ||
1763                     ((unsigned char) source[i] > 126)) {
1764                         need_to_encode = 1;
1765                         AddrUtf8[nColons] = 1;
1766                 }
1767                 if (source[i] == '"')
1768                         InQuotes = !InQuotes;
1769                 if (!InQuotes && source[i] == ',') {
1770                         AddrPtr[nColons] = i;
1771                         nColons++;
1772                 }
1773                 i++;
1774         }
1775         if (need_to_encode == 0) {
1776                 free(AddrPtr);
1777                 free(AddrUtf8);
1778                 return source;
1779         }
1780
1781         SourceLen = i;
1782         EncodedMaxLen = nColons * (sizeof(headerStr) + 3) + SourceLen * 3;
1783         Encoded = (char*) malloc (EncodedMaxLen);
1784
1785         for (i = 0; i < nColons; i++)
1786                 source[AddrPtr[i]++] = '\0';
1787         /* TODO: if libidn, this might get larger*/
1788         user = malloc(SourceLen + 1);
1789         node = malloc(SourceLen + 1);
1790         name = malloc(SourceLen + 1);
1791
1792         nPtr = Encoded;
1793         *nPtr = '\0';
1794         for (i = 0; i < nColons && nPtr != NULL; i++) {
1795                 nmax = EncodedMaxLen - (nPtr - Encoded);
1796                 if (AddrUtf8[i]) {
1797                         process_rfc822_addr(&source[AddrPtr[i]],
1798                                             user,
1799                                             node,
1800                                             name);
1801                         /* TODO: libIDN here ! */
1802                         if (IsEmptyStr(name)) {
1803                                 n = snprintf(nPtr, nmax,
1804                                              (i==0)?"%s@%s" : ",%s@%s",
1805                                              user, node);
1806                         }
1807                         else {
1808                                 EncodedName = rfc2047encode(name, strlen(name));
1809                                 n = snprintf(nPtr, nmax,
1810                                              (i==0)?"%s <%s@%s>" : ",%s <%s@%s>",
1811                                              EncodedName, user, node);
1812                                 free(EncodedName);
1813                         }
1814                 }
1815                 else {
1816                         n = snprintf(nPtr, nmax,
1817                                      (i==0)?"%s" : ",%s",
1818                                      &source[AddrPtr[i]]);
1819                 }
1820                 if (n > 0 )
1821                         nPtr += n;
1822                 else {
1823                         char *ptr, *nnPtr;
1824                         ptr = (char*) malloc(EncodedMaxLen * 2);
1825                         memcpy(ptr, Encoded, EncodedMaxLen);
1826                         nnPtr = ptr + (nPtr - Encoded), nPtr = nnPtr;
1827                         free(Encoded), Encoded = ptr;
1828                         EncodedMaxLen *= 2;
1829                         i--; /* do it once more with properly lengthened buffer */
1830                 }
1831         }
1832         for (i = 0; i < nColons; i++)
1833                 source[--AddrPtr[i]] = ',';
1834
1835         free(user);
1836         free(node);
1837         free(name);
1838         free(AddrUtf8);
1839         free(AddrPtr);
1840         return Encoded;
1841 }
1842
1843
1844 /* If the last item in a list of recipients was truncated to a partial address,
1845  * remove it completely in order to avoid choking libSieve
1846  */
1847 void sanitize_truncated_recipient(char *str)
1848 {
1849         if (!str) return;
1850         if (num_tokens(str, ',') < 2) return;
1851
1852         int len = strlen(str);
1853         if (len < 900) return;
1854         if (len > 998) str[998] = 0;
1855
1856         char *cptr = strrchr(str, ',');
1857         if (!cptr) return;
1858
1859         char *lptr = strchr(cptr, '<');
1860         char *rptr = strchr(cptr, '>');
1861
1862         if ( (lptr) && (rptr) && (rptr > lptr) ) return;
1863
1864         *cptr = 0;
1865 }
1866
1867
1868 void OutputCtdlMsgHeaders(
1869         struct CtdlMessage *TheMessage,
1870         int do_proto)           /* do Citadel protocol responses? */
1871 {
1872         char allkeys[30];
1873         int i, k, n;
1874         int suppress_f = 0;
1875         char buf[SIZ];
1876         char display_name[256];
1877
1878         /* begin header processing loop for Citadel message format */
1879         safestrncpy(display_name, "<unknown>", sizeof display_name);
1880         if (TheMessage->cm_fields['A']) {
1881                 strcpy(buf, TheMessage->cm_fields['A']);
1882                 if (TheMessage->cm_anon_type == MES_ANONONLY) {
1883                         safestrncpy(display_name, "****", sizeof display_name);
1884                 }
1885                 else if (TheMessage->cm_anon_type == MES_ANONOPT) {
1886                         safestrncpy(display_name, "anonymous", sizeof display_name);
1887                 }
1888                 else {
1889                         safestrncpy(display_name, buf, sizeof display_name);
1890                 }
1891                 if ((is_room_aide())
1892                     && ((TheMessage->cm_anon_type == MES_ANONONLY)
1893                         || (TheMessage->cm_anon_type == MES_ANONOPT))) {
1894                         size_t tmp = strlen(display_name);
1895                         snprintf(&display_name[tmp],
1896                                  sizeof display_name - tmp,
1897                                  " [%s]", buf);
1898                 }
1899         }
1900
1901         /* Don't show Internet address for users on the
1902          * local Citadel network.
1903          */
1904         suppress_f = 0;
1905         if (TheMessage->cm_fields['N'] != NULL)
1906                 if (!IsEmptyStr(TheMessage->cm_fields['N']))
1907                         if (haschar(TheMessage->cm_fields['N'], '.') == 0) {
1908                                 suppress_f = 1;
1909                         }
1910
1911         /* Now spew the header fields in the order we like them. */
1912         n = safestrncpy(allkeys, FORDER, sizeof allkeys);
1913         for (i=0; i<n; ++i) {
1914                 k = (int) allkeys[i];
1915                 if (k != 'M') {
1916                         if ( (TheMessage->cm_fields[k] != NULL)
1917                              && (msgkeys[k] != NULL) ) {
1918                                 if ((k == 'V') || (k == 'R') || (k == 'Y')) {
1919                                         sanitize_truncated_recipient(TheMessage->cm_fields[k]);
1920                                 }
1921                                 if (k == 'A') {
1922                                         if (do_proto) cprintf("%s=%s\n",
1923                                                               msgkeys[k],
1924                                                               display_name);
1925                                 }
1926                                 else if ((k == 'F') && (suppress_f)) {
1927                                         /* do nothing */
1928                                 }
1929                                 /* Masquerade display name if needed */
1930                                 else {
1931                                         if (do_proto) cprintf("%s=%s\n",
1932                                                               msgkeys[k],
1933                                                               TheMessage->cm_fields[k]
1934                                                 );
1935                                 }
1936                         }
1937                 }
1938         }
1939
1940 }
1941
1942 void OutputRFC822MsgHeaders(
1943         struct CtdlMessage *TheMessage,
1944         int flags,              /* should the bessage be exported clean */
1945         const char *nl,
1946         char *mid, long sizeof_mid,
1947         char *suser, long sizeof_suser,
1948         char *luser, long sizeof_luser,
1949         char *fuser, long sizeof_fuser,
1950         char *snode, long sizeof_snode)
1951 {
1952         char datestamp[100];
1953         int subject_found = 0;
1954         char buf[SIZ];
1955         int i, j, k;
1956         char *mptr = NULL;
1957         char *mpptr = NULL;
1958         char *hptr;
1959
1960         for (i = 0; i < 256; ++i) {
1961                 if (TheMessage->cm_fields[i]) {
1962                         mptr = mpptr = TheMessage->cm_fields[i];
1963
1964                         if (i == 'A') {
1965                                 safestrncpy(luser, mptr, sizeof_luser);
1966                                 safestrncpy(suser, mptr, sizeof_suser);
1967                         }
1968                         else if (i == 'Y') {
1969                                 if ((flags & QP_EADDR) != 0) {
1970                                         mptr = qp_encode_email_addrs(mptr);
1971                                 }
1972                                 sanitize_truncated_recipient(mptr);
1973                                 cprintf("CC: %s%s", mptr, nl);
1974                         }
1975                         else if (i == 'P') {
1976                                 cprintf("Return-Path: %s%s", mptr, nl);
1977                         }
1978                         else if (i == 'L') {
1979                                 cprintf("List-ID: %s%s", mptr, nl);
1980                         }
1981                         else if (i == 'V') {
1982                                 if ((flags & QP_EADDR) != 0)
1983                                         mptr = qp_encode_email_addrs(mptr);
1984                                 hptr = mptr;
1985                                 while ((*hptr != '\0') && isspace(*hptr))
1986                                         hptr ++;
1987                                 if (!IsEmptyStr(hptr))
1988                                         cprintf("Envelope-To: %s%s", hptr, nl);
1989                         }
1990                         else if (i == 'U') {
1991                                 cprintf("Subject: %s%s", mptr, nl);
1992                                 subject_found = 1;
1993                         }
1994                         else if (i == 'I')
1995                                 safestrncpy(mid, mptr, sizeof_mid); /// TODO: detect @ here and copy @nodename in if not found.
1996                         else if (i == 'F')
1997                                 safestrncpy(fuser, mptr, sizeof_fuser);
1998                         /* else if (i == 'O')
1999                            cprintf("X-Citadel-Room: %s%s",
2000                            mptr, nl); */
2001                         else if (i == 'N')
2002                                 safestrncpy(snode, mptr, sizeof_snode);
2003                         else if (i == 'R')
2004                         {
2005                                 if (haschar(mptr, '@') == 0)
2006                                 {
2007                                         sanitize_truncated_recipient(mptr);
2008                                         cprintf("To: %s@%s", mptr, config.c_fqdn);
2009                                         cprintf("%s", nl);
2010                                 }
2011                                 else
2012                                 {
2013                                         if ((flags & QP_EADDR) != 0) {
2014                                                 mptr = qp_encode_email_addrs(mptr);
2015                                         }
2016                                         sanitize_truncated_recipient(mptr);
2017                                         cprintf("To: %s", mptr);
2018                                         cprintf("%s", nl);
2019                                 }
2020                         }
2021                         else if (i == 'T') {
2022                                 datestring(datestamp, sizeof datestamp,
2023                                            atol(mptr), DATESTRING_RFC822);
2024                                 cprintf("Date: %s%s", datestamp, nl);
2025                         }
2026                         else if (i == 'W') {
2027                                 cprintf("References: ");
2028                                 k = num_tokens(mptr, '|');
2029                                 for (j=0; j<k; ++j) {
2030                                         extract_token(buf, mptr, j, '|', sizeof buf);
2031                                         cprintf("<%s>", buf);
2032                                         if (j == (k-1)) {
2033                                                 cprintf("%s", nl);
2034                                         }
2035                                         else {
2036                                                 cprintf(" ");
2037                                         }
2038                                 }
2039                         }
2040                         else if (i == 'K') {
2041                                 cprintf("Reply-To: <%s>%s", mptr, nl);
2042                         }
2043                         if (mptr != mpptr)
2044                                 free (mptr);
2045                 }
2046         }
2047         if (subject_found == 0) {
2048                 cprintf("Subject: (no subject)%s", nl);
2049         }
2050 }
2051
2052
2053 void Dump_RFC822HeadersBody(
2054         struct CtdlMessage *TheMessage,
2055         int headers_only,       /* eschew the message body? */
2056         int flags,              /* should the bessage be exported clean? */
2057
2058         const char *nl)
2059 {
2060         cit_uint8_t prev_ch;
2061         int eoh = 0;
2062         const char *StartOfText = StrBufNOTNULL;
2063         char outbuf[1024];
2064         int outlen = 0;
2065         int nllen = strlen(nl);
2066         char *mptr;
2067         int rc;
2068
2069         mptr = TheMessage->cm_fields['M'];
2070
2071
2072         prev_ch = '\0';
2073         while (*mptr != '\0') {
2074                 if (*mptr == '\r') {
2075                         /* do nothing */
2076                 }
2077                 else {
2078                         if ((!eoh) &&
2079                             (*mptr == '\n'))
2080                         {
2081                                 eoh = (*(mptr+1) == '\r') && (*(mptr+2) == '\n');
2082                                 if (!eoh)
2083                                         eoh = *(mptr+1) == '\n';
2084                                 if (eoh)
2085                                 {
2086                                         StartOfText = mptr;
2087                                         StartOfText = strchr(StartOfText, '\n');
2088                                         StartOfText = strchr(StartOfText, '\n');
2089                                 }
2090                         }
2091                         if (((headers_only == HEADERS_NONE) && (mptr >= StartOfText)) ||
2092                             ((headers_only == HEADERS_ONLY) && (mptr < StartOfText)) ||
2093                             ((headers_only != HEADERS_NONE) &&
2094                              (headers_only != HEADERS_ONLY))
2095                                 ) {
2096                                 if (*mptr == '\n') {
2097                                         memcpy(&outbuf[outlen], nl, nllen);
2098                                         outlen += nllen;
2099                                         outbuf[outlen] = '\0';
2100                                 }
2101                                 else {
2102                                         outbuf[outlen++] = *mptr;
2103                                 }
2104                         }
2105                 }
2106                 if (flags & ESC_DOT)
2107                 {
2108                         if ((prev_ch == '\n') &&
2109                             (*mptr == '.') &&
2110                             ((*(mptr+1) == '\r') || (*(mptr+1) == '\n')))
2111                         {
2112                                 outbuf[outlen++] = '.';
2113                         }
2114                         prev_ch = *mptr;
2115                 }
2116                 ++mptr;
2117                 if (outlen > 1000) {
2118                         if (client_write(outbuf, outlen) == -1)
2119                         {
2120                                 syslog(LOG_ERR, "Dump_RFC822HeadersBody(): aborting due to write failure.\n");
2121                                 return;
2122                         }
2123                         outlen = 0;
2124                 }
2125         }
2126         if (outlen > 0) {
2127                 rc = client_write(outbuf, outlen);
2128                 outlen = 0;
2129         }
2130 }
2131
2132
2133
2134 /* If the format type on disk is 1 (fixed-format), then we want
2135  * everything to be output completely literally ... regardless of
2136  * what message transfer format is in use.
2137  */
2138 void DumpFormatFixed(
2139         struct CtdlMessage *TheMessage,
2140         int mode,               /* how would you like that message? */
2141         const char *nl)
2142 {
2143         cit_uint8_t ch;
2144         char buf[SIZ];
2145         int buflen;
2146         int xlline = 0;
2147         int nllen = strlen (nl);
2148         char *mptr;
2149
2150         mptr = TheMessage->cm_fields['M'];
2151
2152         if (mode == MT_MIME) {
2153                 cprintf("Content-type: text/plain\n\n");
2154         }
2155         *buf = '\0';
2156         buflen = 0;
2157         while (ch = *mptr++, ch > 0) {
2158                 if (ch == '\n')
2159                         ch = '\r';
2160
2161                 if ((buflen > 250) && (!xlline)){
2162                         int tbuflen;
2163                         tbuflen = buflen;
2164
2165                         while ((buflen > 0) &&
2166                                (!isspace(buf[buflen])))
2167                                 buflen --;
2168                         if (buflen == 0) {
2169                                 xlline = 1;
2170                         }
2171                         else {
2172                                 mptr -= tbuflen - buflen;
2173                                 buf[buflen] = '\0';
2174                                 ch = '\r';
2175                         }
2176                 }
2177                 /* if we reach the outer bounds of our buffer,
2178                    abort without respect what whe purge. */
2179                 if (xlline &&
2180                     ((isspace(ch)) ||
2181                      (buflen > SIZ - nllen - 2)))
2182                         ch = '\r';
2183
2184                 if (ch == '\r') {
2185                         memcpy (&buf[buflen], nl, nllen);
2186                         buflen += nllen;
2187                         buf[buflen] = '\0';
2188
2189                         if (client_write(buf, buflen) == -1)
2190                         {
2191                                 syslog(LOG_ERR, "DumpFormatFixed(): aborting due to write failure.\n");
2192                                 return;
2193                         }
2194                         *buf = '\0';
2195                         buflen = 0;
2196                         xlline = 0;
2197                 } else {
2198                         buf[buflen] = ch;
2199                         buflen++;
2200                 }
2201         }
2202         buf[buflen] = '\0';
2203         if (!IsEmptyStr(buf))
2204                 cprintf("%s%s", buf, nl);
2205 }
2206
2207 /*
2208  * Get a message off disk.  (returns om_* values found in msgbase.h)
2209  */
2210 int CtdlOutputPreLoadedMsg(
2211                 struct CtdlMessage *TheMessage,
2212                 int mode,               /* how would you like that message? */
2213                 int headers_only,       /* eschew the message body? */
2214                 int do_proto,           /* do Citadel protocol responses? */
2215                 int crlf,               /* Use CRLF newlines instead of LF? */
2216                 int flags               /* should the bessage be exported clean? */
2217 ) {
2218         int i;
2219         char *mptr = NULL;
2220         const char *nl; /* newline string */
2221         struct ma_info ma;
2222
2223         /* Buffers needed for RFC822 translation.  These are all filled
2224          * using functions that are bounds-checked, and therefore we can
2225          * make them substantially smaller than SIZ.
2226          */
2227         char suser[100];
2228         char luser[100];
2229         char fuser[100];
2230         char snode[100];
2231         char mid[100];
2232
2233         syslog(LOG_DEBUG, "CtdlOutputPreLoadedMsg(TheMessage=%s, %d, %d, %d, %d\n",
2234                 ((TheMessage == NULL) ? "NULL" : "not null"),
2235                 mode, headers_only, do_proto, crlf);
2236
2237         strcpy(mid, "unknown");
2238         nl = (crlf ? "\r\n" : "\n");
2239
2240         if (!is_valid_message(TheMessage)) {
2241                 syslog(LOG_ERR,
2242                         "ERROR: invalid preloaded message for output\n");
2243                 cit_backtrace ();
2244                 return(om_no_such_msg);
2245         }
2246
2247         /* Suppress envelope recipients if required to avoid disclosing BCC addresses.
2248          * Pad it with spaces in order to avoid changing the RFC822 length of the message.
2249          */
2250         if ( (flags & SUPPRESS_ENV_TO) && (TheMessage->cm_fields['V'] != NULL) ) {
2251                 memset(TheMessage->cm_fields['V'], ' ', strlen(TheMessage->cm_fields['V']));
2252         }
2253
2254         /* Are we downloading a MIME component? */
2255         if (mode == MT_DOWNLOAD) {
2256                 if (TheMessage->cm_format_type != FMT_RFC822) {
2257                         if (do_proto)
2258                                 cprintf("%d This is not a MIME message.\n",
2259                                 ERROR + ILLEGAL_VALUE);
2260                 } else if (CC->download_fp != NULL) {
2261                         if (do_proto) cprintf(
2262                                 "%d You already have a download open.\n",
2263                                 ERROR + RESOURCE_BUSY);
2264                 } else {
2265                         /* Parse the message text component */
2266                         mptr = TheMessage->cm_fields['M'];
2267                         mime_parser(mptr, NULL, *mime_download, NULL, NULL, NULL, 0);
2268                         /* If there's no file open by this time, the requested
2269                          * section wasn't found, so print an error
2270                          */
2271                         if (CC->download_fp == NULL) {
2272                                 if (do_proto) cprintf(
2273                                         "%d Section %s not found.\n",
2274                                         ERROR + FILE_NOT_FOUND,
2275                                         CC->download_desired_section);
2276                         }
2277                 }
2278                 return((CC->download_fp != NULL) ? om_ok : om_mime_error);
2279         }
2280
2281         /* MT_SPEW_SECTION is like MT_DOWNLOAD except it outputs the whole MIME part
2282          * in a single server operation instead of opening a download file.
2283          */
2284         if (mode == MT_SPEW_SECTION) {
2285                 if (TheMessage->cm_format_type != FMT_RFC822) {
2286                         if (do_proto)
2287                                 cprintf("%d This is not a MIME message.\n",
2288                                 ERROR + ILLEGAL_VALUE);
2289                 } else {
2290                         /* Parse the message text component */
2291                         int found_it = 0;
2292
2293                         mptr = TheMessage->cm_fields['M'];
2294                         mime_parser(mptr, NULL, *mime_spew_section, NULL, NULL, (void *)&found_it, 0);
2295                         /* If section wasn't found, print an error
2296                          */
2297                         if (!found_it) {
2298                                 if (do_proto) cprintf(
2299                                         "%d Section %s not found.\n",
2300                                         ERROR + FILE_NOT_FOUND,
2301                                         CC->download_desired_section);
2302                         }
2303                 }
2304                 return((CC->download_fp != NULL) ? om_ok : om_mime_error);
2305         }
2306
2307         /* now for the user-mode message reading loops */
2308         if (do_proto) cprintf("%d msg:\n", LISTING_FOLLOWS);
2309
2310         /* Does the caller want to skip the headers? */
2311         if (headers_only == HEADERS_NONE) goto START_TEXT;
2312
2313         /* Tell the client which format type we're using. */
2314         if ( (mode == MT_CITADEL) && (do_proto) ) {
2315                 cprintf("type=%d\n", TheMessage->cm_format_type);
2316         }
2317
2318         /* nhdr=yes means that we're only displaying headers, no body */
2319         if ( (TheMessage->cm_anon_type == MES_ANONONLY)
2320            && ((mode == MT_CITADEL) || (mode == MT_MIME))
2321            && (do_proto)
2322            ) {
2323                 cprintf("nhdr=yes\n");
2324         }
2325
2326         if ((mode == MT_CITADEL) || (mode == MT_MIME))
2327                 OutputCtdlMsgHeaders(TheMessage, do_proto);
2328
2329
2330         /* begin header processing loop for RFC822 transfer format */
2331         strcpy(suser, "");
2332         strcpy(luser, "");
2333         strcpy(fuser, "");
2334         strcpy(snode, NODENAME);
2335         if (mode == MT_RFC822)
2336                 OutputRFC822MsgHeaders(
2337                         TheMessage,
2338                         flags,
2339                         nl,
2340                         mid, sizeof(mid),
2341                         suser, sizeof(suser),
2342                         luser, sizeof(luser),
2343                         fuser, sizeof(fuser),
2344                         snode, sizeof(snode)
2345                         );
2346
2347
2348         for (i=0; !IsEmptyStr(&suser[i]); ++i) {
2349                 suser[i] = tolower(suser[i]);
2350                 if (!isalnum(suser[i])) suser[i]='_';
2351         }
2352
2353         if (mode == MT_RFC822) {
2354                 if (!strcasecmp(snode, NODENAME)) {
2355                         safestrncpy(snode, FQDN, sizeof snode);
2356                 }
2357
2358                 /* Construct a fun message id */
2359                 cprintf("Message-ID: <%s", mid);/// todo: this possibly breaks threadding mails.
2360                 if (strchr(mid, '@')==NULL) {
2361                         cprintf("@%s", snode);
2362                 }
2363                 cprintf(">%s", nl);
2364
2365                 if (!is_room_aide() && (TheMessage->cm_anon_type == MES_ANONONLY)) {
2366                         cprintf("From: \"----\" <x@x.org>%s", nl);
2367                 }
2368                 else if (!is_room_aide() && (TheMessage->cm_anon_type == MES_ANONOPT)) {
2369                         cprintf("From: \"anonymous\" <x@x.org>%s", nl);
2370                 }
2371                 else if (!IsEmptyStr(fuser)) {
2372                         cprintf("From: \"%s\" <%s>%s", luser, fuser, nl);
2373                 }
2374                 else {
2375                         cprintf("From: \"%s\" <%s@%s>%s", luser, suser, snode, nl);
2376                 }
2377
2378                 /* Blank line signifying RFC822 end-of-headers */
2379                 if (TheMessage->cm_format_type != FMT_RFC822) {
2380                         cprintf("%s", nl);
2381                 }
2382         }
2383
2384         /* end header processing loop ... at this point, we're in the text */
2385 START_TEXT:
2386         if (headers_only == HEADERS_FAST) goto DONE;
2387
2388         /* Tell the client about the MIME parts in this message */
2389         if (TheMessage->cm_format_type == FMT_RFC822) {
2390                 if ( (mode == MT_CITADEL) || (mode == MT_MIME) ) {
2391                         mptr = TheMessage->cm_fields['M'];
2392                         memset(&ma, 0, sizeof(struct ma_info));
2393                         mime_parser(mptr, NULL,
2394                                 (do_proto ? *list_this_part : NULL),
2395                                 (do_proto ? *list_this_pref : NULL),
2396                                 (do_proto ? *list_this_suff : NULL),
2397                                 (void *)&ma, 1);
2398                 }
2399                 else if (mode == MT_RFC822) {   /* unparsed RFC822 dump */
2400                         Dump_RFC822HeadersBody(
2401                                 TheMessage,
2402                                 headers_only,
2403                                 flags,
2404                                 nl);
2405                         goto DONE;
2406                 }
2407         }
2408
2409         if (headers_only == HEADERS_ONLY) {
2410                 goto DONE;
2411         }
2412
2413         /* signify start of msg text */
2414         if ( (mode == MT_CITADEL) || (mode == MT_MIME) ) {
2415                 if (do_proto) cprintf("text\n");
2416         }
2417
2418         if (TheMessage->cm_format_type == FMT_FIXED)
2419                 DumpFormatFixed(
2420                         TheMessage,
2421                         mode,           /* how would you like that message? */
2422                         nl);
2423
2424         /* If the message on disk is format 0 (Citadel vari-format), we
2425          * output using the formatter at 80 columns.  This is the final output
2426          * form if the transfer format is RFC822, but if the transfer format
2427          * is Citadel proprietary, it'll still work, because the indentation
2428          * for new paragraphs is correct and the client will reformat the
2429          * message to the reader's screen width.
2430          */
2431         if (TheMessage->cm_format_type == FMT_CITADEL) {
2432                 mptr = TheMessage->cm_fields['M'];
2433
2434                 if (mode == MT_MIME) {
2435                         cprintf("Content-type: text/x-citadel-variformat\n\n");
2436                 }
2437                 memfmout(mptr, nl);
2438         }
2439
2440         /* If the message on disk is format 4 (MIME), we've gotta hand it
2441          * off to the MIME parser.  The client has already been told that
2442          * this message is format 1 (fixed format), so the callback function
2443          * we use will display those parts as-is.
2444          */
2445         if (TheMessage->cm_format_type == FMT_RFC822) {
2446                 memset(&ma, 0, sizeof(struct ma_info));
2447
2448                 if (mode == MT_MIME) {
2449                         ma.use_fo_hooks = 0;
2450                         strcpy(ma.chosen_part, "1");
2451                         ma.chosen_pref = 9999;
2452                         ma.dont_decode = CC->msg4_dont_decode;
2453                         mime_parser(mptr, NULL,
2454                                 *choose_preferred, *fixed_output_pre,
2455                                 *fixed_output_post, (void *)&ma, 1);
2456                         mime_parser(mptr, NULL,
2457                                 *output_preferred, NULL, NULL, (void *)&ma, 1);
2458                 }
2459                 else {
2460                         ma.use_fo_hooks = 1;
2461                         mime_parser(mptr, NULL,
2462                                 *fixed_output, *fixed_output_pre,
2463                                 *fixed_output_post, (void *)&ma, 0);
2464                 }
2465
2466         }
2467
2468 DONE:   /* now we're done */
2469         if (do_proto) cprintf("000\n");
2470         return(om_ok);
2471 }
2472
2473
2474 /*
2475  * display a message (mode 0 - Citadel proprietary)
2476  */
2477 void cmd_msg0(char *cmdbuf)
2478 {
2479         long msgid;
2480         int headers_only = HEADERS_ALL;
2481
2482         msgid = extract_long(cmdbuf, 0);
2483         headers_only = extract_int(cmdbuf, 1);
2484
2485         CtdlOutputMsg(msgid, MT_CITADEL, headers_only, 1, 0, NULL, 0);
2486         return;
2487 }
2488
2489
2490 /*
2491  * display a message (mode 2 - RFC822)
2492  */
2493 void cmd_msg2(char *cmdbuf)
2494 {
2495         long msgid;
2496         int headers_only = HEADERS_ALL;
2497
2498         msgid = extract_long(cmdbuf, 0);
2499         headers_only = extract_int(cmdbuf, 1);
2500
2501         CtdlOutputMsg(msgid, MT_RFC822, headers_only, 1, 1, NULL, 0);
2502 }
2503
2504
2505
2506 /*
2507  * display a message (mode 3 - IGnet raw format - internal programs only)
2508  */
2509 void cmd_msg3(char *cmdbuf)
2510 {
2511         long msgnum;
2512         struct CtdlMessage *msg = NULL;
2513         struct ser_ret smr;
2514
2515         if (CC->internal_pgm == 0) {
2516                 cprintf("%d This command is for internal programs only.\n",
2517                         ERROR + HIGHER_ACCESS_REQUIRED);
2518                 return;
2519         }
2520
2521         msgnum = extract_long(cmdbuf, 0);
2522         msg = CtdlFetchMessage(msgnum, 1);
2523         if (msg == NULL) {
2524                 cprintf("%d Message %ld not found.\n",
2525                         ERROR + MESSAGE_NOT_FOUND, msgnum);
2526                 return;
2527         }
2528
2529         serialize_message(&smr, msg);
2530         CtdlFreeMessage(msg);
2531
2532         if (smr.len == 0) {
2533                 cprintf("%d Unable to serialize message\n",
2534                         ERROR + INTERNAL_ERROR);
2535                 return;
2536         }
2537
2538         cprintf("%d %ld\n", BINARY_FOLLOWS, (long)smr.len);
2539         client_write((char *)smr.ser, (int)smr.len);
2540         free(smr.ser);
2541 }
2542
2543
2544
2545 /*
2546  * Display a message using MIME content types
2547  */
2548 void cmd_msg4(char *cmdbuf)
2549 {
2550         long msgid;
2551         char section[64];
2552
2553         msgid = extract_long(cmdbuf, 0);
2554         extract_token(section, cmdbuf, 1, '|', sizeof section);
2555         CtdlOutputMsg(msgid, MT_MIME, 0, 1, 0, (section[0] ? section : NULL) , 0);
2556 }
2557
2558
2559
2560 /*
2561  * Client tells us its preferred message format(s)
2562  */
2563 void cmd_msgp(char *cmdbuf)
2564 {
2565         if (!strcasecmp(cmdbuf, "dont_decode")) {
2566                 CC->msg4_dont_decode = 1;
2567                 cprintf("%d MSG4 will not pre-decode messages.\n", CIT_OK);
2568         }
2569         else {
2570                 safestrncpy(CC->preferred_formats, cmdbuf, sizeof(CC->preferred_formats));
2571                 cprintf("%d Preferred MIME formats have been set.\n", CIT_OK);
2572         }
2573 }
2574
2575
2576 /*
2577  * Open a component of a MIME message as a download file
2578  */
2579 void cmd_opna(char *cmdbuf)
2580 {
2581         long msgid;
2582         char desired_section[128];
2583
2584         msgid = extract_long(cmdbuf, 0);
2585         extract_token(desired_section, cmdbuf, 1, '|', sizeof desired_section);
2586         safestrncpy(CC->download_desired_section, desired_section,
2587                 sizeof CC->download_desired_section);
2588         CtdlOutputMsg(msgid, MT_DOWNLOAD, 0, 1, 1, NULL, 0);
2589 }
2590
2591
2592 /*
2593  * Open a component of a MIME message and transmit it all at once
2594  */
2595 void cmd_dlat(char *cmdbuf)
2596 {
2597         long msgid;
2598         char desired_section[128];
2599
2600         msgid = extract_long(cmdbuf, 0);
2601         extract_token(desired_section, cmdbuf, 1, '|', sizeof desired_section);
2602         safestrncpy(CC->download_desired_section, desired_section,
2603                 sizeof CC->download_desired_section);
2604         CtdlOutputMsg(msgid, MT_SPEW_SECTION, 0, 1, 1, NULL, 0);
2605 }
2606
2607
2608 /*
2609  * Save one or more message pointers into a specified room
2610  * (Returns 0 for success, nonzero for failure)
2611  * roomname may be NULL to use the current room
2612  *
2613  * Note that the 'supplied_msg' field may be set to NULL, in which case
2614  * the message will be fetched from disk, by number, if we need to perform
2615  * replication checks.  This adds an additional database read, so if the
2616  * caller already has the message in memory then it should be supplied.  (Obviously
2617  * this mode of operation only works if we're saving a single message.)
2618  */
2619 int CtdlSaveMsgPointersInRoom(char *roomname, long newmsgidlist[], int num_newmsgs,
2620                         int do_repl_check, struct CtdlMessage *supplied_msg, int suppress_refcount_adj
2621 ) {
2622         int i, j, unique;
2623         char hold_rm[ROOMNAMELEN];
2624         struct cdbdata *cdbfr;
2625         int num_msgs;
2626         long *msglist;
2627         long highest_msg = 0L;
2628
2629         long msgid = 0;
2630         struct CtdlMessage *msg = NULL;
2631
2632         long *msgs_to_be_merged = NULL;
2633         int num_msgs_to_be_merged = 0;
2634
2635         syslog(LOG_DEBUG,
2636                 "CtdlSaveMsgPointersInRoom(room=%s, num_msgs=%d, repl=%d, suppress_rca=%d)\n",
2637                 roomname, num_newmsgs, do_repl_check, suppress_refcount_adj
2638         );
2639
2640         strcpy(hold_rm, CC->room.QRname);
2641
2642         /* Sanity checks */
2643         if (newmsgidlist == NULL) return(ERROR + INTERNAL_ERROR);
2644         if (num_newmsgs < 1) return(ERROR + INTERNAL_ERROR);
2645         if (num_newmsgs > 1) supplied_msg = NULL;
2646
2647         /* Now the regular stuff */
2648         if (CtdlGetRoomLock(&CC->room,
2649            ((roomname != NULL) ? roomname : CC->room.QRname) )
2650            != 0) {
2651                 syslog(LOG_ERR, "No such room <%s>\n", roomname);
2652                 return(ERROR + ROOM_NOT_FOUND);
2653         }
2654
2655
2656         msgs_to_be_merged = malloc(sizeof(long) * num_newmsgs);
2657         num_msgs_to_be_merged = 0;
2658
2659
2660         cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
2661         if (cdbfr == NULL) {
2662                 msglist = NULL;
2663                 num_msgs = 0;
2664         } else {
2665                 msglist = (long *) cdbfr->ptr;
2666                 cdbfr->ptr = NULL;      /* CtdlSaveMsgPointerInRoom() now owns this memory */
2667                 num_msgs = cdbfr->len / sizeof(long);
2668                 cdb_free(cdbfr);
2669         }
2670
2671
2672         /* Create a list of msgid's which were supplied by the caller, but do
2673          * not already exist in the target room.  It is absolutely taboo to
2674          * have more than one reference to the same message in a room.
2675          */
2676         for (i=0; i<num_newmsgs; ++i) {
2677                 unique = 1;
2678                 if (num_msgs > 0) for (j=0; j<num_msgs; ++j) {
2679                         if (msglist[j] == newmsgidlist[i]) {
2680                                 unique = 0;
2681                         }
2682                 }
2683                 if (unique) {
2684                         msgs_to_be_merged[num_msgs_to_be_merged++] = newmsgidlist[i];
2685                 }
2686         }
2687
2688         syslog(LOG_DEBUG, "%d unique messages to be merged\n", num_msgs_to_be_merged);
2689
2690         /*
2691          * Now merge the new messages
2692          */
2693         msglist = realloc(msglist, (sizeof(long) * (num_msgs + num_msgs_to_be_merged)) );
2694         if (msglist == NULL) {
2695                 syslog(LOG_ALERT, "ERROR: can't realloc message list!\n");
2696         }
2697         memcpy(&msglist[num_msgs], msgs_to_be_merged, (sizeof(long) * num_msgs_to_be_merged) );
2698         num_msgs += num_msgs_to_be_merged;
2699
2700         /* Sort the message list, so all the msgid's are in order */
2701         num_msgs = sort_msglist(msglist, num_msgs);
2702
2703         /* Determine the highest message number */
2704         highest_msg = msglist[num_msgs - 1];
2705
2706         /* Write it back to disk. */
2707         cdb_store(CDB_MSGLISTS, &CC->room.QRnumber, (int)sizeof(long),
2708                   msglist, (int)(num_msgs * sizeof(long)));
2709
2710         /* Free up the memory we used. */
2711         free(msglist);
2712
2713         /* Update the highest-message pointer and unlock the room. */
2714         CC->room.QRhighest = highest_msg;
2715         CtdlPutRoomLock(&CC->room);
2716
2717         /* Perform replication checks if necessary */
2718         if ( (DoesThisRoomNeedEuidIndexing(&CC->room)) && (do_repl_check) ) {
2719                 syslog(LOG_DEBUG, "CtdlSaveMsgPointerInRoom() doing repl checks\n");
2720
2721                 for (i=0; i<num_msgs_to_be_merged; ++i) {
2722                         msgid = msgs_to_be_merged[i];
2723
2724                         if (supplied_msg != NULL) {
2725                                 msg = supplied_msg;
2726                         }
2727                         else {
2728                                 msg = CtdlFetchMessage(msgid, 0);
2729                         }
2730
2731                         if (msg != NULL) {
2732                                 ReplicationChecks(msg);
2733
2734                                 /* If the message has an Exclusive ID, index that... */
2735                                 if (msg->cm_fields['E'] != NULL) {
2736                                         index_message_by_euid(msg->cm_fields['E'], &CC->room, msgid);
2737                                 }
2738
2739                                 /* Free up the memory we may have allocated */
2740                                 if (msg != supplied_msg) {
2741                                         CtdlFreeMessage(msg);
2742                                 }
2743                         }
2744
2745                 }
2746         }
2747
2748         else {
2749                 syslog(LOG_DEBUG, "CtdlSaveMsgPointerInRoom() skips repl checks\n");
2750         }
2751
2752         /* Submit this room for processing by hooks */
2753         PerformRoomHooks(&CC->room);
2754
2755         /* Go back to the room we were in before we wandered here... */
2756         CtdlGetRoom(&CC->room, hold_rm);
2757
2758         /* Bump the reference count for all messages which were merged */
2759         if (!suppress_refcount_adj) {
2760                 for (i=0; i<num_msgs_to_be_merged; ++i) {
2761                         AdjRefCount(msgs_to_be_merged[i], +1);
2762                 }
2763         }
2764
2765         /* Free up memory... */
2766         if (msgs_to_be_merged != NULL) {
2767                 free(msgs_to_be_merged);
2768         }
2769
2770         /* Return success. */
2771         return (0);
2772 }
2773
2774
2775 /*
2776  * This is the same as CtdlSaveMsgPointersInRoom() but it only accepts
2777  * a single message.
2778  */
2779 int CtdlSaveMsgPointerInRoom(char *roomname, long msgid,
2780                         int do_repl_check, struct CtdlMessage *supplied_msg)
2781 {
2782         return CtdlSaveMsgPointersInRoom(roomname, &msgid, 1, do_repl_check, supplied_msg, 0);
2783 }
2784
2785
2786
2787
2788 /*
2789  * Message base operation to save a new message to the message store
2790  * (returns new message number)
2791  *
2792  * This is the back end for CtdlSubmitMsg() and should not be directly
2793  * called by server-side modules.
2794  *
2795  */
2796 long send_message(struct CtdlMessage *msg) {
2797         long newmsgid;
2798         long retval;
2799         char msgidbuf[256];
2800         struct ser_ret smr;
2801         int is_bigmsg = 0;
2802         char *holdM = NULL;
2803
2804         /* Get a new message number */
2805         newmsgid = get_new_message_number();
2806         snprintf(msgidbuf, sizeof msgidbuf, "%08lX-%08lX@%s",
2807                 (long unsigned int) time(NULL),
2808                 (long unsigned int) newmsgid,
2809                 config.c_fqdn
2810         );
2811
2812         /* Generate an ID if we don't have one already */
2813         if (msg->cm_fields['I']==NULL) {
2814                 msg->cm_fields['I'] = strdup(msgidbuf);
2815         }
2816
2817         /* If the message is big, set its body aside for storage elsewhere */
2818         if (msg->cm_fields['M'] != NULL) {
2819                 if (strlen(msg->cm_fields['M']) > BIGMSG) {
2820                         is_bigmsg = 1;
2821                         holdM = msg->cm_fields['M'];
2822                         msg->cm_fields['M'] = NULL;
2823                 }
2824         }
2825
2826         /* Serialize our data structure for storage in the database */
2827         serialize_message(&smr, msg);
2828
2829         if (is_bigmsg) {
2830                 msg->cm_fields['M'] = holdM;
2831         }
2832
2833         if (smr.len == 0) {
2834                 cprintf("%d Unable to serialize message\n",
2835                         ERROR + INTERNAL_ERROR);
2836                 return (-1L);
2837         }
2838
2839         /* Write our little bundle of joy into the message base */
2840         if (cdb_store(CDB_MSGMAIN, &newmsgid, (int)sizeof(long),
2841                       smr.ser, smr.len) < 0) {
2842                 syslog(LOG_ERR, "Can't store message\n");
2843                 retval = 0L;
2844         } else {
2845                 if (is_bigmsg) {
2846                         cdb_store(CDB_BIGMSGS,
2847                                 &newmsgid,
2848                                 (int)sizeof(long),
2849                                 holdM,
2850                                 (strlen(holdM) + 1)
2851                         );
2852                 }
2853                 retval = newmsgid;
2854         }
2855
2856         /* Free the memory we used for the serialized message */
2857         free(smr.ser);
2858
2859         /* Return the *local* message ID to the caller
2860          * (even if we're storing an incoming network message)
2861          */
2862         return(retval);
2863 }
2864
2865
2866
2867 /*
2868  * Serialize a struct CtdlMessage into the format used on disk and network.
2869  *
2870  * This function loads up a "struct ser_ret" (defined in server.h) which
2871  * contains the length of the serialized message and a pointer to the
2872  * serialized message in memory.  THE LATTER MUST BE FREED BY THE CALLER.
2873  */
2874 void serialize_message(struct ser_ret *ret,             /* return values */
2875                         struct CtdlMessage *msg)        /* unserialized msg */
2876 {
2877         size_t wlen, fieldlen;
2878         int i;
2879         static char *forder = FORDER;
2880
2881         /*
2882          * Check for valid message format
2883          */
2884         if (is_valid_message(msg) == 0) {
2885                 syslog(LOG_ERR, "serialize_message() aborting due to invalid message\n");
2886                 ret->len = 0;
2887                 ret->ser = NULL;
2888                 return;
2889         }
2890
2891         ret->len = 3;
2892         for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL)
2893                 ret->len = ret->len +
2894                         strlen(msg->cm_fields[(int)forder[i]]) + 2;
2895
2896         ret->ser = malloc(ret->len);
2897         if (ret->ser == NULL) {
2898                 syslog(LOG_ERR, "serialize_message() malloc(%ld) failed: %s\n",
2899                         (long)ret->len, strerror(errno));
2900                 ret->len = 0;
2901                 ret->ser = NULL;
2902                 return;
2903         }
2904
2905         ret->ser[0] = 0xFF;
2906         ret->ser[1] = msg->cm_anon_type;
2907         ret->ser[2] = msg->cm_format_type;
2908         wlen = 3;
2909
2910         for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL) {
2911                 fieldlen = strlen(msg->cm_fields[(int)forder[i]]);
2912                 ret->ser[wlen++] = (char)forder[i];
2913                 safestrncpy((char *)&ret->ser[wlen], msg->cm_fields[(int)forder[i]], fieldlen+1);
2914                 wlen = wlen + fieldlen + 1;
2915         }
2916         if (ret->len != wlen) syslog(LOG_ERR, "ERROR: len=%ld wlen=%ld\n",
2917                 (long)ret->len, (long)wlen);
2918
2919         return;
2920 }
2921
2922
2923 /*
2924  * Serialize a struct CtdlMessage into the format used on disk and network.
2925  *
2926  * This function loads up a "struct ser_ret" (defined in server.h) which
2927  * contains the length of the serialized message and a pointer to the
2928  * serialized message in memory.  THE LATTER MUST BE FREED BY THE CALLER.
2929  */
2930 void dump_message(struct CtdlMessage *msg,      /* unserialized msg */
2931                   long Siz)                     /* how many chars ? */
2932 {
2933         size_t wlen;
2934         int i;
2935         static char *forder = FORDER;
2936         char *buf;
2937
2938         /*
2939          * Check for valid message format
2940          */
2941         if (is_valid_message(msg) == 0) {
2942                 syslog(LOG_ERR, "dump_message() aborting due to invalid message\n");
2943                 return;
2944         }
2945
2946         buf = (char*) malloc (Siz + 1);
2947
2948         wlen = 3;
2949
2950         for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL) {
2951                         snprintf (buf, Siz, " msg[%c] = %s ...\n", (char) forder[i],
2952                                    msg->cm_fields[(int)forder[i]]);
2953                         if (client_write (buf, strlen(buf)) == -1)
2954                         {
2955                                 syslog(LOG_ERR, "dump_message(): aborting due to write failure.\n");
2956                                 return;
2957                         }
2958                 }
2959
2960         return;
2961 }
2962
2963
2964
2965 /*
2966  * Check to see if any messages already exist in the current room which
2967  * carry the same Exclusive ID as this one.  If any are found, delete them.
2968  */
2969 void ReplicationChecks(struct CtdlMessage *msg) {
2970         long old_msgnum = (-1L);
2971
2972         if (DoesThisRoomNeedEuidIndexing(&CC->room) == 0) return;
2973
2974         syslog(LOG_DEBUG, "Performing replication checks in <%s>\n",
2975                 CC->room.QRname);
2976
2977         /* No exclusive id?  Don't do anything. */
2978         if (msg == NULL) return;
2979         if (msg->cm_fields['E'] == NULL) return;
2980         if (IsEmptyStr(msg->cm_fields['E'])) return;
2981         /*syslog(LOG_DEBUG, "Exclusive ID: <%s> for room <%s>\n",
2982                 msg->cm_fields['E'], CC->room.QRname);*/
2983
2984         old_msgnum = CtdlLocateMessageByEuid(msg->cm_fields['E'], &CC->room);
2985         if (old_msgnum > 0L) {
2986                 syslog(LOG_DEBUG, "ReplicationChecks() replacing message %ld\n", old_msgnum);
2987                 CtdlDeleteMessages(CC->room.QRname, &old_msgnum, 1, "");
2988         }
2989 }
2990
2991
2992
2993 /*
2994  * Save a message to disk and submit it into the delivery system.
2995  */
2996 long CtdlSubmitMsg(struct CtdlMessage *msg,     /* message to save */
2997                    struct recptypes *recps,     /* recipients (if mail) */
2998                    const char *force,           /* force a particular room? */
2999                    int flags                    /* should the message be exported clean? */
3000 ) {
3001         char submit_filename[128];
3002         char generated_timestamp[32];
3003         char hold_rm[ROOMNAMELEN];
3004         char actual_rm[ROOMNAMELEN];
3005         char force_room[ROOMNAMELEN];
3006         char content_type[SIZ];                 /* We have to learn this */
3007         char recipient[SIZ];
3008         long newmsgid;
3009         const char *mptr = NULL;
3010         struct ctdluser userbuf;
3011         int a, i;
3012         struct MetaData smi;
3013         FILE *network_fp = NULL;
3014         static int seqnum = 1;
3015         struct CtdlMessage *imsg = NULL;
3016         char *instr = NULL;
3017         size_t instr_alloc = 0;
3018         struct ser_ret smr;
3019         char *hold_R, *hold_D;
3020         char *collected_addresses = NULL;
3021         struct addresses_to_be_filed *aptr = NULL;
3022         StrBuf *saved_rfc822_version = NULL;
3023         int qualified_for_journaling = 0;
3024         CitContext *CCC = MyContext();
3025         char bounce_to[1024] = "";
3026         size_t tmp = 0;
3027         int rv = 0;
3028
3029         syslog(LOG_DEBUG, "CtdlSubmitMsg() called\n");
3030         if (is_valid_message(msg) == 0) return(-1);     /* self check */
3031
3032         /* If this message has no timestamp, we take the liberty of
3033          * giving it one, right now.
3034          */
3035         if (msg->cm_fields['T'] == NULL) {
3036                 snprintf(generated_timestamp, sizeof generated_timestamp, "%ld", (long)time(NULL));
3037                 msg->cm_fields['T'] = strdup(generated_timestamp);
3038         }
3039
3040         /* If this message has no path, we generate one.
3041          */
3042         if (msg->cm_fields['P'] == NULL) {
3043                 if (msg->cm_fields['A'] != NULL) {
3044                         msg->cm_fields['P'] = strdup(msg->cm_fields['A']);
3045                         for (a=0; !IsEmptyStr(&msg->cm_fields['P'][a]); ++a) {
3046                                 if (isspace(msg->cm_fields['P'][a])) {
3047                                         msg->cm_fields['P'][a] = ' ';
3048                                 }
3049                         }
3050                 }
3051                 else {
3052                         msg->cm_fields['P'] = strdup("unknown");
3053                 }
3054         }
3055
3056         if (force == NULL) {
3057                 strcpy(force_room, "");
3058         }
3059         else {
3060                 strcpy(force_room, force);
3061         }
3062
3063         /* Learn about what's inside, because it's what's inside that counts */
3064         if (msg->cm_fields['M'] == NULL) {
3065                 syslog(LOG_ERR, "ERROR: attempt to save message with NULL body\n");
3066                 return(-2);
3067         }
3068
3069         switch (msg->cm_format_type) {
3070         case 0:
3071                 strcpy(content_type, "text/x-citadel-variformat");
3072                 break;
3073         case 1:
3074                 strcpy(content_type, "text/plain");
3075                 break;
3076         case 4:
3077                 strcpy(content_type, "text/plain");
3078                 mptr = bmstrcasestr(msg->cm_fields['M'], "Content-type:");
3079                 if (mptr != NULL) {
3080                         char *aptr;
3081                         safestrncpy(content_type, &mptr[13], sizeof content_type);
3082                         striplt(content_type);
3083                         aptr = content_type;
3084                         while (!IsEmptyStr(aptr)) {
3085                                 if ((*aptr == ';')
3086                                     || (*aptr == ' ')
3087                                     || (*aptr == 13)
3088                                     || (*aptr == 10)) {
3089                                         *aptr = 0;
3090                                 }
3091                                 else aptr++;
3092                         }
3093                 }
3094         }
3095
3096         /* Goto the correct room */
3097         syslog(LOG_DEBUG, "Selected room %s\n", (recps) ? CCC->room.QRname : SENTITEMS);
3098         strcpy(hold_rm, CCC->room.QRname);
3099         strcpy(actual_rm, CCC->room.QRname);
3100         if (recps != NULL) {
3101                 strcpy(actual_rm, SENTITEMS);
3102         }
3103
3104         /* If the user is a twit, move to the twit room for posting */
3105         if (TWITDETECT) {
3106                 if (CCC->user.axlevel == AxProbU) {
3107                         strcpy(hold_rm, actual_rm);
3108                         strcpy(actual_rm, config.c_twitroom);
3109                         syslog(LOG_DEBUG, "Diverting to twit room\n");
3110                 }
3111         }
3112
3113         /* ...or if this message is destined for Aide> then go there. */
3114         if (!IsEmptyStr(force_room)) {
3115                 strcpy(actual_rm, force_room);
3116         }
3117
3118         syslog(LOG_DEBUG, "Final selection: %s\n", actual_rm);
3119         if (strcasecmp(actual_rm, CCC->room.QRname)) {
3120                 /* CtdlGetRoom(&CCC->room, actual_rm); */
3121                 CtdlUserGoto(actual_rm, 0, 1, NULL, NULL);
3122         }
3123
3124         /*
3125          * If this message has no O (room) field, generate one.
3126          */
3127         if (msg->cm_fields['O'] == NULL) {
3128                 msg->cm_fields['O'] = strdup(CCC->room.QRname);
3129         }
3130
3131         /* Perform "before save" hooks (aborting if any return nonzero) */
3132         syslog(LOG_DEBUG, "Performing before-save hooks\n");
3133         if (PerformMessageHooks(msg, EVT_BEFORESAVE) > 0) return(-3);
3134
3135         /*
3136          * If this message has an Exclusive ID, and the room is replication
3137          * checking enabled, then do replication checks.
3138          */
3139         if (DoesThisRoomNeedEuidIndexing(&CCC->room)) {
3140                 ReplicationChecks(msg);
3141         }
3142
3143         /* Save it to disk */
3144         syslog(LOG_DEBUG, "Saving to disk\n");
3145         newmsgid = send_message(msg);
3146         if (newmsgid <= 0L) return(-5);
3147
3148         /* Write a supplemental message info record.  This doesn't have to
3149          * be a critical section because nobody else knows about this message
3150          * yet.
3151          */
3152         syslog(LOG_DEBUG, "Creating MetaData record\n");
3153         memset(&smi, 0, sizeof(struct MetaData));
3154         smi.meta_msgnum = newmsgid;
3155         smi.meta_refcount = 0;
3156         safestrncpy(smi.meta_content_type, content_type,
3157                         sizeof smi.meta_content_type);
3158
3159         /*
3160          * Measure how big this message will be when rendered as RFC822.
3161          * We do this for two reasons:
3162          * 1. We need the RFC822 length for the new metadata record, so the
3163          *    POP and IMAP services don't have to calculate message lengths
3164          *    while the user is waiting (multiplied by potentially hundreds
3165          *    or thousands of messages).
3166          * 2. If journaling is enabled, we will need an RFC822 version of the
3167          *    message to attach to the journalized copy.
3168          */
3169         if (CCC->redirect_buffer != NULL) {
3170                 syslog(LOG_ALERT, "CCC->redirect_buffer is not NULL during message submission!\n");
3171                 abort();
3172         }
3173         CCC->redirect_buffer = NewStrBufPlain(NULL, SIZ);
3174         CtdlOutputPreLoadedMsg(msg, MT_RFC822, HEADERS_ALL, 0, 1, QP_EADDR);
3175         smi.meta_rfc822_length = StrLength(CCC->redirect_buffer);
3176         saved_rfc822_version = CCC->redirect_buffer;
3177         CCC->redirect_buffer = NULL;
3178
3179         PutMetaData(&smi);
3180
3181         /* Now figure out where to store the pointers */
3182         syslog(LOG_DEBUG, "Storing pointers\n");
3183
3184         /* If this is being done by the networker delivering a private
3185          * message, we want to BYPASS saving the sender's copy (because there
3186          * is no local sender; it would otherwise go to the Trashcan).
3187          */
3188         if ((!CCC->internal_pgm) || (recps == NULL)) {
3189                 if (CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 1, msg) != 0) {
3190                         syslog(LOG_ERR, "ERROR saving message pointer!\n");
3191                         CtdlSaveMsgPointerInRoom(config.c_aideroom, newmsgid, 0, msg);
3192                 }
3193         }
3194
3195         /* For internet mail, drop a copy in the outbound queue room */
3196         if ((recps != NULL) && (recps->num_internet > 0)) {
3197                 CtdlSaveMsgPointerInRoom(SMTP_SPOOLOUT_ROOM, newmsgid, 0, msg);
3198         }
3199
3200         /* If other rooms are specified, drop them there too. */
3201         if ((recps != NULL) && (recps->num_room > 0))
3202           for (i=0; i<num_tokens(recps->recp_room, '|'); ++i) {
3203                 extract_token(recipient, recps->recp_room, i,
3204                                         '|', sizeof recipient);
3205                 syslog(LOG_DEBUG, "Delivering to room <%s>\n", recipient);
3206                 CtdlSaveMsgPointerInRoom(recipient, newmsgid, 0, msg);
3207         }
3208
3209         /* Bump this user's messages posted counter. */
3210         syslog(LOG_DEBUG, "Updating user\n");
3211         CtdlGetUserLock(&CCC->user, CCC->curr_user);
3212         CCC->user.posted = CCC->user.posted + 1;
3213         CtdlPutUserLock(&CCC->user);
3214
3215         /* Decide where bounces need to be delivered */
3216         if ((recps != NULL) && (recps->bounce_to != NULL)) {
3217                 safestrncpy(bounce_to, recps->bounce_to, sizeof bounce_to);
3218         }
3219         else if (CCC->logged_in) {
3220                 snprintf(bounce_to, sizeof bounce_to, "%s@%s", CCC->user.fullname, config.c_nodename);
3221         }
3222         else {
3223                 snprintf(bounce_to, sizeof bounce_to, "%s@%s", msg->cm_fields['A'], msg->cm_fields['N']);
3224         }
3225
3226         /* If this is private, local mail, make a copy in the
3227          * recipient's mailbox and bump the reference count.
3228          */
3229         if ((recps != NULL) && (recps->num_local > 0))
3230           for (i=0; i<num_tokens(recps->recp_local, '|'); ++i) {
3231                 extract_token(recipient, recps->recp_local, i,
3232                                         '|', sizeof recipient);
3233                 syslog(LOG_DEBUG, "Delivering private local mail to <%s>\n",
3234                         recipient);
3235                 if (CtdlGetUser(&userbuf, recipient) == 0) {
3236                         // Add a flag so the Funambol module knows its mail
3237                         msg->cm_fields['W'] = strdup(recipient);
3238                         CtdlMailboxName(actual_rm, sizeof actual_rm, &userbuf, MAILROOM);
3239                         CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0, msg);
3240                         CtdlBumpNewMailCounter(userbuf.usernum);
3241                         if (!IsEmptyStr(config.c_funambol_host) || !IsEmptyStr(config.c_pager_program)) {
3242                         /* Generate a instruction message for the Funambol notification
3243                          * server, in the same style as the SMTP queue
3244                          */
3245                            instr_alloc = 1024;
3246                            instr = malloc(instr_alloc);
3247                            snprintf(instr, instr_alloc,
3248                         "Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
3249                         "bounceto|%s\n",
3250                         SPOOLMIME, newmsgid, (long)time(NULL),
3251                         bounce_to
3252                         );
3253
3254                            imsg = malloc(sizeof(struct CtdlMessage));
3255                            memset(imsg, 0, sizeof(struct CtdlMessage));
3256                            imsg->cm_magic = CTDLMESSAGE_MAGIC;
3257                            imsg->cm_anon_type = MES_NORMAL;
3258                            imsg->cm_format_type = FMT_RFC822;
3259                            imsg->cm_fields['A'] = strdup("Citadel");
3260                            imsg->cm_fields['J'] = strdup("do not journal");
3261                            imsg->cm_fields['M'] = instr;        /* imsg owns this memory now */
3262                            imsg->cm_fields['W'] = strdup(recipient);
3263                            CtdlSubmitMsg(imsg, NULL, FNBL_QUEUE_ROOM, 0);
3264                            CtdlFreeMessage(imsg);
3265                         }
3266                 }
3267                 else {
3268                         syslog(LOG_DEBUG, "No user <%s>\n", recipient);
3269                         CtdlSaveMsgPointerInRoom(config.c_aideroom,
3270                                 newmsgid, 0, msg);
3271                 }
3272         }
3273
3274         /* Perform "after save" hooks */
3275         syslog(LOG_DEBUG, "Performing after-save hooks\n");
3276         PerformMessageHooks(msg, EVT_AFTERSAVE);
3277
3278         /* For IGnet mail, we have to save a new copy into the spooler for
3279          * each recipient, with the R and D fields set to the recipient and
3280          * destination-node.  This has two ugly side effects: all other
3281          * recipients end up being unlisted in this recipient's copy of the
3282          * message, and it has to deliver multiple messages to the same
3283          * node.  We'll revisit this again in a year or so when everyone has
3284          * a network spool receiver that can handle the new style messages.
3285          */
3286         if ((recps != NULL) && (recps->num_ignet > 0))
3287           for (i=0; i<num_tokens(recps->recp_ignet, '|'); ++i) {
3288                 extract_token(recipient, recps->recp_ignet, i,
3289                                 '|', sizeof recipient);
3290
3291                 hold_R = msg->cm_fields['R'];
3292                 hold_D = msg->cm_fields['D'];
3293                 msg->cm_fields['R'] = malloc(SIZ);
3294                 msg->cm_fields['D'] = malloc(128);
3295                 extract_token(msg->cm_fields['R'], recipient, 0, '@', SIZ);
3296                 extract_token(msg->cm_fields['D'], recipient, 1, '@', 128);
3297
3298                 serialize_message(&smr, msg);
3299                 if (smr.len > 0) {
3300                         snprintf(submit_filename, sizeof submit_filename,
3301                                          "%s/netmail.%04lx.%04x.%04x",
3302                                          ctdl_netin_dir,
3303                                          (long) getpid(), CCC->cs_pid, ++seqnum);
3304                         network_fp = fopen(submit_filename, "wb+");
3305                         if (network_fp != NULL) {
3306                                 rv = fwrite(smr.ser, smr.len, 1, network_fp);
3307                                 fclose(network_fp);
3308                         }
3309                         free(smr.ser);
3310                 }
3311
3312                 free(msg->cm_fields['R']);
3313                 free(msg->cm_fields['D']);
3314                 msg->cm_fields['R'] = hold_R;
3315                 msg->cm_fields['D'] = hold_D;
3316         }
3317
3318         /* Go back to the room we started from */
3319         syslog(LOG_DEBUG, "Returning to original room %s\n", hold_rm);
3320         if (strcasecmp(hold_rm, CCC->room.QRname))
3321                 CtdlUserGoto(hold_rm, 0, 1, NULL, NULL);
3322
3323         /* For internet mail, generate delivery instructions.
3324          * Yes, this is recursive.  Deal with it.  Infinite recursion does
3325          * not happen because the delivery instructions message does not
3326          * contain a recipient.
3327          */
3328         if ((recps != NULL) && (recps->num_internet > 0)) {
3329                 syslog(LOG_DEBUG, "Generating delivery instructions\n");
3330                 instr_alloc = 1024;
3331                 instr = malloc(instr_alloc);
3332                 snprintf(instr, instr_alloc,
3333                         "Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
3334                         "bounceto|%s\n",
3335                         SPOOLMIME, newmsgid, (long)time(NULL),
3336                         bounce_to
3337                 );
3338
3339                 if (recps->envelope_from != NULL) {
3340                         tmp = strlen(instr);
3341                         snprintf(&instr[tmp], instr_alloc-tmp, "envelope_from|%s\n", recps->envelope_from);
3342                 }
3343
3344                 for (i=0; i<num_tokens(recps->recp_internet, '|'); ++i) {
3345                         tmp = strlen(instr);
3346                         extract_token(recipient, recps->recp_internet, i, '|', sizeof recipient);
3347                         if ((tmp + strlen(recipient) + 32) > instr_alloc) {
3348                                 instr_alloc = instr_alloc * 2;
3349                                 instr = realloc(instr, instr_alloc);
3350                         }
3351                         snprintf(&instr[tmp], instr_alloc - tmp, "remote|%s|0||\n", recipient);
3352                 }
3353
3354                 imsg = malloc(sizeof(struct CtdlMessage));
3355                 memset(imsg, 0, sizeof(struct CtdlMessage));
3356                 imsg->cm_magic = CTDLMESSAGE_MAGIC;
3357                 imsg->cm_anon_type = MES_NORMAL;
3358                 imsg->cm_format_type = FMT_RFC822;
3359                 imsg->cm_fields['A'] = strdup("Citadel");
3360                 imsg->cm_fields['J'] = strdup("do not journal");
3361                 imsg->cm_fields['M'] = instr;   /* imsg owns this memory now */
3362                 CtdlSubmitMsg(imsg, NULL, SMTP_SPOOLOUT_ROOM, QP_EADDR);
3363                 CtdlFreeMessage(imsg);
3364         }
3365
3366         /*
3367          * Any addresses to harvest for someone's address book?
3368          */
3369         if ( (CCC->logged_in) && (recps != NULL) ) {
3370                 collected_addresses = harvest_collected_addresses(msg);
3371         }
3372
3373         if (collected_addresses != NULL) {
3374                 aptr = (struct addresses_to_be_filed *)
3375                         malloc(sizeof(struct addresses_to_be_filed));
3376                 CtdlMailboxName(actual_rm, sizeof actual_rm,
3377                         &CCC->user, USERCONTACTSROOM);
3378                 aptr->roomname = strdup(actual_rm);
3379                 aptr->collected_addresses = collected_addresses;
3380                 begin_critical_section(S_ATBF);
3381                 aptr->next = atbf;
3382                 atbf = aptr;
3383                 end_critical_section(S_ATBF);
3384         }
3385
3386         /*
3387          * Determine whether this message qualifies for journaling.
3388          */
3389         if (msg->cm_fields['J'] != NULL) {
3390                 qualified_for_journaling = 0;
3391         }
3392         else {
3393                 if (recps == NULL) {
3394                         qualified_for_journaling = config.c_journal_pubmsgs;
3395                 }
3396                 else if (recps->num_local + recps->num_ignet + recps->num_internet > 0) {
3397                         qualified_for_journaling = config.c_journal_email;
3398                 }
3399                 else {
3400                         qualified_for_journaling = config.c_journal_pubmsgs;
3401                 }
3402         }
3403
3404         /*
3405          * Do we have to perform journaling?  If so, hand off the saved
3406          * RFC822 version will be handed off to the journaler for background
3407          * submit.  Otherwise, we have to free the memory ourselves.
3408          */
3409         if (saved_rfc822_version != NULL) {
3410                 if (qualified_for_journaling) {
3411                         JournalBackgroundSubmit(msg, saved_rfc822_version, recps);
3412                 }
3413                 else {
3414                         FreeStrBuf(&saved_rfc822_version);
3415                 }
3416         }
3417
3418         /* Done. */
3419         return(newmsgid);
3420 }
3421
3422
3423
3424 void aide_message (char *text, char *subject)
3425 {
3426         quickie_message("Citadel",NULL,NULL,AIDEROOM,text,FMT_CITADEL,subject);
3427 }
3428
3429
3430 /*
3431  * Convenience function for generating small administrative messages.
3432  */
3433 void quickie_message(const char *from, const char *fromaddr, char *to, char *room, const char *text,
3434                         int format_type, const char *subject)
3435 {
3436         struct CtdlMessage *msg;
3437         struct recptypes *recp = NULL;
3438
3439         msg = malloc(sizeof(struct CtdlMessage));
3440         memset(msg, 0, sizeof(struct CtdlMessage));
3441         msg->cm_magic = CTDLMESSAGE_MAGIC;
3442         msg->cm_anon_type = MES_NORMAL;
3443         msg->cm_format_type = format_type;
3444
3445         if (from != NULL) {
3446                 msg->cm_fields['A'] = strdup(from);
3447         }
3448         else if (fromaddr != NULL) {
3449                 msg->cm_fields['A'] = strdup(fromaddr);
3450                 if (strchr(msg->cm_fields['A'], '@')) {
3451                         *strchr(msg->cm_fields['A'], '@') = 0;
3452                 }
3453         }
3454         else {
3455                 msg->cm_fields['A'] = strdup("Citadel");
3456         }
3457
3458         if (fromaddr != NULL) msg->cm_fields['F'] = strdup(fromaddr);
3459         if (room != NULL) msg->cm_fields['O'] = strdup(room);
3460         msg->cm_fields['N'] = strdup(NODENAME);
3461         if (to != NULL) {
3462                 msg->cm_fields['R'] = strdup(to);
3463                 recp = validate_recipients(to, NULL, 0);
3464         }
3465         if (subject != NULL) {
3466                 msg->cm_fields['U'] = strdup(subject);
3467         }
3468         msg->cm_fields['M'] = strdup(text);
3469
3470         CtdlSubmitMsg(msg, recp, room, 0);
3471         CtdlFreeMessage(msg);
3472         if (recp != NULL) free_recipients(recp);
3473 }
3474
3475
3476
3477 /*
3478  * Back end function used by CtdlMakeMessage() and similar functions
3479  */
3480 StrBuf *CtdlReadMessageBodyBuf(char *terminator,        /* token signalling EOT */
3481                                long tlen,
3482                                size_t maxlen,           /* maximum message length */
3483                                char *exist,             /* if non-null, append to it;
3484                                                            exist is ALWAYS freed  */
3485                                int crlf,                /* CRLF newlines instead of LF */
3486                                int *sock                /* socket handle or 0 for this session's client socket */
3487                         )
3488 {
3489         StrBuf *Message;
3490         StrBuf *LineBuf;
3491         int flushing = 0;
3492         int finished = 0;
3493         int dotdot = 0;
3494
3495         LineBuf = NewStrBufPlain(NULL, SIZ);
3496         if (exist == NULL) {
3497                 Message = NewStrBufPlain(NULL, 4 * SIZ);
3498         }
3499         else {
3500                 Message = NewStrBufPlain(exist, -1);
3501                 free(exist);
3502         }
3503
3504         /* Do we need to change leading ".." to "." for SMTP escaping? */
3505         if ((tlen == 1) && (*terminator == '.')) {
3506                 dotdot = 1;
3507         }
3508
3509         /* read in the lines of message text one by one */
3510         do {
3511                 if (sock != NULL) {
3512                         if ((CtdlSockGetLine(sock, LineBuf, 5) < 0) ||
3513                             (*sock == -1))
3514                                 finished = 1;
3515                 }
3516                 else {
3517                         if (CtdlClientGetLine(LineBuf) < 0) finished = 1;
3518                 }
3519                 if ((StrLength(LineBuf) == tlen) &&
3520                     (!strcmp(ChrPtr(LineBuf), terminator)))
3521                         finished = 1;
3522
3523                 if ( (!flushing) && (!finished) ) {
3524                         if (crlf) {
3525                                 StrBufAppendBufPlain(LineBuf, HKEY("\r\n"), 0);
3526                         }
3527                         else {
3528                                 StrBufAppendBufPlain(LineBuf, HKEY("\n"), 0);
3529                         }
3530
3531                         /* Unescape SMTP-style input of two dots at the beginning of the line */
3532                         if ((dotdot) &&
3533                             (StrLength(LineBuf) == 2) &&
3534                             (!strcmp(ChrPtr(LineBuf), "..")))
3535                         {
3536                                 StrBufCutLeft(LineBuf, 1);
3537                         }
3538
3539                         StrBufAppendBuf(Message, LineBuf, 0);
3540                 }
3541
3542                 /* if we've hit the max msg length, flush the rest */
3543                 if (StrLength(Message) >= maxlen) flushing = 1;
3544
3545         } while (!finished);
3546         FreeStrBuf(&LineBuf);
3547         return Message;
3548 }
3549
3550 void DeleteAsyncMsg(ReadAsyncMsg **Msg)
3551 {
3552         if (*Msg == NULL)
3553                 return;
3554         FreeStrBuf(&(*Msg)->MsgBuf);
3555
3556         free(*Msg);
3557         *Msg = NULL;
3558 }
3559
3560 ReadAsyncMsg *NewAsyncMsg(const char *terminator,       /* token signalling EOT */
3561                           long tlen,
3562                           size_t maxlen,                /* maximum message length */
3563                           size_t expectlen,             /* if we expect a message, how long should it be? */
3564                           char *exist,                  /* if non-null, append to it;
3565                                                            exist is ALWAYS freed  */
3566                           long eLen,                    /* length of exist */
3567                           int crlf                      /* CRLF newlines instead of LF */
3568         )
3569 {
3570         ReadAsyncMsg *NewMsg;
3571
3572         NewMsg = (ReadAsyncMsg *)malloc(sizeof(ReadAsyncMsg));
3573         memset(NewMsg, 0, sizeof(ReadAsyncMsg));
3574
3575         if (exist == NULL) {
3576                 long len;
3577
3578                 if (expectlen == 0) {
3579                         len = 4 * SIZ;
3580                 }
3581                 else {
3582                         len = expectlen + 10;
3583                 }
3584                 NewMsg->MsgBuf = NewStrBufPlain(NULL, len);
3585         }
3586         else {
3587                 NewMsg->MsgBuf = NewStrBufPlain(exist, eLen);
3588                 free(exist);
3589         }
3590         /* Do we need to change leading ".." to "." for SMTP escaping? */
3591         if ((tlen == 1) && (*terminator == '.')) {
3592                 NewMsg->dodot = 1;
3593         }
3594
3595         NewMsg->terminator = terminator;
3596         NewMsg->tlen = tlen;
3597
3598         NewMsg->maxlen = maxlen;
3599
3600         NewMsg->crlf = crlf;
3601
3602         return NewMsg;
3603 }
3604
3605 /*
3606  * Back end function used by CtdlMakeMessage() and similar functions
3607  */
3608 eReadState CtdlReadMessageBodyAsync(AsyncIO *IO)
3609 {
3610         ReadAsyncMsg *ReadMsg;
3611         int MsgFinished = 0;
3612         eReadState Finished = eMustReadMore;
3613
3614 #ifdef BIGBAD_IODBG
3615         char fn [SIZ];
3616         FILE *fd;
3617         const char *pch = ChrPtr(IO->SendBuf.Buf);
3618         const char *pchh = IO->SendBuf.ReadWritePointer;
3619         long nbytes;
3620
3621         if (pchh == NULL)
3622                 pchh = pch;
3623
3624         nbytes = StrLength(IO->SendBuf.Buf) - (pchh - pch);
3625         snprintf(fn, SIZ, "/tmp/foolog_ev_%s.%d",
3626                  ((CitContext*)(IO->CitContext))->ServiceName,
3627                  IO->SendBuf.fd);
3628
3629         fd = fopen(fn, "a+");
3630 #endif
3631
3632         ReadMsg = IO->ReadMsg;
3633
3634         /* read in the lines of message text one by one */
3635         do {
3636                 Finished = StrBufChunkSipLine(IO->IOBuf, &IO->RecvBuf);
3637
3638                 switch (Finished) {
3639                 case eMustReadMore: /// read new from socket...
3640 #ifdef BIGBAD_IODBG
3641                         if (IO->RecvBuf.ReadWritePointer != NULL) {
3642                                 nbytes = StrLength(IO->RecvBuf.Buf) - (IO->RecvBuf.ReadWritePointer - ChrPtr(IO->RecvBuf.Buf));
3643                                 fprintf(fd, "Read; Line unfinished: %ld Bytes still in buffer [", nbytes);
3644
3645                                 fwrite(IO->RecvBuf.ReadWritePointer, nbytes, 1, fd);
3646
3647                                 fprintf(fd, "]\n");
3648                         } else {
3649                                 fprintf(fd, "BufferEmpty! \n");
3650                         }
3651                         fclose(fd);
3652 #endif
3653                         return Finished;
3654                     break;
3655                 case eBufferNotEmpty: /* shouldn't happen... */
3656                 case eReadSuccess: /// done for now...
3657                     break;
3658                 case eReadFail: /// WHUT?
3659                     ///todo: shut down!
3660                         break;
3661                 }
3662
3663
3664                 if ((StrLength(IO->IOBuf) == ReadMsg->tlen) &&
3665                     (!strcmp(ChrPtr(IO->IOBuf), ReadMsg->terminator))) {
3666                         MsgFinished = 1;
3667 #ifdef BIGBAD_IODBG
3668                         fprintf(fd, "found Terminator; Message Size: %d\n", StrLength(ReadMsg->MsgBuf));
3669 #endif
3670                 }
3671                 else if (!ReadMsg->flushing) {
3672
3673 #ifdef BIGBAD_IODBG
3674                         fprintf(fd, "Read Line: [%d][%s]\n", StrLength(IO->IOBuf), ChrPtr(IO->IOBuf));
3675 #endif
3676
3677                         /* Unescape SMTP-style input of two dots at the beginning of the line */
3678                         if ((ReadMsg->dodot) &&
3679                             (StrLength(IO->IOBuf) == 2) &&  /* TODO: do we just unescape lines with two dots or any line? */
3680                             (!strcmp(ChrPtr(IO->IOBuf), "..")))
3681                         {
3682 #ifdef BIGBAD_IODBG
3683                                 fprintf(fd, "UnEscaped!\n");
3684 #endif
3685                                 StrBufCutLeft(IO->IOBuf, 1);
3686                         }
3687
3688                         if (ReadMsg->crlf) {
3689                                 StrBufAppendBufPlain(IO->IOBuf, HKEY("\r\n"), 0);
3690                         }
3691                         else {
3692                                 StrBufAppendBufPlain(IO->IOBuf, HKEY("\n"), 0);
3693                         }
3694
3695                         StrBufAppendBuf(ReadMsg->MsgBuf, IO->IOBuf, 0);
3696                 }
3697
3698                 /* if we've hit the max msg length, flush the rest */
3699                 if (StrLength(ReadMsg->MsgBuf) >= ReadMsg->maxlen) ReadMsg->flushing = 1;
3700
3701         } while (!MsgFinished);
3702
3703 #ifdef BIGBAD_IODBG
3704         fprintf(fd, "Done with reading; %s.\n, ",
3705                 (MsgFinished)?"Message Finished": "FAILED");
3706         fclose(fd);
3707 #endif
3708         if (MsgFinished)
3709                 return eReadSuccess;
3710         else
3711                 return eAbort;
3712 }
3713
3714
3715 /*
3716  * Back end function used by CtdlMakeMessage() and similar functions
3717  */
3718 char *CtdlReadMessageBody(char *terminator,     /* token signalling EOT */
3719                           long tlen,
3720                           size_t maxlen,                /* maximum message length */
3721                           char *exist,          /* if non-null, append to it;
3722                                                    exist is ALWAYS freed  */
3723                           int crlf,             /* CRLF newlines instead of LF */
3724                           int *sock             /* socket handle or 0 for this session's client socket */
3725         )
3726 {
3727         StrBuf *Message;
3728
3729         Message = CtdlReadMessageBodyBuf(terminator,
3730                                          tlen,
3731                                          maxlen,
3732                                          exist,
3733                                          crlf,
3734                                          sock);
3735         if (Message == NULL)
3736                 return NULL;
3737         else
3738                 return SmashStrBuf(&Message);
3739 }
3740
3741
3742 /*
3743  * Build a binary message to be saved on disk.
3744  * (NOTE: if you supply 'preformatted_text', the buffer you give it
3745  * will become part of the message.  This means you are no longer
3746  * responsible for managing that memory -- it will be freed along with
3747  * the rest of the fields when CtdlFreeMessage() is called.)
3748  */
3749
3750 struct CtdlMessage *CtdlMakeMessage(
3751         struct ctdluser *author,        /* author's user structure */
3752         char *recipient,                /* NULL if it's not mail */
3753         char *recp_cc,                  /* NULL if it's not mail */
3754         char *room,                     /* room where it's going */
3755         int type,                       /* see MES_ types in header file */
3756         int format_type,                /* variformat, plain text, MIME... */
3757         char *fake_name,                /* who we're masquerading as */
3758         char *my_email,                 /* which of my email addresses to use (empty is ok) */
3759         char *subject,                  /* Subject (optional) */
3760         char *supplied_euid,            /* ...or NULL if this is irrelevant */
3761         char *preformatted_text,        /* ...or NULL to read text from client */
3762         char *references                /* Thread references */
3763 ) {
3764         char dest_node[256];
3765         char buf[1024];
3766         struct CtdlMessage *msg;
3767         StrBuf *FakeAuthor;
3768         StrBuf *FakeEncAuthor = NULL;
3769
3770         msg = malloc(sizeof(struct CtdlMessage));
3771         memset(msg, 0, sizeof(struct CtdlMessage));
3772         msg->cm_magic = CTDLMESSAGE_MAGIC;
3773         msg->cm_anon_type = type;
3774         msg->cm_format_type = format_type;
3775
3776         /* Don't confuse the poor folks if it's not routed mail. */
3777         strcpy(dest_node, "");
3778
3779         if (recipient != NULL) striplt(recipient);
3780         if (recp_cc != NULL) striplt(recp_cc);
3781
3782         /* Path or Return-Path */
3783         if (my_email == NULL) my_email = "";
3784
3785         if (!IsEmptyStr(my_email)) {
3786                 msg->cm_fields['P'] = strdup(my_email);
3787         }
3788         else {
3789                 snprintf(buf, sizeof buf, "%s", author->fullname);
3790                 msg->cm_fields['P'] = strdup(buf);
3791         }
3792         convert_spaces_to_underscores(msg->cm_fields['P']);
3793
3794         snprintf(buf, sizeof buf, "%ld", (long)time(NULL));     /* timestamp */
3795         msg->cm_fields['T'] = strdup(buf);
3796
3797         if ((fake_name != NULL) && (fake_name[0])) {            /* author */
3798                 FakeAuthor = NewStrBufPlain (fake_name, -1);
3799         }
3800         else {
3801                 FakeAuthor = NewStrBufPlain (author->fullname, -1);
3802         }
3803         StrBufRFC2047encode(&FakeEncAuthor, FakeAuthor);
3804         msg->cm_fields['A'] = SmashStrBuf(&FakeEncAuthor);
3805         FreeStrBuf(&FakeAuthor);
3806
3807         if (CC->room.QRflags & QR_MAILBOX) {            /* room */
3808                 msg->cm_fields['O'] = strdup(&CC->room.QRname[11]);
3809         }
3810         else {
3811                 msg->cm_fields['O'] = strdup(CC->room.QRname);
3812         }
3813
3814         msg->cm_fields['N'] = strdup(NODENAME);         /* nodename */
3815         msg->cm_fields['H'] = strdup(HUMANNODE);                /* hnodename */
3816
3817         if ((recipient != NULL) && (recipient[0] != 0)) {
3818                 msg->cm_fields['R'] = strdup(recipient);
3819         }
3820         if ((recp_cc != NULL) && (recp_cc[0] != 0)) {
3821                 msg->cm_fields['Y'] = strdup(recp_cc);
3822         }
3823         if (dest_node[0] != 0) {
3824                 msg->cm_fields['D'] = strdup(dest_node);
3825         }
3826
3827         if (!IsEmptyStr(my_email)) {
3828                 msg->cm_fields['F'] = strdup(my_email);
3829         }
3830         else if ( (author == &CC->user) && (!IsEmptyStr(CC->cs_inet_email)) ) {
3831                 msg->cm_fields['F'] = strdup(CC->cs_inet_email);
3832         }
3833
3834         if (subject != NULL) {
3835                 long length;
3836                 striplt(subject);
3837                 length = strlen(subject);
3838                 if (length > 0) {
3839                         long i;
3840                         long IsAscii;
3841                         IsAscii = -1;
3842                         i = 0;
3843                         while ((subject[i] != '\0') &&
3844                                (IsAscii = isascii(subject[i]) != 0 ))
3845                                 i++;
3846                         if (IsAscii != 0)
3847                                 msg->cm_fields['U'] = strdup(subject);
3848                         else /* ok, we've got utf8 in the string. */
3849                         {
3850                                 msg->cm_fields['U'] = rfc2047encode(subject, length);
3851                         }
3852
3853                 }
3854         }
3855
3856         if (supplied_euid != NULL) {
3857                 msg->cm_fields['E'] = strdup(supplied_euid);
3858         }
3859
3860         if (references != NULL) {
3861                 if (!IsEmptyStr(references)) {
3862                         msg->cm_fields['W'] = strdup(references);
3863                 }
3864         }
3865
3866         if (preformatted_text != NULL) {
3867                 msg->cm_fields['M'] = preformatted_text;
3868         }
3869         else {
3870                 msg->cm_fields['M'] = CtdlReadMessageBody(HKEY("000"), config.c_maxmsglen, NULL, 0, 0);
3871         }
3872
3873         return(msg);
3874 }
3875
3876
3877 /*
3878  * Check to see whether we have permission to post a message in the current
3879  * room.  Returns a *CITADEL ERROR CODE* and puts a message in errmsgbuf, or
3880  * returns 0 on success.
3881  */
3882 int CtdlDoIHavePermissionToPostInThisRoom(
3883         char *errmsgbuf,
3884         size_t n,
3885         const char* RemoteIdentifier,
3886         int PostPublic,
3887         int is_reply
3888 ) {
3889         int ra;
3890
3891         if (!(CC->logged_in) &&
3892             (PostPublic == POST_LOGGED_IN)) {
3893                 snprintf(errmsgbuf, n, "Not logged in.");
3894                 return (ERROR + NOT_LOGGED_IN);
3895         }
3896         else if (PostPublic == CHECK_EXISTANCE) {
3897                 return (0); // We're Evaling whether a recipient exists
3898         }
3899         else if (!(CC->logged_in)) {
3900
3901                 if ((CC->room.QRflags & QR_READONLY)) {
3902                         snprintf(errmsgbuf, n, "Not logged in.");
3903                         return (ERROR + NOT_LOGGED_IN);
3904                 }
3905                 if (CC->room.QRflags2 & QR2_MODERATED) {
3906                         snprintf(errmsgbuf, n, "Not logged in Moderation feature not yet implemented!");
3907                         return (ERROR + NOT_LOGGED_IN);
3908                 }
3909                 if ((PostPublic!=POST_LMTP) &&(CC->room.QRflags2 & QR2_SMTP_PUBLIC) == 0) {
3910                         SpoolControl *sc;
3911                         char filename[SIZ];
3912                         int found;
3913
3914                         if (RemoteIdentifier == NULL)
3915                         {
3916                                 snprintf(errmsgbuf, n, "Need sender to permit access.");
3917                                 return (ERROR + USERNAME_REQUIRED);
3918                         }
3919
3920                         assoc_file_name(filename, sizeof filename, &CC->room, ctdl_netcfg_dir);
3921                         begin_critical_section(S_NETCONFIGS);
3922                         if (!read_spoolcontrol_file(&sc, filename))
3923                         {
3924                                 end_critical_section(S_NETCONFIGS);
3925                                 snprintf(errmsgbuf, n,
3926                                         "This mailing list only accepts posts from subscribers.");
3927                                 return (ERROR + NO_SUCH_USER);
3928                         }
3929                         end_critical_section(S_NETCONFIGS);
3930                         found = is_recipient (sc, RemoteIdentifier);
3931                         free_spoolcontrol_struct(&sc);
3932                         if (found) {
3933                                 return (0);
3934                         }
3935                         else {
3936                                 snprintf(errmsgbuf, n,
3937                                         "This mailing list only accepts posts from subscribers.");
3938                                 return (ERROR + NO_SUCH_USER);
3939                         }
3940                 }
3941                 return (0);
3942
3943         }
3944
3945         if ((CC->user.axlevel < AxProbU)
3946             && ((CC->room.QRflags & QR_MAILBOX) == 0)) {
3947                 snprintf(errmsgbuf, n, "Need to be validated to enter (except in %s> to sysop)", MAILROOM);
3948                 return (ERROR + HIGHER_ACCESS_REQUIRED);
3949         }
3950
3951         CtdlRoomAccess(&CC->room, &CC->user, &ra, NULL);
3952
3953         if (ra & UA_POSTALLOWED) {
3954                 strcpy(errmsgbuf, "OK to post or reply here");
3955                 return(0);
3956         }
3957
3958         if ( (ra & UA_REPLYALLOWED) && (is_reply) ) {
3959                 /*
3960                  * To be thorough, we ought to check to see if the message they are
3961                  * replying to is actually a valid one in this room, but unless this
3962                  * actually becomes a problem we'll go with high performance instead.
3963                  */
3964                 strcpy(errmsgbuf, "OK to reply here");
3965                 return(0);
3966         }
3967
3968         if ( (ra & UA_REPLYALLOWED) && (!is_reply) ) {
3969                 /* Clarify what happened with a better error message */
3970                 snprintf(errmsgbuf, n, "You may only reply to existing messages here.");
3971                 return (ERROR + HIGHER_ACCESS_REQUIRED);
3972         }
3973
3974         snprintf(errmsgbuf, n, "Higher access is required to post in this room.");
3975         return (ERROR + HIGHER_ACCESS_REQUIRED);
3976
3977 }
3978
3979
3980 /*
3981  * Check to see if the specified user has Internet mail permission
3982  * (returns nonzero if permission is granted)
3983  */
3984 int CtdlCheckInternetMailPermission(struct ctdluser *who) {
3985
3986         /* Do not allow twits to send Internet mail */
3987         if (who->axlevel <= AxProbU) return(0);
3988
3989         /* Globally enabled? */
3990         if (config.c_restrict == 0) return(1);
3991
3992         /* User flagged ok? */
3993         if (who->flags & US_INTERNET) return(2);
3994
3995         /* Aide level access? */
3996         if (who->axlevel >= AxAideU) return(3);
3997
3998         /* No mail for you! */
3999         return(0);
4000 }
4001
4002
4003 /*
4004  * Validate recipients, count delivery types and errors, and handle aliasing
4005  * FIXME check for dupes!!!!!
4006  *
4007  * Returns 0 if all addresses are ok, ret->num_error = -1 if no addresses
4008  * were specified, or the number of addresses found invalid.
4009  *
4010  * Caller needs to free the result using free_recipients()
4011  */
4012 struct recptypes *validate_recipients(const char *supplied_recipients,
4013                                       const char *RemoteIdentifier,
4014                                       int Flags) {
4015         struct recptypes *ret;
4016         char *recipients = NULL;
4017         char this_recp[256];
4018         char this_recp_cooked[256];
4019         char append[SIZ];
4020         int num_recps = 0;
4021         int i, j;
4022         int mailtype;
4023         int invalid;
4024         struct ctdluser tempUS;
4025         struct ctdlroom tempQR;
4026         struct ctdlroom tempQR2;
4027         int err = 0;
4028         char errmsg[SIZ];
4029         int in_quotes = 0;
4030
4031         /* Initialize */
4032         ret = (struct recptypes *) malloc(sizeof(struct recptypes));
4033         if (ret == NULL) return(NULL);
4034
4035         /* Set all strings to null and numeric values to zero */
4036         memset(ret, 0, sizeof(struct recptypes));
4037
4038         if (supplied_recipients == NULL) {
4039                 recipients = strdup("");
4040         }
4041         else {
4042                 recipients = strdup(supplied_recipients);
4043         }
4044
4045         /* Allocate some memory.  Yes, this allocates 500% more memory than we will
4046          * actually need, but it's healthier for the heap than doing lots of tiny
4047          * realloc() calls instead.
4048          */
4049
4050         ret->errormsg = malloc(strlen(recipients) + 1024);
4051         ret->recp_local = malloc(strlen(recipients) + 1024);
4052         ret->recp_internet = malloc(strlen(recipients) + 1024);
4053         ret->recp_ignet = malloc(strlen(recipients) + 1024);
4054         ret->recp_room = malloc(strlen(recipients) + 1024);
4055         ret->display_recp = malloc(strlen(recipients) + 1024);
4056
4057         ret->errormsg[0] = 0;
4058         ret->recp_local[0] = 0;
4059         ret->recp_internet[0] = 0;
4060         ret->recp_ignet[0] = 0;
4061         ret->recp_room[0] = 0;
4062         ret->display_recp[0] = 0;
4063
4064         ret->recptypes_magic = RECPTYPES_MAGIC;
4065
4066         /* Change all valid separator characters to commas */
4067         for (i=0; !IsEmptyStr(&recipients[i]); ++i) {
4068                 if ((recipients[i] == ';') || (recipients[i] == '|')) {
4069                         recipients[i] = ',';
4070                 }
4071         }
4072
4073         /* Now start extracting recipients... */
4074
4075         while (!IsEmptyStr(recipients)) {
4076
4077                 for (i=0; i<=strlen(recipients); ++i) {
4078                         if (recipients[i] == '\"') in_quotes = 1 - in_quotes;
4079                         if ( ( (recipients[i] == ',') && (!in_quotes) ) || (recipients[i] == 0) ) {
4080                                 safestrncpy(this_recp, recipients, i+1);
4081                                 this_recp[i] = 0;
4082                                 if (recipients[i] == ',') {
4083                                         strcpy(recipients, &recipients[i+1]);
4084                                 }
4085                                 else {
4086                                         strcpy(recipients, "");
4087                                 }
4088                                 break;
4089                         }
4090                 }
4091
4092                 striplt(this_recp);
4093                 if (IsEmptyStr(this_recp))
4094                         break;
4095                 syslog(LOG_DEBUG, "Evaluating recipient #%d: %s\n", num_recps, this_recp);
4096                 ++num_recps;
4097                 mailtype = alias(this_recp);
4098                 mailtype = alias(this_recp);
4099                 mailtype = alias(this_recp);
4100                 j = 0;
4101                 for (j=0; !IsEmptyStr(&this_recp[j]); ++j) {
4102                         if (this_recp[j]=='_') {
4103                                 this_recp_cooked[j] = ' ';
4104                         }
4105                         else {
4106                                 this_recp_cooked[j] = this_recp[j];
4107                         }
4108                 }
4109                 this_recp_cooked[j] = '\0';
4110                 invalid = 0;
4111                 errmsg[0] = 0;
4112                 switch(mailtype) {
4113                         case MES_LOCAL:
4114                                 if (!strcasecmp(this_recp, "sysop")) {
4115                                         ++ret->num_room;
4116                                         strcpy(this_recp, config.c_aideroom);
4117                                         if (!IsEmptyStr(ret->recp_room)) {
4118                                                 strcat(ret->recp_room, "|");
4119                                         }
4120                                         strcat(ret->recp_room, this_recp);
4121                                 }
4122                                 else if ( (!strncasecmp(this_recp, "room_", 5))
4123                                       && (!CtdlGetRoom(&tempQR, &this_recp_cooked[5])) ) {
4124
4125                                         /* Save room so we can restore it later */
4126                                         tempQR2 = CC->room;
4127                                         CC->room = tempQR;
4128
4129                                         /* Check permissions to send mail to this room */
4130                                         err = CtdlDoIHavePermissionToPostInThisRoom(
4131                                                 errmsg,
4132                                                 sizeof errmsg,
4133                                                 RemoteIdentifier,
4134                                                 Flags,
4135                                                 0                       /* 0 = not a reply */
4136                                         );
4137                                         if (err)
4138                                         {
4139                                                 ++ret->num_error;
4140                                                 invalid = 1;
4141                                         }
4142                                         else {
4143                                                 ++ret->num_room;
4144                                                 if (!IsEmptyStr(ret->recp_room)) {
4145                                                         strcat(ret->recp_room, "|");
4146                                                 }
4147                                                 strcat(ret->recp_room, &this_recp_cooked[5]);
4148                                         }
4149
4150                                         /* Restore room in case something needs it */
4151                                         CC->room = tempQR2;
4152
4153                                 }
4154                                 else if (CtdlGetUser(&tempUS, this_recp) == 0) {
4155                                         ++ret->num_local;
4156                                         strcpy(this_recp, tempUS.fullname);
4157                                         if (!IsEmptyStr(ret->recp_local)) {
4158                                                 strcat(ret->recp_local, "|");
4159                                         }
4160                                         strcat(ret->recp_local, this_recp);
4161                                 }
4162                                 else if (CtdlGetUser(&tempUS, this_recp_cooked) == 0) {
4163                                         ++ret->num_local;
4164                                         strcpy(this_recp, tempUS.fullname);
4165                                         if (!IsEmptyStr(ret->recp_local)) {
4166                                                 strcat(ret->recp_local, "|");
4167                                         }
4168                                         strcat(ret->recp_local, this_recp);
4169                                 }
4170                                 else {
4171                                         ++ret->num_error;
4172                                         invalid = 1;
4173                                 }
4174                                 break;
4175                         case MES_INTERNET:
4176                                 /* Yes, you're reading this correctly: if the target
4177                                  * domain points back to the local system or an attached
4178                                  * Citadel directory, the address is invalid.  That's
4179                                  * because if the address were valid, we would have
4180                                  * already translated it to a local address by now.
4181                                  */
4182                                 if (IsDirectory(this_recp, 0)) {
4183                                         ++ret->num_error;
4184                                         invalid = 1;
4185                                 }
4186                                 else {
4187                                         ++ret->num_internet;
4188                                         if (!IsEmptyStr(ret->recp_internet)) {
4189                                                 strcat(ret->recp_internet, "|");
4190                                         }
4191                                         strcat(ret->recp_internet, this_recp);
4192                                 }
4193                                 break;
4194                         case MES_IGNET:
4195                                 ++ret->num_ignet;
4196                                 if (!IsEmptyStr(ret->recp_ignet)) {
4197                                         strcat(ret->recp_ignet, "|");
4198                                 }
4199                                 strcat(ret->recp_ignet, this_recp);
4200                                 break;
4201                         case MES_ERROR:
4202                                 ++ret->num_error;
4203                                 invalid = 1;
4204                                 break;
4205                 }
4206                 if (invalid) {
4207                         if (IsEmptyStr(errmsg)) {
4208                                 snprintf(append, sizeof append, "Invalid recipient: %s", this_recp);
4209                         }
4210                         else {
4211                                 snprintf(append, sizeof append, "%s", errmsg);
4212                         }
4213                         if ( (strlen(ret->errormsg) + strlen(append) + 3) < SIZ) {
4214                                 if (!IsEmptyStr(ret->errormsg)) {
4215                                         strcat(ret->errormsg, "; ");
4216                                 }
4217                                 strcat(ret->errormsg, append);
4218                         }
4219                 }
4220                 else {
4221                         if (IsEmptyStr(ret->display_recp)) {
4222                                 strcpy(append, this_recp);
4223                         }
4224                         else {
4225                                 snprintf(append, sizeof append, ", %s", this_recp);
4226                         }
4227                         if ( (strlen(ret->display_recp)+strlen(append)) < SIZ) {
4228                                 strcat(ret->display_recp, append);
4229                         }
4230                 }
4231         }
4232
4233         if ((ret->num_local + ret->num_internet + ret->num_ignet +
4234            ret->num_room + ret->num_error) == 0) {
4235                 ret->num_error = (-1);
4236                 strcpy(ret->errormsg, "No recipients specified.");
4237         }
4238
4239         syslog(LOG_DEBUG, "validate_recipients()\n");
4240         syslog(LOG_DEBUG, " local: %d <%s>\n", ret->num_local, ret->recp_local);
4241         syslog(LOG_DEBUG, "  room: %d <%s>\n", ret->num_room, ret->recp_room);
4242         syslog(LOG_DEBUG, "  inet: %d <%s>\n", ret->num_internet, ret->recp_internet);
4243         syslog(LOG_DEBUG, " ignet: %d <%s>\n", ret->num_ignet, ret->recp_ignet);
4244         syslog(LOG_DEBUG, " error: %d <%s>\n", ret->num_error, ret->errormsg);
4245
4246         free(recipients);
4247         return(ret);
4248 }
4249
4250
4251 /*
4252  * Destructor for struct recptypes
4253  */
4254 void free_recipients(struct recptypes *valid) {
4255
4256         if (valid == NULL) {
4257                 return;
4258         }
4259
4260         if (valid->recptypes_magic != RECPTYPES_MAGIC) {
4261                 syslog(LOG_EMERG, "Attempt to call free_recipients() on some other data type!\n");
4262                 abort();
4263         }
4264
4265         if (valid->errormsg != NULL)            free(valid->errormsg);
4266         if (valid->recp_local != NULL)          free(valid->recp_local);
4267         if (valid->recp_internet != NULL)       free(valid->recp_internet);
4268         if (valid->recp_ignet != NULL)          free(valid->recp_ignet);
4269         if (valid->recp_room != NULL)           free(valid->recp_room);
4270         if (valid->display_recp != NULL)        free(valid->display_recp);
4271         if (valid->bounce_to != NULL)           free(valid->bounce_to);
4272         if (valid->envelope_from != NULL)       free(valid->envelope_from);
4273         free(valid);
4274 }
4275
4276
4277
4278 /*
4279  * message entry  -  mode 0 (normal)
4280  */
4281 void cmd_ent0(char *entargs)
4282 {
4283         int post = 0;
4284         char recp[SIZ];
4285         char cc[SIZ];
4286         char bcc[SIZ];
4287         char supplied_euid[128];
4288         int anon_flag = 0;
4289         int format_type = 0;
4290         char newusername[256];
4291         char newuseremail[256];
4292         struct CtdlMessage *msg;
4293         int anonymous = 0;
4294         char errmsg[SIZ];
4295         int err = 0;
4296         struct recptypes *valid = NULL;
4297         struct recptypes *valid_to = NULL;
4298         struct recptypes *valid_cc = NULL;
4299         struct recptypes *valid_bcc = NULL;
4300         char subject[SIZ];
4301         int subject_required = 0;
4302         int do_confirm = 0;
4303         long msgnum;
4304         int i, j;
4305         char buf[256];
4306         int newuseremail_ok = 0;
4307         char references[SIZ];
4308         char *ptr;
4309
4310         unbuffer_output();
4311
4312         post = extract_int(entargs, 0);
4313         extract_token(recp, entargs, 1, '|', sizeof recp);
4314         anon_flag = extract_int(entargs, 2);
4315         format_type = extract_int(entargs, 3);
4316         extract_token(subject, entargs, 4, '|', sizeof subject);
4317         extract_token(newusername, entargs, 5, '|', sizeof newusername);
4318         do_confirm = extract_int(entargs, 6);
4319         extract_token(cc, entargs, 7, '|', sizeof cc);
4320         extract_token(bcc, entargs, 8, '|', sizeof bcc);
4321         switch(CC->room.QRdefaultview) {
4322                 case VIEW_NOTES:
4323                 case VIEW_WIKI:
4324                         extract_token(supplied_euid, entargs, 9, '|', sizeof supplied_euid);
4325                         break;
4326                 default:
4327                         supplied_euid[0] = 0;
4328                         break;
4329         }
4330         extract_token(newuseremail, entargs, 10, '|', sizeof newuseremail);
4331         extract_token(references, entargs, 11, '|', sizeof references);
4332         for (ptr=references; *ptr != 0; ++ptr) {
4333                 if (*ptr == '!') *ptr = '|';
4334         }
4335
4336         /* first check to make sure the request is valid. */
4337
4338         err = CtdlDoIHavePermissionToPostInThisRoom(
4339                 errmsg,
4340                 sizeof errmsg,
4341                 NULL,
4342                 POST_LOGGED_IN,
4343                 (!IsEmptyStr(references))               /* is this a reply?  or a top-level post? */
4344         );
4345         if (err)
4346         {
4347                 cprintf("%d %s\n", err, errmsg);
4348                 return;
4349         }
4350
4351         /* Check some other permission type things. */
4352
4353         if (IsEmptyStr(newusername)) {
4354                 strcpy(newusername, CC->user.fullname);
4355         }
4356         if (  (CC->user.axlevel < AxAideU)
4357            && (strcasecmp(newusername, CC->user.fullname))
4358            && (strcasecmp(newusername, CC->cs_inet_fn))
4359         ) {
4360                 cprintf("%d You don't have permission to author messages as '%s'.\n",
4361                         ERROR + HIGHER_ACCESS_REQUIRED,
4362                         newusername
4363                 );
4364                 return;
4365         }
4366
4367
4368         if (IsEmptyStr(newuseremail)) {
4369                 newuseremail_ok = 1;
4370         }
4371
4372         if (!IsEmptyStr(newuseremail)) {
4373                 if (!strcasecmp(newuseremail, CC->cs_inet_email)) {
4374                         newuseremail_ok = 1;
4375                 }
4376                 else if (!IsEmptyStr(CC->cs_inet_other_emails)) {
4377                         j = num_tokens(CC->cs_inet_other_emails, '|');
4378                         for (i=0; i<j; ++i) {
4379                                 extract_token(buf, CC->cs_inet_other_emails, i, '|', sizeof buf);
4380                                 if (!strcasecmp(newuseremail, buf)) {
4381                                         newuseremail_ok = 1;
4382                                 }
4383                         }
4384                 }
4385         }
4386
4387         if (!newuseremail_ok) {
4388                 cprintf("%d You don't have permission to author messages as '%s'.\n",
4389                         ERROR + HIGHER_ACCESS_REQUIRED,
4390                         newuseremail
4391                 );
4392                 return;
4393         }
4394
4395         CC->cs_flags |= CS_POSTING;
4396
4397         /* In mailbox rooms we have to behave a little differently --
4398          * make sure the user has specified at least one recipient.  Then
4399          * validate the recipient(s).  We do this for the Mail> room, as
4400          * well as any room which has the "Mailbox" view set - unless it
4401          * is the DRAFTS room which does not require recipients
4402          */
4403
4404         if ( (  ( (CC->room.QRflags & QR_MAILBOX) && (!strcasecmp(&CC->room.QRname[11], MAILROOM)) )
4405              || ( (CC->room.QRflags & QR_MAILBOX) && (CC->curr_view == VIEW_MAILBOX) )
4406         ) && (strcasecmp(&CC->room.QRname[11], USERDRAFTROOM)) !=0 ) {
4407                 if (CC->user.axlevel < AxProbU) {
4408                         strcpy(recp, "sysop");
4409                         strcpy(cc, "");
4410                         strcpy(bcc, "");
4411                 }
4412
4413                 valid_to = validate_recipients(recp, NULL, 0);
4414                 if (valid_to->num_error > 0) {
4415                         cprintf("%d %s\n", ERROR + NO_SUCH_USER, valid_to->errormsg);
4416                         free_recipients(valid_to);
4417                         return;
4418                 }
4419
4420                 valid_cc = validate_recipients(cc, NULL, 0);
4421                 if (valid_cc->num_error > 0) {
4422                         cprintf("%d %s\n", ERROR + NO_SUCH_USER, valid_cc->errormsg);
4423                         free_recipients(valid_to);
4424                         free_recipients(valid_cc);
4425                         return;
4426                 }
4427
4428                 valid_bcc = validate_recipients(bcc, NULL, 0);
4429                 if (valid_bcc->num_error > 0) {
4430                         cprintf("%d %s\n", ERROR + NO_SUCH_USER, valid_bcc->errormsg);
4431                         free_recipients(valid_to);
4432                         free_recipients(valid_cc);
4433                         free_recipients(valid_bcc);
4434                         return;
4435                 }
4436
4437                 /* Recipient required, but none were specified */
4438                 if ( (valid_to->num_error < 0) && (valid_cc->num_error < 0) && (valid_bcc->num_error < 0) ) {
4439                         free_recipients(valid_to);
4440                         free_recipients(valid_cc);
4441                         free_recipients(valid_bcc);
4442                         cprintf("%d At least one recipient is required.\n", ERROR + NO_SUCH_USER);
4443                         return;
4444                 }
4445
4446                 if (valid_to->num_internet + valid_cc->num_internet + valid_bcc->num_internet > 0) {
4447                         if (CtdlCheckInternetMailPermission(&CC->user)==0) {
4448                                 cprintf("%d You do not have permission "
4449                                         "to send Internet mail.\n",
4450                                         ERROR + HIGHER_ACCESS_REQUIRED);
4451                                 free_recipients(valid_to);
4452                                 free_recipients(valid_cc);
4453                                 free_recipients(valid_bcc);
4454                                 return;
4455                         }
4456                 }
4457
4458                 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)
4459                    && (CC->user.axlevel < AxNetU) ) {
4460                         cprintf("%d Higher access required for network mail.\n",
4461                                 ERROR + HIGHER_ACCESS_REQUIRED);
4462                         free_recipients(valid_to);
4463                         free_recipients(valid_cc);
4464                         free_recipients(valid_bcc);
4465                         return;
4466                 }
4467
4468                 if ((RESTRICT_INTERNET == 1)
4469                     && (valid_to->num_internet + valid_cc->num_internet + valid_bcc->num_internet > 0)
4470                     && ((CC->user.flags & US_INTERNET) == 0)
4471                     && (!CC->internal_pgm)) {
4472                         cprintf("%d You don't have access to Internet mail.\n",
4473                                 ERROR + HIGHER_ACCESS_REQUIRED);
4474                         free_recipients(valid_to);
4475                         free_recipients(valid_cc);
4476                         free_recipients(valid_bcc);
4477                         return;
4478                 }
4479
4480         }
4481
4482         /* Is this a room which has anonymous-only or anonymous-option? */
4483         anonymous = MES_NORMAL;
4484         if (CC->room.QRflags & QR_ANONONLY) {
4485                 anonymous = MES_ANONONLY;
4486         }
4487         if (CC->room.QRflags & QR_ANONOPT) {
4488                 if (anon_flag == 1) {   /* only if the user requested it */
4489                         anonymous = MES_ANONOPT;
4490                 }
4491         }
4492
4493         if ((CC->room.QRflags & QR_MAILBOX) == 0) {
4494                 recp[0] = 0;
4495         }
4496
4497         /* Recommend to the client that the use of a message subject is
4498          * strongly recommended in this room, if either the SUBJECTREQ flag
4499          * is set, or if there is one or more Internet email recipients.
4500          */
4501         if (CC->room.QRflags2 & QR2_SUBJECTREQ) subject_required = 1;
4502         if ((valid_to)  && (valid_to->num_internet > 0))        subject_required = 1;
4503         if ((valid_cc)  && (valid_cc->num_internet > 0))        subject_required = 1;
4504         if ((valid_bcc) && (valid_bcc->num_internet > 0))       subject_required = 1;
4505
4506         /* If we're only checking the validity of the request, return
4507          * success without creating the message.
4508          */
4509         if (post == 0) {
4510                 cprintf("%d %s|%d\n", CIT_OK,
4511                         ((valid_to != NULL) ? valid_to->display_recp : ""),
4512                         subject_required);
4513                 free_recipients(valid_to);
4514                 free_recipients(valid_cc);
4515                 free_recipients(valid_bcc);
4516                 return;
4517         }
4518
4519         /* We don't need these anymore because we'll do it differently below */
4520         free_recipients(valid_to);
4521         free_recipients(valid_cc);
4522         free_recipients(valid_bcc);
4523
4524         /* Read in the message from the client. */
4525         if (do_confirm) {
4526                 cprintf("%d send message\n", START_CHAT_MODE);
4527         } else {
4528                 cprintf("%d send message\n", SEND_LISTING);
4529         }
4530
4531         msg = CtdlMakeMessage(&CC->user, recp, cc,
4532                 CC->room.QRname, anonymous, format_type,
4533                 newusername, newuseremail, subject,
4534                 ((!IsEmptyStr(supplied_euid)) ? supplied_euid : NULL),
4535                 NULL, references);
4536
4537         /* Put together one big recipients struct containing to/cc/bcc all in
4538          * one.  This is for the envelope.
4539          */
4540         char *all_recps = malloc(SIZ * 3);
4541         strcpy(all_recps, recp);
4542         if (!IsEmptyStr(cc)) {
4543                 if (!IsEmptyStr(all_recps)) {
4544                         strcat(all_recps, ",");
4545                 }
4546                 strcat(all_recps, cc);
4547         }
4548         if (!IsEmptyStr(bcc)) {
4549                 if (!IsEmptyStr(all_recps)) {
4550                         strcat(all_recps, ",");
4551                 }
4552                 strcat(all_recps, bcc);
4553         }
4554         if (!IsEmptyStr(all_recps)) {
4555                 valid = validate_recipients(all_recps, NULL, 0);
4556         }
4557         else {
4558                 valid = NULL;
4559         }
4560         free(all_recps);
4561
4562         if (msg != NULL) {
4563                 msgnum = CtdlSubmitMsg(msg, valid, "", QP_EADDR);
4564
4565                 if (do_confirm) {
4566                         cprintf("%ld\n", msgnum);
4567                         if (msgnum >= 0L) {
4568                                 cprintf("Message accepted.\n");
4569                         }
4570                         else {
4571                                 cprintf("Internal error.\n");
4572                         }
4573                         if (msg->cm_fields['E'] != NULL) {
4574                                 cprintf("%s\n", msg->cm_fields['E']);
4575                         } else {
4576                                 cprintf("\n");
4577                         }
4578                         cprintf("000\n");
4579                 }
4580
4581                 CtdlFreeMessage(msg);
4582         }
4583         if (valid != NULL) {
4584                 free_recipients(valid);
4585         }
4586         return;
4587 }
4588
4589
4590
4591 /*
4592  * API function to delete messages which match a set of criteria
4593  * (returns the actual number of messages deleted)
4594  */
4595 int CtdlDeleteMessages(char *room_name,         /* which room */
4596                         long *dmsgnums,         /* array of msg numbers to be deleted */
4597                         int num_dmsgnums,       /* number of msgs to be deleted, or 0 for "any" */
4598                         char *content_type      /* or "" for any.  regular expressions expected. */
4599 )
4600 {
4601         struct ctdlroom qrbuf;
4602         struct cdbdata *cdbfr;
4603         long *msglist = NULL;
4604         long *dellist = NULL;
4605         int num_msgs = 0;
4606         int i, j;
4607         int num_deleted = 0;
4608         int delete_this;
4609         struct MetaData smi;
4610         regex_t re;
4611         regmatch_t pm;
4612         int need_to_free_re = 0;
4613
4614         if (content_type) if (!IsEmptyStr(content_type)) {
4615                 regcomp(&re, content_type, 0);
4616                 need_to_free_re = 1;
4617         }
4618         syslog(LOG_DEBUG, "CtdlDeleteMessages(%s, %d msgs, %s)\n",
4619                 room_name, num_dmsgnums, content_type);
4620
4621         /* get room record, obtaining a lock... */
4622         if (CtdlGetRoomLock(&qrbuf, room_name) != 0) {
4623                 syslog(LOG_ERR, "CtdlDeleteMessages(): Room <%s> not found\n",
4624                         room_name);
4625                 if (need_to_free_re) regfree(&re);
4626                 return (0);     /* room not found */
4627         }
4628         cdbfr = cdb_fetch(CDB_MSGLISTS, &qrbuf.QRnumber, sizeof(long));
4629
4630         if (cdbfr != NULL) {
4631                 dellist = malloc(cdbfr->len);
4632                 msglist = (long *) cdbfr->ptr;
4633                 cdbfr->ptr = NULL;      /* CtdlDeleteMessages() now owns this memory */
4634                 num_msgs = cdbfr->len / sizeof(long);
4635                 cdb_free(cdbfr);
4636         }
4637         if (num_msgs > 0) {
4638                 for (i = 0; i < num_msgs; ++i) {
4639                         delete_this = 0x00;
4640
4641                         /* Set/clear a bit for each criterion */
4642
4643                         /* 0 messages in the list or a null list means that we are
4644                          * interested in deleting any messages which meet the other criteria.
4645                          */
4646                         if ((num_dmsgnums == 0) || (dmsgnums == NULL)) {
4647                                 delete_this |= 0x01;
4648                         }
4649                         else {
4650                                 for (j=0; j<num_dmsgnums; ++j) {
4651                                         if (msglist[i] == dmsgnums[j]) {
4652                                                 delete_this |= 0x01;
4653                                         }
4654                                 }
4655                         }
4656
4657                         if (IsEmptyStr(content_type)) {
4658                                 delete_this |= 0x02;
4659                         } else {
4660                                 GetMetaData(&smi, msglist[i]);
4661                                 if (regexec(&re, smi.meta_content_type, 1, &pm, 0) == 0) {
4662                                         delete_this |= 0x02;
4663                                 }
4664                         }
4665
4666                         /* Delete message only if all bits are set */
4667                         if (delete_this == 0x03) {
4668                                 dellist[num_deleted++] = msglist[i];
4669                                 msglist[i] = 0L;
4670                         }
4671                 }
4672
4673                 num_msgs = sort_msglist(msglist, num_msgs);
4674                 cdb_store(CDB_MSGLISTS, &qrbuf.QRnumber, (int)sizeof(long),
4675                           msglist, (int)(num_msgs * sizeof(long)));
4676
4677                 if (num_msgs > 0)
4678                         qrbuf.QRhighest = msglist[num_msgs - 1];
4679                 else
4680                         qrbuf.QRhighest = 0;
4681         }
4682         CtdlPutRoomLock(&qrbuf);
4683
4684         /* Go through the messages we pulled out of the index, and decrement
4685          * their reference counts by 1.  If this is the only room the message
4686          * was in, the reference count will reach zero and the message will
4687          * automatically be deleted from the database.  We do this in a
4688          * separate pass because there might be plug-in hooks getting called,
4689          * and we don't want that happening during an S_ROOMS critical
4690          * section.
4691          */
4692         if (num_deleted) for (i=0; i<num_deleted; ++i) {
4693                 PerformDeleteHooks(qrbuf.QRname, dellist[i]);
4694                 AdjRefCount(dellist[i], -1);
4695         }
4696
4697         /* Now free the memory we used, and go away. */
4698         if (msglist != NULL) free(msglist);
4699         if (dellist != NULL) free(dellist);
4700         syslog(LOG_DEBUG, "%d message(s) deleted.\n", num_deleted);
4701         if (need_to_free_re) regfree(&re);
4702         return (num_deleted);
4703 }
4704
4705
4706
4707 /*
4708  * Check whether the current user has permission to delete messages from
4709  * the current room (returns 1 for yes, 0 for no)
4710  */
4711 int CtdlDoIHavePermissionToDeleteMessagesFromThisRoom(void) {
4712         int ra;
4713         CtdlRoomAccess(&CC->room, &CC->user, &ra, NULL);
4714         if (ra & UA_DELETEALLOWED) return(1);
4715         return(0);
4716 }
4717
4718
4719
4720
4721 /*
4722  * Delete message from current room
4723  */
4724 void cmd_dele(char *args)
4725 {
4726         int num_deleted;
4727         int i;
4728         char msgset[SIZ];
4729         char msgtok[32];
4730         long *msgs;
4731         int num_msgs = 0;
4732
4733         extract_token(msgset, args, 0, '|', sizeof msgset);
4734         num_msgs = num_tokens(msgset, ',');
4735         if (num_msgs < 1) {
4736                 cprintf("%d Nothing to do.\n", CIT_OK);
4737                 return;
4738         }
4739
4740         if (CtdlDoIHavePermissionToDeleteMessagesFromThisRoom() == 0) {
4741                 cprintf("%d Higher access required.\n",
4742                         ERROR + HIGHER_ACCESS_REQUIRED);
4743                 return;
4744         }
4745
4746         /*
4747          * Build our message set to be moved/copied
4748          */
4749         msgs = malloc(num_msgs * sizeof(long));
4750         for (i=0; i<num_msgs; ++i) {
4751                 extract_token(msgtok, msgset, i, ',', sizeof msgtok);
4752                 msgs[i] = atol(msgtok);
4753         }
4754
4755         num_deleted = CtdlDeleteMessages(CC->room.QRname, msgs, num_msgs, "");
4756         free(msgs);
4757
4758         if (num_deleted) {
4759                 cprintf("%d %d message%s deleted.\n", CIT_OK,
4760                         num_deleted, ((num_deleted != 1) ? "s" : ""));
4761         } else {
4762                 cprintf("%d Message not found.\n", ERROR + MESSAGE_NOT_FOUND);
4763         }
4764 }
4765
4766
4767
4768
4769 /*
4770  * move or copy a message to another room
4771  */
4772 void cmd_move(char *args)
4773 {
4774         char msgset[SIZ];
4775         char msgtok[32];
4776         long *msgs;
4777         int num_msgs = 0;
4778
4779         char targ[ROOMNAMELEN];
4780         struct ctdlroom qtemp;
4781         int err;
4782         int is_copy = 0;
4783         int ra;
4784         int permit = 0;
4785         int i;
4786
4787         extract_token(msgset, args, 0, '|', sizeof msgset);
4788         num_msgs = num_tokens(msgset, ',');
4789         if (num_msgs < 1) {
4790                 cprintf("%d Nothing to do.\n", CIT_OK);
4791                 return;
4792         }
4793
4794         extract_token(targ, args, 1, '|', sizeof targ);
4795         convert_room_name_macros(targ, sizeof targ);
4796         targ[ROOMNAMELEN - 1] = 0;
4797         is_copy = extract_int(args, 2);
4798
4799         if (CtdlGetRoom(&qtemp, targ) != 0) {
4800                 cprintf("%d '%s' does not exist.\n", ERROR + ROOM_NOT_FOUND, targ);
4801                 return;
4802         }
4803
4804         if (!strcasecmp(qtemp.QRname, CC->room.QRname)) {
4805                 cprintf("%d Source and target rooms are the same.\n", ERROR + ALREADY_EXISTS);
4806                 return;
4807         }
4808
4809         CtdlGetUser(&CC->user, CC->curr_user);
4810         CtdlRoomAccess(&qtemp, &CC->user, &ra, NULL);
4811
4812         /* Check for permission to perform this operation.
4813          * Remember: "CC->room" is source, "qtemp" is target.
4814          */
4815         permit = 0;
4816
4817         /* Aides can move/copy */
4818         if (CC->user.axlevel >= AxAideU) permit = 1;
4819
4820         /* Room aides can move/copy */
4821         if (CC->user.usernum == CC->room.QRroomaide) permit = 1;
4822
4823         /* Permit move/copy from personal rooms */
4824         if ((CC->room.QRflags & QR_MAILBOX)
4825            && (qtemp.QRflags & QR_MAILBOX)) permit = 1;
4826
4827         /* Permit only copy from public to personal room */
4828         if ( (is_copy)
4829            && (!(CC->room.QRflags & QR_MAILBOX))
4830            && (qtemp.QRflags & QR_MAILBOX)) permit = 1;
4831
4832         /* Permit message removal from collaborative delete rooms */
4833         if (CC->room.QRflags2 & QR2_COLLABDEL) permit = 1;
4834
4835         /* Users allowed to post into the target room may move into it too. */
4836         if ((CC->room.QRflags & QR_MAILBOX) &&
4837             (qtemp.QRflags & UA_POSTALLOWED))  permit = 1;
4838
4839         /* User must have access to target room */
4840         if (!(ra & UA_KNOWN))  permit = 0;
4841
4842         if (!permit) {
4843                 cprintf("%d Higher access required.\n",
4844                         ERROR + HIGHER_ACCESS_REQUIRED);
4845                 return;
4846         }
4847
4848         /*
4849          * Build our message set to be moved/copied
4850          */
4851         msgs = malloc(num_msgs * sizeof(long));
4852         for (i=0; i<num_msgs; ++i) {
4853                 extract_token(msgtok, msgset, i, ',', sizeof msgtok);
4854                 msgs[i] = atol(msgtok);
4855         }
4856
4857         /*
4858          * Do the copy
4859          */
4860         err = CtdlSaveMsgPointersInRoom(targ, msgs, num_msgs, 1, NULL, 0);
4861         if (err != 0) {
4862                 cprintf("%d Cannot store message(s) in %s: error %d\n",
4863                         err, targ, err);
4864                 free(msgs);
4865                 return;
4866         }
4867
4868         /* Now delete the message from the source room,
4869          * if this is a 'move' rather than a 'copy' operation.
4870          */
4871         if (is_copy == 0) {
4872                 CtdlDeleteMessages(CC->room.QRname, msgs, num_msgs, "");
4873         }
4874         free(msgs);
4875
4876         cprintf("%d Message(s) %s.\n", CIT_OK, (is_copy ? "copied" : "moved") );
4877 }
4878
4879
4880
4881 /*
4882  * GetMetaData()  -  Get the supplementary record for a message
4883  */
4884 void GetMetaData(struct MetaData *smibuf, long msgnum)
4885 {
4886
4887         struct cdbdata *cdbsmi;
4888         long TheIndex;
4889
4890         memset(smibuf, 0, sizeof(struct MetaData));
4891         smibuf->meta_msgnum = msgnum;
4892         smibuf->meta_refcount = 1;      /* Default reference count is 1 */
4893
4894         /* Use the negative of the message number for its supp record index */
4895         TheIndex = (0L - msgnum);
4896
4897         cdbsmi = cdb_fetch(CDB_MSGMAIN, &TheIndex, sizeof(long));
4898         if (cdbsmi == NULL) {
4899                 return;         /* record not found; go with defaults */
4900         }
4901         memcpy(smibuf, cdbsmi->ptr,
4902                ((cdbsmi->len > sizeof(struct MetaData)) ?
4903                 sizeof(struct MetaData) : cdbsmi->len));
4904         cdb_free(cdbsmi);
4905         return;
4906 }
4907
4908
4909 /*
4910  * PutMetaData()  -  (re)write supplementary record for a message
4911  */
4912 void PutMetaData(struct MetaData *smibuf)
4913 {
4914         long TheIndex;
4915
4916         /* Use the negative of the message number for the metadata db index */
4917         TheIndex = (0L - smibuf->meta_msgnum);
4918
4919         cdb_store(CDB_MSGMAIN,
4920                   &TheIndex, (int)sizeof(long),
4921                   smibuf, (int)sizeof(struct MetaData));
4922
4923 }
4924
4925 /*
4926  * AdjRefCount  -  submit an adjustment to the reference count for a message.
4927  *                 (These are just queued -- we actually process them later.)
4928  */
4929 void AdjRefCount(long msgnum, int incr)
4930 {
4931         struct arcq new_arcq;
4932         int rv = 0;
4933
4934         syslog(LOG_DEBUG, "AdjRefCount() msg %ld ref count delta %+d\n",
4935                 msgnum, incr
4936         );
4937
4938         begin_critical_section(S_SUPPMSGMAIN);
4939         if (arcfp == NULL) {
4940                 arcfp = fopen(file_arcq, "ab+");
4941         }
4942         end_critical_section(S_SUPPMSGMAIN);
4943
4944         /* msgnum < 0 means that we're trying to close the file */
4945         if (msgnum < 0) {
4946                 syslog(LOG_DEBUG, "Closing the AdjRefCount queue file\n");
4947                 begin_critical_section(S_SUPPMSGMAIN);
4948                 if (arcfp != NULL) {
4949                         fclose(arcfp);
4950                         arcfp = NULL;
4951                 }
4952                 end_critical_section(S_SUPPMSGMAIN);
4953                 return;
4954         }
4955
4956         /*
4957          * If we can't open the queue, perform the operation synchronously.
4958          */
4959         if (arcfp == NULL) {
4960                 TDAP_AdjRefCount(msgnum, incr);
4961                 return;
4962         }
4963
4964         new_arcq.arcq_msgnum = msgnum;
4965         new_arcq.arcq_delta = incr;
4966         rv = fwrite(&new_arcq, sizeof(struct arcq), 1, arcfp);
4967         fflush(arcfp);
4968
4969         return;
4970 }
4971
4972
4973 /*
4974  * TDAP_ProcessAdjRefCountQueue()
4975  *
4976  * Process the queue of message count adjustments that was created by calls
4977  * to AdjRefCount() ... by reading the queue and calling TDAP_AdjRefCount()
4978  * for each one.  This should be an "off hours" operation.
4979  */
4980 int TDAP_ProcessAdjRefCountQueue(void)
4981 {
4982         char file_arcq_temp[PATH_MAX];
4983         int r;
4984         FILE *fp;
4985         struct arcq arcq_rec;
4986         int num_records_processed = 0;
4987
4988         snprintf(file_arcq_temp, sizeof file_arcq_temp, "%s.%04x", file_arcq, rand());
4989
4990         begin_critical_section(S_SUPPMSGMAIN);
4991         if (arcfp != NULL) {
4992                 fclose(arcfp);
4993                 arcfp = NULL;
4994         }
4995
4996         r = link(file_arcq, file_arcq_temp);
4997         if (r != 0) {
4998                 syslog(LOG_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
4999                 end_critical_section(S_SUPPMSGMAIN);
5000                 return(num_records_processed);
5001         }
5002
5003         unlink(file_arcq);
5004         end_critical_section(S_SUPPMSGMAIN);
5005
5006         fp = fopen(file_arcq_temp, "rb");
5007         if (fp == NULL) {
5008                 syslog(LOG_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
5009                 return(num_records_processed);
5010         }
5011
5012         while (fread(&arcq_rec, sizeof(struct arcq), 1, fp) == 1) {
5013                 TDAP_AdjRefCount(arcq_rec.arcq_msgnum, arcq_rec.arcq_delta);
5014                 ++num_records_processed;
5015         }
5016
5017         fclose(fp);
5018         r = unlink(file_arcq_temp);
5019         if (r != 0) {
5020                 syslog(LOG_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
5021         }
5022
5023         return(num_records_processed);
5024 }
5025
5026
5027
5028 /*
5029  * TDAP_AdjRefCount  -  adjust the reference count for a message.
5030  *                      This one does it "for real" because it's called by
5031  *                      the autopurger function that processes the queue
5032  *                      created by AdjRefCount().   If a message's reference
5033  *                      count becomes zero, we also delete the message from
5034  *                      disk and de-index it.
5035  */
5036 void TDAP_AdjRefCount(long msgnum, int incr)
5037 {
5038
5039         struct MetaData smi;
5040         long delnum;
5041
5042         /* This is a *tight* critical section; please keep it that way, as
5043          * it may get called while nested in other critical sections.
5044          * Complicating this any further will surely cause deadlock!
5045          */
5046         begin_critical_section(S_SUPPMSGMAIN);
5047         GetMetaData(&smi, msgnum);
5048         smi.meta_refcount += incr;
5049         PutMetaData(&smi);
5050         end_critical_section(S_SUPPMSGMAIN);
5051         syslog(LOG_DEBUG, "TDAP_AdjRefCount() msg %ld ref count delta %+d, is now %d\n",
5052                 msgnum, incr, smi.meta_refcount
5053         );
5054
5055         /* If the reference count is now zero, delete the message
5056          * (and its supplementary record as well).
5057          */
5058         if (smi.meta_refcount == 0) {
5059                 syslog(LOG_DEBUG, "Deleting message <%ld>\n", msgnum);
5060
5061                 /* Call delete hooks with NULL room to show it has gone altogether */
5062                 PerformDeleteHooks(NULL, msgnum);
5063
5064                 /* Remove from message base */
5065                 delnum = msgnum;
5066                 cdb_delete(CDB_MSGMAIN, &delnum, (int)sizeof(long));
5067                 cdb_delete(CDB_BIGMSGS, &delnum, (int)sizeof(long));
5068
5069                 /* Remove metadata record */
5070                 delnum = (0L - msgnum);
5071                 cdb_delete(CDB_MSGMAIN, &delnum, (int)sizeof(long));
5072         }
5073
5074 }
5075
5076 /*
5077  * Write a generic object to this room
5078  *
5079  * Note: this could be much more efficient.  Right now we use two temporary
5080  * files, and still pull the message into memory as with all others.
5081  */
5082 void CtdlWriteObject(char *req_room,                    /* Room to stuff it in */
5083                         char *content_type,             /* MIME type of this object */
5084                         char *raw_message,              /* Data to be written */
5085                         off_t raw_length,               /* Size of raw_message */
5086                         struct ctdluser *is_mailbox,    /* Mailbox room? */
5087                         int is_binary,                  /* Is encoding necessary? */
5088                         int is_unique,                  /* Del others of this type? */
5089                         unsigned int flags              /* Internal save flags */
5090                         )
5091 {
5092
5093         struct ctdlroom qrbuf;
5094         char roomname[ROOMNAMELEN];
5095         struct CtdlMessage *msg;
5096         char *encoded_message = NULL;
5097
5098         if (is_mailbox != NULL) {
5099                 CtdlMailboxName(roomname, sizeof roomname, is_mailbox, req_room);
5100         }
5101         else {
5102                 safestrncpy(roomname, req_room, sizeof(roomname));
5103         }
5104
5105         syslog(LOG_DEBUG, "Raw length is %ld\n", (long)raw_length);
5106
5107         if (is_binary) {
5108                 encoded_message = malloc((size_t) (((raw_length * 134) / 100) + 4096 ) );
5109         }
5110         else {
5111                 encoded_message = malloc((size_t)(raw_length + 4096));
5112         }
5113
5114         sprintf(encoded_message, "Content-type: %s\n", content_type);
5115
5116         if (is_binary) {
5117                 sprintf(&encoded_message[strlen(encoded_message)],
5118                         "Content-transfer-encoding: base64\n\n"
5119                 );
5120         }
5121         else {
5122                 sprintf(&encoded_message[strlen(encoded_message)],
5123                         "Content-transfer-encoding: 7bit\n\n"
5124                 );
5125         }
5126
5127         if (is_binary) {
5128                 CtdlEncodeBase64(
5129                         &encoded_message[strlen(encoded_message)],
5130                         raw_message,
5131                         (int)raw_length,
5132                         0
5133                 );
5134         }
5135         else {
5136                 memcpy(
5137                         &encoded_message[strlen(encoded_message)],
5138                         raw_message,
5139                         (int)(raw_length+1)
5140                 );
5141         }
5142
5143         syslog(LOG_DEBUG, "Allocating\n");
5144         msg = malloc(sizeof(struct CtdlMessage));
5145         memset(msg, 0, sizeof(struct CtdlMessage));
5146         msg->cm_magic = CTDLMESSAGE_MAGIC;
5147         msg->cm_anon_type = MES_NORMAL;
5148         msg->cm_format_type = 4;
5149         msg->cm_fields['A'] = strdup(CC->user.fullname);
5150         msg->cm_fields['O'] = strdup(req_room);
5151         msg->cm_fields['N'] = strdup(config.c_nodename);
5152         msg->cm_fields['H'] = strdup(config.c_humannode);
5153         msg->cm_flags = flags;
5154
5155         msg->cm_fields['M'] = encoded_message;
5156
5157         /* Create the requested room if we have to. */
5158         if (CtdlGetRoom(&qrbuf, roomname) != 0) {
5159                 CtdlCreateRoom(roomname,
5160                         ( (is_mailbox != NULL) ? 5 : 3 ),
5161                         "", 0, 1, 0, VIEW_BBS);
5162         }
5163         /* If the caller specified this object as unique, delete all
5164          * other objects of this type that are currently in the room.
5165          */
5166         if (is_unique) {
5167                 syslog(LOG_DEBUG, "Deleted %d other msgs of this type\n",
5168                         CtdlDeleteMessages(roomname, NULL, 0, content_type)
5169                 );
5170         }
5171         /* Now write the data */
5172         CtdlSubmitMsg(msg, NULL, roomname, 0);
5173         CtdlFreeMessage(msg);
5174 }
5175
5176
5177
5178
5179
5180
5181 void CtdlGetSysConfigBackend(long msgnum, void *userdata) {
5182         config_msgnum = msgnum;
5183 }
5184
5185
5186 char *CtdlGetSysConfig(char *sysconfname) {
5187         char hold_rm[ROOMNAMELEN];
5188         long msgnum;
5189         char *conf;
5190         struct CtdlMessage *msg;
5191         char buf[SIZ];
5192
5193         strcpy(hold_rm, CC->room.QRname);
5194         if (CtdlGetRoom(&CC->room, SYSCONFIGROOM) != 0) {
5195                 CtdlGetRoom(&CC->room, hold_rm);
5196                 return NULL;
5197         }
5198
5199
5200         /* We want the last (and probably only) config in this room */
5201         begin_critical_section(S_CONFIG);
5202         config_msgnum = (-1L);
5203         CtdlForEachMessage(MSGS_LAST, 1, NULL, sysconfname, NULL,
5204                 CtdlGetSysConfigBackend, NULL);
5205         msgnum = config_msgnum;
5206         end_critical_section(S_CONFIG);
5207
5208         if (msgnum < 0L) {
5209                 conf = NULL;
5210         }
5211         else {
5212                 msg = CtdlFetchMessage(msgnum, 1);
5213                 if (msg != NULL) {
5214                         conf = strdup(msg->cm_fields['M']);
5215                         CtdlFreeMessage(msg);
5216                 }
5217                 else {
5218                         conf = NULL;
5219                 }
5220         }
5221
5222         CtdlGetRoom(&CC->room, hold_rm);
5223
5224         if (conf != NULL) do {
5225                 extract_token(buf, conf, 0, '\n', sizeof buf);
5226                 strcpy(conf, &conf[strlen(buf)+1]);
5227         } while ( (!IsEmptyStr(conf)) && (!IsEmptyStr(buf)) );
5228
5229         return(conf);
5230 }
5231
5232
5233 void CtdlPutSysConfig(char *sysconfname, char *sysconfdata) {
5234         CtdlWriteObject(SYSCONFIGROOM, sysconfname, sysconfdata, (strlen(sysconfdata)+1), NULL, 0, 1, 0);
5235 }
5236
5237
5238 /*
5239  * Determine whether a given Internet address belongs to the current user
5240  */
5241 int CtdlIsMe(char *addr, int addr_buf_len)
5242 {
5243         struct recptypes *recp;
5244         int i;
5245
5246         recp = validate_recipients(addr, NULL, 0);
5247         if (recp == NULL) return(0);
5248
5249         if (recp->num_local == 0) {
5250                 free_recipients(recp);
5251                 return(0);
5252         }
5253
5254         for (i=0; i<recp->num_local; ++i) {
5255                 extract_token(addr, recp->recp_local, i, '|', addr_buf_len);
5256                 if (!strcasecmp(addr, CC->user.fullname)) {
5257                         free_recipients(recp);
5258                         return(1);
5259                 }
5260         }
5261
5262         free_recipients(recp);
5263         return(0);
5264 }
5265
5266
5267 /*
5268  * Citadel protocol command to do the same
5269  */
5270 void cmd_isme(char *argbuf) {
5271         char addr[256];
5272
5273         if (CtdlAccessCheck(ac_logged_in)) return;
5274         extract_token(addr, argbuf, 0, '|', sizeof addr);
5275
5276         if (CtdlIsMe(addr, sizeof addr)) {
5277                 cprintf("%d %s\n", CIT_OK, addr);
5278         }
5279         else {
5280                 cprintf("%d Not you.\n", ERROR + ILLEGAL_VALUE);
5281         }
5282
5283 }
5284
5285
5286 /*****************************************************************************/
5287 /*                      MODULE INITIALIZATION STUFF                          */
5288 /*****************************************************************************/
5289
5290 CTDL_MODULE_INIT(msgbase)
5291 {
5292         if (!threading) {
5293                 CtdlRegisterProtoHook(cmd_msgs, "MSGS", "Output a list of messages in the current room");
5294                 CtdlRegisterProtoHook(cmd_msg0, "MSG0", "Output a message in plain text format");
5295                 CtdlRegisterProtoHook(cmd_msg2, "MSG2", "Output a message in RFC822 format");
5296                 CtdlRegisterProtoHook(cmd_msg3, "MSG3", "Output a message in raw format (deprecated)");
5297                 CtdlRegisterProtoHook(cmd_msg4, "MSG4", "Output a message in the client's preferred format");
5298                 CtdlRegisterProtoHook(cmd_msgp, "MSGP", "Select preferred format for MSG4 output");
5299                 CtdlRegisterProtoHook(cmd_opna, "OPNA", "Open an attachment for download");
5300                 CtdlRegisterProtoHook(cmd_dlat, "DLAT", "Download an attachment");
5301                 CtdlRegisterProtoHook(cmd_ent0, "ENT0", "Enter a message");
5302                 CtdlRegisterProtoHook(cmd_dele, "DELE", "Delete a message");
5303                 CtdlRegisterProtoHook(cmd_move, "MOVE", "Move or copy a message to another room");
5304                 CtdlRegisterProtoHook(cmd_isme, "ISME", "Determine whether an email address belongs to a user");
5305         }
5306
5307         /* return our Subversion id for the Log */
5308         return "msgbase";
5309 }