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