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