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