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, "Selected room %s\n", (recps) ? CC->room.QRname : SENTITEMS);
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: %s\n",
1989                         (CC->user.axlevel == 2) ? config.c_twitroom : "OK");
1990         if (TWITDETECT) {
1991                 if (CC->user.axlevel == 2) {
1992                         strcpy(hold_rm, actual_rm);
1993                         strcpy(actual_rm, config.c_twitroom);
1994                 }
1995         }
1996
1997         /* ...or if this message is destined for Aide> then go there. */
1998         if (strlen(force_room) > 0) {
1999                 strcpy(actual_rm, force_room);
2000         }
2001
2002         lprintf(9, "Final selection: %s\n", actual_rm);
2003         if (strcasecmp(actual_rm, CC->room.QRname)) {
2004                 getroom(&CC->room, actual_rm);
2005         }
2006
2007         /*
2008          * If this message has no O (room) field, generate one.
2009          */
2010         if (msg->cm_fields['O'] == NULL) {
2011                 msg->cm_fields['O'] = strdoop(CC->room.QRname);
2012         }
2013
2014         /* Perform "before save" hooks (aborting if any return nonzero) */
2015         lprintf(9, "Performing before-save hooks\n");
2016         if (PerformMessageHooks(msg, EVT_BEFORESAVE) > 0) return(-1);
2017
2018         /* If this message has an Extended ID, perform replication checks */
2019         lprintf(9, "Performing replication checks\n");
2020         if (ReplicationChecks(msg) > 0) return(-1);
2021
2022         /* Save it to disk */
2023         lprintf(9, "Saving to disk\n");
2024         newmsgid = send_message(msg, NULL);
2025         if (newmsgid <= 0L) return(-1);
2026
2027         /* Write a supplemental message info record.  This doesn't have to
2028          * be a critical section because nobody else knows about this message
2029          * yet.
2030          */
2031         lprintf(9, "Creating MetaData record\n");
2032         memset(&smi, 0, sizeof(struct MetaData));
2033         smi.meta_msgnum = newmsgid;
2034         smi.meta_refcount = 0;
2035         safestrncpy(smi.meta_content_type, content_type, 64);
2036         PutMetaData(&smi);
2037
2038         /* Now figure out where to store the pointers */
2039         lprintf(9, "Storing pointers\n");
2040
2041         /* If this is being done by the networker delivering a private
2042          * message, we want to BYPASS saving the sender's copy (because there
2043          * is no local sender; it would otherwise go to the Trashcan).
2044          */
2045         if ((!CC->internal_pgm) || (recps == NULL)) {
2046                 if (CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0) != 0) {
2047                         lprintf(3, "ERROR saving message pointer!\n");
2048                         CtdlSaveMsgPointerInRoom(config.c_aideroom, newmsgid, 0);
2049                 }
2050         }
2051
2052         /* For internet mail, drop a copy in the outbound queue room */
2053         if (recps != NULL)
2054          if (recps->num_internet > 0) {
2055                 CtdlSaveMsgPointerInRoom(SMTP_SPOOLOUT_ROOM, newmsgid, 0);
2056         }
2057
2058         /* If other rooms are specified, drop them there too. */
2059         if (recps != NULL)
2060          if (recps->num_room > 0)
2061           for (i=0; i<num_tokens(recps->recp_room, '|'); ++i) {
2062                 extract(recipient, recps->recp_room, i);
2063                 lprintf(9, "Delivering to local room <%s>\n", recipient);
2064                 CtdlSaveMsgPointerInRoom(recipient, newmsgid, 0);
2065         }
2066
2067         /* Bump this user's messages posted counter. */
2068         lprintf(9, "Updating user\n");
2069         lgetuser(&CC->user, CC->curr_user);
2070         CC->user.posted = CC->user.posted + 1;
2071         lputuser(&CC->user);
2072
2073         /* If this is private, local mail, make a copy in the
2074          * recipient's mailbox and bump the reference count.
2075          */
2076         if (recps != NULL)
2077          if (recps->num_local > 0)
2078           for (i=0; i<num_tokens(recps->recp_local, '|'); ++i) {
2079                 extract(recipient, recps->recp_local, i);
2080                 lprintf(9, "Delivering private local mail to <%s>\n",
2081                         recipient);
2082                 if (getuser(&userbuf, recipient) == 0) {
2083                         MailboxName(actual_rm, sizeof actual_rm, &userbuf, MAILROOM);
2084                         CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0);
2085                         BumpNewMailCounter(userbuf.usernum);
2086                 }
2087                 else {
2088                         lprintf(9, "No user <%s>\n", recipient);
2089                         CtdlSaveMsgPointerInRoom(config.c_aideroom, newmsgid, 0);
2090                 }
2091         }
2092
2093         /* Perform "after save" hooks */
2094         lprintf(9, "Performing after-save hooks\n");
2095         PerformMessageHooks(msg, EVT_AFTERSAVE);
2096
2097         /* For IGnet mail, we have to save a new copy into the spooler for
2098          * each recipient, with the R and D fields set to the recipient and
2099          * destination-node.  This has two ugly side effects: all other
2100          * recipients end up being unlisted in this recipient's copy of the
2101          * message, and it has to deliver multiple messages to the same
2102          * node.  We'll revisit this again in a year or so when everyone has
2103          * a network spool receiver that can handle the new style messages.
2104          */
2105         if (recps != NULL)
2106          if (recps->num_ignet > 0)
2107           for (i=0; i<num_tokens(recps->recp_ignet, '|'); ++i) {
2108                 extract(recipient, recps->recp_ignet, i);
2109
2110                 hold_R = msg->cm_fields['R'];
2111                 hold_D = msg->cm_fields['D'];
2112                 msg->cm_fields['R'] = mallok(SIZ);
2113                 msg->cm_fields['D'] = mallok(SIZ);
2114                 extract_token(msg->cm_fields['R'], recipient, 0, '@');
2115                 extract_token(msg->cm_fields['D'], recipient, 1, '@');
2116
2117                 serialize_message(&smr, msg);
2118                 if (smr.len > 0) {
2119                         snprintf(aaa, sizeof aaa,
2120                                 "./network/spoolin/netmail.%04lx.%04x.%04x",
2121                                 (long) getpid(), CC->cs_pid, ++seqnum);
2122                         network_fp = fopen(aaa, "wb+");
2123                         if (network_fp != NULL) {
2124                                 fwrite(smr.ser, smr.len, 1, network_fp);
2125                                 fclose(network_fp);
2126                         }
2127                         phree(smr.ser);
2128                 }
2129
2130                 phree(msg->cm_fields['R']);
2131                 phree(msg->cm_fields['D']);
2132                 msg->cm_fields['R'] = hold_R;
2133                 msg->cm_fields['D'] = hold_D;
2134         }
2135
2136         /* Go back to the room we started from */
2137         lprintf(9, "Returning to original room %s\n", hold_rm);
2138         if (strcasecmp(hold_rm, CC->room.QRname))
2139                 getroom(&CC->room, hold_rm);
2140
2141         /* For internet mail, generate delivery instructions.
2142          * Yes, this is recursive.  Deal with it.  Infinite recursion does
2143          * not happen because the delivery instructions message does not
2144          * contain a recipient.
2145          */
2146         if (recps != NULL)
2147          if (recps->num_internet > 0) {
2148                 lprintf(9, "Generating delivery instructions\n");
2149                 instr = mallok(SIZ * 2);
2150                 snprintf(instr, SIZ * 2,
2151                         "Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
2152                         "bounceto|%s@%s\n",
2153                         SPOOLMIME, newmsgid, (long)time(NULL),
2154                         msg->cm_fields['A'], msg->cm_fields['N']
2155                 );
2156
2157                 for (i=0; i<num_tokens(recps->recp_internet, '|'); ++i) {
2158                         size_t tmp = strlen(instr);
2159                         extract(recipient, recps->recp_internet, i);
2160                         snprintf(&instr[tmp], SIZ * 2 - tmp,
2161                                  "remote|%s|0||\n", recipient);
2162                 }
2163
2164                 imsg = mallok(sizeof(struct CtdlMessage));
2165                 memset(imsg, 0, sizeof(struct CtdlMessage));
2166                 imsg->cm_magic = CTDLMESSAGE_MAGIC;
2167                 imsg->cm_anon_type = MES_NORMAL;
2168                 imsg->cm_format_type = FMT_RFC822;
2169                 imsg->cm_fields['A'] = strdoop("Citadel");
2170                 imsg->cm_fields['M'] = instr;
2171                 CtdlSubmitMsg(imsg, NULL, SMTP_SPOOLOUT_ROOM);
2172                 CtdlFreeMessage(imsg);
2173         }
2174
2175         return(newmsgid);
2176 }
2177
2178
2179
2180 /*
2181  * Convenience function for generating small administrative messages.
2182  */
2183 void quickie_message(char *from, char *to, char *room, char *text,
2184                         int format_type, char *subject)
2185 {
2186         struct CtdlMessage *msg;
2187         struct recptypes *recp = NULL;
2188
2189         msg = mallok(sizeof(struct CtdlMessage));
2190         memset(msg, 0, sizeof(struct CtdlMessage));
2191         msg->cm_magic = CTDLMESSAGE_MAGIC;
2192         msg->cm_anon_type = MES_NORMAL;
2193         msg->cm_format_type = format_type;
2194         msg->cm_fields['A'] = strdoop(from);
2195         if (room != NULL) msg->cm_fields['O'] = strdoop(room);
2196         msg->cm_fields['N'] = strdoop(NODENAME);
2197         if (to != NULL) {
2198                 msg->cm_fields['R'] = strdoop(to);
2199                 recp = validate_recipients(to);
2200         }
2201         if (subject != NULL) {
2202                 msg->cm_fields['U'] = strdoop(subject);
2203         }
2204         msg->cm_fields['M'] = strdoop(text);
2205
2206         CtdlSubmitMsg(msg, recp, room);
2207         CtdlFreeMessage(msg);
2208         if (recp != NULL) phree(recp);
2209 }
2210
2211
2212
2213 /*
2214  * Back end function used by CtdlMakeMessage() and similar functions
2215  */
2216 char *CtdlReadMessageBody(char *terminator,     /* token signalling EOT */
2217                         size_t maxlen,          /* maximum message length */
2218                         char *exist,            /* if non-null, append to it;
2219                                                    exist is ALWAYS freed  */
2220                         int crlf                /* CRLF newlines instead of LF */
2221                         ) {
2222         char buf[SIZ];
2223         int linelen;
2224         size_t message_len = 0;
2225         size_t buffer_len = 0;
2226         char *ptr;
2227         char *m;
2228         int flushing = 0;
2229         int finished = 0;
2230
2231         if (exist == NULL) {
2232                 m = mallok(4096);
2233                 m[0] = 0;
2234                 buffer_len = 4096;
2235                 message_len = 0;
2236         }
2237         else {
2238                 message_len = strlen(exist);
2239                 buffer_len = message_len + 4096;
2240                 m = reallok(exist, buffer_len);
2241                 if (m == NULL) {
2242                         phree(exist);
2243                         return m;
2244                 }
2245         }
2246
2247         /* flush the input if we have nowhere to store it */
2248         if (m == NULL) {
2249                 flushing = 1;
2250         }
2251
2252         /* read in the lines of message text one by one */
2253         do {
2254                 if (client_gets(buf) < 1) finished = 1;
2255                 if (!strcmp(buf, terminator)) finished = 1;
2256                 if (crlf) {
2257                         strcat(buf, "\r\n");
2258                 }
2259                 else {
2260                         strcat(buf, "\n");
2261                 }
2262
2263                 if ( (!flushing) && (!finished) ) {
2264                         /* Measure the line */
2265                         linelen = strlen(buf);
2266
2267                         /* augment the buffer if we have to */
2268                         if ((message_len + linelen) >= buffer_len) {
2269                                 ptr = reallok(m, (buffer_len * 2) );
2270                                 if (ptr == NULL) {      /* flush if can't allocate */
2271                                         flushing = 1;
2272                                 } else {
2273                                         buffer_len = (buffer_len * 2);
2274                                         m = ptr;
2275                                         lprintf(9, "buffer_len is now %ld\n", (long)buffer_len);
2276                                 }
2277                         }
2278
2279                         /* Add the new line to the buffer.  NOTE: this loop must avoid
2280                         * using functions like strcat() and strlen() because they
2281                         * traverse the entire buffer upon every call, and doing that
2282                         * for a multi-megabyte message slows it down beyond usability.
2283                         */
2284                         strcpy(&m[message_len], buf);
2285                         message_len += linelen;
2286                 }
2287
2288                 /* if we've hit the max msg length, flush the rest */
2289                 if (message_len >= maxlen) flushing = 1;
2290
2291         } while (!finished);
2292         return(m);
2293 }
2294
2295
2296
2297
2298 /*
2299  * Build a binary message to be saved on disk.
2300  * (NOTE: if you supply 'preformatted_text', the buffer you give it
2301  * will become part of the message.  This means you are no longer
2302  * responsible for managing that memory -- it will be freed along with
2303  * the rest of the fields when CtdlFreeMessage() is called.)
2304  */
2305
2306 struct CtdlMessage *CtdlMakeMessage(
2307         struct ctdluser *author,        /* author's user structure */
2308         char *recipient,                /* NULL if it's not mail */
2309         char *room,                     /* room where it's going */
2310         int type,                       /* see MES_ types in header file */
2311         int format_type,                /* variformat, plain text, MIME... */
2312         char *fake_name,                /* who we're masquerading as */
2313         char *subject,                  /* Subject (optional) */
2314         char *preformatted_text         /* ...or NULL to read text from client */
2315 ) {
2316         char dest_node[SIZ];
2317         char buf[SIZ];
2318         struct CtdlMessage *msg;
2319
2320         msg = mallok(sizeof(struct CtdlMessage));
2321         memset(msg, 0, sizeof(struct CtdlMessage));
2322         msg->cm_magic = CTDLMESSAGE_MAGIC;
2323         msg->cm_anon_type = type;
2324         msg->cm_format_type = format_type;
2325
2326         /* Don't confuse the poor folks if it's not routed mail. */
2327         strcpy(dest_node, "");
2328
2329         striplt(recipient);
2330
2331         snprintf(buf, sizeof buf, "cit%ld", author->usernum);   /* Path */
2332         msg->cm_fields['P'] = strdoop(buf);
2333
2334         snprintf(buf, sizeof buf, "%ld", (long)time(NULL));     /* timestamp */
2335         msg->cm_fields['T'] = strdoop(buf);
2336
2337         if (fake_name[0])                                       /* author */
2338                 msg->cm_fields['A'] = strdoop(fake_name);
2339         else
2340                 msg->cm_fields['A'] = strdoop(author->fullname);
2341
2342         if (CC->room.QRflags & QR_MAILBOX) {            /* room */
2343                 msg->cm_fields['O'] = strdoop(&CC->room.QRname[11]);
2344         }
2345         else {
2346                 msg->cm_fields['O'] = strdoop(CC->room.QRname);
2347         }
2348
2349         msg->cm_fields['N'] = strdoop(NODENAME);                /* nodename */
2350         msg->cm_fields['H'] = strdoop(HUMANNODE);               /* hnodename */
2351
2352         if (recipient[0] != 0) {
2353                 msg->cm_fields['R'] = strdoop(recipient);
2354         }
2355         if (dest_node[0] != 0) {
2356                 msg->cm_fields['D'] = strdoop(dest_node);
2357         }
2358
2359         if ( (author == &CC->user) && (strlen(CC->cs_inet_email) > 0) ) {
2360                 msg->cm_fields['F'] = strdoop(CC->cs_inet_email);
2361         }
2362
2363         if (subject != NULL) {
2364                 striplt(subject);
2365                 if (strlen(subject) > 0) {
2366                         msg->cm_fields['U'] = strdoop(subject);
2367                 }
2368         }
2369
2370         if (preformatted_text != NULL) {
2371                 msg->cm_fields['M'] = preformatted_text;
2372         }
2373         else {
2374                 msg->cm_fields['M'] = CtdlReadMessageBody("000",
2375                                         config.c_maxmsglen, NULL, 0);
2376         }
2377
2378         return(msg);
2379 }
2380
2381
2382 /*
2383  * Check to see whether we have permission to post a message in the current
2384  * room.  Returns a *CITADEL ERROR CODE* and puts a message in errmsgbuf, or
2385  * returns 0 on success.
2386  */
2387 int CtdlDoIHavePermissionToPostInThisRoom(char *errmsgbuf, size_t n) {
2388
2389         if (!(CC->logged_in)) {
2390                 snprintf(errmsgbuf, n, "Not logged in.");
2391                 return (ERROR + NOT_LOGGED_IN);
2392         }
2393
2394         if ((CC->user.axlevel < 2)
2395             && ((CC->room.QRflags & QR_MAILBOX) == 0)) {
2396                 snprintf(errmsgbuf, n, "Need to be validated to enter "
2397                                 "(except in %s> to sysop)", MAILROOM);
2398                 return (ERROR + HIGHER_ACCESS_REQUIRED);
2399         }
2400
2401         if ((CC->user.axlevel < 4)
2402            && (CC->room.QRflags & QR_NETWORK)) {
2403                 snprintf(errmsgbuf, n, "Need net privileges to enter here.");
2404                 return (ERROR + HIGHER_ACCESS_REQUIRED);
2405         }
2406
2407         if ((CC->user.axlevel < 6)
2408            && (CC->room.QRflags & QR_READONLY)) {
2409                 snprintf(errmsgbuf, n, "Sorry, this is a read-only room.");
2410                 return (ERROR + HIGHER_ACCESS_REQUIRED);
2411         }
2412
2413         strcpy(errmsgbuf, "Ok");
2414         return(0);
2415 }
2416
2417
2418 /*
2419  * Check to see if the specified user has Internet mail permission
2420  * (returns nonzero if permission is granted)
2421  */
2422 int CtdlCheckInternetMailPermission(struct ctdluser *who) {
2423
2424         /* Globally enabled? */
2425         if (config.c_restrict == 0) return(1);
2426
2427         /* User flagged ok? */
2428         if (who->flags & US_INTERNET) return(2);
2429
2430         /* Aide level access? */
2431         if (who->axlevel >= 6) return(3);
2432
2433         /* No mail for you! */
2434         return(0);
2435 }
2436
2437
2438
2439 /*
2440  * Validate recipients, count delivery types and errors, and handle aliasing
2441  * FIXME check for dupes!!!!!
2442  */
2443 struct recptypes *validate_recipients(char *recipients) {
2444         struct recptypes *ret;
2445         char this_recp[SIZ];
2446         char this_recp_cooked[SIZ];
2447         char append[SIZ];
2448         int num_recps;
2449         int i, j;
2450         int mailtype;
2451         int invalid;
2452         struct ctdluser tempUS;
2453         struct ctdlroom tempQR;
2454
2455         /* Initialize */
2456         ret = (struct recptypes *) malloc(sizeof(struct recptypes));
2457         if (ret == NULL) return(NULL);
2458         memset(ret, 0, sizeof(struct recptypes));
2459
2460         ret->num_local = 0;
2461         ret->num_internet = 0;
2462         ret->num_ignet = 0;
2463         ret->num_error = 0;
2464         ret->num_room = 0;
2465
2466         if (recipients == NULL) {
2467                 num_recps = 0;
2468         }
2469         else if (strlen(recipients) == 0) {
2470                 num_recps = 0;
2471         }
2472         else {
2473                 /* Change all valid separator characters to commas */
2474                 for (i=0; i<strlen(recipients); ++i) {
2475                         if ((recipients[i] == ';') || (recipients[i] == '|')) {
2476                                 recipients[i] = ',';
2477                         }
2478                 }
2479
2480                 /* Count 'em up */
2481                 num_recps = num_tokens(recipients, ',');
2482         }
2483
2484         if (num_recps > 0) for (i=0; i<num_recps; ++i) {
2485                 extract_token(this_recp, recipients, i, ',');
2486                 striplt(this_recp);
2487                 lprintf(9, "Evaluating recipient #%d <%s>\n", i, this_recp);
2488                 mailtype = alias(this_recp);
2489                 mailtype = alias(this_recp);
2490                 mailtype = alias(this_recp);
2491                 for (j=0; j<=strlen(this_recp); ++j) {
2492                         if (this_recp[j]=='_') {
2493                                 this_recp_cooked[j] = ' ';
2494                         }
2495                         else {
2496                                 this_recp_cooked[j] = this_recp[j];
2497                         }
2498                 }
2499                 invalid = 0;
2500                 switch(mailtype) {
2501                         case MES_LOCAL:
2502                                 if (!strcasecmp(this_recp, "sysop")) {
2503                                         ++ret->num_room;
2504                                         strcpy(this_recp, config.c_aideroom);
2505                                         if (strlen(ret->recp_room) > 0) {
2506                                                 strcat(ret->recp_room, "|");
2507                                         }
2508                                         strcat(ret->recp_room, this_recp);
2509                                 }
2510                                 else if (getuser(&tempUS, this_recp) == 0) {
2511                                         ++ret->num_local;
2512                                         strcpy(this_recp, tempUS.fullname);
2513                                         if (strlen(ret->recp_local) > 0) {
2514                                                 strcat(ret->recp_local, "|");
2515                                         }
2516                                         strcat(ret->recp_local, this_recp);
2517                                 }
2518                                 else if (getuser(&tempUS, this_recp_cooked) == 0) {
2519                                         ++ret->num_local;
2520                                         strcpy(this_recp, tempUS.fullname);
2521                                         if (strlen(ret->recp_local) > 0) {
2522                                                 strcat(ret->recp_local, "|");
2523                                         }
2524                                         strcat(ret->recp_local, this_recp);
2525                                 }
2526                                 else if ( (!strncasecmp(this_recp, "room_", 5))
2527                                       && (!getroom(&tempQR, &this_recp_cooked[5])) ) {
2528                                         ++ret->num_room;
2529                                         if (strlen(ret->recp_room) > 0) {
2530                                                 strcat(ret->recp_room, "|");
2531                                         }
2532                                         strcat(ret->recp_room, &this_recp_cooked[5]);
2533                                 }
2534                                 else {
2535                                         ++ret->num_error;
2536                                         invalid = 1;
2537                                 }
2538                                 break;
2539                         case MES_INTERNET:
2540                                 /* Yes, you're reading this correctly: if the target
2541                                  * domain points back to the local system or an attached
2542                                  * Citadel directory, the address is invalid.  That's
2543                                  * because if the address were valid, we would have
2544                                  * already translated it to a local address by now.
2545                                  */
2546                                 if (IsDirectory(this_recp)) {
2547                                         ++ret->num_error;
2548                                         invalid = 1;
2549                                 }
2550                                 else {
2551                                         ++ret->num_internet;
2552                                         if (strlen(ret->recp_internet) > 0) {
2553                                                 strcat(ret->recp_internet, "|");
2554                                         }
2555                                         strcat(ret->recp_internet, this_recp);
2556                                 }
2557                                 break;
2558                         case MES_IGNET:
2559                                 ++ret->num_ignet;
2560                                 if (strlen(ret->recp_ignet) > 0) {
2561                                         strcat(ret->recp_ignet, "|");
2562                                 }
2563                                 strcat(ret->recp_ignet, this_recp);
2564                                 break;
2565                         case MES_ERROR:
2566                                 ++ret->num_error;
2567                                 invalid = 1;
2568                                 break;
2569                 }
2570                 if (invalid) {
2571                         if (strlen(ret->errormsg) == 0) {
2572                                 snprintf(append, sizeof append,
2573                                          "Invalid recipient: %s",
2574                                          this_recp);
2575                         }
2576                         else {
2577                                 snprintf(append, sizeof append,
2578                                          ", %s", this_recp);
2579                         }
2580                         if ( (strlen(ret->errormsg) + strlen(append)) < SIZ) {
2581                                 strcat(ret->errormsg, append);
2582                         }
2583                 }
2584                 else {
2585                         if (strlen(ret->display_recp) == 0) {
2586                                 strcpy(append, this_recp);
2587                         }
2588                         else {
2589                                 snprintf(append, sizeof append, ", %s",
2590                                          this_recp);
2591                         }
2592                         if ( (strlen(ret->display_recp)+strlen(append)) < SIZ) {
2593                                 strcat(ret->display_recp, append);
2594                         }
2595                 }
2596         }
2597
2598         if ((ret->num_local + ret->num_internet + ret->num_ignet +
2599            ret->num_room + ret->num_error) == 0) {
2600                 ++ret->num_error;
2601                 strcpy(ret->errormsg, "No recipients specified.");
2602         }
2603
2604         lprintf(9, "validate_recipients()\n");
2605         lprintf(9, " local: %d <%s>\n", ret->num_local, ret->recp_local);
2606         lprintf(9, "  room: %d <%s>\n", ret->num_room, ret->recp_room);
2607         lprintf(9, "  inet: %d <%s>\n", ret->num_internet, ret->recp_internet);
2608         lprintf(9, " ignet: %d <%s>\n", ret->num_ignet, ret->recp_ignet);
2609         lprintf(9, " error: %d <%s>\n", ret->num_error, ret->errormsg);
2610
2611         return(ret);
2612 }
2613
2614
2615
2616 /*
2617  * message entry  -  mode 0 (normal)
2618  */
2619 void cmd_ent0(char *entargs)
2620 {
2621         int post = 0;
2622         char recp[SIZ];
2623         char masquerade_as[SIZ];
2624         int anon_flag = 0;
2625         int format_type = 0;
2626         char newusername[SIZ];
2627         struct CtdlMessage *msg;
2628         int anonymous = 0;
2629         char errmsg[SIZ];
2630         int err = 0;
2631         struct recptypes *valid = NULL;
2632         char subject[SIZ];
2633
2634         post = extract_int(entargs, 0);
2635         extract(recp, entargs, 1);
2636         anon_flag = extract_int(entargs, 2);
2637         format_type = extract_int(entargs, 3);
2638         extract(subject, entargs, 4);
2639
2640         /* first check to make sure the request is valid. */
2641
2642         err = CtdlDoIHavePermissionToPostInThisRoom(errmsg, sizeof errmsg);
2643         if (err) {
2644                 cprintf("%d %s\n", err, errmsg);
2645                 return;
2646         }
2647
2648         /* Check some other permission type things. */
2649
2650         if (post == 2) {
2651                 if (CC->user.axlevel < 6) {
2652                         cprintf("%d You don't have permission to masquerade.\n",
2653                                 ERROR + HIGHER_ACCESS_REQUIRED);
2654                         return;
2655                 }
2656                 extract(newusername, entargs, 5);
2657                 memset(CC->fake_postname, 0, sizeof(CC->fake_postname) );
2658                 safestrncpy(CC->fake_postname, newusername,
2659                         sizeof(CC->fake_postname) );
2660                 cprintf("%d ok\n", CIT_OK);
2661                 return;
2662         }
2663         CC->cs_flags |= CS_POSTING;
2664
2665         /* In the Mail> room we have to behave a little differently --
2666          * make sure the user has specified at least one recipient.  Then
2667          * validate the recipient(s).
2668          */
2669         if ( (CC->room.QRflags & QR_MAILBOX)
2670            && (!strcasecmp(&CC->room.QRname[11], MAILROOM)) ) {
2671
2672                 if (CC->user.axlevel < 2) {
2673                         strcpy(recp, "sysop");
2674                 }
2675
2676                 valid = validate_recipients(recp);
2677                 if (valid->num_error > 0) {
2678                         cprintf("%d %s\n",
2679                                 ERROR + NO_SUCH_USER, valid->errormsg);
2680                         phree(valid);
2681                         return;
2682                 }
2683                 if (valid->num_internet > 0) {
2684                         if (CtdlCheckInternetMailPermission(&CC->user)==0) {
2685                                 cprintf("%d You do not have permission "
2686                                         "to send Internet mail.\n",
2687                                         ERROR + HIGHER_ACCESS_REQUIRED);
2688                                 phree(valid);
2689                                 return;
2690                         }
2691                 }
2692
2693                 if ( ( (valid->num_internet + valid->num_ignet) > 0)
2694                    && (CC->user.axlevel < 4) ) {
2695                         cprintf("%d Higher access required for network mail.\n",
2696                                 ERROR + HIGHER_ACCESS_REQUIRED);
2697                         phree(valid);
2698                         return;
2699                 }
2700
2701                 if ((RESTRICT_INTERNET == 1) && (valid->num_internet > 0)
2702                     && ((CC->user.flags & US_INTERNET) == 0)
2703                     && (!CC->internal_pgm)) {
2704                         cprintf("%d You don't have access to Internet mail.\n",
2705                                 ERROR + HIGHER_ACCESS_REQUIRED);
2706                         phree(valid);
2707                         return;
2708                 }
2709
2710         }
2711
2712         /* Is this a room which has anonymous-only or anonymous-option? */
2713         anonymous = MES_NORMAL;
2714         if (CC->room.QRflags & QR_ANONONLY) {
2715                 anonymous = MES_ANONONLY;
2716         }
2717         if (CC->room.QRflags & QR_ANONOPT) {
2718                 if (anon_flag == 1) {   /* only if the user requested it */
2719                         anonymous = MES_ANONOPT;
2720                 }
2721         }
2722
2723         if ((CC->room.QRflags & QR_MAILBOX) == 0) {
2724                 recp[0] = 0;
2725         }
2726
2727         /* If we're only checking the validity of the request, return
2728          * success without creating the message.
2729          */
2730         if (post == 0) {
2731                 cprintf("%d %s\n", CIT_OK,
2732                         ((valid != NULL) ? valid->display_recp : "") );
2733                 phree(valid);
2734                 return;
2735         }
2736
2737         /* Handle author masquerading */
2738         if (CC->fake_postname[0]) {
2739                 strcpy(masquerade_as, CC->fake_postname);
2740         }
2741         else if (CC->fake_username[0]) {
2742                 strcpy(masquerade_as, CC->fake_username);
2743         }
2744         else {
2745                 strcpy(masquerade_as, "");
2746         }
2747
2748         /* Read in the message from the client. */
2749         cprintf("%d send message\n", SEND_LISTING);
2750         msg = CtdlMakeMessage(&CC->user, recp,
2751                 CC->room.QRname, anonymous, format_type,
2752                 masquerade_as, subject, NULL);
2753
2754         if (msg != NULL) {
2755                 CtdlSubmitMsg(msg, valid, "");
2756                 CtdlFreeMessage(msg);
2757         }
2758         CC->fake_postname[0] = '\0';
2759         phree(valid);
2760         return;
2761 }
2762
2763
2764
2765 /*
2766  * API function to delete messages which match a set of criteria
2767  * (returns the actual number of messages deleted)
2768  */
2769 int CtdlDeleteMessages(char *room_name,         /* which room */
2770                        long dmsgnum,            /* or "0" for any */
2771                        char *content_type       /* or "" for any */
2772 )
2773 {
2774
2775         struct ctdlroom qrbuf;
2776         struct cdbdata *cdbfr;
2777         long *msglist = NULL;
2778         long *dellist = NULL;
2779         int num_msgs = 0;
2780         int i;
2781         int num_deleted = 0;
2782         int delete_this;
2783         struct MetaData smi;
2784
2785         lprintf(9, "CtdlDeleteMessages(%s, %ld, %s)\n",
2786                 room_name, dmsgnum, content_type);
2787
2788         /* get room record, obtaining a lock... */
2789         if (lgetroom(&qrbuf, room_name) != 0) {
2790                 lprintf(7, "CtdlDeleteMessages(): Room <%s> not found\n",
2791                         room_name);
2792                 return (0);     /* room not found */
2793         }
2794         cdbfr = cdb_fetch(CDB_MSGLISTS, &qrbuf.QRnumber, sizeof(long));
2795
2796         if (cdbfr != NULL) {
2797                 msglist = mallok(cdbfr->len);
2798                 dellist = mallok(cdbfr->len);
2799                 memcpy(msglist, cdbfr->ptr, cdbfr->len);
2800                 num_msgs = cdbfr->len / sizeof(long);
2801                 cdb_free(cdbfr);
2802         }
2803         if (num_msgs > 0) {
2804                 for (i = 0; i < num_msgs; ++i) {
2805                         delete_this = 0x00;
2806
2807                         /* Set/clear a bit for each criterion */
2808
2809                         if ((dmsgnum == 0L) || (msglist[i] == dmsgnum)) {
2810                                 delete_this |= 0x01;
2811                         }
2812                         if (strlen(content_type) == 0) {
2813                                 delete_this |= 0x02;
2814                         } else {
2815                                 GetMetaData(&smi, msglist[i]);
2816                                 if (!strcasecmp(smi.meta_content_type,
2817                                                 content_type)) {
2818                                         delete_this |= 0x02;
2819                                 }
2820                         }
2821
2822                         /* Delete message only if all bits are set */
2823                         if (delete_this == 0x03) {
2824                                 dellist[num_deleted++] = msglist[i];
2825                                 msglist[i] = 0L;
2826                         }
2827                 }
2828
2829                 num_msgs = sort_msglist(msglist, num_msgs);
2830                 cdb_store(CDB_MSGLISTS, &qrbuf.QRnumber, sizeof(long),
2831                           msglist, (num_msgs * sizeof(long)));
2832
2833                 qrbuf.QRhighest = msglist[num_msgs - 1];
2834         }
2835         lputroom(&qrbuf);
2836
2837         /* Go through the messages we pulled out of the index, and decrement
2838          * their reference counts by 1.  If this is the only room the message
2839          * was in, the reference count will reach zero and the message will
2840          * automatically be deleted from the database.  We do this in a
2841          * separate pass because there might be plug-in hooks getting called,
2842          * and we don't want that happening during an S_ROOMS critical
2843          * section.
2844          */
2845         if (num_deleted) for (i=0; i<num_deleted; ++i) {
2846                 PerformDeleteHooks(qrbuf.QRname, dellist[i]);
2847                 AdjRefCount(dellist[i], -1);
2848         }
2849
2850         /* Now free the memory we used, and go away. */
2851         if (msglist != NULL) phree(msglist);
2852         if (dellist != NULL) phree(dellist);
2853         lprintf(9, "%d message(s) deleted.\n", num_deleted);
2854         return (num_deleted);
2855 }
2856
2857
2858
2859 /*
2860  * Check whether the current user has permission to delete messages from
2861  * the current room (returns 1 for yes, 0 for no)
2862  */
2863 int CtdlDoIHavePermissionToDeleteMessagesFromThisRoom(void) {
2864         getuser(&CC->user, CC->curr_user);
2865         if ((CC->user.axlevel < 6)
2866             && (CC->user.usernum != CC->room.QRroomaide)
2867             && ((CC->room.QRflags & QR_MAILBOX) == 0)
2868             && (!(CC->internal_pgm))) {
2869                 return(0);
2870         }
2871         return(1);
2872 }
2873
2874
2875
2876 /*
2877  * Delete message from current room
2878  */
2879 void cmd_dele(char *delstr)
2880 {
2881         long delnum;
2882         int num_deleted;
2883
2884         if (CtdlDoIHavePermissionToDeleteMessagesFromThisRoom() == 0) {
2885                 cprintf("%d Higher access required.\n",
2886                         ERROR + HIGHER_ACCESS_REQUIRED);
2887                 return;
2888         }
2889         delnum = extract_long(delstr, 0);
2890
2891         num_deleted = CtdlDeleteMessages(CC->room.QRname, delnum, "");
2892
2893         if (num_deleted) {
2894                 cprintf("%d %d message%s deleted.\n", CIT_OK,
2895                         num_deleted, ((num_deleted != 1) ? "s" : ""));
2896         } else {
2897                 cprintf("%d Message %ld not found.\n", ERROR, delnum);
2898         }
2899 }
2900
2901
2902 /*
2903  * Back end API function for moves and deletes
2904  */
2905 int CtdlCopyMsgToRoom(long msgnum, char *dest) {
2906         int err;
2907
2908         err = CtdlSaveMsgPointerInRoom(dest, msgnum,
2909                 (SM_VERIFY_GOODNESS | SM_DO_REPL_CHECK) );
2910         if (err != 0) return(err);
2911
2912         return(0);
2913 }
2914
2915
2916
2917 /*
2918  * move or copy a message to another room
2919  */
2920 void cmd_move(char *args)
2921 {
2922         long num;
2923         char targ[SIZ];
2924         struct ctdlroom qtemp;
2925         int err;
2926         int is_copy = 0;
2927
2928         num = extract_long(args, 0);
2929         extract(targ, args, 1);
2930         targ[ROOMNAMELEN - 1] = 0;
2931         is_copy = extract_int(args, 2);
2932
2933         if (getroom(&qtemp, targ) != 0) {
2934                 cprintf("%d '%s' does not exist.\n", ERROR, targ);
2935                 return;
2936         }
2937
2938         getuser(&CC->user, CC->curr_user);
2939         /* Aides can move/copy */
2940         if ((CC->user.axlevel < 6)
2941             /* Roomaides can move/copy */
2942             && (CC->user.usernum != CC->room.QRroomaide)
2943             /* Permit move/copy to/from personal rooms */
2944             && (!((CC->room.QRflags & QR_MAILBOX)
2945                             && (qtemp.QRflags & QR_MAILBOX)))
2946             /* Permit only copy from public to personal room */
2947             && (!(is_copy && !(CC->room.QRflags & QR_MAILBOX)
2948                             && (qtemp.QRflags & QR_MAILBOX)))) {
2949                 cprintf("%d Higher access required.\n",
2950                         ERROR + HIGHER_ACCESS_REQUIRED);
2951                 return;
2952         }
2953
2954         err = CtdlCopyMsgToRoom(num, targ);
2955         if (err != 0) {
2956                 cprintf("%d Cannot store message in %s: error %d\n",
2957                         err, targ, err);
2958                 return;
2959         }
2960
2961         /* Now delete the message from the source room,
2962          * if this is a 'move' rather than a 'copy' operation.
2963          */
2964         if (is_copy == 0) {
2965                 CtdlDeleteMessages(CC->room.QRname, num, "");
2966         }
2967
2968         cprintf("%d Message %s.\n", CIT_OK, (is_copy ? "copied" : "moved") );
2969 }
2970
2971
2972
2973 /*
2974  * GetMetaData()  -  Get the supplementary record for a message
2975  */
2976 void GetMetaData(struct MetaData *smibuf, long msgnum)
2977 {
2978
2979         struct cdbdata *cdbsmi;
2980         long TheIndex;
2981
2982         memset(smibuf, 0, sizeof(struct MetaData));
2983         smibuf->meta_msgnum = msgnum;
2984         smibuf->meta_refcount = 1;      /* Default reference count is 1 */
2985
2986         /* Use the negative of the message number for its supp record index */
2987         TheIndex = (0L - msgnum);
2988
2989         cdbsmi = cdb_fetch(CDB_MSGMAIN, &TheIndex, sizeof(long));
2990         if (cdbsmi == NULL) {
2991                 return;         /* record not found; go with defaults */
2992         }
2993         memcpy(smibuf, cdbsmi->ptr,
2994                ((cdbsmi->len > sizeof(struct MetaData)) ?
2995                 sizeof(struct MetaData) : cdbsmi->len));
2996         cdb_free(cdbsmi);
2997         return;
2998 }
2999
3000
3001 /*
3002  * PutMetaData()  -  (re)write supplementary record for a message
3003  */
3004 void PutMetaData(struct MetaData *smibuf)
3005 {
3006         long TheIndex;
3007
3008         /* Use the negative of the message number for the metadata db index */
3009         TheIndex = (0L - smibuf->meta_msgnum);
3010
3011         lprintf(9, "PutMetaData(%ld) - ref count is %d\n",
3012                 smibuf->meta_msgnum, smibuf->meta_refcount);
3013
3014         cdb_store(CDB_MSGMAIN,
3015                   &TheIndex, sizeof(long),
3016                   smibuf, sizeof(struct MetaData));
3017
3018 }
3019
3020 /*
3021  * AdjRefCount  -  change the reference count for a message;
3022  *                 delete the message if it reaches zero
3023  */
3024 void AdjRefCount(long msgnum, int incr)
3025 {
3026
3027         struct MetaData smi;
3028         long delnum;
3029
3030         /* This is a *tight* critical section; please keep it that way, as
3031          * it may get called while nested in other critical sections.
3032          * Complicating this any further will surely cause deadlock!
3033          */
3034         begin_critical_section(S_SUPPMSGMAIN);
3035         GetMetaData(&smi, msgnum);
3036         lprintf(9, "Ref count for message <%ld> before write is <%d>\n",
3037                 msgnum, smi.meta_refcount);
3038         smi.meta_refcount += incr;
3039         PutMetaData(&smi);
3040         end_critical_section(S_SUPPMSGMAIN);
3041         lprintf(9, "Ref count for message <%ld> after write is <%d>\n",
3042                 msgnum, smi.meta_refcount);
3043
3044         /* If the reference count is now zero, delete the message
3045          * (and its supplementary record as well).
3046          */
3047         if (smi.meta_refcount == 0) {
3048                 lprintf(9, "Deleting message <%ld>\n", msgnum);
3049                 delnum = msgnum;
3050                 cdb_delete(CDB_MSGMAIN, &delnum, sizeof(long));
3051
3052                 /* We have to delete the metadata record too! */
3053                 delnum = (0L - msgnum);
3054                 cdb_delete(CDB_MSGMAIN, &delnum, sizeof(long));
3055         }
3056 }
3057
3058 /*
3059  * Write a generic object to this room
3060  *
3061  * Note: this could be much more efficient.  Right now we use two temporary
3062  * files, and still pull the message into memory as with all others.
3063  */
3064 void CtdlWriteObject(char *req_room,            /* Room to stuff it in */
3065                         char *content_type,     /* MIME type of this object */
3066                         char *tempfilename,     /* Where to fetch it from */
3067                         struct ctdluser *is_mailbox,    /* Mailbox room? */
3068                         int is_binary,          /* Is encoding necessary? */
3069                         int is_unique,          /* Del others of this type? */
3070                         unsigned int flags      /* Internal save flags */
3071                         )
3072 {
3073
3074         FILE *fp;
3075         struct ctdlroom qrbuf;
3076         char roomname[ROOMNAMELEN];
3077         struct CtdlMessage *msg;
3078
3079         char *raw_message = NULL;
3080         char *encoded_message = NULL;
3081         off_t raw_length = 0;
3082
3083         if (is_mailbox != NULL)
3084                 MailboxName(roomname, sizeof roomname, is_mailbox, req_room);
3085         else
3086                 safestrncpy(roomname, req_room, sizeof(roomname));
3087         lprintf(9, "CtdlWriteObject() to <%s> (flags=%d)\n", roomname, flags);
3088
3089
3090         fp = fopen(tempfilename, "rb");
3091         if (fp == NULL) {
3092                 lprintf(5, "Cannot open %s: %s\n",
3093                         tempfilename, strerror(errno));
3094                 return;
3095         }
3096         fseek(fp, 0L, SEEK_END);
3097         raw_length = ftell(fp);
3098         rewind(fp);
3099         lprintf(9, "Raw length is %ld\n", (long)raw_length);
3100
3101         raw_message = mallok((size_t)raw_length + 2);
3102         fread(raw_message, (size_t)raw_length, 1, fp);
3103         fclose(fp);
3104
3105         if (is_binary) {
3106                 encoded_message = mallok((size_t)
3107                         (((raw_length * 134) / 100) + 4096 ) );
3108         }
3109         else {
3110                 encoded_message = mallok((size_t)(raw_length + 4096));
3111         }
3112
3113         sprintf(encoded_message, "Content-type: %s\n", content_type);
3114
3115         if (is_binary) {
3116                 sprintf(&encoded_message[strlen(encoded_message)],
3117                         "Content-transfer-encoding: base64\n\n"
3118                 );
3119         }
3120         else {
3121                 sprintf(&encoded_message[strlen(encoded_message)],
3122                         "Content-transfer-encoding: 7bit\n\n"
3123                 );
3124         }
3125
3126         if (is_binary) {
3127                 CtdlEncodeBase64(
3128                         &encoded_message[strlen(encoded_message)],
3129                         raw_message,
3130                         (int)raw_length
3131                 );
3132         }
3133         else {
3134                 raw_message[raw_length] = 0;
3135                 memcpy(
3136                         &encoded_message[strlen(encoded_message)],
3137                         raw_message,
3138                         (int)(raw_length+1)
3139                 );
3140         }
3141
3142         phree(raw_message);
3143
3144         lprintf(9, "Allocating\n");
3145         msg = mallok(sizeof(struct CtdlMessage));
3146         memset(msg, 0, sizeof(struct CtdlMessage));
3147         msg->cm_magic = CTDLMESSAGE_MAGIC;
3148         msg->cm_anon_type = MES_NORMAL;
3149         msg->cm_format_type = 4;
3150         msg->cm_fields['A'] = strdoop(CC->user.fullname);
3151         msg->cm_fields['O'] = strdoop(req_room);
3152         msg->cm_fields['N'] = strdoop(config.c_nodename);
3153         msg->cm_fields['H'] = strdoop(config.c_humannode);
3154         msg->cm_flags = flags;
3155
3156         msg->cm_fields['M'] = encoded_message;
3157
3158         /* Create the requested room if we have to. */
3159         if (getroom(&qrbuf, roomname) != 0) {
3160                 create_room(roomname,
3161                         ( (is_mailbox != NULL) ? 5 : 3 ),
3162                         "", 0, 1, 0);
3163         }
3164         /* If the caller specified this object as unique, delete all
3165          * other objects of this type that are currently in the room.
3166          */
3167         if (is_unique) {
3168                 lprintf(9, "Deleted %d other msgs of this type\n",
3169                         CtdlDeleteMessages(roomname, 0L, content_type));
3170         }
3171         /* Now write the data */
3172         CtdlSubmitMsg(msg, NULL, roomname);
3173         CtdlFreeMessage(msg);
3174 }
3175
3176
3177
3178
3179
3180
3181 void CtdlGetSysConfigBackend(long msgnum, void *userdata) {
3182         config_msgnum = msgnum;
3183 }
3184
3185
3186 char *CtdlGetSysConfig(char *sysconfname) {
3187         char hold_rm[ROOMNAMELEN];
3188         long msgnum;
3189         char *conf;
3190         struct CtdlMessage *msg;
3191         char buf[SIZ];
3192
3193         strcpy(hold_rm, CC->room.QRname);
3194         if (getroom(&CC->room, SYSCONFIGROOM) != 0) {
3195                 getroom(&CC->room, hold_rm);
3196                 return NULL;
3197         }
3198
3199
3200         /* We want the last (and probably only) config in this room */
3201         begin_critical_section(S_CONFIG);
3202         config_msgnum = (-1L);
3203         CtdlForEachMessage(MSGS_LAST, 1, sysconfname, NULL,
3204                 CtdlGetSysConfigBackend, NULL);
3205         msgnum = config_msgnum;
3206         end_critical_section(S_CONFIG);
3207
3208         if (msgnum < 0L) {
3209                 conf = NULL;
3210         }
3211         else {
3212                 msg = CtdlFetchMessage(msgnum);
3213                 if (msg != NULL) {
3214                         conf = strdoop(msg->cm_fields['M']);
3215                         CtdlFreeMessage(msg);
3216                 }
3217                 else {
3218                         conf = NULL;
3219                 }
3220         }
3221
3222         getroom(&CC->room, hold_rm);
3223
3224         if (conf != NULL) do {
3225                 extract_token(buf, conf, 0, '\n');
3226                 strcpy(conf, &conf[strlen(buf)+1]);
3227         } while ( (strlen(conf)>0) && (strlen(buf)>0) );
3228
3229         return(conf);
3230 }
3231
3232 void CtdlPutSysConfig(char *sysconfname, char *sysconfdata) {
3233         char temp[PATH_MAX];
3234         FILE *fp;
3235
3236         strcpy(temp, tmpnam(NULL));
3237
3238         fp = fopen(temp, "w");
3239         if (fp == NULL) return;
3240         fprintf(fp, "%s", sysconfdata);
3241         fclose(fp);
3242
3243         /* this handy API function does all the work for us */
3244         CtdlWriteObject(SYSCONFIGROOM, sysconfname, temp, NULL, 0, 1, 0);
3245         unlink(temp);
3246 }
3247
3248
3249 /*
3250  * Determine whether a given Internet address belongs to the current user
3251  */
3252 int CtdlIsMe(char *addr) {
3253         struct recptypes *recp;
3254         int i;
3255
3256         recp = validate_recipients(addr);
3257         if (recp == NULL) return(0);
3258
3259         if (recp->num_local == 0) {
3260                 phree(recp);
3261                 return(0);
3262         }
3263
3264         for (i=0; i<recp->num_local; ++i) {
3265                 extract(addr, recp->recp_local, i);
3266                 if (!strcasecmp(addr, CC->user.fullname)) {
3267                         phree(recp);
3268                         return(1);
3269                 }
3270         }
3271
3272         phree(recp);
3273         return(0);
3274 }
3275
3276
3277 /*
3278  * Citadel protocol command to do the same
3279  */
3280 void cmd_isme(char *argbuf) {
3281         char addr[SIZ];
3282
3283         if (CtdlAccessCheck(ac_logged_in)) return;
3284         extract(addr, argbuf, 0);
3285
3286         if (CtdlIsMe(addr)) {
3287                 cprintf("%d %s\n", CIT_OK, addr);
3288         }
3289         else {
3290                 cprintf("%d Not you.\n", ERROR);
3291         }
3292
3293 }