citadel/msgbase.c

   1 /*
   2  * $Id$
   3  *
   4  * Implements the message store.
   5  *
   6  */
   7
   8 #ifdef DLL_EXPORT
   9 #define IN_LIBCIT
  10 #endif
  11
  12 #include "sysdep.h"
  13 #include <stdlib.h>
  14 #include <unistd.h>
  15 #include <stdio.h>
  16 #include <fcntl.h>
  17
  18 #if TIME_WITH_SYS_TIME
  19 # include <sys/time.h>
  20 # include <time.h>
  21 #else
  22 # if HAVE_SYS_TIME_H
  23 #  include <sys/time.h>
  24 # else
  25 #  include <time.h>
  26 # endif
  27 #endif
  28
  29
  30 #include <ctype.h>
  31 #include <string.h>
  32 #include <syslog.h>
  33 #include <limits.h>
  34 #include <errno.h>
  35 #include <stdarg.h>
  36 #include <sys/stat.h>
  37 #include "citadel.h"
  38 #include "server.h"
  39 #include "serv_extensions.h"
  40 #include "database.h"
  41 #include "msgbase.h"
  42 #include "support.h"
  43 #include "sysdep_decls.h"
  44 #include "citserver.h"
  45 #include "room_ops.h"
  46 #include "user_ops.h"
  47 #include "file_ops.h"
  48 #include "control.h"
  49 #include "tools.h"
  50 #include "mime_parser.h"
  51 #include "html.h"
  52 #include "genstamp.h"
  53 #include "internet_addressing.h"
  54
  55 #define desired_section ((char *)CtdlGetUserData(SYM_DESIRED_SECTION))
  56 #define ma ((struct ma_info *)CtdlGetUserData(SYM_MA_INFO))
  57 #define msg_repl ((struct repl *)CtdlGetUserData(SYM_REPL))
  58
  59 extern struct config config;
  60 long config_msgnum;
  61
  62
  63 /*
  64  * This really belongs in serv_network.c, but I don't know how to export
  65  * symbols between modules.
  66  */
  67 struct FilterList *filterlist = NULL;
  68
  69
  70 /*
  71  * These are the four-character field headers we use when outputting
  72  * messages in Citadel format (as opposed to RFC822 format).
  73  */
  74 char *msgkeys[] = {
  75         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  76         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  77         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  78         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  79         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  80         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  81         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  82         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  83         NULL,
  84         "from",
  85         NULL, NULL, NULL,
  86         "exti",
  87         "rfca",
  88         NULL,
  89         "hnod",
  90         "msgn",
  91         NULL, NULL, NULL,
  92         "text",
  93         "node",
  94         "room",
  95         "path",
  96         NULL,
  97         "rcpt",
  98         "spec",
  99         "time",
 100         "subj",
 101         NULL,
 102         NULL,
 103         NULL,
 104         NULL,
 105         NULL
 106 };
 107
 108 /*
 109  * This function is self explanatory.
 110  * (What can I say, I'm in a weird mood today...)
 111  */
 112 void remove_any_whitespace_to_the_left_or_right_of_at_symbol(char *name)
 113 {
 114         int i;
 115
 116         for (i = 0; i < strlen(name); ++i) {
 117                 if (name[i] == '@') {
 118                         while (isspace(name[i - 1]) && i > 0) {
 119                                 strcpy(&name[i - 1], &name[i]);
 120                                 --i;
 121                         }
 122                         while (isspace(name[i + 1])) {
 123                                 strcpy(&name[i + 1], &name[i + 2]);
 124                         }
 125                 }
 126         }
 127 }
 128
 129
 130 /*
 131  * Aliasing for network mail.
 132  * (Error messages have been commented out, because this is a server.)
 133  */
 134 int alias(char *name)
 135 {                               /* process alias and routing info for mail */
 136         FILE *fp;
 137         int a, i;
 138         char aaa[SIZ], bbb[SIZ];
 139         char *ignetcfg = NULL;
 140         char *ignetmap = NULL;
 141         int at = 0;
 142         char node[SIZ];
 143         char testnode[SIZ];
 144         char buf[SIZ];
 145
 146         striplt(name);
 147         remove_any_whitespace_to_the_left_or_right_of_at_symbol(name);
 148
 149         fp = fopen("network/mail.aliases", "r");
 150         if (fp == NULL) {
 151                 fp = fopen("/dev/null", "r");
 152         }
 153         if (fp == NULL) {
 154                 return (MES_ERROR);
 155         }
 156         strcpy(aaa, "");
 157         strcpy(bbb, "");
 158         while (fgets(aaa, sizeof aaa, fp) != NULL) {
 159                 while (isspace(name[0]))
 160                         strcpy(name, &name[1]);
 161                 aaa[strlen(aaa) - 1] = 0;
 162                 strcpy(bbb, "");
 163                 for (a = 0; a < strlen(aaa); ++a) {
 164                         if (aaa[a] == ',') {
 165                                 strcpy(bbb, &aaa[a + 1]);
 166                                 aaa[a] = 0;
 167                         }
 168                 }
 169                 if (!strcasecmp(name, aaa))
 170                         strcpy(name, bbb);
 171         }
 172         fclose(fp);
 173
 174         /* Hit the Global Address Book */
 175         if (CtdlDirectoryLookup(aaa, name) == 0) {
 176                 strcpy(name, aaa);
 177         }
 178
 179         lprintf(7, "Mail is being forwarded to %s\n", name);
 180
 181         /* Change "user @ xxx" to "user" if xxx is an alias for this host */
 182         for (a=0; a<strlen(name); ++a) {
 183                 if (name[a] == '@') {
 184                         if (CtdlHostAlias(&name[a+1]) == hostalias_localhost) {
 185                                 name[a] = 0;
 186                                 lprintf(7, "Changed to <%s>\n", name);
 187                         }
 188                 }
 189         }
 190
 191         /* determine local or remote type, see citadel.h */
 192         at = haschar(name, '@');
 193         if (at == 0) return(MES_LOCAL);         /* no @'s - local address */
 194         if (at > 1) return(MES_ERROR);          /* >1 @'s - invalid address */
 195         remove_any_whitespace_to_the_left_or_right_of_at_symbol(name);
 196
 197         /* figure out the delivery mode */
 198         extract_token(node, name, 1, '@');
 199
 200         /* If there are one or more dots in the nodename, we assume that it
 201          * is an FQDN and will attempt SMTP delivery to the Internet.
 202          */
 203         if (haschar(node, '.') > 0) {
 204                 return(MES_INTERNET);
 205         }
 206
 207         /* Otherwise we look in the IGnet maps for a valid Citadel node.
 208          * Try directly-connected nodes first...
 209          */
 210         ignetcfg = CtdlGetSysConfig(IGNETCFG);
 211         for (i=0; i<num_tokens(ignetcfg, '\n'); ++i) {
 212                 extract_token(buf, ignetcfg, i, '\n');
 213                 extract_token(testnode, buf, 0, '|');
 214                 if (!strcasecmp(node, testnode)) {
 215                         phree(ignetcfg);
 216                         return(MES_IGNET);
 217                 }
 218         }
 219         phree(ignetcfg);
 220
 221         /*
 222          * Then try nodes that are two or more hops away.
 223          */
 224         ignetmap = CtdlGetSysConfig(IGNETMAP);
 225         for (i=0; i<num_tokens(ignetmap, '\n'); ++i) {
 226                 extract_token(buf, ignetmap, i, '\n');
 227                 extract_token(testnode, buf, 0, '|');
 228                 if (!strcasecmp(node, testnode)) {
 229                         phree(ignetmap);
 230                         return(MES_IGNET);
 231                 }
 232         }
 233         phree(ignetmap);
 234
 235         /* If we get to this point it's an invalid node name */
 236         return (MES_ERROR);
 237 }
 238
 239
 240 void get_mm(void)
 241 {
 242         FILE *fp;
 243
 244         fp = fopen("citadel.control", "r");
 245         fread((char *) &CitControl, sizeof(struct CitControl), 1, fp);
 246         fclose(fp);
 247 }
 248
 249
 250
 251 void simple_listing(long msgnum, void *userdata)
 252 {
 253         cprintf("%ld\n", msgnum);
 254 }
 255
 256
 257
 258 /* Determine if a given message matches the fields in a message template.
 259  * Return 0 for a successful match.
 260  */
 261 int CtdlMsgCmp(struct CtdlMessage *msg, struct CtdlMessage *template) {
 262         int i;
 263
 264         /* If there aren't any fields in the template, all messages will
 265          * match.
 266          */
 267         if (template == NULL) return(0);
 268
 269         /* Null messages are bogus. */
 270         if (msg == NULL) return(1);
 271
 272         for (i='A'; i<='Z'; ++i) {
 273                 if (template->cm_fields[i] != NULL) {
 274                         if (msg->cm_fields[i] == NULL) {
 275                                 return 1;
 276                         }
 277                         if (strcasecmp(msg->cm_fields[i],
 278                                 template->cm_fields[i])) return 1;
 279                 }
 280         }
 281
 282         /* All compares succeeded: we have a match! */
 283         return 0;
 284 }
 285
 286
 287
 288 /*
 289  * Retrieve the "seen" message list for the current room.
 290  */
 291 void CtdlGetSeen(char *buf) {
 292         struct visit vbuf;
 293
 294         /* Learn about the user and room in question */
 295         CtdlGetRelationship(&vbuf, &CC->usersupp, &CC->quickroom);
 296
 297         safestrncpy(buf, vbuf.v_seen, SIZ);
 298 }
 299
 300
 301
 302 /*
 303  * Manipulate the "seen msgs" string.
 304  */
 305 void CtdlSetSeen(long target_msgnum, int target_setting) {
 306         char newseen[SIZ];
 307         struct cdbdata *cdbfr;
 308         int i;
 309         int is_seen = 0;
 310         int was_seen = 1;
 311         long lo = (-1L);
 312         long hi = (-1L);
 313         struct visit vbuf;
 314         long *msglist;
 315         int num_msgs = 0;
 316
 317         /* Learn about the user and room in question */
 318         CtdlGetRelationship(&vbuf, &CC->usersupp, &CC->quickroom);
 319
 320         /* Load the message list */
 321         cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->quickroom.QRnumber, sizeof(long));
 322         if (cdbfr != NULL) {
 323                 msglist = mallok(cdbfr->len);
 324                 memcpy(msglist, cdbfr->ptr, cdbfr->len);
 325                 num_msgs = cdbfr->len / sizeof(long);
 326                 cdb_free(cdbfr);
 327         } else {
 328                 return; /* No messages at all?  No further action. */
 329         }
 330
 331         lprintf(9, "before optimize: %s\n", vbuf.v_seen);
 332         strcpy(newseen, "");
 333
 334         for (i=0; i<num_msgs; ++i) {
 335                 is_seen = 0;
 336
 337                 if (msglist[i] == target_msgnum) {
 338                         is_seen = target_setting;
 339                 }
 340                 else {
 341                         if (is_msg_in_mset(vbuf.v_seen, msglist[i])) {
 342                                 is_seen = 1;
 343                         }
 344                 }
 345
 346                 if (is_seen == 1) {
 347                         if (lo < 0L) lo = msglist[i];
 348                         hi = msglist[i];
 349                 }
 350                 if (  ((is_seen == 0) && (was_seen == 1))
 351                    || ((is_seen == 1) && (i == num_msgs-1)) ) {
 352                         size_t tmp;
 353
 354                         if ( (strlen(newseen) + 20) > SIZ) {
 355                                 strcpy(newseen, &newseen[20]);
 356                                 newseen[0] = '*';
 357                         }
 358                         tmp = strlen(newseen);
 359                         if (tmp > 0) {
 360                                 strcat(newseen, ",");
 361                                 tmp++;
 362                         }
 363                         if (lo == hi) {
 364                                 snprintf(&newseen[tmp], sizeof newseen - tmp,
 365                                          "%ld", lo);
 366                         }
 367                         else {
 368                                 snprintf(&newseen[tmp], sizeof newseen - tmp,
 369                                          "%ld:%ld", lo, hi);
 370                         }
 371                         lo = (-1L);
 372                         hi = (-1L);
 373                 }
 374                 was_seen = is_seen;
 375         }
 376
 377         safestrncpy(vbuf.v_seen, newseen, SIZ);
 378         lprintf(9, " after optimize: %s\n", vbuf.v_seen);
 379         phree(msglist);
 380         CtdlSetRelationship(&vbuf, &CC->usersupp, &CC->quickroom);
 381 }
 382
 383
 384 /*
 385  * API function to perform an operation for each qualifying message in the
 386  * current room.  (Returns the number of messages processed.)
 387  */
 388 int CtdlForEachMessage(int mode, long ref,
 389                         char *content_type,
 390                         struct CtdlMessage *compare,
 391                         void (*CallBack) (long, void *),
 392                         void *userdata)
 393 {
 394
 395         int a;
 396         struct visit vbuf;
 397         struct cdbdata *cdbfr;
 398         long *msglist = NULL;
 399         int num_msgs = 0;
 400         int num_processed = 0;
 401         long thismsg;
 402         struct MetaData smi;
 403         struct CtdlMessage *msg;
 404         int is_seen;
 405         long lastold = 0L;
 406         int printed_lastold = 0;
 407
 408         /* Learn about the user and room in question */
 409         get_mm();
 410         getuser(&CC->usersupp, CC->curr_user);
 411         CtdlGetRelationship(&vbuf, &CC->usersupp, &CC->quickroom);
 412
 413         /* Load the message list */
 414         cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->quickroom.QRnumber, sizeof(long));
 415         if (cdbfr != NULL) {
 416                 msglist = mallok(cdbfr->len);
 417                 memcpy(msglist, cdbfr->ptr, cdbfr->len);
 418                 num_msgs = cdbfr->len / sizeof(long);
 419                 cdb_free(cdbfr);
 420         } else {
 421                 return 0;       /* No messages at all?  No further action. */
 422         }
 423
 424
 425         /*
 426          * Now begin the traversal.
 427          */
 428         if (num_msgs > 0) for (a = 0; a < num_msgs; ++a) {
 429
 430                 /* If the caller is looking for a specific MIME type, filter
 431                  * out all messages which are not of the type requested.
 432                  */
 433                 if (content_type != NULL) if (strlen(content_type) > 0) {
 434
 435                         /* This call to GetMetaData() sits inside this loop
 436                          * so that we only do the extra database read per msg
 437                          * if we need to.  Doing the extra read all the time
 438                          * really kills the server.  If we ever need to use
 439                          * metadata for another search criterion, we need to
 440                          * move the read somewhere else -- but still be smart
 441                          * enough to only do the read if the caller has
 442                          * specified something that will need it.
 443                          */
 444                         GetMetaData(&smi, msglist[a]);
 445
 446                         if (strcasecmp(smi.meta_content_type, content_type)) {
 447                                 msglist[a] = 0L;
 448                         }
 449                 }
 450         }
 451
 452         num_msgs = sort_msglist(msglist, num_msgs);
 453
 454         /* If a template was supplied, filter out the messages which
 455          * don't match.  (This could induce some delays!)
 456          */
 457         if (num_msgs > 0) {
 458                 if (compare != NULL) {
 459                         for (a = 0; a < num_msgs; ++a) {
 460                                 msg = CtdlFetchMessage(msglist[a]);
 461                                 if (msg != NULL) {
 462                                         if (CtdlMsgCmp(msg, compare)) {
 463                                                 msglist[a] = 0L;
 464                                         }
 465                                         CtdlFreeMessage(msg);
 466                                 }
 467                         }
 468                 }
 469         }
 470
 471
 472         /*
 473          * Now iterate through the message list, according to the
 474          * criteria supplied by the caller.
 475          */
 476         if (num_msgs > 0)
 477                 for (a = 0; a < num_msgs; ++a) {
 478                         thismsg = msglist[a];
 479                         is_seen = is_msg_in_mset(vbuf.v_seen, thismsg);
 480                         if (is_seen) lastold = thismsg;
 481                         if ((thismsg > 0L)
 482                             && (
 483
 484                                        (mode == MSGS_ALL)
 485                                        || ((mode == MSGS_OLD) && (is_seen))
 486                                        || ((mode == MSGS_NEW) && (!is_seen))
 487                                        || ((mode == MSGS_LAST) && (a >= (num_msgs - ref)))
 488                                    || ((mode == MSGS_FIRST) && (a < ref))
 489                                 || ((mode == MSGS_GT) && (thismsg > ref))
 490                                 || ((mode == MSGS_EQ) && (thismsg == ref))
 491                             )
 492                             ) {
 493                                 if ((mode == MSGS_NEW) && (CC->usersupp.flags & US_LASTOLD) && (lastold > 0L) && (printed_lastold == 0) && (!is_seen)) {
 494                                         if (CallBack)
 495                                                 CallBack(lastold, userdata);
 496                                         printed_lastold = 1;
 497                                         ++num_processed;
 498                                 }
 499                                 if (CallBack) CallBack(thismsg, userdata);
 500                                 ++num_processed;
 501                         }
 502                 }
 503         phree(msglist);         /* Clean up */
 504         return num_processed;
 505 }
 506
 507
 508
 509 /*
 510  * cmd_msgs()  -  get list of message #'s in this room
 511  *                implements the MSGS server command using CtdlForEachMessage()
 512  */
 513 void cmd_msgs(char *cmdbuf)
 514 {
 515         int mode = 0;
 516         char which[SIZ];
 517         char buf[SIZ];
 518         char tfield[SIZ];
 519         char tvalue[SIZ];
 520         int cm_ref = 0;
 521         int i;
 522         int with_template = 0;
 523         struct CtdlMessage *template = NULL;
 524
 525         extract(which, cmdbuf, 0);
 526         cm_ref = extract_int(cmdbuf, 1);
 527         with_template = extract_int(cmdbuf, 2);
 528
 529         mode = MSGS_ALL;
 530         strcat(which, "   ");
 531         if (!strncasecmp(which, "OLD", 3))
 532                 mode = MSGS_OLD;
 533         else if (!strncasecmp(which, "NEW", 3))
 534                 mode = MSGS_NEW;
 535         else if (!strncasecmp(which, "FIRST", 5))
 536                 mode = MSGS_FIRST;
 537         else if (!strncasecmp(which, "LAST", 4))
 538                 mode = MSGS_LAST;
 539         else if (!strncasecmp(which, "GT", 2))
 540                 mode = MSGS_GT;
 541
 542         if ((!(CC->logged_in)) && (!(CC->internal_pgm))) {
 543                 cprintf("%d not logged in\n", ERROR + NOT_LOGGED_IN);
 544                 return;
 545         }
 546
 547         if (with_template) {
 548                 cprintf("%d Send template then receive message list\n",
 549                         START_CHAT_MODE);
 550                 template = (struct CtdlMessage *)
 551                         mallok(sizeof(struct CtdlMessage));
 552                 memset(template, 0, sizeof(struct CtdlMessage));
 553                 while(client_gets(buf), strcmp(buf,"000")) {
 554                         extract(tfield, buf, 0);
 555                         extract(tvalue, buf, 1);
 556                         for (i='A'; i<='Z'; ++i) if (msgkeys[i]!=NULL) {
 557                                 if (!strcasecmp(tfield, msgkeys[i])) {
 558                                         template->cm_fields[i] =
 559                                                 strdoop(tvalue);
 560                                 }
 561                         }
 562                 }
 563         }
 564         else {
 565                 cprintf("%d Message list...\n", LISTING_FOLLOWS);
 566         }
 567
 568         CtdlForEachMessage(mode, cm_ref,
 569                 NULL, template, simple_listing, NULL);
 570         if (template != NULL) CtdlFreeMessage(template);
 571         cprintf("000\n");
 572 }
 573
 574
 575
 576
 577 /*
 578  * help_subst()  -  support routine for help file viewer
 579  */
 580 void help_subst(char *strbuf, char *source, char *dest)
 581 {
 582         char workbuf[SIZ];
 583         int p;
 584
 585         while (p = pattern2(strbuf, source), (p >= 0)) {
 586                 strcpy(workbuf, &strbuf[p + strlen(source)]);
 587                 strcpy(&strbuf[p], dest);
 588                 strcat(strbuf, workbuf);
 589         }
 590 }
 591
 592
 593 void do_help_subst(char *buffer)
 594 {
 595         char buf2[16];
 596
 597         help_subst(buffer, "^nodename", config.c_nodename);
 598         help_subst(buffer, "^humannode", config.c_humannode);
 599         help_subst(buffer, "^fqdn", config.c_fqdn);
 600         help_subst(buffer, "^username", CC->usersupp.fullname);
 601         snprintf(buf2, sizeof buf2, "%ld", CC->usersupp.usernum);
 602         help_subst(buffer, "^usernum", buf2);
 603         help_subst(buffer, "^sysadm", config.c_sysadm);
 604         help_subst(buffer, "^variantname", CITADEL);
 605         snprintf(buf2, sizeof buf2, "%d", config.c_maxsessions);
 606         help_subst(buffer, "^maxsessions", buf2);
 607         help_subst(buffer, "^bbsdir", BBSDIR);
 608 }
 609
 610
 611
 612 /*
 613  * memfmout()  -  Citadel text formatter and paginator.
 614  *             Although the original purpose of this routine was to format
 615  *             text to the reader's screen width, all we're really using it
 616  *             for here is to format text out to 80 columns before sending it
 617  *             to the client.  The client software may reformat it again.
 618  */
 619 void memfmout(
 620         int width,              /* screen width to use */
 621         char *mptr,             /* where are we going to get our text from? */
 622         char subst,             /* nonzero if we should do substitutions */
 623         char *nl)               /* string to terminate lines with */
 624 {
 625         int a, b, c;
 626         int real = 0;
 627         int old = 0;
 628         cit_uint8_t ch;
 629         char aaa[140];
 630         char buffer[SIZ];
 631
 632         strcpy(aaa, "");
 633         old = 255;
 634         strcpy(buffer, "");
 635         c = 1;                  /* c is the current pos */
 636
 637         do {
 638                 if (subst) {
 639                         while (ch = *mptr, ((ch != 0) && (strlen(buffer) < 126))) {
 640                                 ch = *mptr++;
 641                                 buffer[strlen(buffer) + 1] = 0;
 642                                 buffer[strlen(buffer)] = ch;
 643                         }
 644
 645                         if (buffer[0] == '^')
 646                                 do_help_subst(buffer);
 647
 648                         buffer[strlen(buffer) + 1] = 0;
 649                         a = buffer[0];
 650                         strcpy(buffer, &buffer[1]);
 651                 } else {
 652                         ch = *mptr++;
 653                 }
 654
 655                 old = real;
 656                 real = ch;
 657
 658                 if (((ch == 13) || (ch == 10)) && (old != 13) && (old != 10))
 659                         ch = 32;
 660                 if (((old == 13) || (old == 10)) && (isspace(real))) {
 661                         cprintf("%s", nl);
 662                         c = 1;
 663                 }
 664                 if (ch > 126)
 665                         continue;
 666
 667                 if (ch > 32) {
 668                         if (((strlen(aaa) + c) > (width - 5)) && (strlen(aaa) > (width - 5))) {
 669                                 cprintf("%s%s", nl, aaa);
 670                                 c = strlen(aaa);
 671                                 aaa[0] = 0;
 672                         }
 673                         b = strlen(aaa);
 674                         aaa[b] = ch;
 675                         aaa[b + 1] = 0;
 676                 }
 677                 if (ch == 32) {
 678                         if ((strlen(aaa) + c) > (width - 5)) {
 679                                 cprintf("%s", nl);
 680                                 c = 1;
 681                         }
 682                         cprintf("%s ", aaa);
 683                         ++c;
 684                         c = c + strlen(aaa);
 685                         strcpy(aaa, "");
 686                 }
 687                 if ((ch == 13) || (ch == 10)) {
 688                         cprintf("%s%s", aaa, nl);
 689                         c = 1;
 690                         strcpy(aaa, "");
 691                 }
 692
 693         } while (ch > 0);
 694
 695         cprintf("%s%s", aaa, nl);
 696 }
 697
 698
 699
 700 /*
 701  * Callback function for mime parser that simply lists the part
 702  */
 703 void list_this_part(char *name, char *filename, char *partnum, char *disp,
 704                     void *content, char *cbtype, size_t length, char *encoding,
 705                     void *cbuserdata)
 706 {
 707
 708         cprintf("part=%s|%s|%s|%s|%s|%ld\n",
 709                 name, filename, partnum, disp, cbtype, (long)length);
 710 }
 711
 712 /*
 713  * Callback function for multipart prefix
 714  */
 715 void list_this_pref(char *name, char *filename, char *partnum, char *disp,
 716                     void *content, char *cbtype, size_t length, char *encoding,
 717                     void *cbuserdata)
 718 {
 719         cprintf("pref=%s|%s\n", partnum, cbtype);
 720 }
 721
 722 /*
 723  * Callback function for multipart sufffix
 724  */
 725 void list_this_suff(char *name, char *filename, char *partnum, char *disp,
 726                     void *content, char *cbtype, size_t length, char *encoding,
 727                     void *cbuserdata)
 728 {
 729         cprintf("suff=%s|%s\n", partnum, cbtype);
 730 }
 731
 732
 733 /*
 734  * Callback function for mime parser that opens a section for downloading
 735  */
 736 void mime_download(char *name, char *filename, char *partnum, char *disp,
 737                    void *content, char *cbtype, size_t length, char *encoding,
 738                    void *cbuserdata)
 739 {
 740
 741         /* Silently go away if there's already a download open... */
 742         if (CC->download_fp != NULL)
 743                 return;
 744
 745         /* ...or if this is not the desired section */
 746         if (strcasecmp(desired_section, partnum))
 747                 return;
 748
 749         CC->download_fp = tmpfile();
 750         if (CC->download_fp == NULL)
 751                 return;
 752
 753         fwrite(content, length, 1, CC->download_fp);
 754         fflush(CC->download_fp);
 755         rewind(CC->download_fp);
 756
 757         OpenCmdResult(filename, cbtype);
 758 }
 759
 760
 761
 762 /*
 763  * Load a message from disk into memory.
 764  * This is used by CtdlOutputMsg() and other fetch functions.
 765  *
 766  * NOTE: Caller is responsible for freeing the returned CtdlMessage struct
 767  *       using the CtdlMessageFree() function.
 768  */
 769 struct CtdlMessage *CtdlFetchMessage(long msgnum)
 770 {
 771         struct cdbdata *dmsgtext;
 772         struct CtdlMessage *ret = NULL;
 773         char *mptr;
 774         cit_uint8_t ch;
 775         cit_uint8_t field_header;
 776         size_t field_length;
 777
 778         dmsgtext = cdb_fetch(CDB_MSGMAIN, &msgnum, sizeof(long));
 779         if (dmsgtext == NULL) {
 780                 return NULL;
 781         }
 782         mptr = dmsgtext->ptr;
 783
 784         /* Parse the three bytes that begin EVERY message on disk.
 785          * The first is always 0xFF, the on-disk magic number.
 786          * The second is the anonymous/public type byte.
 787          * The third is the format type byte (vari, fixed, or MIME).
 788          */
 789         ch = *mptr++;
 790         if (ch != 255) {
 791                 lprintf(5, "Message %ld appears to be corrupted.\n", msgnum);
 792                 cdb_free(dmsgtext);
 793                 return NULL;
 794         }
 795         ret = (struct CtdlMessage *) mallok(sizeof(struct CtdlMessage));
 796         memset(ret, 0, sizeof(struct CtdlMessage));
 797
 798         ret->cm_magic = CTDLMESSAGE_MAGIC;
 799         ret->cm_anon_type = *mptr++;    /* Anon type byte */
 800         ret->cm_format_type = *mptr++;  /* Format type byte */
 801
 802         /*
 803          * The rest is zero or more arbitrary fields.  Load them in.
 804          * We're done when we encounter either a zero-length field or
 805          * have just processed the 'M' (message text) field.
 806          */
 807         do {
 808                 field_length = strlen(mptr);
 809                 if (field_length == 0)
 810                         break;
 811                 field_header = *mptr++;
 812                 ret->cm_fields[field_header] = mallok(field_length);
 813                 strcpy(ret->cm_fields[field_header], mptr);
 814
 815                 while (*mptr++ != 0);   /* advance to next field */
 816
 817         } while ((field_length > 0) && (field_header != 'M'));
 818
 819         cdb_free(dmsgtext);
 820
 821         /* Always make sure there's something in the msg text field */
 822         if (ret->cm_fields['M'] == NULL)
 823                 ret->cm_fields['M'] = strdoop("<no text>\n");
 824
 825         /* Perform "before read" hooks (aborting if any return nonzero) */
 826         if (PerformMessageHooks(ret, EVT_BEFOREREAD) > 0) {
 827                 CtdlFreeMessage(ret);
 828                 return NULL;
 829         }
 830
 831         return (ret);
 832 }
 833
 834
 835 /*
 836  * Returns 1 if the supplied pointer points to a valid Citadel message.
 837  * If the pointer is NULL or the magic number check fails, returns 0.
 838  */
 839 int is_valid_message(struct CtdlMessage *msg) {
 840         if (msg == NULL)
 841                 return 0;
 842         if ((msg->cm_magic) != CTDLMESSAGE_MAGIC) {
 843                 lprintf(3, "is_valid_message() -- self-check failed\n");
 844                 return 0;
 845         }
 846         return 1;
 847 }
 848
 849
 850 /*
 851  * 'Destructor' for struct CtdlMessage
 852  */
 853 void CtdlFreeMessage(struct CtdlMessage *msg)
 854 {
 855         int i;
 856
 857         if (is_valid_message(msg) == 0) return;
 858
 859         for (i = 0; i < 256; ++i)
 860                 if (msg->cm_fields[i] != NULL) {
 861                         phree(msg->cm_fields[i]);
 862                 }
 863
 864         msg->cm_magic = 0;      /* just in case */
 865         phree(msg);
 866 }
 867
 868
 869 /*
 870  * Pre callback function for multipart/alternative
 871  *
 872  * NOTE: this differs from the standard behavior for a reason.  Normally when
 873  *       displaying multipart/alternative you want to show the _last_ usable
 874  *       format in the message.  Here we show the _first_ one, because it's
 875  *       usually text/plain.  Since this set of functions is designed for text
 876  *       output to non-MIME-aware clients, this is the desired behavior.
 877  *
 878  */
 879 void fixed_output_pre(char *name, char *filename, char *partnum, char *disp,
 880                 void *content, char *cbtype, size_t length, char *encoding,
 881                 void *cbuserdata)
 882 {
 883                 lprintf(9, "fixed_output_pre() type=<%s>\n", cbtype);
 884                 if (!strcasecmp(cbtype, "multipart/alternative")) {
 885                         ++ma->is_ma;
 886                         ma->did_print = 0;
 887                         return;
 888                 }
 889 }
 890
 891 /*
 892  * Post callback function for multipart/alternative
 893  */
 894 void fixed_output_post(char *name, char *filename, char *partnum, char *disp,
 895                 void *content, char *cbtype, size_t length, char *encoding,
 896                 void *cbuserdata)
 897 {
 898                 lprintf(9, "fixed_output_post() type=<%s>\n", cbtype);
 899                 if (!strcasecmp(cbtype, "multipart/alternative")) {
 900                         --ma->is_ma;
 901                         ma->did_print = 0;
 902                         return;
 903                 }
 904 }
 905
 906 /*
 907  * Inline callback function for mime parser that wants to display text
 908  */
 909 void fixed_output(char *name, char *filename, char *partnum, char *disp,
 910                 void *content, char *cbtype, size_t length, char *encoding,
 911                 void *cbuserdata)
 912         {
 913                 char *ptr;
 914                 char *wptr;
 915                 size_t wlen;
 916
 917                 lprintf(9, "fixed_output() type=<%s>\n", cbtype);
 918
 919                 /*
 920                  * If we're in the middle of a multipart/alternative scope and
 921                  * we've already printed another section, skip this one.
 922                  */
 923                 if ( (ma->is_ma == 1) && (ma->did_print == 1) ) {
 924                         lprintf(9, "Skipping part %s (%s)\n", partnum, cbtype);
 925                         return;
 926                 }
 927                 ma->did_print = 1;
 928
 929                 if ( (!strcasecmp(cbtype, "text/plain"))
 930                    || (strlen(cbtype)==0) ) {
 931                         wptr = content;
 932                         if (length > 0) {
 933                                 client_write(wptr, length);
 934                                 if (wptr[length-1] != '\n') {
 935                                         cprintf("\n");
 936                                 }
 937                         }
 938                 }
 939                 else if (!strcasecmp(cbtype, "text/html")) {
 940                         ptr = html_to_ascii(content, 80, 0);
 941                         wlen = strlen(ptr);
 942                         client_write(ptr, wlen);
 943                         if (ptr[wlen-1] != '\n') {
 944                                 cprintf("\n");
 945                         }
 946                         phree(ptr);
 947                 }
 948                 else if (strncasecmp(cbtype, "multipart/", 10)) {
 949                         cprintf("Part %s: %s (%s) (%ld bytes)\r\n",
 950                                 partnum, filename, cbtype, (long)length);
 951                 }
 952         }
 953
 954 /*
 955  * The client is elegant and sophisticated and wants to be choosy about
 956  * MIME content types, so figure out which multipart/alternative part
 957  * we're going to send.
 958  */
 959 void choose_preferred(char *name, char *filename, char *partnum, char *disp,
 960                 void *content, char *cbtype, size_t length, char *encoding,
 961                 void *cbuserdata)
 962 {
 963         char buf[SIZ];
 964         int i;
 965
 966         if (ma->is_ma > 0) {
 967                 for (i=0; i<num_tokens(CC->preferred_formats, '|'); ++i) {
 968                         extract(buf, CC->preferred_formats, i);
 969                         if (!strcasecmp(buf, cbtype)) {
 970                                 strcpy(ma->chosen_part, partnum);
 971                         }
 972                 }
 973         }
 974 }
 975
 976 /*
 977  * Now that we've chosen our preferred part, output it.
 978  */
 979 void output_preferred(char *name, char *filename, char *partnum, char *disp,
 980                 void *content, char *cbtype, size_t length, char *encoding,
 981                 void *cbuserdata)
 982 {
 983         int i;
 984         char buf[SIZ];
 985         int add_newline = 0;
 986         char *text_content;
 987
 988         /* This is not the MIME part you're looking for... */
 989         if (strcasecmp(partnum, ma->chosen_part)) return;
 990
 991         /* If the content-type of this part is in our preferred formats
 992          * list, we can simply output it verbatim.
 993          */
 994         for (i=0; i<num_tokens(CC->preferred_formats, '|'); ++i) {
 995                 extract(buf, CC->preferred_formats, i);
 996                 if (!strcasecmp(buf, cbtype)) {
 997                         /* Yeah!  Go!  W00t!! */
 998
 999                         text_content = (char *)content;
1000                         if (text_content[length-1] != '\n') {
1001                                 ++add_newline;
1002                         }
1003
1004                         cprintf("Content-type: %s\n", cbtype);
1005                         cprintf("Content-length: %d\n",
1006                                 (int)(length + add_newline) );
1007                         if (strlen(encoding) > 0) {
1008                                 cprintf("Content-transfer-encoding: %s\n", encoding);
1009                         }
1010                         else {
1011                                 cprintf("Content-transfer-encoding: 7bit\n");
1012                         }
1013                         cprintf("\n");
1014                         client_write(content, length);
1015                         if (add_newline) cprintf("\n");
1016                         return;
1017                 }
1018         }
1019
1020         /* No translations required or possible: output as text/plain */
1021         cprintf("Content-type: text/plain\n\n");
1022         fixed_output(name, filename, partnum, disp, content, cbtype,
1023                         length, encoding, cbuserdata);
1024 }
1025
1026
1027 /*
1028  * Get a message off disk.  (returns om_* values found in msgbase.h)
1029  *
1030  */
1031 int CtdlOutputMsg(long msg_num,         /* message number (local) to fetch */
1032                 int mode,               /* how would you like that message? */
1033                 int headers_only,       /* eschew the message body? */
1034                 int do_proto,           /* do Citadel protocol responses? */
1035                 int crlf                /* Use CRLF newlines instead of LF? */
1036 ) {
1037         struct CtdlMessage *TheMessage;
1038         int retcode;
1039
1040         lprintf(7, "CtdlOutputMsg() msgnum=%ld, mode=%d\n",
1041                 msg_num, mode);
1042
1043         TheMessage = NULL;
1044
1045         if ((!(CC->logged_in)) && (!(CC->internal_pgm))) {
1046                 if (do_proto) cprintf("%d Not logged in.\n",
1047                         ERROR + NOT_LOGGED_IN);
1048                 return(om_not_logged_in);
1049         }
1050
1051         /* FIXME ... small security issue
1052          * We need to check to make sure the requested message is actually
1053          * in the current room, and set msg_ok to 1 only if it is.  This
1054          * functionality is currently missing because I'm in a hurry to replace
1055          * broken production code with nonbroken pre-beta code.  :(   -- ajc
1056          *
1057          if (!msg_ok) {
1058          if (do_proto) cprintf("%d Message %ld is not in this room.\n",
1059          ERROR, msg_num);
1060          return(om_no_such_msg);
1061          }
1062          */
1063
1064         /*
1065          * Fetch the message from disk.
1066          */
1067         TheMessage = CtdlFetchMessage(msg_num);
1068
1069         if (TheMessage == NULL) {
1070                 if (do_proto) cprintf("%d Can't locate msg %ld on disk\n",
1071                         ERROR, msg_num);
1072                 return(om_no_such_msg);
1073         }
1074
1075         retcode = CtdlOutputPreLoadedMsg(
1076                         TheMessage, msg_num, mode,
1077                         headers_only, do_proto, crlf);
1078
1079         CtdlFreeMessage(TheMessage);
1080
1081         return(retcode);
1082 }
1083
1084
1085 /*
1086  * Get a message off disk.  (returns om_* values found in msgbase.h)
1087  *
1088  */
1089 int CtdlOutputPreLoadedMsg(struct CtdlMessage *TheMessage,
1090                 long msg_num,
1091                 int mode,               /* how would you like that message? */
1092                 int headers_only,       /* eschew the message body? */
1093                 int do_proto,           /* do Citadel protocol responses? */
1094                 int crlf                /* Use CRLF newlines instead of LF? */
1095 ) {
1096         int i, k;
1097         char buf[1024];
1098         cit_uint8_t ch;
1099         char allkeys[SIZ];
1100         char display_name[SIZ];
1101         char *mptr;
1102         char *nl;       /* newline string */
1103         int suppress_f = 0;
1104         int subject_found = 0;
1105
1106         /* buffers needed for RFC822 translation */
1107         char suser[SIZ];
1108         char luser[SIZ];
1109         char fuser[SIZ];
1110         char snode[SIZ];
1111         char lnode[SIZ];
1112         char mid[SIZ];
1113         char datestamp[SIZ];
1114         /*                                       */
1115
1116         snprintf(mid, sizeof mid, "%ld", msg_num);
1117         nl = (crlf ? "\r\n" : "\n");
1118
1119         if (!is_valid_message(TheMessage)) {
1120                 lprintf(1, "ERROR: invalid preloaded message for output\n");
1121                 return(om_no_such_msg);
1122         }
1123
1124         /* Are we downloading a MIME component? */
1125         if (mode == MT_DOWNLOAD) {
1126                 if (TheMessage->cm_format_type != FMT_RFC822) {
1127                         if (do_proto)
1128                                 cprintf("%d This is not a MIME message.\n",
1129                                 ERROR);
1130                 } else if (CC->download_fp != NULL) {
1131                         if (do_proto) cprintf(
1132                                 "%d You already have a download open.\n",
1133                                 ERROR);
1134                 } else {
1135                         /* Parse the message text component */
1136                         mptr = TheMessage->cm_fields['M'];
1137                         mime_parser(mptr, NULL,
1138                                 *mime_download, NULL, NULL,
1139                                 NULL, 0);
1140                         /* If there's no file open by this time, the requested
1141                          * section wasn't found, so print an error
1142                          */
1143                         if (CC->download_fp == NULL) {
1144                                 if (do_proto) cprintf(
1145                                         "%d Section %s not found.\n",
1146                                         ERROR + FILE_NOT_FOUND,
1147                                         desired_section);
1148                         }
1149                 }
1150                 return((CC->download_fp != NULL) ? om_ok : om_mime_error);
1151         }
1152
1153         /* now for the user-mode message reading loops */
1154         if (do_proto) cprintf("%d Message %ld:\n", LISTING_FOLLOWS, msg_num);
1155
1156         /* Does the caller want to skip the headers? */
1157         if (headers_only == HEADERS_NONE) goto START_TEXT;
1158
1159         /* Tell the client which format type we're using. */
1160         if ( (mode == MT_CITADEL) && (do_proto) ) {
1161                 cprintf("type=%d\n", TheMessage->cm_format_type);
1162         }
1163
1164         /* nhdr=yes means that we're only displaying headers, no body */
1165         if ( (TheMessage->cm_anon_type == MES_ANONONLY)
1166            && (mode == MT_CITADEL)
1167            && (do_proto)
1168            ) {
1169                 cprintf("nhdr=yes\n");
1170         }
1171
1172         /* begin header processing loop for Citadel message format */
1173
1174         if ((mode == MT_CITADEL) || (mode == MT_MIME)) {
1175
1176                 strcpy(display_name, "<unknown>");
1177                 if (TheMessage->cm_fields['A']) {
1178                         strcpy(buf, TheMessage->cm_fields['A']);
1179                         PerformUserHooks(buf, (-1L), EVT_OUTPUTMSG);
1180                         if (TheMessage->cm_anon_type == MES_ANONONLY) {
1181                                 strcpy(display_name, "****");
1182                         }
1183                         else if (TheMessage->cm_anon_type == MES_ANONOPT) {
1184                                 strcpy(display_name, "anonymous");
1185                         }
1186                         else {
1187                                 strcpy(display_name, buf);
1188                         }
1189                         if ((is_room_aide())
1190                             && ((TheMessage->cm_anon_type == MES_ANONONLY)
1191                              || (TheMessage->cm_anon_type == MES_ANONOPT))) {
1192                                 size_t tmp = strlen(display_name);
1193                                 snprintf(&display_name[tmp],
1194                                          sizeof display_name - tmp,
1195                                          " [%s]", buf);
1196                         }
1197                 }
1198
1199                 /* Don't show Internet address for users on the
1200                  * local Citadel network.
1201                  */
1202                 suppress_f = 0;
1203                 if (TheMessage->cm_fields['N'] != NULL)
1204                    if (strlen(TheMessage->cm_fields['N']) > 0)
1205                       if (haschar(TheMessage->cm_fields['N'], '.') == 0) {
1206                         suppress_f = 1;
1207                 }
1208
1209                 /* Now spew the header fields in the order we like them. */
1210                 strcpy(allkeys, FORDER);
1211                 for (i=0; i<strlen(allkeys); ++i) {
1212                         k = (int) allkeys[i];
1213                         if (k != 'M') {
1214                                 if ( (TheMessage->cm_fields[k] != NULL)
1215                                    && (msgkeys[k] != NULL) ) {
1216                                         if (k == 'A') {
1217                                                 if (do_proto) cprintf("%s=%s\n",
1218                                                         msgkeys[k],
1219                                                         display_name);
1220                                         }
1221                                         else if ((k == 'F') && (suppress_f)) {
1222                                                 /* do nothing */
1223                                         }
1224                                         /* Masquerade display name if needed */
1225                                         else {
1226                                                 if (do_proto) cprintf("%s=%s\n",
1227                                                         msgkeys[k],
1228                                                         TheMessage->cm_fields[k]
1229                                         );
1230                                         }
1231                                 }
1232                         }
1233                 }
1234
1235         }
1236
1237         /* begin header processing loop for RFC822 transfer format */
1238
1239         strcpy(suser, "");
1240         strcpy(luser, "");
1241         strcpy(fuser, "");
1242         strcpy(snode, NODENAME);
1243         strcpy(lnode, HUMANNODE);
1244         if (mode == MT_RFC822) {
1245                 cprintf("X-UIDL: %ld%s", msg_num, nl);
1246                 for (i = 0; i < 256; ++i) {
1247                         if (TheMessage->cm_fields[i]) {
1248                                 mptr = TheMessage->cm_fields[i];
1249
1250                                 if (i == 'A') {
1251                                         strcpy(luser, mptr);
1252                                         strcpy(suser, mptr);
1253                                 }
1254 /****
1255  "Path:" removed for now because it confuses brain-dead Microsoft shitware
1256  into thinking that mail messages are newsgroup messages instead.  When we
1257  add NNTP support back into Citadel we'll have to add code to only output
1258  this field when appropriate.
1259                                 else if (i == 'P') {
1260                                         cprintf("Path: %s%s", mptr, nl);
1261                                 }
1262  ****/
1263                                 else if (i == 'U') {
1264                                         cprintf("Subject: %s%s", mptr, nl);
1265                                         subject_found = 1;
1266                                 }
1267                                 else if (i == 'I')
1268                                         safestrncpy(mid, mptr, sizeof mid);
1269                                 else if (i == 'H')
1270                                         safestrncpy(lnode, mptr, sizeof lnode);
1271                                 else if (i == 'F')
1272                                         safestrncpy(fuser, mptr, sizeof fuser);
1273                                 else if (i == 'O')
1274                                         cprintf("X-Citadel-Room: %s%s",
1275                                                 mptr, nl);
1276                                 else if (i == 'N')
1277                                         safestrncpy(snode, mptr, sizeof snode);
1278                                 else if (i == 'R')
1279                                         cprintf("To: %s%s", mptr, nl);
1280                                 else if (i == 'T') {
1281                                         datestring(datestamp, sizeof datestamp,
1282                                                 atol(mptr), DATESTRING_RFC822);
1283                                         cprintf("Date: %s%s", datestamp, nl);
1284                                 }
1285                         }
1286                 }
1287                 if (subject_found == 0) {
1288                         cprintf("Subject: (no subject)%s", nl);
1289                 }
1290         }
1291
1292         for (i=0; i<strlen(suser); ++i) {
1293                 suser[i] = tolower(suser[i]);
1294                 if (!isalnum(suser[i])) suser[i]='_';
1295         }
1296
1297         if (mode == MT_RFC822) {
1298                 if (!strcasecmp(snode, NODENAME)) {
1299                         strcpy(snode, FQDN);
1300                 }
1301
1302                 /* Construct a fun message id */
1303                 cprintf("Message-ID: <%s", mid);
1304                 if (strchr(mid, '@')==NULL) {
1305                         cprintf("@%s", snode);
1306                 }
1307                 cprintf(">%s", nl);
1308
1309                 PerformUserHooks(luser, (-1L), EVT_OUTPUTMSG);
1310
1311                 if (strlen(fuser) > 0) {
1312                         cprintf("From: %s (%s)%s", fuser, luser, nl);
1313                 }
1314                 else {
1315                         cprintf("From: %s@%s (%s)%s", suser, snode, luser, nl);
1316                 }
1317
1318                 cprintf("Organization: %s%s", lnode, nl);
1319
1320                 /* Blank line signifying RFC822 end-of-headers */
1321                 if (TheMessage->cm_format_type != FMT_RFC822) {
1322                         cprintf("%s", nl);
1323                 }
1324         }
1325
1326         /* end header processing loop ... at this point, we're in the text */
1327 START_TEXT:
1328         mptr = TheMessage->cm_fields['M'];
1329
1330         /* Tell the client about the MIME parts in this message */
1331         if (TheMessage->cm_format_type == FMT_RFC822) {
1332                 if ( (mode == MT_CITADEL) || (mode == MT_MIME) ) {
1333                         mime_parser(mptr, NULL,
1334                                 *list_this_part,
1335                                 *list_this_pref,
1336                                 *list_this_suff,
1337                                 NULL, 0);
1338                 }
1339                 else if (mode == MT_RFC822) {   /* unparsed RFC822 dump */
1340                         /* FIXME ... we have to put some code in here to avoid
1341                          * printing duplicate header information when both
1342                          * Citadel and RFC822 headers exist.  Preference should
1343                          * probably be given to the RFC822 headers.
1344                          */
1345                         int done_rfc822_hdrs = 0;
1346                         while (ch=*(mptr++), ch!=0) {
1347                                 if (ch==13) {
1348                                         /* do nothing */
1349                                 }
1350                                 else if (ch==10) {
1351                                         if (!done_rfc822_hdrs) {
1352                                                 if (headers_only != HEADERS_NONE) {
1353                                                         cprintf("%s", nl);
1354                                                 }
1355                                         }
1356                                         else {
1357                                                 if (headers_only != HEADERS_ONLY) {
1358                                                         cprintf("%s", nl);
1359                                                 }
1360                                         }
1361                                         if ((*(mptr) == 13) || (*(mptr) == 10)) {
1362                                                 done_rfc822_hdrs = 1;
1363                                         }
1364                                 }
1365                                 else {
1366                                         if (done_rfc822_hdrs) {
1367                                                 if (headers_only != HEADERS_NONE) {
1368                                                         cprintf("%c", ch);
1369                                                 }
1370                                         }
1371                                         else {
1372                                                 if (headers_only != HEADERS_ONLY) {
1373                                                         cprintf("%c", ch);
1374                                                 }
1375                                         }
1376                                         if ((*mptr == 13) || (*mptr == 10)) {
1377                                                 done_rfc822_hdrs = 1;
1378                                         }
1379                                 }
1380                         }
1381                         goto DONE;
1382                 }
1383         }
1384
1385         if (headers_only == HEADERS_ONLY) {
1386                 goto DONE;
1387         }
1388
1389         /* signify start of msg text */
1390         if ( (mode == MT_CITADEL) || (mode == MT_MIME) ) {
1391                 if (do_proto) cprintf("text\n");
1392         }
1393
1394         /* If the format type on disk is 1 (fixed-format), then we want
1395          * everything to be output completely literally ... regardless of
1396          * what message transfer format is in use.
1397          */
1398         if (TheMessage->cm_format_type == FMT_FIXED) {
1399                 if (mode == MT_MIME) {
1400                         cprintf("Content-type: text/plain\n\n");
1401                 }
1402                 strcpy(buf, "");
1403                 while (ch = *mptr++, ch > 0) {
1404                         if (ch == 13)
1405                                 ch = 10;
1406                         if ((ch == 10) || (strlen(buf) > 250)) {
1407                                 cprintf("%s%s", buf, nl);
1408                                 strcpy(buf, "");
1409                         } else {
1410                                 buf[strlen(buf) + 1] = 0;
1411                                 buf[strlen(buf)] = ch;
1412                         }
1413                 }
1414                 if (strlen(buf) > 0)
1415                         cprintf("%s%s", buf, nl);
1416         }
1417
1418         /* If the message on disk is format 0 (Citadel vari-format), we
1419          * output using the formatter at 80 columns.  This is the final output
1420          * form if the transfer format is RFC822, but if the transfer format
1421          * is Citadel proprietary, it'll still work, because the indentation
1422          * for new paragraphs is correct and the client will reformat the
1423          * message to the reader's screen width.
1424          */
1425         if (TheMessage->cm_format_type == FMT_CITADEL) {
1426                 if (mode == MT_MIME) {
1427                         cprintf("Content-type: text/x-citadel-variformat\n\n");
1428                 }
1429                 memfmout(80, mptr, 0, nl);
1430         }
1431
1432         /* If the message on disk is format 4 (MIME), we've gotta hand it
1433          * off to the MIME parser.  The client has already been told that
1434          * this message is format 1 (fixed format), so the callback function
1435          * we use will display those parts as-is.
1436          */
1437         if (TheMessage->cm_format_type == FMT_RFC822) {
1438                 CtdlAllocUserData(SYM_MA_INFO, sizeof(struct ma_info));
1439                 memset(ma, 0, sizeof(struct ma_info));
1440
1441                 if (mode == MT_MIME) {
1442                         strcpy(ma->chosen_part, "1");
1443                         mime_parser(mptr, NULL,
1444                                 *choose_preferred, *fixed_output_pre,
1445                                 *fixed_output_post, NULL, 0);
1446                         mime_parser(mptr, NULL,
1447                                 *output_preferred, NULL, NULL, NULL, 0);
1448                 }
1449                 else {
1450                         mime_parser(mptr, NULL,
1451                                 *fixed_output, *fixed_output_pre,
1452                                 *fixed_output_post, NULL, 0);
1453                 }
1454         }
1455
1456 DONE:   /* now we're done */
1457         if (do_proto) cprintf("000\n");
1458         return(om_ok);
1459 }
1460
1461
1462
1463 /*
1464  * display a message (mode 0 - Citadel proprietary)
1465  */
1466 void cmd_msg0(char *cmdbuf)
1467 {
1468         long msgid;
1469         int headers_only = HEADERS_ALL;
1470
1471         msgid = extract_long(cmdbuf, 0);
1472         headers_only = extract_int(cmdbuf, 1);
1473
1474         CtdlOutputMsg(msgid, MT_CITADEL, headers_only, 1, 0);
1475         return;
1476 }
1477
1478
1479 /*
1480  * display a message (mode 2 - RFC822)
1481  */
1482 void cmd_msg2(char *cmdbuf)
1483 {
1484         long msgid;
1485         int headers_only = HEADERS_ALL;
1486
1487         msgid = extract_long(cmdbuf, 0);
1488         headers_only = extract_int(cmdbuf, 1);
1489
1490         CtdlOutputMsg(msgid, MT_RFC822, headers_only, 1, 1);
1491 }
1492
1493
1494
1495 /*
1496  * display a message (mode 3 - IGnet raw format - internal programs only)
1497  */
1498 void cmd_msg3(char *cmdbuf)
1499 {
1500         long msgnum;
1501         struct CtdlMessage *msg;
1502         struct ser_ret smr;
1503
1504         if (CC->internal_pgm == 0) {
1505                 cprintf("%d This command is for internal programs only.\n",
1506                         ERROR);
1507                 return;
1508         }
1509
1510         msgnum = extract_long(cmdbuf, 0);
1511         msg = CtdlFetchMessage(msgnum);
1512         if (msg == NULL) {
1513                 cprintf("%d Message %ld not found.\n",
1514                         ERROR, msgnum);
1515                 return;
1516         }
1517
1518         serialize_message(&smr, msg);
1519         CtdlFreeMessage(msg);
1520
1521         if (smr.len == 0) {
1522                 cprintf("%d Unable to serialize message\n",
1523                         ERROR+INTERNAL_ERROR);
1524                 return;
1525         }
1526
1527         cprintf("%d %ld\n", BINARY_FOLLOWS, (long)smr.len);
1528         client_write(smr.ser, smr.len);
1529         phree(smr.ser);
1530 }
1531
1532
1533
1534 /*
1535  * Display a message using MIME content types
1536  */
1537 void cmd_msg4(char *cmdbuf)
1538 {
1539         long msgid;
1540
1541         msgid = extract_long(cmdbuf, 0);
1542         CtdlOutputMsg(msgid, MT_MIME, 0, 1, 0);
1543 }
1544
1545
1546
1547 /*
1548  * Client tells us its preferred message format(s)
1549  */
1550 void cmd_msgp(char *cmdbuf)
1551 {
1552         safestrncpy(CC->preferred_formats, cmdbuf,
1553                         sizeof(CC->preferred_formats));
1554         cprintf("%d ok\n", CIT_OK);
1555 }
1556
1557
1558 /*
1559  * Open a component of a MIME message as a download file
1560  */
1561 void cmd_opna(char *cmdbuf)
1562 {
1563         long msgid;
1564
1565         CtdlAllocUserData(SYM_DESIRED_SECTION, SIZ);
1566
1567         msgid = extract_long(cmdbuf, 0);
1568         extract(desired_section, cmdbuf, 1);
1569
1570         CtdlOutputMsg(msgid, MT_DOWNLOAD, 0, 1, 1);
1571 }
1572
1573
1574 /*
1575  * Save a message pointer into a specified room
1576  * (Returns 0 for success, nonzero for failure)
1577  * roomname may be NULL to use the current room
1578  */
1579 int CtdlSaveMsgPointerInRoom(char *roomname, long msgid, int flags) {
1580         int i;
1581         char hold_rm[ROOMNAMELEN];
1582         struct cdbdata *cdbfr;
1583         int num_msgs;
1584         long *msglist;
1585         long highest_msg = 0L;
1586         struct CtdlMessage *msg = NULL;
1587
1588         lprintf(9, "CtdlSaveMsgPointerInRoom(%s, %ld, %d)\n",
1589                 roomname, msgid, flags);
1590
1591         strcpy(hold_rm, CC->quickroom.QRname);
1592
1593         /* We may need to check to see if this message is real */
1594         if (  (flags & SM_VERIFY_GOODNESS)
1595            || (flags & SM_DO_REPL_CHECK)
1596            ) {
1597                 msg = CtdlFetchMessage(msgid);
1598                 if (msg == NULL) return(ERROR + ILLEGAL_VALUE);
1599         }
1600
1601         /* Perform replication checks if necessary */
1602         if ( (flags & SM_DO_REPL_CHECK) && (msg != NULL) ) {
1603
1604                 if (getroom(&CC->quickroom,
1605                    ((roomname != NULL) ? roomname : CC->quickroom.QRname) )
1606                    != 0) {
1607                         lprintf(9, "No such room <%s>\n", roomname);
1608                         if (msg != NULL) CtdlFreeMessage(msg);
1609                         return(ERROR + ROOM_NOT_FOUND);
1610                 }
1611
1612                 if (ReplicationChecks(msg) != 0) {
1613                         getroom(&CC->quickroom, hold_rm);
1614                         if (msg != NULL) CtdlFreeMessage(msg);
1615                         lprintf(9, "Did replication, and newer exists\n");
1616                         return(0);
1617                 }
1618         }
1619
1620         /* Now the regular stuff */
1621         if (lgetroom(&CC->quickroom,
1622            ((roomname != NULL) ? roomname : CC->quickroom.QRname) )
1623            != 0) {
1624                 lprintf(9, "No such room <%s>\n", roomname);
1625                 if (msg != NULL) CtdlFreeMessage(msg);
1626                 return(ERROR + ROOM_NOT_FOUND);
1627         }
1628
1629         cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->quickroom.QRnumber, sizeof(long));
1630         if (cdbfr == NULL) {
1631                 msglist = NULL;
1632                 num_msgs = 0;
1633         } else {
1634                 msglist = mallok(cdbfr->len);
1635                 if (msglist == NULL)
1636                         lprintf(3, "ERROR malloc msglist!\n");
1637                 num_msgs = cdbfr->len / sizeof(long);
1638                 memcpy(msglist, cdbfr->ptr, cdbfr->len);
1639                 cdb_free(cdbfr);
1640         }
1641
1642
1643         /* Make sure the message doesn't already exist in this room.  It
1644          * is absolutely taboo to have more than one reference to the same
1645          * message in a room.
1646          */
1647         if (num_msgs > 0) for (i=0; i<num_msgs; ++i) {
1648                 if (msglist[i] == msgid) {
1649                         lputroom(&CC->quickroom);       /* unlock the room */
1650                         getroom(&CC->quickroom, hold_rm);
1651                         if (msg != NULL) CtdlFreeMessage(msg);
1652                         return(ERROR + ALREADY_EXISTS);
1653                 }
1654         }
1655
1656         /* Now add the new message */
1657         ++num_msgs;
1658         msglist = reallok(msglist,
1659                           (num_msgs * sizeof(long)));
1660
1661         if (msglist == NULL) {
1662                 lprintf(3, "ERROR: can't realloc message list!\n");
1663         }
1664         msglist[num_msgs - 1] = msgid;
1665
1666         /* Sort the message list, so all the msgid's are in order */
1667         num_msgs = sort_msglist(msglist, num_msgs);
1668
1669         /* Determine the highest message number */
1670         highest_msg = msglist[num_msgs - 1];
1671
1672         /* Write it back to disk. */
1673         cdb_store(CDB_MSGLISTS, &CC->quickroom.QRnumber, sizeof(long),
1674                   msglist, num_msgs * sizeof(long));
1675
1676         /* Free up the memory we used. */
1677         phree(msglist);
1678
1679         /* Update the highest-message pointer and unlock the room. */
1680         CC->quickroom.QRhighest = highest_msg;
1681         lputroom(&CC->quickroom);
1682         getroom(&CC->quickroom, hold_rm);
1683
1684         /* Bump the reference count for this message. */
1685         if ((flags & SM_DONT_BUMP_REF)==0) {
1686                 AdjRefCount(msgid, +1);
1687         }
1688
1689         /* Return success. */
1690         if (msg != NULL) CtdlFreeMessage(msg);
1691         return (0);
1692 }
1693
1694
1695
1696 /*
1697  * Message base operation to send a message to the master file
1698  * (returns new message number)
1699  *
1700  * This is the back end for CtdlSubmitMsg() and should not be directly
1701  * called by server-side modules.
1702  *
1703  */
1704 long send_message(struct CtdlMessage *msg,      /* pointer to buffer */
1705                 FILE *save_a_copy)              /* save a copy to disk? */
1706 {
1707         long newmsgid;
1708         long retval;
1709         char msgidbuf[SIZ];
1710         struct ser_ret smr;
1711
1712         /* Get a new message number */
1713         newmsgid = get_new_message_number();
1714         snprintf(msgidbuf, sizeof msgidbuf, "%ld@%s", newmsgid, config.c_fqdn);
1715
1716         /* Generate an ID if we don't have one already */
1717         if (msg->cm_fields['I']==NULL) {
1718                 msg->cm_fields['I'] = strdoop(msgidbuf);
1719         }
1720
1721         serialize_message(&smr, msg);
1722
1723         if (smr.len == 0) {
1724                 cprintf("%d Unable to serialize message\n",
1725                         ERROR+INTERNAL_ERROR);
1726                 return (-1L);
1727         }
1728
1729         /* Write our little bundle of joy into the message base */
1730         if (cdb_store(CDB_MSGMAIN, &newmsgid, sizeof(long),
1731                       smr.ser, smr.len) < 0) {
1732                 lprintf(2, "Can't store message\n");
1733                 retval = 0L;
1734         } else {
1735                 retval = newmsgid;
1736         }
1737
1738         /* If the caller specified that a copy should be saved to a particular
1739          * file handle, do that now too.
1740          */
1741         if (save_a_copy != NULL) {
1742                 fwrite(smr.ser, smr.len, 1, save_a_copy);
1743         }
1744
1745         /* Free the memory we used for the serialized message */
1746         phree(smr.ser);
1747
1748         /* Return the *local* message ID to the caller
1749          * (even if we're storing an incoming network message)
1750          */
1751         return(retval);
1752 }
1753
1754
1755
1756 /*
1757  * Serialize a struct CtdlMessage into the format used on disk and network.
1758  *
1759  * This function loads up a "struct ser_ret" (defined in server.h) which
1760  * contains the length of the serialized message and a pointer to the
1761  * serialized message in memory.  THE LATTER MUST BE FREED BY THE CALLER.
1762  */
1763 void serialize_message(struct ser_ret *ret,             /* return values */
1764                         struct CtdlMessage *msg)        /* unserialized msg */
1765 {
1766         size_t wlen;
1767         int i;
1768         static char *forder = FORDER;
1769
1770         if (is_valid_message(msg) == 0) return;         /* self check */
1771
1772         ret->len = 3;
1773         for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL)
1774                 ret->len = ret->len +
1775                         strlen(msg->cm_fields[(int)forder[i]]) + 2;
1776
1777         lprintf(9, "serialize_message() calling malloc(%ld)\n", (long)ret->len);
1778         ret->ser = mallok(ret->len);
1779         if (ret->ser == NULL) {
1780                 ret->len = 0;
1781                 return;
1782         }
1783
1784         ret->ser[0] = 0xFF;
1785         ret->ser[1] = msg->cm_anon_type;
1786         ret->ser[2] = msg->cm_format_type;
1787         wlen = 3;
1788
1789         for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL) {
1790                 ret->ser[wlen++] = (char)forder[i];
1791                 strcpy(&ret->ser[wlen], msg->cm_fields[(int)forder[i]]);
1792                 wlen = wlen + strlen(msg->cm_fields[(int)forder[i]]) + 1;
1793         }
1794         if (ret->len != wlen) lprintf(3, "ERROR: len=%ld wlen=%ld\n",
1795                 (long)ret->len, (long)wlen);
1796
1797         return;
1798 }
1799
1800
1801
1802 /*
1803  * Back end for the ReplicationChecks() function
1804  */
1805 void check_repl(long msgnum, void *userdata) {
1806         struct CtdlMessage *msg;
1807         time_t timestamp = (-1L);
1808
1809         lprintf(9, "check_repl() found message %ld\n", msgnum);
1810         msg = CtdlFetchMessage(msgnum);
1811         if (msg == NULL) return;
1812         if (msg->cm_fields['T'] != NULL) {
1813                 timestamp = atol(msg->cm_fields['T']);
1814         }
1815         CtdlFreeMessage(msg);
1816
1817         if (timestamp > msg_repl->highest) {
1818                 msg_repl->highest = timestamp;  /* newer! */
1819                 lprintf(9, "newer!\n");
1820                 return;
1821         }
1822         lprintf(9, "older!\n");
1823
1824         /* Existing isn't newer?  Then delete the old one(s). */
1825         CtdlDeleteMessages(CC->quickroom.QRname, msgnum, "");
1826 }
1827
1828
1829 /*
1830  * Check to see if any messages already exist which carry the same Extended ID
1831  * as this one.
1832  *
1833  * If any are found:
1834  * -> With older timestamps: delete them and return 0.  Message will be saved.
1835  * -> With newer timestamps: return 1.  Message save will be aborted.
1836  */
1837 int ReplicationChecks(struct CtdlMessage *msg) {
1838         struct CtdlMessage *template;
1839         int abort_this = 0;
1840
1841         lprintf(9, "ReplicationChecks() started\n");
1842         /* No extended id?  Don't do anything. */
1843         if (msg->cm_fields['E'] == NULL) return 0;
1844         if (strlen(msg->cm_fields['E']) == 0) return 0;
1845         lprintf(9, "Extended ID: <%s>\n", msg->cm_fields['E']);
1846
1847         CtdlAllocUserData(SYM_REPL, sizeof(struct repl));
1848         strcpy(msg_repl->extended_id, msg->cm_fields['E']);
1849         msg_repl->highest = atol(msg->cm_fields['T']);
1850
1851         template = (struct CtdlMessage *) malloc(sizeof(struct CtdlMessage));
1852         memset(template, 0, sizeof(struct CtdlMessage));
1853         template->cm_fields['E'] = strdoop(msg->cm_fields['E']);
1854
1855         CtdlForEachMessage(MSGS_ALL, 0L, NULL, template, check_repl, NULL);
1856
1857         /* If a newer message exists with the same Extended ID, abort
1858          * this save.
1859          */
1860         if (msg_repl->highest > atol(msg->cm_fields['T']) ) {
1861                 abort_this = 1;
1862                 }
1863
1864         CtdlFreeMessage(template);
1865         lprintf(9, "ReplicationChecks() returning %d\n", abort_this);
1866         return(abort_this);
1867 }
1868
1869
1870
1871
1872 /*
1873  * Save a message to disk and submit it into the delivery system.
1874  */
1875 long CtdlSubmitMsg(struct CtdlMessage *msg,     /* message to save */
1876                 struct recptypes *recps,        /* recipients (if mail) */
1877                 char *force                     /* force a particular room? */
1878 ) {
1879         char aaa[SIZ];
1880         char hold_rm[ROOMNAMELEN];
1881         char actual_rm[ROOMNAMELEN];
1882         char force_room[ROOMNAMELEN];
1883         char content_type[SIZ];                 /* We have to learn this */
1884         char recipient[SIZ];
1885         long newmsgid;
1886         char *mptr = NULL;
1887         struct usersupp userbuf;
1888         int a, i;
1889         struct MetaData smi;
1890         FILE *network_fp = NULL;
1891         static int seqnum = 1;
1892         struct CtdlMessage *imsg = NULL;
1893         char *instr;
1894         struct ser_ret smr;
1895         char *hold_R, *hold_D;
1896
1897         lprintf(9, "CtdlSubmitMsg() called\n");
1898         if (is_valid_message(msg) == 0) return(-1);     /* self check */
1899
1900         /* If this message has no timestamp, we take the liberty of
1901          * giving it one, right now.
1902          */
1903         if (msg->cm_fields['T'] == NULL) {
1904                 lprintf(9, "Generating timestamp\n");
1905                 snprintf(aaa, sizeof aaa, "%ld", (long)time(NULL));
1906                 msg->cm_fields['T'] = strdoop(aaa);
1907         }
1908
1909         /* If this message has no path, we generate one.
1910          */
1911         if (msg->cm_fields['P'] == NULL) {
1912                 lprintf(9, "Generating path\n");
1913                 if (msg->cm_fields['A'] != NULL) {
1914                         msg->cm_fields['P'] = strdoop(msg->cm_fields['A']);
1915                         for (a=0; a<strlen(msg->cm_fields['P']); ++a) {
1916                                 if (isspace(msg->cm_fields['P'][a])) {
1917                                         msg->cm_fields['P'][a] = ' ';
1918                                 }
1919                         }
1920                 }
1921                 else {
1922                         msg->cm_fields['P'] = strdoop("unknown");
1923                 }
1924         }
1925
1926         if (force == NULL) {
1927                 strcpy(force_room, "");
1928         }
1929         else {
1930                 strcpy(force_room, force);
1931         }
1932
1933         /* Learn about what's inside, because it's what's inside that counts */
1934         lprintf(9, "Learning what's inside\n");
1935         if (msg->cm_fields['M'] == NULL) {
1936                 lprintf(1, "ERROR: attempt to save message with NULL body\n");
1937         }
1938
1939         switch (msg->cm_format_type) {
1940         case 0:
1941                 strcpy(content_type, "text/x-citadel-variformat");
1942                 break;
1943         case 1:
1944                 strcpy(content_type, "text/plain");
1945                 break;
1946         case 4:
1947                 strcpy(content_type, "text/plain");
1948                 /* advance past header fields */
1949                 mptr = msg->cm_fields['M'];
1950                 a = strlen(mptr);
1951                 while ((--a) > 0) {
1952                         if (!strncasecmp(mptr, "Content-type: ", 14)) {
1953                                 safestrncpy(content_type, mptr,
1954                                             sizeof(content_type));
1955                                 strcpy(content_type, &content_type[14]);
1956                                 for (a = 0; a < strlen(content_type); ++a)
1957                                         if ((content_type[a] == ';')
1958                                             || (content_type[a] == ' ')
1959                                             || (content_type[a] == 13)
1960                                             || (content_type[a] == 10))
1961                                                 content_type[a] = 0;
1962                                 break;
1963                         }
1964                         ++mptr;
1965                 }
1966         }
1967
1968         /* Goto the correct room */
1969         lprintf(9, "Switching rooms\n");
1970         strcpy(hold_rm, CC->quickroom.QRname);
1971         strcpy(actual_rm, CC->quickroom.QRname);
1972         if (recps != NULL) {
1973                 strcpy(actual_rm, SENTITEMS);
1974         }
1975
1976         /* If the user is a twit, move to the twit room for posting */
1977         lprintf(9, "Handling twit stuff\n");
1978         if (TWITDETECT) {
1979                 if (CC->usersupp.axlevel == 2) {
1980                         strcpy(hold_rm, actual_rm);
1981                         strcpy(actual_rm, config.c_twitroom);
1982                 }
1983         }
1984
1985         /* ...or if this message is destined for Aide> then go there. */
1986         if (strlen(force_room) > 0) {
1987                 strcpy(actual_rm, force_room);
1988         }
1989
1990         lprintf(9, "Possibly relocating\n");
1991         if (strcasecmp(actual_rm, CC->quickroom.QRname)) {
1992                 getroom(&CC->quickroom, actual_rm);
1993         }
1994
1995         /*
1996          * If this message has no O (room) field, generate one.
1997          */
1998         if (msg->cm_fields['O'] == NULL) {
1999                 msg->cm_fields['O'] = strdoop(CC->quickroom.QRname);
2000         }
2001
2002         /* Perform "before save" hooks (aborting if any return nonzero) */
2003         lprintf(9, "Performing before-save hooks\n");
2004         if (PerformMessageHooks(msg, EVT_BEFORESAVE) > 0) return(-1);
2005
2006         /* If this message has an Extended ID, perform replication checks */
2007         lprintf(9, "Performing replication checks\n");
2008         if (ReplicationChecks(msg) > 0) return(-1);
2009
2010         /* Save it to disk */
2011         lprintf(9, "Saving to disk\n");
2012         newmsgid = send_message(msg, NULL);
2013         if (newmsgid <= 0L) return(-1);
2014
2015         /* Write a supplemental message info record.  This doesn't have to
2016          * be a critical section because nobody else knows about this message
2017          * yet.
2018          */
2019         lprintf(9, "Creating MetaData record\n");
2020         memset(&smi, 0, sizeof(struct MetaData));
2021         smi.meta_msgnum = newmsgid;
2022         smi.meta_refcount = 0;
2023         safestrncpy(smi.meta_content_type, content_type, 64);
2024         PutMetaData(&smi);
2025
2026         /* Now figure out where to store the pointers */
2027         lprintf(9, "Storing pointers\n");
2028
2029         /* If this is being done by the networker delivering a private
2030          * message, we want to BYPASS saving the sender's copy (because there
2031          * is no local sender; it would otherwise go to the Trashcan).
2032          */
2033         if ((!CC->internal_pgm) || (recps == NULL)) {
2034                 if (CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0) != 0) {
2035                         lprintf(3, "ERROR saving message pointer!\n");
2036                         CtdlSaveMsgPointerInRoom(config.c_aideroom, newmsgid, 0);
2037                 }
2038         }
2039
2040         /* For internet mail, drop a copy in the outbound queue room */
2041         if (recps != NULL)
2042          if (recps->num_internet > 0) {
2043                 CtdlSaveMsgPointerInRoom(SMTP_SPOOLOUT_ROOM, newmsgid, 0);
2044         }
2045
2046         /* If other rooms are specified, drop them there too. */
2047         if (recps != NULL)
2048          if (recps->num_room > 0)
2049           for (i=0; i<num_tokens(recps->recp_room, '|'); ++i) {
2050                 extract(recipient, recps->recp_room, i);
2051                 lprintf(9, "Delivering to local room <%s>\n", recipient);
2052                 CtdlSaveMsgPointerInRoom(recipient, newmsgid, 0);
2053         }
2054
2055         /* Bump this user's messages posted counter. */
2056         lprintf(9, "Updating user\n");
2057         lgetuser(&CC->usersupp, CC->curr_user);
2058         CC->usersupp.posted = CC->usersupp.posted + 1;
2059         lputuser(&CC->usersupp);
2060
2061         /* If this is private, local mail, make a copy in the
2062          * recipient's mailbox and bump the reference count.
2063          */
2064         if (recps != NULL)
2065          if (recps->num_local > 0)
2066           for (i=0; i<num_tokens(recps->recp_local, '|'); ++i) {
2067                 extract(recipient, recps->recp_local, i);
2068                 lprintf(9, "Delivering private local mail to <%s>\n",
2069                         recipient);
2070                 if (getuser(&userbuf, recipient) == 0) {
2071                         MailboxName(actual_rm, sizeof actual_rm, &userbuf, MAILROOM);
2072                         CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0);
2073                         BumpNewMailCounter(userbuf.usernum);
2074                 }
2075                 else {
2076                         lprintf(9, "No user <%s>\n", recipient);
2077                         CtdlSaveMsgPointerInRoom(config.c_aideroom, newmsgid, 0);
2078                 }
2079         }
2080
2081         /* Perform "after save" hooks */
2082         lprintf(9, "Performing after-save hooks\n");
2083         PerformMessageHooks(msg, EVT_AFTERSAVE);
2084
2085         /* For IGnet mail, we have to save a new copy into the spooler for
2086          * each recipient, with the R and D fields set to the recipient and
2087          * destination-node.  This has two ugly side effects: all other
2088          * recipients end up being unlisted in this recipient's copy of the
2089          * message, and it has to deliver multiple messages to the same
2090          * node.  We'll revisit this again in a year or so when everyone has
2091          * a network spool receiver that can handle the new style messages.
2092          */
2093         if (recps != NULL)
2094          if (recps->num_ignet > 0)
2095           for (i=0; i<num_tokens(recps->recp_ignet, '|'); ++i) {
2096                 extract(recipient, recps->recp_ignet, i);
2097
2098                 hold_R = msg->cm_fields['R'];
2099                 hold_D = msg->cm_fields['D'];
2100                 msg->cm_fields['R'] = mallok(SIZ);
2101                 msg->cm_fields['D'] = mallok(SIZ);
2102                 extract_token(msg->cm_fields['R'], recipient, 0, '@');
2103                 extract_token(msg->cm_fields['D'], recipient, 1, '@');
2104
2105                 serialize_message(&smr, msg);
2106                 if (smr.len > 0) {
2107                         snprintf(aaa, sizeof aaa,
2108                                 "./network/spoolin/netmail.%04lx.%04x.%04x",
2109                                 (long) getpid(), CC->cs_pid, ++seqnum);
2110                         network_fp = fopen(aaa, "wb+");
2111                         if (network_fp != NULL) {
2112                                 fwrite(smr.ser, smr.len, 1, network_fp);
2113                                 fclose(network_fp);
2114                         }
2115                         phree(smr.ser);
2116                 }
2117
2118                 phree(msg->cm_fields['R']);
2119                 phree(msg->cm_fields['D']);
2120                 msg->cm_fields['R'] = hold_R;
2121                 msg->cm_fields['D'] = hold_D;
2122         }
2123
2124         /* Go back to the room we started from */
2125         lprintf(9, "Returning to original room\n");
2126         if (strcasecmp(hold_rm, CC->quickroom.QRname))
2127                 getroom(&CC->quickroom, hold_rm);
2128
2129         /* For internet mail, generate delivery instructions.
2130          * Yes, this is recursive.  Deal with it.  Infinite recursion does
2131          * not happen because the delivery instructions message does not
2132          * contain a recipient.
2133          */
2134         if (recps != NULL)
2135          if (recps->num_internet > 0) {
2136                 lprintf(9, "Generating delivery instructions\n");
2137                 instr = mallok(SIZ * 2);
2138                 snprintf(instr, SIZ * 2,
2139                         "Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
2140                         "bounceto|%s@%s\n",
2141                         SPOOLMIME, newmsgid, (long)time(NULL),
2142                         msg->cm_fields['A'], msg->cm_fields['N']
2143                 );
2144
2145                 for (i=0; i<num_tokens(recps->recp_internet, '|'); ++i) {
2146                         size_t tmp = strlen(instr);
2147                         extract(recipient, recps->recp_internet, i);
2148                         snprintf(&instr[tmp], SIZ * 2 - tmp,
2149                                  "remote|%s|0||\n", recipient);
2150                 }
2151
2152                 imsg = mallok(sizeof(struct CtdlMessage));
2153                 memset(imsg, 0, sizeof(struct CtdlMessage));
2154                 imsg->cm_magic = CTDLMESSAGE_MAGIC;
2155                 imsg->cm_anon_type = MES_NORMAL;
2156                 imsg->cm_format_type = FMT_RFC822;
2157                 imsg->cm_fields['A'] = strdoop("Citadel");
2158                 imsg->cm_fields['M'] = instr;
2159                 CtdlSubmitMsg(imsg, NULL, SMTP_SPOOLOUT_ROOM);
2160                 CtdlFreeMessage(imsg);
2161         }
2162
2163         return(newmsgid);
2164 }
2165
2166
2167
2168 /*
2169  * Convenience function for generating small administrative messages.
2170  */
2171 void quickie_message(char *from, char *to, char *room, char *text,
2172                         int format_type, char *subject)
2173 {
2174         struct CtdlMessage *msg;
2175         struct recptypes *recp = NULL;
2176
2177         msg = mallok(sizeof(struct CtdlMessage));
2178         memset(msg, 0, sizeof(struct CtdlMessage));
2179         msg->cm_magic = CTDLMESSAGE_MAGIC;
2180         msg->cm_anon_type = MES_NORMAL;
2181         msg->cm_format_type = format_type;
2182         msg->cm_fields['A'] = strdoop(from);
2183         if (room != NULL) msg->cm_fields['O'] = strdoop(room);
2184         msg->cm_fields['N'] = strdoop(NODENAME);
2185         if (to != NULL) {
2186                 msg->cm_fields['R'] = strdoop(to);
2187                 recp = validate_recipients(to);
2188         }
2189         if (subject != NULL) {
2190                 msg->cm_fields['U'] = strdoop(subject);
2191         }
2192         msg->cm_fields['M'] = strdoop(text);
2193
2194         CtdlSubmitMsg(msg, recp, room);
2195         CtdlFreeMessage(msg);
2196         if (recp != NULL) phree(recp);
2197 }
2198
2199
2200
2201 /*
2202  * Back end function used by CtdlMakeMessage() and similar functions
2203  */
2204 char *CtdlReadMessageBody(char *terminator,     /* token signalling EOT */
2205                         size_t maxlen,          /* maximum message length */
2206                         char *exist,            /* if non-null, append to it;
2207                                                    exist is ALWAYS freed  */
2208                         int crlf                /* CRLF newlines instead of LF */
2209                         ) {
2210         char buf[SIZ];
2211         int linelen;
2212         size_t message_len = 0;
2213         size_t buffer_len = 0;
2214         char *ptr;
2215         char *m;
2216         int flushing = 0;
2217         int finished = 0;
2218
2219         if (exist == NULL) {
2220                 m = mallok(4096);
2221                 m[0] = 0;
2222                 buffer_len = 4096;
2223                 message_len = 0;
2224         }
2225         else {
2226                 message_len = strlen(exist);
2227                 buffer_len = message_len + 4096;
2228                 m = reallok(exist, buffer_len);
2229                 if (m == NULL) {
2230                         phree(exist);
2231                         return m;
2232                 }
2233         }
2234
2235         /* flush the input if we have nowhere to store it */
2236         if (m == NULL) {
2237                 flushing = 1;
2238         }
2239
2240         /* read in the lines of message text one by one */
2241         do {
2242                 if (client_gets(buf) < 1) finished = 1;
2243                 if (!strcmp(buf, terminator)) finished = 1;
2244                 if (crlf) {
2245                         strcat(buf, "\r\n");
2246                 }
2247                 else {
2248                         strcat(buf, "\n");
2249                 }
2250
2251                 if ( (!flushing) && (!finished) ) {
2252                         /* Measure the line */
2253                         linelen = strlen(buf);
2254
2255                         /* augment the buffer if we have to */
2256                         if ((message_len + linelen) >= buffer_len) {
2257                                 ptr = reallok(m, (buffer_len * 2) );
2258                                 if (ptr == NULL) {      /* flush if can't allocate */
2259                                         flushing = 1;
2260                                 } else {
2261                                         buffer_len = (buffer_len * 2);
2262                                         m = ptr;
2263                                         lprintf(9, "buffer_len is now %ld\n", (long)buffer_len);
2264                                 }
2265                         }
2266
2267                         /* Add the new line to the buffer.  NOTE: this loop must avoid
2268                         * using functions like strcat() and strlen() because they
2269                         * traverse the entire buffer upon every call, and doing that
2270                         * for a multi-megabyte message slows it down beyond usability.
2271                         */
2272                         strcpy(&m[message_len], buf);
2273                         message_len += linelen;
2274                 }
2275
2276                 /* if we've hit the max msg length, flush the rest */
2277                 if (message_len >= maxlen) flushing = 1;
2278
2279         } while (!finished);
2280         return(m);
2281 }
2282
2283
2284
2285
2286 /*
2287  * Build a binary message to be saved on disk.
2288  * (NOTE: if you supply 'preformatted_text', the buffer you give it
2289  * will become part of the message.  This means you are no longer
2290  * responsible for managing that memory -- it will be freed along with
2291  * the rest of the fields when CtdlFreeMessage() is called.)
2292  */
2293
2294 struct CtdlMessage *CtdlMakeMessage(
2295         struct usersupp *author,        /* author's usersupp structure */
2296         char *recipient,                /* NULL if it's not mail */
2297         char *room,                     /* room where it's going */
2298         int type,                       /* see MES_ types in header file */
2299         int format_type,                /* variformat, plain text, MIME... */
2300         char *fake_name,                /* who we're masquerading as */
2301         char *subject,                  /* Subject (optional) */
2302         char *preformatted_text         /* ...or NULL to read text from client */
2303 ) {
2304         char dest_node[SIZ];
2305         char buf[SIZ];
2306         struct CtdlMessage *msg;
2307
2308         msg = mallok(sizeof(struct CtdlMessage));
2309         memset(msg, 0, sizeof(struct CtdlMessage));
2310         msg->cm_magic = CTDLMESSAGE_MAGIC;
2311         msg->cm_anon_type = type;
2312         msg->cm_format_type = format_type;
2313
2314         /* Don't confuse the poor folks if it's not routed mail. */
2315         strcpy(dest_node, "");
2316
2317         striplt(recipient);
2318
2319         snprintf(buf, sizeof buf, "cit%ld", author->usernum);   /* Path */
2320         msg->cm_fields['P'] = strdoop(buf);
2321
2322         snprintf(buf, sizeof buf, "%ld", (long)time(NULL));     /* timestamp */
2323         msg->cm_fields['T'] = strdoop(buf);
2324
2325         if (fake_name[0])                                       /* author */
2326                 msg->cm_fields['A'] = strdoop(fake_name);
2327         else
2328                 msg->cm_fields['A'] = strdoop(author->fullname);
2329
2330         if (CC->quickroom.QRflags & QR_MAILBOX) {               /* room */
2331                 msg->cm_fields['O'] = strdoop(&CC->quickroom.QRname[11]);
2332         }
2333         else {
2334                 msg->cm_fields['O'] = strdoop(CC->quickroom.QRname);
2335         }
2336
2337         msg->cm_fields['N'] = strdoop(NODENAME);                /* nodename */
2338         msg->cm_fields['H'] = strdoop(HUMANNODE);               /* hnodename */
2339
2340         if (recipient[0] != 0) {
2341                 msg->cm_fields['R'] = strdoop(recipient);
2342         }
2343         if (dest_node[0] != 0) {
2344                 msg->cm_fields['D'] = strdoop(dest_node);
2345         }
2346
2347         if ( (author == &CC->usersupp) && (strlen(CC->cs_inet_email) > 0) ) {
2348                 msg->cm_fields['F'] = strdoop(CC->cs_inet_email);
2349         }
2350
2351         if (subject != NULL) {
2352                 striplt(subject);
2353                 if (strlen(subject) > 0) {
2354                         msg->cm_fields['U'] = strdoop(subject);
2355                 }
2356         }
2357
2358         if (preformatted_text != NULL) {
2359                 msg->cm_fields['M'] = preformatted_text;
2360         }
2361         else {
2362                 msg->cm_fields['M'] = CtdlReadMessageBody("000",
2363                                         config.c_maxmsglen, NULL, 0);
2364         }
2365
2366         return(msg);
2367 }
2368
2369
2370 /*
2371  * Check to see whether we have permission to post a message in the current
2372  * room.  Returns a *CITADEL ERROR CODE* and puts a message in errmsgbuf, or
2373  * returns 0 on success.
2374  */
2375 int CtdlDoIHavePermissionToPostInThisRoom(char *errmsgbuf, size_t n) {
2376
2377         if (!(CC->logged_in)) {
2378                 snprintf(errmsgbuf, n, "Not logged in.");
2379                 return (ERROR + NOT_LOGGED_IN);
2380         }
2381
2382         if ((CC->usersupp.axlevel < 2)
2383             && ((CC->quickroom.QRflags & QR_MAILBOX) == 0)) {
2384                 snprintf(errmsgbuf, n, "Need to be validated to enter "
2385                                 "(except in %s> to sysop)", MAILROOM);
2386                 return (ERROR + HIGHER_ACCESS_REQUIRED);
2387         }
2388
2389         if ((CC->usersupp.axlevel < 4)
2390            && (CC->quickroom.QRflags & QR_NETWORK)) {
2391                 snprintf(errmsgbuf, n, "Need net privileges to enter here.");
2392                 return (ERROR + HIGHER_ACCESS_REQUIRED);
2393         }
2394
2395         if ((CC->usersupp.axlevel < 6)
2396            && (CC->quickroom.QRflags & QR_READONLY)) {
2397                 snprintf(errmsgbuf, n, "Sorry, this is a read-only room.");
2398                 return (ERROR + HIGHER_ACCESS_REQUIRED);
2399         }
2400
2401         strcpy(errmsgbuf, "Ok");
2402         return(0);
2403 }
2404
2405
2406 /*
2407  * Check to see if the specified user has Internet mail permission
2408  * (returns nonzero if permission is granted)
2409  */
2410 int CtdlCheckInternetMailPermission(struct usersupp *who) {
2411
2412         /* Globally enabled? */
2413         if (config.c_restrict == 0) return(1);
2414
2415         /* User flagged ok? */
2416         if (who->flags & US_INTERNET) return(2);
2417
2418         /* Aide level access? */
2419         if (who->axlevel >= 6) return(3);
2420
2421         /* No mail for you! */
2422         return(0);
2423 }
2424
2425
2426
2427 /*
2428  * Validate recipients, count delivery types and errors, and handle aliasing
2429  * FIXME check for dupes!!!!!
2430  */
2431 struct recptypes *validate_recipients(char *recipients) {
2432         struct recptypes *ret;
2433         char this_recp[SIZ];
2434         char this_recp_cooked[SIZ];
2435         char append[SIZ];
2436         int num_recps;
2437         int i, j;
2438         int mailtype;
2439         int invalid;
2440         struct usersupp tempUS;
2441         struct quickroom tempQR;
2442
2443         /* Initialize */
2444         ret = (struct recptypes *) malloc(sizeof(struct recptypes));
2445         if (ret == NULL) return(NULL);
2446         memset(ret, 0, sizeof(struct recptypes));
2447
2448         ret->num_local = 0;
2449         ret->num_internet = 0;
2450         ret->num_ignet = 0;
2451         ret->num_error = 0;
2452         ret->num_room = 0;
2453
2454         if (recipients == NULL) {
2455                 num_recps = 0;
2456         }
2457         else if (strlen(recipients) == 0) {
2458                 num_recps = 0;
2459         }
2460         else {
2461                 /* Change all valid separator characters to commas */
2462                 for (i=0; i<strlen(recipients); ++i) {
2463                         if ((recipients[i] == ';') || (recipients[i] == '|')) {
2464                                 recipients[i] = ',';
2465                         }
2466                 }
2467
2468                 /* Count 'em up */
2469                 num_recps = num_tokens(recipients, ',');
2470         }
2471
2472         if (num_recps > 0) for (i=0; i<num_recps; ++i) {
2473                 extract_token(this_recp, recipients, i, ',');
2474                 striplt(this_recp);
2475                 lprintf(9, "Evaluating recipient #%d <%s>\n", i, this_recp);
2476                 mailtype = alias(this_recp);
2477                 mailtype = alias(this_recp);
2478                 mailtype = alias(this_recp);
2479                 for (j=0; j<=strlen(this_recp); ++j) {
2480                         if (this_recp[j]=='_') {
2481                                 this_recp_cooked[j] = ' ';
2482                         }
2483                         else {
2484                                 this_recp_cooked[j] = this_recp[j];
2485                         }
2486                 }
2487                 invalid = 0;
2488                 switch(mailtype) {
2489                         case MES_LOCAL:
2490                                 if (!strcasecmp(this_recp, "sysop")) {
2491                                         ++ret->num_room;
2492                                         strcpy(this_recp, config.c_aideroom);
2493                                         if (strlen(ret->recp_room) > 0) {
2494                                                 strcat(ret->recp_room, "|");
2495                                         }
2496                                         strcat(ret->recp_room, this_recp);
2497                                 }
2498                                 else if (getuser(&tempUS, this_recp) == 0) {
2499                                         ++ret->num_local;
2500                                         strcpy(this_recp, tempUS.fullname);
2501                                         if (strlen(ret->recp_local) > 0) {
2502                                                 strcat(ret->recp_local, "|");
2503                                         }
2504                                         strcat(ret->recp_local, this_recp);
2505                                 }
2506                                 else if (getuser(&tempUS, this_recp_cooked) == 0) {
2507                                         ++ret->num_local;
2508                                         strcpy(this_recp, tempUS.fullname);
2509                                         if (strlen(ret->recp_local) > 0) {
2510                                                 strcat(ret->recp_local, "|");
2511                                         }
2512                                         strcat(ret->recp_local, this_recp);
2513                                 }
2514                                 else if ( (!strncasecmp(this_recp, "room_", 5))
2515                                       && (!getroom(&tempQR, &this_recp_cooked[5])) ) {
2516                                         ++ret->num_room;
2517                                         if (strlen(ret->recp_room) > 0) {
2518                                                 strcat(ret->recp_room, "|");
2519                                         }
2520                                         strcat(ret->recp_room, &this_recp_cooked[5]);
2521                                 }
2522                                 else {
2523                                         ++ret->num_error;
2524                                         invalid = 1;
2525                                 }
2526                                 break;
2527                         case MES_INTERNET:
2528                                 ++ret->num_internet;
2529                                 if (strlen(ret->recp_internet) > 0) {
2530                                         strcat(ret->recp_internet, "|");
2531                                 }
2532                                 strcat(ret->recp_internet, this_recp);
2533                                 break;
2534                         case MES_IGNET:
2535                                 ++ret->num_ignet;
2536                                 if (strlen(ret->recp_ignet) > 0) {
2537                                         strcat(ret->recp_ignet, "|");
2538                                 }
2539                                 strcat(ret->recp_ignet, this_recp);
2540                                 break;
2541                         case MES_ERROR:
2542                                 ++ret->num_error;
2543                                 invalid = 1;
2544                                 break;
2545                 }
2546                 if (invalid) {
2547                         if (strlen(ret->errormsg) == 0) {
2548                                 snprintf(append, sizeof append,
2549                                          "Invalid recipient: %s",
2550                                          this_recp);
2551                         }
2552                         else {
2553                                 snprintf(append, sizeof append,
2554                                          ", %s", this_recp);
2555                         }
2556                         if ( (strlen(ret->errormsg) + strlen(append)) < SIZ) {
2557                                 strcat(ret->errormsg, append);
2558                         }
2559                 }
2560                 else {
2561                         if (strlen(ret->display_recp) == 0) {
2562                                 strcpy(append, this_recp);
2563                         }
2564                         else {
2565                                 snprintf(append, sizeof append, ", %s",
2566                                          this_recp);
2567                         }
2568                         if ( (strlen(ret->display_recp)+strlen(append)) < SIZ) {
2569                                 strcat(ret->display_recp, append);
2570                         }
2571                 }
2572         }
2573
2574         if ((ret->num_local + ret->num_internet + ret->num_ignet +
2575            ret->num_room + ret->num_error) == 0) {
2576                 ++ret->num_error;
2577                 strcpy(ret->errormsg, "No recipients specified.");
2578         }
2579
2580         lprintf(9, "validate_recipients()\n");
2581         lprintf(9, " local: %d <%s>\n", ret->num_local, ret->recp_local);
2582         lprintf(9, "  room: %d <%s>\n", ret->num_room, ret->recp_room);
2583         lprintf(9, "  inet: %d <%s>\n", ret->num_internet, ret->recp_internet);
2584         lprintf(9, " ignet: %d <%s>\n", ret->num_ignet, ret->recp_ignet);
2585         lprintf(9, " error: %d <%s>\n", ret->num_error, ret->errormsg);
2586
2587         return(ret);
2588 }
2589
2590
2591
2592 /*
2593  * message entry  -  mode 0 (normal)
2594  */
2595 void cmd_ent0(char *entargs)
2596 {
2597         int post = 0;
2598         char recp[SIZ];
2599         char masquerade_as[SIZ];
2600         int anon_flag = 0;
2601         int format_type = 0;
2602         char newusername[SIZ];
2603         struct CtdlMessage *msg;
2604         int anonymous = 0;
2605         char errmsg[SIZ];
2606         int err = 0;
2607         struct recptypes *valid = NULL;
2608         char subject[SIZ];
2609
2610         post = extract_int(entargs, 0);
2611         extract(recp, entargs, 1);
2612         anon_flag = extract_int(entargs, 2);
2613         format_type = extract_int(entargs, 3);
2614         extract(subject, entargs, 4);
2615
2616         /* first check to make sure the request is valid. */
2617
2618         err = CtdlDoIHavePermissionToPostInThisRoom(errmsg, sizeof errmsg);
2619         if (err) {
2620                 cprintf("%d %s\n", err, errmsg);
2621                 return;
2622         }
2623
2624         /* Check some other permission type things. */
2625
2626         if (post == 2) {
2627                 if (CC->usersupp.axlevel < 6) {
2628                         cprintf("%d You don't have permission to masquerade.\n",
2629                                 ERROR + HIGHER_ACCESS_REQUIRED);
2630                         return;
2631                 }
2632                 extract(newusername, entargs, 5);
2633                 memset(CC->fake_postname, 0, sizeof(CC->fake_postname) );
2634                 safestrncpy(CC->fake_postname, newusername,
2635                         sizeof(CC->fake_postname) );
2636                 cprintf("%d ok\n", CIT_OK);
2637                 return;
2638         }
2639         CC->cs_flags |= CS_POSTING;
2640
2641         /* In the Mail> room we have to behave a little differently --
2642          * make sure the user has specified at least one recipient.  Then
2643          * validate the recipient(s).
2644          */
2645         if ( (CC->quickroom.QRflags & QR_MAILBOX)
2646            && (!strcasecmp(&CC->quickroom.QRname[11], MAILROOM)) ) {
2647
2648                 if (CC->usersupp.axlevel < 2) {
2649                         strcpy(recp, "sysop");
2650                 }
2651
2652                 valid = validate_recipients(recp);
2653                 if (valid->num_error > 0) {
2654                         cprintf("%d %s\n",
2655                                 ERROR + NO_SUCH_USER, valid->errormsg);
2656                         phree(valid);
2657                         return;
2658                 }
2659                 if (valid->num_internet > 0) {
2660                         if (CtdlCheckInternetMailPermission(&CC->usersupp)==0) {
2661                                 cprintf("%d You do not have permission "
2662                                         "to send Internet mail.\n",
2663                                         ERROR + HIGHER_ACCESS_REQUIRED);
2664                                 phree(valid);
2665                                 return;
2666                         }
2667                 }
2668
2669                 if ( ( (valid->num_internet + valid->num_ignet) > 0)
2670                    && (CC->usersupp.axlevel < 4) ) {
2671                         cprintf("%d Higher access required for network mail.\n",
2672                                 ERROR + HIGHER_ACCESS_REQUIRED);
2673                         phree(valid);
2674                         return;
2675                 }
2676
2677                 if ((RESTRICT_INTERNET == 1) && (valid->num_internet > 0)
2678                     && ((CC->usersupp.flags & US_INTERNET) == 0)
2679                     && (!CC->internal_pgm)) {
2680                         cprintf("%d You don't have access to Internet mail.\n",
2681                                 ERROR + HIGHER_ACCESS_REQUIRED);
2682                         phree(valid);
2683                         return;
2684                 }
2685
2686         }
2687
2688         /* Is this a room which has anonymous-only or anonymous-option? */
2689         anonymous = MES_NORMAL;
2690         if (CC->quickroom.QRflags & QR_ANONONLY) {
2691                 anonymous = MES_ANONONLY;
2692         }
2693         if (CC->quickroom.QRflags & QR_ANONOPT) {
2694                 if (anon_flag == 1) {   /* only if the user requested it */
2695                         anonymous = MES_ANONOPT;
2696                 }
2697         }
2698
2699         if ((CC->quickroom.QRflags & QR_MAILBOX) == 0) {
2700                 recp[0] = 0;
2701         }
2702
2703         /* If we're only checking the validity of the request, return
2704          * success without creating the message.
2705          */
2706         if (post == 0) {
2707                 cprintf("%d %s\n", CIT_OK,
2708                         ((valid != NULL) ? valid->display_recp : "") );
2709                 phree(valid);
2710                 return;
2711         }
2712
2713         /* Handle author masquerading */
2714         if (CC->fake_postname[0]) {
2715                 strcpy(masquerade_as, CC->fake_postname);
2716         }
2717         else if (CC->fake_username[0]) {
2718                 strcpy(masquerade_as, CC->fake_username);
2719         }
2720         else {
2721                 strcpy(masquerade_as, "");
2722         }
2723
2724         /* Read in the message from the client. */
2725         cprintf("%d send message\n", SEND_LISTING);
2726         msg = CtdlMakeMessage(&CC->usersupp, recp,
2727                 CC->quickroom.QRname, anonymous, format_type,
2728                 masquerade_as, subject, NULL);
2729
2730         if (msg != NULL) {
2731                 CtdlSubmitMsg(msg, valid, "");
2732                 CtdlFreeMessage(msg);
2733         }
2734         CC->fake_postname[0] = '\0';
2735         phree(valid);
2736         return;
2737 }
2738
2739
2740
2741 /*
2742  * API function to delete messages which match a set of criteria
2743  * (returns the actual number of messages deleted)
2744  */
2745 int CtdlDeleteMessages(char *room_name,         /* which room */
2746                        long dmsgnum,            /* or "0" for any */
2747                        char *content_type       /* or "" for any */
2748 )
2749 {
2750
2751         struct quickroom qrbuf;
2752         struct cdbdata *cdbfr;
2753         long *msglist = NULL;
2754         long *dellist = NULL;
2755         int num_msgs = 0;
2756         int i;
2757         int num_deleted = 0;
2758         int delete_this;
2759         struct MetaData smi;
2760
2761         lprintf(9, "CtdlDeleteMessages(%s, %ld, %s)\n",
2762                 room_name, dmsgnum, content_type);
2763
2764         /* get room record, obtaining a lock... */
2765         if (lgetroom(&qrbuf, room_name) != 0) {
2766                 lprintf(7, "CtdlDeleteMessages(): Room <%s> not found\n",
2767                         room_name);
2768                 return (0);     /* room not found */
2769         }
2770         cdbfr = cdb_fetch(CDB_MSGLISTS, &qrbuf.QRnumber, sizeof(long));
2771
2772         if (cdbfr != NULL) {
2773                 msglist = mallok(cdbfr->len);
2774                 dellist = mallok(cdbfr->len);
2775                 memcpy(msglist, cdbfr->ptr, cdbfr->len);
2776                 num_msgs = cdbfr->len / sizeof(long);
2777                 cdb_free(cdbfr);
2778         }
2779         if (num_msgs > 0) {
2780                 for (i = 0; i < num_msgs; ++i) {
2781                         delete_this = 0x00;
2782
2783                         /* Set/clear a bit for each criterion */
2784
2785                         if ((dmsgnum == 0L) || (msglist[i] == dmsgnum)) {
2786                                 delete_this |= 0x01;
2787                         }
2788                         if (strlen(content_type) == 0) {
2789                                 delete_this |= 0x02;
2790                         } else {
2791                                 GetMetaData(&smi, msglist[i]);
2792                                 if (!strcasecmp(smi.meta_content_type,
2793                                                 content_type)) {
2794                                         delete_this |= 0x02;
2795                                 }
2796                         }
2797
2798                         /* Delete message only if all bits are set */
2799                         if (delete_this == 0x03) {
2800                                 dellist[num_deleted++] = msglist[i];
2801                                 msglist[i] = 0L;
2802                         }
2803                 }
2804
2805                 num_msgs = sort_msglist(msglist, num_msgs);
2806                 cdb_store(CDB_MSGLISTS, &qrbuf.QRnumber, sizeof(long),
2807                           msglist, (num_msgs * sizeof(long)));
2808
2809                 qrbuf.QRhighest = msglist[num_msgs - 1];
2810         }
2811         lputroom(&qrbuf);
2812
2813         /* Go through the messages we pulled out of the index, and decrement
2814          * their reference counts by 1.  If this is the only room the message
2815          * was in, the reference count will reach zero and the message will
2816          * automatically be deleted from the database.  We do this in a
2817          * separate pass because there might be plug-in hooks getting called,
2818          * and we don't want that happening during an S_QUICKROOM critical
2819          * section.
2820          */
2821         if (num_deleted) for (i=0; i<num_deleted; ++i) {
2822                 PerformDeleteHooks(qrbuf.QRname, dellist[i]);
2823                 AdjRefCount(dellist[i], -1);
2824         }
2825
2826         /* Now free the memory we used, and go away. */
2827         if (msglist != NULL) phree(msglist);
2828         if (dellist != NULL) phree(dellist);
2829         lprintf(9, "%d message(s) deleted.\n", num_deleted);
2830         return (num_deleted);
2831 }
2832
2833
2834
2835 /*
2836  * Check whether the current user has permission to delete messages from
2837  * the current room (returns 1 for yes, 0 for no)
2838  */
2839 int CtdlDoIHavePermissionToDeleteMessagesFromThisRoom(void) {
2840         getuser(&CC->usersupp, CC->curr_user);
2841         if ((CC->usersupp.axlevel < 6)
2842             && (CC->usersupp.usernum != CC->quickroom.QRroomaide)
2843             && ((CC->quickroom.QRflags & QR_MAILBOX) == 0)
2844             && (!(CC->internal_pgm))) {
2845                 return(0);
2846         }
2847         return(1);
2848 }
2849
2850
2851
2852 /*
2853  * Delete message from current room
2854  */
2855 void cmd_dele(char *delstr)
2856 {
2857         long delnum;
2858         int num_deleted;
2859
2860         if (CtdlDoIHavePermissionToDeleteMessagesFromThisRoom() == 0) {
2861                 cprintf("%d Higher access required.\n",
2862                         ERROR + HIGHER_ACCESS_REQUIRED);
2863                 return;
2864         }
2865         delnum = extract_long(delstr, 0);
2866
2867         num_deleted = CtdlDeleteMessages(CC->quickroom.QRname, delnum, "");
2868
2869         if (num_deleted) {
2870                 cprintf("%d %d message%s deleted.\n", CIT_OK,
2871                         num_deleted, ((num_deleted != 1) ? "s" : ""));
2872         } else {
2873                 cprintf("%d Message %ld not found.\n", ERROR, delnum);
2874         }
2875 }
2876
2877
2878 /*
2879  * Back end API function for moves and deletes
2880  */
2881 int CtdlCopyMsgToRoom(long msgnum, char *dest) {
2882         int err;
2883
2884         err = CtdlSaveMsgPointerInRoom(dest, msgnum,
2885                 (SM_VERIFY_GOODNESS | SM_DO_REPL_CHECK) );
2886         if (err != 0) return(err);
2887
2888         return(0);
2889 }
2890
2891
2892
2893 /*
2894  * move or copy a message to another room
2895  */
2896 void cmd_move(char *args)
2897 {
2898         long num;
2899         char targ[SIZ];
2900         struct quickroom qtemp;
2901         int err;
2902         int is_copy = 0;
2903
2904         num = extract_long(args, 0);
2905         extract(targ, args, 1);
2906         targ[ROOMNAMELEN - 1] = 0;
2907         is_copy = extract_int(args, 2);
2908
2909         if (getroom(&qtemp, targ) != 0) {
2910                 cprintf("%d '%s' does not exist.\n", ERROR, targ);
2911                 return;
2912         }
2913
2914         getuser(&CC->usersupp, CC->curr_user);
2915         /* Aides can move/copy */
2916         if ((CC->usersupp.axlevel < 6)
2917             /* Roomaides can move/copy */
2918             && (CC->usersupp.usernum != CC->quickroom.QRroomaide)
2919             /* Permit move/copy to/from personal rooms */
2920             && (!((CC->quickroom.QRflags & QR_MAILBOX)
2921                             && (qtemp.QRflags & QR_MAILBOX)))
2922             /* Permit only copy from public to personal room */
2923             && (!(is_copy && !(CC->quickroom.QRflags & QR_MAILBOX)
2924                             && (qtemp.QRflags & QR_MAILBOX)))) {
2925                 cprintf("%d Higher access required.\n",
2926                         ERROR + HIGHER_ACCESS_REQUIRED);
2927                 return;
2928         }
2929
2930         err = CtdlCopyMsgToRoom(num, targ);
2931         if (err != 0) {
2932                 cprintf("%d Cannot store message in %s: error %d\n",
2933                         err, targ, err);
2934                 return;
2935         }
2936
2937         /* Now delete the message from the source room,
2938          * if this is a 'move' rather than a 'copy' operation.
2939          */
2940         if (is_copy == 0) {
2941                 CtdlDeleteMessages(CC->quickroom.QRname, num, "");
2942         }
2943
2944         cprintf("%d Message %s.\n", CIT_OK, (is_copy ? "copied" : "moved") );
2945 }
2946
2947
2948
2949 /*
2950  * GetMetaData()  -  Get the supplementary record for a message
2951  */
2952 void GetMetaData(struct MetaData *smibuf, long msgnum)
2953 {
2954
2955         struct cdbdata *cdbsmi;
2956         long TheIndex;
2957
2958         memset(smibuf, 0, sizeof(struct MetaData));
2959         smibuf->meta_msgnum = msgnum;
2960         smibuf->meta_refcount = 1;      /* Default reference count is 1 */
2961
2962         /* Use the negative of the message number for its supp record index */
2963         TheIndex = (0L - msgnum);
2964
2965         cdbsmi = cdb_fetch(CDB_MSGMAIN, &TheIndex, sizeof(long));
2966         if (cdbsmi == NULL) {
2967                 return;         /* record not found; go with defaults */
2968         }
2969         memcpy(smibuf, cdbsmi->ptr,
2970                ((cdbsmi->len > sizeof(struct MetaData)) ?
2971                 sizeof(struct MetaData) : cdbsmi->len));
2972         cdb_free(cdbsmi);
2973         return;
2974 }
2975
2976
2977 /*
2978  * PutMetaData()  -  (re)write supplementary record for a message
2979  */
2980 void PutMetaData(struct MetaData *smibuf)
2981 {
2982         long TheIndex;
2983
2984         /* Use the negative of the message number for the metadata db index */
2985         TheIndex = (0L - smibuf->meta_msgnum);
2986
2987         lprintf(9, "PutMetaData(%ld) - ref count is %d\n",
2988                 smibuf->meta_msgnum, smibuf->meta_refcount);
2989
2990         cdb_store(CDB_MSGMAIN,
2991                   &TheIndex, sizeof(long),
2992                   smibuf, sizeof(struct MetaData));
2993
2994 }
2995
2996 /*
2997  * AdjRefCount  -  change the reference count for a message;
2998  *                 delete the message if it reaches zero
2999  */
3000 void AdjRefCount(long msgnum, int incr)
3001 {
3002
3003         struct MetaData smi;
3004         long delnum;
3005
3006         /* This is a *tight* critical section; please keep it that way, as
3007          * it may get called while nested in other critical sections.
3008          * Complicating this any further will surely cause deadlock!
3009          */
3010         begin_critical_section(S_SUPPMSGMAIN);
3011         GetMetaData(&smi, msgnum);
3012         lprintf(9, "Ref count for message <%ld> before write is <%d>\n",
3013                 msgnum, smi.meta_refcount);
3014         smi.meta_refcount += incr;
3015         PutMetaData(&smi);
3016         end_critical_section(S_SUPPMSGMAIN);
3017         lprintf(9, "Ref count for message <%ld> after write is <%d>\n",
3018                 msgnum, smi.meta_refcount);
3019
3020         /* If the reference count is now zero, delete the message
3021          * (and its supplementary record as well).
3022          */
3023         if (smi.meta_refcount == 0) {
3024                 lprintf(9, "Deleting message <%ld>\n", msgnum);
3025                 delnum = msgnum;
3026                 cdb_delete(CDB_MSGMAIN, &delnum, sizeof(long));
3027
3028                 /* We have to delete the metadata record too! */
3029                 delnum = (0L - msgnum);
3030                 cdb_delete(CDB_MSGMAIN, &delnum, sizeof(long));
3031         }
3032 }
3033
3034 /*
3035  * Write a generic object to this room
3036  *
3037  * Note: this could be much more efficient.  Right now we use two temporary
3038  * files, and still pull the message into memory as with all others.
3039  */
3040 void CtdlWriteObject(char *req_room,            /* Room to stuff it in */
3041                         char *content_type,     /* MIME type of this object */
3042                         char *tempfilename,     /* Where to fetch it from */
3043                         struct usersupp *is_mailbox,    /* Mailbox room? */
3044                         int is_binary,          /* Is encoding necessary? */
3045                         int is_unique,          /* Del others of this type? */
3046                         unsigned int flags      /* Internal save flags */
3047                         )
3048 {
3049
3050         FILE *fp;
3051         struct quickroom qrbuf;
3052         char roomname[ROOMNAMELEN];
3053         struct CtdlMessage *msg;
3054
3055         char *raw_message = NULL;
3056         char *encoded_message = NULL;
3057         off_t raw_length = 0;
3058
3059         if (is_mailbox != NULL)
3060                 MailboxName(roomname, sizeof roomname, is_mailbox, req_room);
3061         else
3062                 safestrncpy(roomname, req_room, sizeof(roomname));
3063         lprintf(9, "CtdlWriteObject() to <%s> (flags=%d)\n", roomname, flags);
3064
3065
3066         fp = fopen(tempfilename, "rb");
3067         if (fp == NULL) {
3068                 lprintf(5, "Cannot open %s: %s\n",
3069                         tempfilename, strerror(errno));
3070                 return;
3071         }
3072         fseek(fp, 0L, SEEK_END);
3073         raw_length = ftell(fp);
3074         rewind(fp);
3075         lprintf(9, "Raw length is %ld\n", (long)raw_length);
3076
3077         raw_message = mallok((size_t)raw_length);
3078         fread(raw_message, (size_t)raw_length, 1, fp);
3079         fclose(fp);
3080
3081         if (is_binary) {
3082                 encoded_message = mallok((size_t)
3083                         (((raw_length * 134) / 100) + 4096 ) );
3084         }
3085         else {
3086                 encoded_message = mallok((size_t)(raw_length + 4096));
3087         }
3088
3089         sprintf(encoded_message, "Content-type: %s\n", content_type);
3090
3091         if (is_binary) {
3092                 sprintf(&encoded_message[strlen(encoded_message)],
3093                         "Content-transfer-encoding: base64\n\n"
3094                 );
3095         }
3096         else {
3097                 sprintf(&encoded_message[strlen(encoded_message)],
3098                         "Content-transfer-encoding: 7bit\n\n"
3099                 );
3100         }
3101
3102         if (is_binary) {
3103                 CtdlEncodeBase64(
3104                         &encoded_message[strlen(encoded_message)],
3105                         raw_message,
3106                         (int)raw_length
3107                 );
3108         }
3109         else {
3110                 raw_message[raw_length] = 0;
3111                 memcpy(
3112                         &encoded_message[strlen(encoded_message)],
3113                         raw_message,
3114                         (int)(raw_length+1)
3115                 );
3116         }
3117
3118         phree(raw_message);
3119
3120         lprintf(9, "Allocating\n");
3121         msg = mallok(sizeof(struct CtdlMessage));
3122         memset(msg, 0, sizeof(struct CtdlMessage));
3123         msg->cm_magic = CTDLMESSAGE_MAGIC;
3124         msg->cm_anon_type = MES_NORMAL;
3125         msg->cm_format_type = 4;
3126         msg->cm_fields['A'] = strdoop(CC->usersupp.fullname);
3127         msg->cm_fields['O'] = strdoop(req_room);
3128         msg->cm_fields['N'] = strdoop(config.c_nodename);
3129         msg->cm_fields['H'] = strdoop(config.c_humannode);
3130         msg->cm_flags = flags;
3131
3132         msg->cm_fields['M'] = encoded_message;
3133
3134         /* Create the requested room if we have to. */
3135         if (getroom(&qrbuf, roomname) != 0) {
3136                 create_room(roomname,
3137                         ( (is_mailbox != NULL) ? 5 : 3 ),
3138                         "", 0, 1, 0);
3139         }
3140         /* If the caller specified this object as unique, delete all
3141          * other objects of this type that are currently in the room.
3142          */
3143         if (is_unique) {
3144                 lprintf(9, "Deleted %d other msgs of this type\n",
3145                         CtdlDeleteMessages(roomname, 0L, content_type));
3146         }
3147         /* Now write the data */
3148         CtdlSubmitMsg(msg, NULL, roomname);
3149         CtdlFreeMessage(msg);
3150 }
3151
3152
3153
3154
3155
3156
3157 void CtdlGetSysConfigBackend(long msgnum, void *userdata) {
3158         config_msgnum = msgnum;
3159 }
3160
3161
3162 char *CtdlGetSysConfig(char *sysconfname) {
3163         char hold_rm[ROOMNAMELEN];
3164         long msgnum;
3165         char *conf;
3166         struct CtdlMessage *msg;
3167         char buf[SIZ];
3168
3169         strcpy(hold_rm, CC->quickroom.QRname);
3170         if (getroom(&CC->quickroom, SYSCONFIGROOM) != 0) {
3171                 getroom(&CC->quickroom, hold_rm);
3172                 return NULL;
3173         }
3174
3175
3176         /* We want the last (and probably only) config in this room */
3177         begin_critical_section(S_CONFIG);
3178         config_msgnum = (-1L);
3179         CtdlForEachMessage(MSGS_LAST, 1, sysconfname, NULL,
3180                 CtdlGetSysConfigBackend, NULL);
3181         msgnum = config_msgnum;
3182         end_critical_section(S_CONFIG);
3183
3184         if (msgnum < 0L) {
3185                 conf = NULL;
3186         }
3187         else {
3188                 msg = CtdlFetchMessage(msgnum);
3189                 if (msg != NULL) {
3190                         conf = strdoop(msg->cm_fields['M']);
3191                         CtdlFreeMessage(msg);
3192                 }
3193                 else {
3194                         conf = NULL;
3195                 }
3196         }
3197
3198         getroom(&CC->quickroom, hold_rm);
3199
3200         if (conf != NULL) do {
3201                 extract_token(buf, conf, 0, '\n');
3202                 strcpy(conf, &conf[strlen(buf)+1]);
3203         } while ( (strlen(conf)>0) && (strlen(buf)>0) );
3204
3205         return(conf);
3206 }
3207
3208 void CtdlPutSysConfig(char *sysconfname, char *sysconfdata) {
3209         char temp[PATH_MAX];
3210         FILE *fp;
3211
3212         strcpy(temp, tmpnam(NULL));
3213
3214         fp = fopen(temp, "w");
3215         if (fp == NULL) return;
3216         fprintf(fp, "%s", sysconfdata);
3217         fclose(fp);
3218
3219         /* this handy API function does all the work for us */
3220         CtdlWriteObject(SYSCONFIGROOM, sysconfname, temp, NULL, 0, 1, 0);
3221         unlink(temp);
3222 }
3223
3224
3225 /*
3226  * Determine whether a given Internet address belongs to the current user
3227  */
3228 int CtdlIsMe(char *addr) {
3229         struct recptypes *recp;
3230         int i;
3231
3232         recp = validate_recipients(addr);
3233         if (recp == NULL) return(0);
3234
3235         if (recp->num_local == 0) {
3236                 phree(recp);
3237                 return(0);
3238         }
3239
3240         for (i=0; i<recp->num_local; ++i) {
3241                 extract(addr, recp->recp_local, i);
3242                 if (!strcasecmp(addr, CC->usersupp.fullname)) {
3243                         phree(recp);
3244                         return(1);
3245                 }
3246         }
3247
3248         phree(recp);
3249         return(0);
3250 }
3251
3252
3253 /*
3254  * Citadel protocol command to do the same
3255  */
3256 void cmd_isme(char *argbuf) {
3257         char addr[SIZ];
3258
3259         if (CtdlAccessCheck(ac_logged_in)) return;
3260         extract(addr, argbuf, 0);
3261
3262         if (CtdlIsMe(addr)) {
3263                 cprintf("%d %s\n", CIT_OK, addr);
3264         }
3265         else {
3266                 cprintf("%d Not you.\n", ERROR);
3267         }
3268
3269 }