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->user, &CC->room);
 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->user, &CC->room);
 319
 320         /* Load the message list */
 321         cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.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->user, &CC->room);
 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->user, CC->curr_user);
 411         CtdlGetRelationship(&vbuf, &CC->user, &CC->room);
 412
 413         /* Load the message list */
 414         cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.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->user.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->user.fullname);
 601         snprintf(buf2, sizeof buf2, "%ld", CC->user.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->room.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->room,
1605                    ((roomname != NULL) ? roomname : CC->room.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->room, 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->room,
1622            ((roomname != NULL) ? roomname : CC->room.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->room.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->room);    /* unlock the room */
1650                         getroom(&CC->room, 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->room.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->room.QRhighest = highest_msg;
1681         lputroom(&CC->room);
1682         getroom(&CC->room, 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->room.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 user 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->room.QRname);
1971         strcpy(actual_rm, CC->room.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->user.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->room.QRname)) {
1992                 getroom(&CC->room, 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->room.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->user, CC->curr_user);
2058         CC->user.posted = CC->user.posted + 1;
2059         lputuser(&CC->user);
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->room.QRname))
2127                 getroom(&CC->room, 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 user *author,    /* author's user 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->room.QRflags & QR_MAILBOX) {            /* room */
2331                 msg->cm_fields['O'] = strdoop(&CC->room.QRname[11]);
2332         }
2333         else {
2334                 msg->cm_fields['O'] = strdoop(CC->room.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->user) && (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->user.axlevel < 2)
2383             && ((CC->room.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->user.axlevel < 4)
2390            && (CC->room.QRflags & QR_NETWORK)) {
2391                 snprintf(errmsgbuf, n, "Need net privileges to enter here.");
2392                 return (ERROR + HIGHER_ACCESS_REQUIRED);
2393         }
2394
2395         if ((CC->user.axlevel < 6)
2396            && (CC->room.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 user *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 user tempUS;
2441         struct room 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                                 /* Yes, you're reading this correctly: if the target
2529                                  * domain points back to the local system or an attached
2530                                  * Citadel directory, the address is invalid.  That's
2531                                  * because if the address were valid, we would have
2532                                  * already translated it to a local address by now.
2533                                  */
2534                                 if (IsDirectory(this_recp)) {
2535                                         ++ret->num_error;
2536                                         invalid = 1;
2537                                 }
2538                                 else {
2539                                         ++ret->num_internet;
2540                                         if (strlen(ret->recp_internet) > 0) {
2541                                                 strcat(ret->recp_internet, "|");
2542                                         }
2543                                         strcat(ret->recp_internet, this_recp);
2544                                 }
2545                                 break;
2546                         case MES_IGNET:
2547                                 ++ret->num_ignet;
2548                                 if (strlen(ret->recp_ignet) > 0) {
2549                                         strcat(ret->recp_ignet, "|");
2550                                 }
2551                                 strcat(ret->recp_ignet, this_recp);
2552                                 break;
2553                         case MES_ERROR:
2554                                 ++ret->num_error;
2555                                 invalid = 1;
2556                                 break;
2557                 }
2558                 if (invalid) {
2559                         if (strlen(ret->errormsg) == 0) {
2560                                 snprintf(append, sizeof append,
2561                                          "Invalid recipient: %s",
2562                                          this_recp);
2563                         }
2564                         else {
2565                                 snprintf(append, sizeof append,
2566                                          ", %s", this_recp);
2567                         }
2568                         if ( (strlen(ret->errormsg) + strlen(append)) < SIZ) {
2569                                 strcat(ret->errormsg, append);
2570                         }
2571                 }
2572                 else {
2573                         if (strlen(ret->display_recp) == 0) {
2574                                 strcpy(append, this_recp);
2575                         }
2576                         else {
2577                                 snprintf(append, sizeof append, ", %s",
2578                                          this_recp);
2579                         }
2580                         if ( (strlen(ret->display_recp)+strlen(append)) < SIZ) {
2581                                 strcat(ret->display_recp, append);
2582                         }
2583                 }
2584         }
2585
2586         if ((ret->num_local + ret->num_internet + ret->num_ignet +
2587            ret->num_room + ret->num_error) == 0) {
2588                 ++ret->num_error;
2589                 strcpy(ret->errormsg, "No recipients specified.");
2590         }
2591
2592         lprintf(9, "validate_recipients()\n");
2593         lprintf(9, " local: %d <%s>\n", ret->num_local, ret->recp_local);
2594         lprintf(9, "  room: %d <%s>\n", ret->num_room, ret->recp_room);
2595         lprintf(9, "  inet: %d <%s>\n", ret->num_internet, ret->recp_internet);
2596         lprintf(9, " ignet: %d <%s>\n", ret->num_ignet, ret->recp_ignet);
2597         lprintf(9, " error: %d <%s>\n", ret->num_error, ret->errormsg);
2598
2599         return(ret);
2600 }
2601
2602
2603
2604 /*
2605  * message entry  -  mode 0 (normal)
2606  */
2607 void cmd_ent0(char *entargs)
2608 {
2609         int post = 0;
2610         char recp[SIZ];
2611         char masquerade_as[SIZ];
2612         int anon_flag = 0;
2613         int format_type = 0;
2614         char newusername[SIZ];
2615         struct CtdlMessage *msg;
2616         int anonymous = 0;
2617         char errmsg[SIZ];
2618         int err = 0;
2619         struct recptypes *valid = NULL;
2620         char subject[SIZ];
2621
2622         post = extract_int(entargs, 0);
2623         extract(recp, entargs, 1);
2624         anon_flag = extract_int(entargs, 2);
2625         format_type = extract_int(entargs, 3);
2626         extract(subject, entargs, 4);
2627
2628         /* first check to make sure the request is valid. */
2629
2630         err = CtdlDoIHavePermissionToPostInThisRoom(errmsg, sizeof errmsg);
2631         if (err) {
2632                 cprintf("%d %s\n", err, errmsg);
2633                 return;
2634         }
2635
2636         /* Check some other permission type things. */
2637
2638         if (post == 2) {
2639                 if (CC->user.axlevel < 6) {
2640                         cprintf("%d You don't have permission to masquerade.\n",
2641                                 ERROR + HIGHER_ACCESS_REQUIRED);
2642                         return;
2643                 }
2644                 extract(newusername, entargs, 5);
2645                 memset(CC->fake_postname, 0, sizeof(CC->fake_postname) );
2646                 safestrncpy(CC->fake_postname, newusername,
2647                         sizeof(CC->fake_postname) );
2648                 cprintf("%d ok\n", CIT_OK);
2649                 return;
2650         }
2651         CC->cs_flags |= CS_POSTING;
2652
2653         /* In the Mail> room we have to behave a little differently --
2654          * make sure the user has specified at least one recipient.  Then
2655          * validate the recipient(s).
2656          */
2657         if ( (CC->room.QRflags & QR_MAILBOX)
2658            && (!strcasecmp(&CC->room.QRname[11], MAILROOM)) ) {
2659
2660                 if (CC->user.axlevel < 2) {
2661                         strcpy(recp, "sysop");
2662                 }
2663
2664                 valid = validate_recipients(recp);
2665                 if (valid->num_error > 0) {
2666                         cprintf("%d %s\n",
2667                                 ERROR + NO_SUCH_USER, valid->errormsg);
2668                         phree(valid);
2669                         return;
2670                 }
2671                 if (valid->num_internet > 0) {
2672                         if (CtdlCheckInternetMailPermission(&CC->user)==0) {
2673                                 cprintf("%d You do not have permission "
2674                                         "to send Internet mail.\n",
2675                                         ERROR + HIGHER_ACCESS_REQUIRED);
2676                                 phree(valid);
2677                                 return;
2678                         }
2679                 }
2680
2681                 if ( ( (valid->num_internet + valid->num_ignet) > 0)
2682                    && (CC->user.axlevel < 4) ) {
2683                         cprintf("%d Higher access required for network mail.\n",
2684                                 ERROR + HIGHER_ACCESS_REQUIRED);
2685                         phree(valid);
2686                         return;
2687                 }
2688
2689                 if ((RESTRICT_INTERNET == 1) && (valid->num_internet > 0)
2690                     && ((CC->user.flags & US_INTERNET) == 0)
2691                     && (!CC->internal_pgm)) {
2692                         cprintf("%d You don't have access to Internet mail.\n",
2693                                 ERROR + HIGHER_ACCESS_REQUIRED);
2694                         phree(valid);
2695                         return;
2696                 }
2697
2698         }
2699
2700         /* Is this a room which has anonymous-only or anonymous-option? */
2701         anonymous = MES_NORMAL;
2702         if (CC->room.QRflags & QR_ANONONLY) {
2703                 anonymous = MES_ANONONLY;
2704         }
2705         if (CC->room.QRflags & QR_ANONOPT) {
2706                 if (anon_flag == 1) {   /* only if the user requested it */
2707                         anonymous = MES_ANONOPT;
2708                 }
2709         }
2710
2711         if ((CC->room.QRflags & QR_MAILBOX) == 0) {
2712                 recp[0] = 0;
2713         }
2714
2715         /* If we're only checking the validity of the request, return
2716          * success without creating the message.
2717          */
2718         if (post == 0) {
2719                 cprintf("%d %s\n", CIT_OK,
2720                         ((valid != NULL) ? valid->display_recp : "") );
2721                 phree(valid);
2722                 return;
2723         }
2724
2725         /* Handle author masquerading */
2726         if (CC->fake_postname[0]) {
2727                 strcpy(masquerade_as, CC->fake_postname);
2728         }
2729         else if (CC->fake_username[0]) {
2730                 strcpy(masquerade_as, CC->fake_username);
2731         }
2732         else {
2733                 strcpy(masquerade_as, "");
2734         }
2735
2736         /* Read in the message from the client. */
2737         cprintf("%d send message\n", SEND_LISTING);
2738         msg = CtdlMakeMessage(&CC->user, recp,
2739                 CC->room.QRname, anonymous, format_type,
2740                 masquerade_as, subject, NULL);
2741
2742         if (msg != NULL) {
2743                 CtdlSubmitMsg(msg, valid, "");
2744                 CtdlFreeMessage(msg);
2745         }
2746         CC->fake_postname[0] = '\0';
2747         phree(valid);
2748         return;
2749 }
2750
2751
2752
2753 /*
2754  * API function to delete messages which match a set of criteria
2755  * (returns the actual number of messages deleted)
2756  */
2757 int CtdlDeleteMessages(char *room_name,         /* which room */
2758                        long dmsgnum,            /* or "0" for any */
2759                        char *content_type       /* or "" for any */
2760 )
2761 {
2762
2763         struct room qrbuf;
2764         struct cdbdata *cdbfr;
2765         long *msglist = NULL;
2766         long *dellist = NULL;
2767         int num_msgs = 0;
2768         int i;
2769         int num_deleted = 0;
2770         int delete_this;
2771         struct MetaData smi;
2772
2773         lprintf(9, "CtdlDeleteMessages(%s, %ld, %s)\n",
2774                 room_name, dmsgnum, content_type);
2775
2776         /* get room record, obtaining a lock... */
2777         if (lgetroom(&qrbuf, room_name) != 0) {
2778                 lprintf(7, "CtdlDeleteMessages(): Room <%s> not found\n",
2779                         room_name);
2780                 return (0);     /* room not found */
2781         }
2782         cdbfr = cdb_fetch(CDB_MSGLISTS, &qrbuf.QRnumber, sizeof(long));
2783
2784         if (cdbfr != NULL) {
2785                 msglist = mallok(cdbfr->len);
2786                 dellist = mallok(cdbfr->len);
2787                 memcpy(msglist, cdbfr->ptr, cdbfr->len);
2788                 num_msgs = cdbfr->len / sizeof(long);
2789                 cdb_free(cdbfr);
2790         }
2791         if (num_msgs > 0) {
2792                 for (i = 0; i < num_msgs; ++i) {
2793                         delete_this = 0x00;
2794
2795                         /* Set/clear a bit for each criterion */
2796
2797                         if ((dmsgnum == 0L) || (msglist[i] == dmsgnum)) {
2798                                 delete_this |= 0x01;
2799                         }
2800                         if (strlen(content_type) == 0) {
2801                                 delete_this |= 0x02;
2802                         } else {
2803                                 GetMetaData(&smi, msglist[i]);
2804                                 if (!strcasecmp(smi.meta_content_type,
2805                                                 content_type)) {
2806                                         delete_this |= 0x02;
2807                                 }
2808                         }
2809
2810                         /* Delete message only if all bits are set */
2811                         if (delete_this == 0x03) {
2812                                 dellist[num_deleted++] = msglist[i];
2813                                 msglist[i] = 0L;
2814                         }
2815                 }
2816
2817                 num_msgs = sort_msglist(msglist, num_msgs);
2818                 cdb_store(CDB_MSGLISTS, &qrbuf.QRnumber, sizeof(long),
2819                           msglist, (num_msgs * sizeof(long)));
2820
2821                 qrbuf.QRhighest = msglist[num_msgs - 1];
2822         }
2823         lputroom(&qrbuf);
2824
2825         /* Go through the messages we pulled out of the index, and decrement
2826          * their reference counts by 1.  If this is the only room the message
2827          * was in, the reference count will reach zero and the message will
2828          * automatically be deleted from the database.  We do this in a
2829          * separate pass because there might be plug-in hooks getting called,
2830          * and we don't want that happening during an S_ROOMS critical
2831          * section.
2832          */
2833         if (num_deleted) for (i=0; i<num_deleted; ++i) {
2834                 PerformDeleteHooks(qrbuf.QRname, dellist[i]);
2835                 AdjRefCount(dellist[i], -1);
2836         }
2837
2838         /* Now free the memory we used, and go away. */
2839         if (msglist != NULL) phree(msglist);
2840         if (dellist != NULL) phree(dellist);
2841         lprintf(9, "%d message(s) deleted.\n", num_deleted);
2842         return (num_deleted);
2843 }
2844
2845
2846
2847 /*
2848  * Check whether the current user has permission to delete messages from
2849  * the current room (returns 1 for yes, 0 for no)
2850  */
2851 int CtdlDoIHavePermissionToDeleteMessagesFromThisRoom(void) {
2852         getuser(&CC->user, CC->curr_user);
2853         if ((CC->user.axlevel < 6)
2854             && (CC->user.usernum != CC->room.QRroomaide)
2855             && ((CC->room.QRflags & QR_MAILBOX) == 0)
2856             && (!(CC->internal_pgm))) {
2857                 return(0);
2858         }
2859         return(1);
2860 }
2861
2862
2863
2864 /*
2865  * Delete message from current room
2866  */
2867 void cmd_dele(char *delstr)
2868 {
2869         long delnum;
2870         int num_deleted;
2871
2872         if (CtdlDoIHavePermissionToDeleteMessagesFromThisRoom() == 0) {
2873                 cprintf("%d Higher access required.\n",
2874                         ERROR + HIGHER_ACCESS_REQUIRED);
2875                 return;
2876         }
2877         delnum = extract_long(delstr, 0);
2878
2879         num_deleted = CtdlDeleteMessages(CC->room.QRname, delnum, "");
2880
2881         if (num_deleted) {
2882                 cprintf("%d %d message%s deleted.\n", CIT_OK,
2883                         num_deleted, ((num_deleted != 1) ? "s" : ""));
2884         } else {
2885                 cprintf("%d Message %ld not found.\n", ERROR, delnum);
2886         }
2887 }
2888
2889
2890 /*
2891  * Back end API function for moves and deletes
2892  */
2893 int CtdlCopyMsgToRoom(long msgnum, char *dest) {
2894         int err;
2895
2896         err = CtdlSaveMsgPointerInRoom(dest, msgnum,
2897                 (SM_VERIFY_GOODNESS | SM_DO_REPL_CHECK) );
2898         if (err != 0) return(err);
2899
2900         return(0);
2901 }
2902
2903
2904
2905 /*
2906  * move or copy a message to another room
2907  */
2908 void cmd_move(char *args)
2909 {
2910         long num;
2911         char targ[SIZ];
2912         struct room qtemp;
2913         int err;
2914         int is_copy = 0;
2915
2916         num = extract_long(args, 0);
2917         extract(targ, args, 1);
2918         targ[ROOMNAMELEN - 1] = 0;
2919         is_copy = extract_int(args, 2);
2920
2921         if (getroom(&qtemp, targ) != 0) {
2922                 cprintf("%d '%s' does not exist.\n", ERROR, targ);
2923                 return;
2924         }
2925
2926         getuser(&CC->user, CC->curr_user);
2927         /* Aides can move/copy */
2928         if ((CC->user.axlevel < 6)
2929             /* Roomaides can move/copy */
2930             && (CC->user.usernum != CC->room.QRroomaide)
2931             /* Permit move/copy to/from personal rooms */
2932             && (!((CC->room.QRflags & QR_MAILBOX)
2933                             && (qtemp.QRflags & QR_MAILBOX)))
2934             /* Permit only copy from public to personal room */
2935             && (!(is_copy && !(CC->room.QRflags & QR_MAILBOX)
2936                             && (qtemp.QRflags & QR_MAILBOX)))) {
2937                 cprintf("%d Higher access required.\n",
2938                         ERROR + HIGHER_ACCESS_REQUIRED);
2939                 return;
2940         }
2941
2942         err = CtdlCopyMsgToRoom(num, targ);
2943         if (err != 0) {
2944                 cprintf("%d Cannot store message in %s: error %d\n",
2945                         err, targ, err);
2946                 return;
2947         }
2948
2949         /* Now delete the message from the source room,
2950          * if this is a 'move' rather than a 'copy' operation.
2951          */
2952         if (is_copy == 0) {
2953                 CtdlDeleteMessages(CC->room.QRname, num, "");
2954         }
2955
2956         cprintf("%d Message %s.\n", CIT_OK, (is_copy ? "copied" : "moved") );
2957 }
2958
2959
2960
2961 /*
2962  * GetMetaData()  -  Get the supplementary record for a message
2963  */
2964 void GetMetaData(struct MetaData *smibuf, long msgnum)
2965 {
2966
2967         struct cdbdata *cdbsmi;
2968         long TheIndex;
2969
2970         memset(smibuf, 0, sizeof(struct MetaData));
2971         smibuf->meta_msgnum = msgnum;
2972         smibuf->meta_refcount = 1;      /* Default reference count is 1 */
2973
2974         /* Use the negative of the message number for its supp record index */
2975         TheIndex = (0L - msgnum);
2976
2977         cdbsmi = cdb_fetch(CDB_MSGMAIN, &TheIndex, sizeof(long));
2978         if (cdbsmi == NULL) {
2979                 return;         /* record not found; go with defaults */
2980         }
2981         memcpy(smibuf, cdbsmi->ptr,
2982                ((cdbsmi->len > sizeof(struct MetaData)) ?
2983                 sizeof(struct MetaData) : cdbsmi->len));
2984         cdb_free(cdbsmi);
2985         return;
2986 }
2987
2988
2989 /*
2990  * PutMetaData()  -  (re)write supplementary record for a message
2991  */
2992 void PutMetaData(struct MetaData *smibuf)
2993 {
2994         long TheIndex;
2995
2996         /* Use the negative of the message number for the metadata db index */
2997         TheIndex = (0L - smibuf->meta_msgnum);
2998
2999         lprintf(9, "PutMetaData(%ld) - ref count is %d\n",
3000                 smibuf->meta_msgnum, smibuf->meta_refcount);
3001
3002         cdb_store(CDB_MSGMAIN,
3003                   &TheIndex, sizeof(long),
3004                   smibuf, sizeof(struct MetaData));
3005
3006 }
3007
3008 /*
3009  * AdjRefCount  -  change the reference count for a message;
3010  *                 delete the message if it reaches zero
3011  */
3012 void AdjRefCount(long msgnum, int incr)
3013 {
3014
3015         struct MetaData smi;
3016         long delnum;
3017
3018         /* This is a *tight* critical section; please keep it that way, as
3019          * it may get called while nested in other critical sections.
3020          * Complicating this any further will surely cause deadlock!
3021          */
3022         begin_critical_section(S_SUPPMSGMAIN);
3023         GetMetaData(&smi, msgnum);
3024         lprintf(9, "Ref count for message <%ld> before write is <%d>\n",
3025                 msgnum, smi.meta_refcount);
3026         smi.meta_refcount += incr;
3027         PutMetaData(&smi);
3028         end_critical_section(S_SUPPMSGMAIN);
3029         lprintf(9, "Ref count for message <%ld> after write is <%d>\n",
3030                 msgnum, smi.meta_refcount);
3031
3032         /* If the reference count is now zero, delete the message
3033          * (and its supplementary record as well).
3034          */
3035         if (smi.meta_refcount == 0) {
3036                 lprintf(9, "Deleting message <%ld>\n", msgnum);
3037                 delnum = msgnum;
3038                 cdb_delete(CDB_MSGMAIN, &delnum, sizeof(long));
3039
3040                 /* We have to delete the metadata record too! */
3041                 delnum = (0L - msgnum);
3042                 cdb_delete(CDB_MSGMAIN, &delnum, sizeof(long));
3043         }
3044 }
3045
3046 /*
3047  * Write a generic object to this room
3048  *
3049  * Note: this could be much more efficient.  Right now we use two temporary
3050  * files, and still pull the message into memory as with all others.
3051  */
3052 void CtdlWriteObject(char *req_room,            /* Room to stuff it in */
3053                         char *content_type,     /* MIME type of this object */
3054                         char *tempfilename,     /* Where to fetch it from */
3055                         struct user *is_mailbox,        /* Mailbox room? */
3056                         int is_binary,          /* Is encoding necessary? */
3057                         int is_unique,          /* Del others of this type? */
3058                         unsigned int flags      /* Internal save flags */
3059                         )
3060 {
3061
3062         FILE *fp;
3063         struct room qrbuf;
3064         char roomname[ROOMNAMELEN];
3065         struct CtdlMessage *msg;
3066
3067         char *raw_message = NULL;
3068         char *encoded_message = NULL;
3069         off_t raw_length = 0;
3070
3071         if (is_mailbox != NULL)
3072                 MailboxName(roomname, sizeof roomname, is_mailbox, req_room);
3073         else
3074                 safestrncpy(roomname, req_room, sizeof(roomname));
3075         lprintf(9, "CtdlWriteObject() to <%s> (flags=%d)\n", roomname, flags);
3076
3077
3078         fp = fopen(tempfilename, "rb");
3079         if (fp == NULL) {
3080                 lprintf(5, "Cannot open %s: %s\n",
3081                         tempfilename, strerror(errno));
3082                 return;
3083         }
3084         fseek(fp, 0L, SEEK_END);
3085         raw_length = ftell(fp);
3086         rewind(fp);
3087         lprintf(9, "Raw length is %ld\n", (long)raw_length);
3088
3089         raw_message = mallok((size_t)raw_length + 2);
3090         fread(raw_message, (size_t)raw_length, 1, fp);
3091         fclose(fp);
3092
3093         if (is_binary) {
3094                 encoded_message = mallok((size_t)
3095                         (((raw_length * 134) / 100) + 4096 ) );
3096         }
3097         else {
3098                 encoded_message = mallok((size_t)(raw_length + 4096));
3099         }
3100
3101         sprintf(encoded_message, "Content-type: %s\n", content_type);
3102
3103         if (is_binary) {
3104                 sprintf(&encoded_message[strlen(encoded_message)],
3105                         "Content-transfer-encoding: base64\n\n"
3106                 );
3107         }
3108         else {
3109                 sprintf(&encoded_message[strlen(encoded_message)],
3110                         "Content-transfer-encoding: 7bit\n\n"
3111                 );
3112         }
3113
3114         if (is_binary) {
3115                 CtdlEncodeBase64(
3116                         &encoded_message[strlen(encoded_message)],
3117                         raw_message,
3118                         (int)raw_length
3119                 );
3120         }
3121         else {
3122                 raw_message[raw_length] = 0;
3123                 memcpy(
3124                         &encoded_message[strlen(encoded_message)],
3125                         raw_message,
3126                         (int)(raw_length+1)
3127                 );
3128         }
3129
3130         phree(raw_message);
3131
3132         lprintf(9, "Allocating\n");
3133         msg = mallok(sizeof(struct CtdlMessage));
3134         memset(msg, 0, sizeof(struct CtdlMessage));
3135         msg->cm_magic = CTDLMESSAGE_MAGIC;
3136         msg->cm_anon_type = MES_NORMAL;
3137         msg->cm_format_type = 4;
3138         msg->cm_fields['A'] = strdoop(CC->user.fullname);
3139         msg->cm_fields['O'] = strdoop(req_room);
3140         msg->cm_fields['N'] = strdoop(config.c_nodename);
3141         msg->cm_fields['H'] = strdoop(config.c_humannode);
3142         msg->cm_flags = flags;
3143
3144         msg->cm_fields['M'] = encoded_message;
3145
3146         /* Create the requested room if we have to. */
3147         if (getroom(&qrbuf, roomname) != 0) {
3148                 create_room(roomname,
3149                         ( (is_mailbox != NULL) ? 5 : 3 ),
3150                         "", 0, 1, 0);
3151         }
3152         /* If the caller specified this object as unique, delete all
3153          * other objects of this type that are currently in the room.
3154          */
3155         if (is_unique) {
3156                 lprintf(9, "Deleted %d other msgs of this type\n",
3157                         CtdlDeleteMessages(roomname, 0L, content_type));
3158         }
3159         /* Now write the data */
3160         CtdlSubmitMsg(msg, NULL, roomname);
3161         CtdlFreeMessage(msg);
3162 }
3163
3164
3165
3166
3167
3168
3169 void CtdlGetSysConfigBackend(long msgnum, void *userdata) {
3170         config_msgnum = msgnum;
3171 }
3172
3173
3174 char *CtdlGetSysConfig(char *sysconfname) {
3175         char hold_rm[ROOMNAMELEN];
3176         long msgnum;
3177         char *conf;
3178         struct CtdlMessage *msg;
3179         char buf[SIZ];
3180
3181         strcpy(hold_rm, CC->room.QRname);
3182         if (getroom(&CC->room, SYSCONFIGROOM) != 0) {
3183                 getroom(&CC->room, hold_rm);
3184                 return NULL;
3185         }
3186
3187
3188         /* We want the last (and probably only) config in this room */
3189         begin_critical_section(S_CONFIG);
3190         config_msgnum = (-1L);
3191         CtdlForEachMessage(MSGS_LAST, 1, sysconfname, NULL,
3192                 CtdlGetSysConfigBackend, NULL);
3193         msgnum = config_msgnum;
3194         end_critical_section(S_CONFIG);
3195
3196         if (msgnum < 0L) {
3197                 conf = NULL;
3198         }
3199         else {
3200                 msg = CtdlFetchMessage(msgnum);
3201                 if (msg != NULL) {
3202                         conf = strdoop(msg->cm_fields['M']);
3203                         CtdlFreeMessage(msg);
3204                 }
3205                 else {
3206                         conf = NULL;
3207                 }
3208         }
3209
3210         getroom(&CC->room, hold_rm);
3211
3212         if (conf != NULL) do {
3213                 extract_token(buf, conf, 0, '\n');
3214                 strcpy(conf, &conf[strlen(buf)+1]);
3215         } while ( (strlen(conf)>0) && (strlen(buf)>0) );
3216
3217         return(conf);
3218 }
3219
3220 void CtdlPutSysConfig(char *sysconfname, char *sysconfdata) {
3221         char temp[PATH_MAX];
3222         FILE *fp;
3223
3224         strcpy(temp, tmpnam(NULL));
3225
3226         fp = fopen(temp, "w");
3227         if (fp == NULL) return;
3228         fprintf(fp, "%s", sysconfdata);
3229         fclose(fp);
3230
3231         /* this handy API function does all the work for us */
3232         CtdlWriteObject(SYSCONFIGROOM, sysconfname, temp, NULL, 0, 1, 0);
3233         unlink(temp);
3234 }
3235
3236
3237 /*
3238  * Determine whether a given Internet address belongs to the current user
3239  */
3240 int CtdlIsMe(char *addr) {
3241         struct recptypes *recp;
3242         int i;
3243
3244         recp = validate_recipients(addr);
3245         if (recp == NULL) return(0);
3246
3247         if (recp->num_local == 0) {
3248                 phree(recp);
3249                 return(0);
3250         }
3251
3252         for (i=0; i<recp->num_local; ++i) {
3253                 extract(addr, recp->recp_local, i);
3254                 if (!strcasecmp(addr, CC->user.fullname)) {
3255                         phree(recp);
3256                         return(1);
3257                 }
3258         }
3259
3260         phree(recp);
3261         return(0);
3262 }
3263
3264
3265 /*
3266  * Citadel protocol command to do the same
3267  */
3268 void cmd_isme(char *argbuf) {
3269         char addr[SIZ];
3270
3271         if (CtdlAccessCheck(ac_logged_in)) return;
3272         extract(addr, argbuf, 0);
3273
3274         if (CtdlIsMe(addr)) {
3275                 cprintf("%d %s\n", CIT_OK, addr);
3276         }
3277         else {
3278                 cprintf("%d Not you.\n", ERROR);
3279         }
3280
3281 }