root/1.8.3/tags/p6/src/extmail.c

/**
 * \file extmail.c
 *
 * \brief The PennMUSH built-in mail system.
 *
 * \verbatim
 *---------------------------------------------------------------
 * extmail.c - Javelin's improved @mail system
 * Based on Amberyl's linked list mailer
 *
 * Summary of mail command syntax:
 * Sending:
 *   @mail[/sendswitch] player-list = message
 *     sendswitches: /silent, /urgent
 *     player-list is a space-separated list of players, aliases, or msg#'s 
 *     to reply to. Players can be names or dbrefs. Aliases start with *
 * Reading/Handling:
 *   @mail[/readswitch] [msg-list [= target]]
 *     With no readswitch, @mail reads msg-list (same as /read)
 *     With no readswitch and no msg-list, @mail lists all messages (/list)
 *     readswitches: /list, /read, /fwd (requires target list of players
 *      to forward messages to), /file (requires target folder to file
 *      to), /tag, /untag, /clear, /unclear, /purge (no msg-list),
 *      /count
 *     Assumes messages in current folder, set by @folder or @mail/folder
 *     msg-list can be one of: a message number, a message range,
 *     (2-3, 4-, -6), sender references (*player), date comparisons
 *     (~0, >2, <5), or the strings "urgent", "tagged", "cleared",
 *     "read", "unread", "all", or "folder"
 *     You can also use 1:2 (folder 1, message 2) and 1:2-3 for ranges.
 * Admin stuff:
 *   @mail[/switch] [player]
 *     Switches include: nuke (used to be "purge"), [efd]stats, debug
 *
 * THEORY OF OPERATION:
 *  Prior to pl11, mail was an unsorted linked list. When mail was sent,
 * it was added onto the end. To read mail, you scanned the whole list.
 * This is still how origmail.c works.
 *  As of pl11, extmail.c maintains mail as a sorted linked list, sorted
 * by recipient and order of receipt. This makes sending mail less
 * efficient (because you have to scan the list to figure out where to
 * insert), but reading/checking/deleting more efficient, 
 * because once you've found where the player's mail starts, you just
 * read from there. 
 *  That wouldn't be so exciting unless there was a fast way to find
 * where a player's mail chain started. Fortunately, there is. We
 * record that information for connected players when they connect,
 * on their descriptor. So, when connected players do reading/etc,
 * it's O(1). Sending to a connected player is O(1). Sending to an
 * unconnected player still requires scanning (O(n)), but you send once, 
 * and read/list/delete etc, multiple times.
 *  And just to make the sending to disconnected players faster, 
 * instead of scanning the whole maildb to find the insertion point,
 * we start the scan from the chain of the connected player with the
 * closest db# to the target player. This scales up very well.
 *--------------------------------------------------------------------
 * \endverbatim
 */

#include "config.h"
#include "copyrite.h"

#ifdef I_SYS_TIME
#include <sys/time.h>
#ifdef TIME_WITH_SYS_TIME
#include <time.h>
#endif
#else
#include <time.h>
#endif
#include <ctype.h>
#ifdef I_SYS_TYPES
#include <sys/types.h>
#endif
#include <string.h>
#ifdef HAVE_STDINT_H
#include <stdint.h>
#endif

#include "conf.h"
#include "externs.h"
#include "mushdb.h"
#include "dbdefs.h"
#include "match.h"
#include "extmail.h"
#include "function.h"
#include "malias.h"
#include "attrib.h"
#include "parse.h"
#include "mymalloc.h"
#include "ansi.h"
#include "pueblo.h"
#include "flags.h"
#include "log.h"
#include "lock.h"
#include "command.h"
#include "dbio.h"
#include "confmagic.h"


extern int do_convtime(const char *str, struct tm *ttm);        /* funtime.c */

static void do_mail_flags
  (dbref player, const char *msglist, mail_flag flag, bool negate);
static char *mail_list_time(const char *the_time, bool flag);
static MAIL *mail_fetch(dbref player, int num);
static MAIL *real_mail_fetch(dbref player, int num, int folder);
static MAIL *mailfun_fetch(dbref player, int nargs, char *arg1, char *arg2);
static void count_mail(dbref player,
                       int folder, int *rcount, int *ucount, int *ccount);
static int real_send_mail(dbref player,
                          dbref target, char *subject, char *message,
                          mail_flag flags, int silent, int nosig);
static void send_mail(dbref player,
                      dbref target, char *subject, char *message,
                      mail_flag flags, int silent, int nosig);
static int send_mail_alias(dbref player,
                           char *aname, char *subject,
                           char *message, mail_flag flags, int silent,
                           int nosig);
static void filter_mail(dbref from, dbref player, char *subject,
                        char *message, int mailnumber, mail_flag flags);
static MAIL *find_insertion_point(dbref player);
static int get_folder_number(dbref player, char *name);
static char *get_folder_name(dbref player, int fld);
static int player_folder(dbref player);
static int parse_folder(dbref player, char *folder_string);
static int mail_match(dbref player, MAIL *mp, struct mail_selector ms, int num);
static int parse_msglist
  (const char *msglist, struct mail_selector *ms, dbref player);
static int parse_message_spec
  (dbref player, const char *s, int *msglow, int *msghigh, int *folder);
static char *status_chars(MAIL *mp);
static char *status_string(MAIL *mp);
static int sign(int x);
static char *get_message(MAIL *mp);
static unsigned char *get_compressed_message(MAIL *mp);
static char *get_subject(MAIL *mp);
static char *get_sender(MAIL *mp, int full);
static int was_sender(dbref player, MAIL *mp);

MAIL *maildb;            /**< The head of the mail list */
MAIL *tail_ptr;          /**< The end of the mail list */

slab *mail_slab; /**< slab for 'struct mail' allocations */

#define HEAD  maildb     /**< The head of the mail list */
#define TAIL  tail_ptr   /**< The end of the mail list */

/** A line of...dashes! */
#define DASH_LINE  \
  "-----------------------------------------------------------------------------"

int mdb_top = 0;                /**< total number of messages in mail db */

/*-------------------------------------------------------------------------*
 *   User mail functions (these are called from game.c)
 *
 * do_mail - cases without a /switch.
 * do_mail_send - sending mail
 * do_mail_read - read messages
 * do_mail_list - list messages
 * do_mail_flags - tagging, untagging, clearing, unclearing of messages
 * do_mail_file - files messages into a new folder
 * do_mail_fwd - forward messages to another player(s)
 * do_mail_count - count messages
 * do_mail_purge - purge cleared messages
 * do_mail_change_folder - change current folder
 * do_mail_unfolder - remove a folder name from MAILFOLDERS
 * do_mail_subject - set the current mail subject
 *-------------------------------------------------------------------------*/

/* Return the uncompressed text of a @mail in a static buffer */
static char *
get_message(MAIL *mp)
{
  static char text[BUFFER_LEN * 2];
  unsigned char tbuf[BUFFER_LEN * 2];

  if (!mp)
    return NULL;

  chunk_fetch(mp->msgid, tbuf, sizeof tbuf);
  strcpy(text, uncompress(tbuf));
  return text;
}

/* Return the compressed text of a @mail in a static buffer */
static unsigned char *
get_compressed_message(MAIL *mp)
{
  static unsigned char text[BUFFER_LEN * 2];

  if (!mp)
    return NULL;

  chunk_fetch(mp->msgid, (unsigned char *) text, sizeof text);
  return text;
}

/* Return the subject of a mail message, or (no subject) */
static char *
get_subject(MAIL *mp)
{
  static char sbuf[SUBJECT_LEN + 1];
  char *p;
  if (mp->subject) {
    strncpy(sbuf, uncompress(mp->subject), SUBJECT_LEN);
    sbuf[SUBJECT_LEN] = '\0';
    /* Stop at a return or a tab */
    for (p = sbuf; *p; p++) {
      if ((*p == '\r') || (*p == '\n') || (*p == '\t')) {
        *p = '\0';
        break;
      }
      if (!isprint((unsigned char) *p)) {
        *p = ' ';
      }
    }
  } else
    strcpy(sbuf, T("(no subject)"));
  return sbuf;
}

/* Return the name of the mail sender. */
static char *
get_sender(MAIL *mp, int full)
{
  static char tbuf1[BUFFER_LEN], *bp;
  bp = tbuf1;
  if (!GoodObject(mp->from))
    safe_str("!Purged!", tbuf1, &bp);
  else if (!was_sender(mp->from, mp))
    safe_str("!Purged!", tbuf1, &bp);
  else if (IsPlayer(mp->from) || !full)
    safe_str(Name(mp->from), tbuf1, &bp);
  else
    safe_format(tbuf1, &bp, "%s (owner: %s)", Name(mp->from),
                Name(Owner(mp->from)));
  *bp = '\0';
  return tbuf1;
}

/* Was this player the sender of this message? */
static int
was_sender(dbref player, MAIL *mp)
{
  /* If the dbrefs don't match, fail. */
  if (mp->from != player)
    return 0;
  /* If we don't know the creation time of the sender, succeed. */
  if (!mp->from_ctime)
    return 1;
  /* Succeed if and only if the creation times match. */
  return (mp->from_ctime == CreTime(player));
}

/** Change folders or rename a folder.
 * \verbatim
 * This implements @mail/folder
 * \endverbatim
 * \param player the enactor.
 * \param fld string containing folder number or name.
 * \param newname string containing folder name, if renaming.
 */
void
do_mail_change_folder(dbref player, char *fld, char *newname)
{
  int pfld;
  char *p;

  if (!fld || !*fld) {
    /* Check mail in all folders */
    for (pfld = MAX_FOLDERS; pfld >= 0; pfld--)
      check_mail(player, pfld, 1);
    pfld = player_folder(player);
    notify_format(player,
                  T("MAIL: Current folder is %d [%s]."), pfld,
                  get_folder_name(player, pfld));
    return;
  }
  pfld = parse_folder(player, fld);
  if (pfld < 0) {
    notify(player, T("MAIL: What folder is that?"));
    return;
  }
  if (newname && *newname) {
    /* We're changing a folder name here */
    if (strlen(newname) > FOLDER_NAME_LEN) {
      notify(player, T("MAIL: Folder name too long"));
      return;
    }
    for (p = newname; p && *p; p++) {
      if (!isalnum((unsigned char) *p)) {
        notify(player, T("MAIL: Illegal folder name"));
        return;
      }
    }
    add_folder_name(player, pfld, newname);
    notify_format(player, T("MAIL: Folder %d now named '%s'"), pfld, newname);
  } else {
    /* Set a new folder */
    set_player_folder(player, pfld);
    notify_format(player,
                  T("MAIL: Current folder set to %d [%s]."), pfld,
                  get_folder_name(player, pfld));
  }
}

/** Remove a folder name.
 * \verbatim
 * This implements @mail/unfolder
 * \endverbatim
 * \param player the enactor.
 * \param fld string containing folder number or name.
 */
void
do_mail_unfolder(dbref player, char *fld)
{
  int pfld;

  if (!fld || !*fld) {
    notify(player, T("MAIL: You must specify a folder name or number"));
    return;
  }
  pfld = parse_folder(player, fld);
  if (pfld < 0) {
    notify(player, T("MAIL: What folder is that?"));
    return;
  }
  add_folder_name(player, pfld, NULL);
  notify_format(player, T("MAIL: Folder %d now has no name"), pfld);
}


/** Tag a set of mail messages.
 * \param player the enactor.
 * \param msglist string specifying messages to tag.
 */
void
do_mail_tag(dbref player, const char *msglist)
{
  do_mail_flags(player, msglist, M_TAG, 0);
}

/** Clear a set of mail messages.
 * \param player the enactor.
 * \param msglist string specifying messages to clear.
 */
void
do_mail_clear(dbref player, const char *msglist)
{
  do_mail_flags(player, msglist, M_CLEARED, 0);
}

/** Untag a set of mail messages.
 * \param player the enactor.
 * \param msglist string specifying messages to untag.
 */
void
do_mail_untag(dbref player, const char *msglist)
{
  do_mail_flags(player, msglist, M_TAG, 1);
}

/** Unclear a set of mail messages.
 * \param player the enactor.
 * \param msglist string specifying messages to unclear.
 */
void
do_mail_unclear(dbref player, const char *msglist)
{
  do_mail_flags(player, msglist, M_CLEARED, 1);
}


/** Set or clear a flag on a set of messages.
 * \param player the enactor.
 * \param msglist string representing list of messages to operate on.
 * \param flag flag to set or clear.
 * \param negate if 1, clear the flag; if 0, set the flag.
 */
static void
do_mail_flags(dbref player, const char *msglist, mail_flag flag, bool negate)
{
  MAIL *mp;
  struct mail_selector ms;
  int j;
  mail_flag folder;
  folder_array i;
  int notified = 0;

  if (!parse_msglist(msglist, &ms, player)) {
    return;
  }
  FA_Init(i, j);
  j = 0;
  folder = AllInFolder(ms) ? player_folder(player) : MSFolder(ms);
  for (mp = find_exact_starting_point(player);
       mp && (mp->to == player); mp = mp->next) {
    if ((mp->to == player) && (All(ms) || (Folder(mp) == folder))) {
      i[Folder(mp)]++;
      if (mail_match(player, mp, ms, i[Folder(mp)])) {
        j++;
        if (negate) {
          mp->read &= ~flag;
        } else {
          mp->read |= flag;
        }
        switch (flag) {
        case M_TAG:
          if (All(ms)) {
            if (!notified) {
              notify_format(player,
                            T("MAIL: All messages in all folders %s."),
                            negate ? "untagged" : "tagged");
              notified++;
            }
          } else
            notify_format(player,
                          "MAIL: Msg #%d:%d %s.", Folder(mp),
                          i[Folder(mp)], negate ? "untagged" : "tagged");
          break;
        case M_CLEARED:
          if (All(ms)) {
            if (!notified) {
              notify_format(player,
                            T("MAIL: All messages in all folders %s."),
                            negate ? "uncleared" : "cleared");
              notified++;
            }
          } else {
            if (Unread(mp) && !negate) {
              notify_format(player,
                            T
                            ("MAIL: Unread Msg #%d:%d cleared! Use @mail/unclear %d:%d to recover."),
                            Folder(mp), i[Folder(mp)], Folder(mp),
                            i[Folder(mp)]);
            } else {
              notify_format(player,
                            (negate ? T("MAIL: Msg #%d:%d uncleared.") :
                             T("MAIL: Msg #%d:%d cleared.")), Folder(mp),
                            i[Folder(mp)]);
            }
          }
          break;
        }
      }
    }
  }
  if (!j) {
    /* ran off the end of the list without finding anything */
    notify(player, T("MAIL: You don't have any matching messages!"));
  }
  return;
}

/** File messages into a folder.
 * \verbatim
 * This implements @mail/file.
 * \endverbatim
 * \param player the enactor.
 * \param msglist list of messages to file.
 * \param folder name or number of folder to put messages in.
 */
void
do_mail_file(dbref player, char *msglist, char *folder)
{
  MAIL *mp;
  struct mail_selector ms;
  int j, foldernum;
  mail_flag origfold;
  folder_array i;
  int notified = 0;

  if (!parse_msglist(msglist, &ms, player)) {
    return;
  }
  if ((foldernum = parse_folder(player, folder)) == -1) {
    notify(player, T("MAIL: Invalid folder specification"));
    return;
  }
  FA_Init(i, j);
  j = 0;
  origfold = AllInFolder(ms) ? player_folder(player) : MSFolder(ms);
  for (mp = find_exact_starting_point(player);
       mp && (mp->to == player); mp = mp->next) {
    if ((mp->to == player) && (All(ms) || (Folder(mp) == origfold))) {
      i[Folder(mp)]++;
      if (mail_match(player, mp, ms, i[Folder(mp)])) {
        j++;
        mp->read &= M_FMASK;    /* Clear the folder */
        mp->read &= ~M_CLEARED; /* Unclear it if it was marked cleared */
        mp->read |= FolderBit(foldernum);
        if (All(ms)) {
          if (!notified) {
            notify_format(player,
                          T("MAIL: All messages filed in folder %d [%s]"),
                          foldernum, get_folder_name(player, foldernum));
            notified++;
          }
        } else
          notify_format(player,
                        T("MAIL: Msg %d:%d filed in folder %d [%s]"),
                        origfold, i[origfold], foldernum,
                        get_folder_name(player, foldernum));
      }
    }
  }
  if (!j) {
    /* ran off the end of the list without finding anything */
    notify(player, T("MAIL: You don't have any matching messages!"));
  }
  return;
}

/** Read mail messages.
 * This displays the contents of a set of mail messages.
 * \param player the enactor.
 * \param msglist list of messages to read.
 */
void
do_mail_read(dbref player, char *msglist)
{
  MAIL *mp;
  char tbuf1[BUFFER_LEN];
  char folderheader[BUFFER_LEN];
  struct mail_selector ms;
  int j;
  mail_flag folder;
  folder_array i;

  if (!parse_msglist(msglist, &ms, player)) {
    return;
  }
  folder = AllInFolder(ms) ? player_folder(player) : MSFolder(ms);
  FA_Init(i, j);
  j = 0;
  for (mp = find_exact_starting_point(player);
       mp && (mp->to == player); mp = mp->next) {
    if ((mp->to == player) && (All(ms) || Folder(mp) == folder)) {
      i[Folder(mp)]++;
      if (mail_match(player, mp, ms, i[Folder(mp)])) {
        /* Read it */
        j++;
        if (SUPPORT_PUEBLO) {
          notify_noenter(player, open_tag("SAMP"));
          snprintf(folderheader, BUFFER_LEN,
                   "%c%cA XCH_HINT=\"List messages in this folder\" XCH_CMD=\"@mail/list %d:1-\"%c%s%c%c/A%c",
                   TAG_START, MARKUP_HTML, Folder(mp), TAG_END, T("Folder:"),
                   TAG_START, MARKUP_HTML, TAG_END);
        } else
          mush_strncpy(folderheader, T("Folder:"), BUFFER_LEN);
        notify(player, DASH_LINE);
        mush_strncpy(tbuf1, get_sender(mp, 1), BUFFER_LEN);
        notify_format(player,
                      T
                      ("From: %-55s %s\nDate: %-25s   %s %2d   Message: %d\nStatus: %s"),
                      tbuf1, ((*tbuf1 != '!') && IsPlayer(mp->from)
                              && Connected(mp->from)
                              && (!hidden(mp->from)
                                  || Priv_Who(player))) ? " (Conn)" : "      ",
                      show_time(mp->time, 0), folderheader, Folder(mp),
                      i[Folder(mp)], status_string(mp));
        notify_format(player, T("Subject: %s"), get_subject(mp));
        notify(player, DASH_LINE);
        if (SUPPORT_PUEBLO)
          notify_noenter(player, close_tag("SAMP"));
        strcpy(tbuf1, get_message(mp));
        notify(player, tbuf1);
        if (SUPPORT_PUEBLO)
          notify(player, wrap_tag("SAMP", DASH_LINE));
        else
          notify(player, DASH_LINE);
        if (Unread(mp))
          mp->read |= M_MSGREAD;        /* mark message as read */
      }
    }
  }
  if (!j) {
    /* ran off the end of the list without finding anything */
    notify(player, T("MAIL: You don't have that many matching messages!"));
  }
  return;
}


/** List the flags, number, sender, subject, and date of messages in a
 * concise format.
 * \param player the enactor.
 * \param msglist list of messages to list.
 */
void
do_mail_list(dbref player, const char *msglist)
{
  char subj[30];
  char sender[30];
  MAIL *mp;
  struct mail_selector ms;
  int j;
  mail_flag folder;
  folder_array i;

  if (!parse_msglist(msglist, &ms, player)) {
    return;
  }
  FA_Init(i, j);
  j = 0;
  folder = AllInFolder(ms) ? player_folder(player) : MSFolder(ms);
  if (SUPPORT_PUEBLO)
    notify_noenter(player, open_tag("SAMP"));
  notify_format(player,
                T
                ("---------------------------  MAIL (folder %2d)  ------------------------------"),
                folder);
  for (mp = find_exact_starting_point(player); mp && (mp->to == player);
       mp = mp->next) {
    if ((mp->to == player) && (All(ms) || Folder(mp) == folder)) {
      i[Folder(mp)]++;
      if (mail_match(player, mp, ms, i[Folder(mp)])) {
        /* list it */
        if (SUPPORT_PUEBLO)
          notify_noenter(player,
                         tprintf
                         ("%c%cA XCH_CMD=\"@mail/read %d:%d\" XCH_HINT=\"Read message %d in folder %d\"%c",
                          TAG_START, MARKUP_HTML, Folder(mp), i[Folder(mp)],
                          i[Folder(mp)], Folder(mp), TAG_END));
        strcpy(subj, chopstr(get_subject(mp), 28));
        strcpy(sender, chopstr(get_sender(mp, 0), 12));
        notify_format(player, "[%s] %2d:%-3d %c%-12s  %-*s %s",
                      status_chars(mp), Folder(mp), i[Folder(mp)],
                      ((*sender != '!') && (Connected(mp->from) &&
                                            (!hidden(mp->from)
                                             || Priv_Who(player)))
                       ? '*' : ' '), sender, 30, subj,
                      mail_list_time(show_time(mp->time, 0), 1));
        if (SUPPORT_PUEBLO)
          notify_noenter(player, tprintf("%c%c/A%c", TAG_START,
                                         MARKUP_HTML, TAG_END));
      }
    }
  }
  notify(player, DASH_LINE);
  if (SUPPORT_PUEBLO)
    notify(player, close_tag("SAMP"));
  return;
}

static char *
mail_list_time(const char *the_time, bool flag /* 1 for no year */ )
{
  static char newtime[BUFFER_LEN];
  const char *p;
  char *q;
  int i;
  p = the_time;
  q = newtime;
  if (!p || !*p)
    return NULL;
  /* Format of the_time is: day mon dd hh:mm:ss yyyy */
  /* Chop out :ss */
  for (i = 0; i < 16; i++) {
    if (*p)
      *q++ = *p++;
  }
  if (!flag) {
    for (i = 0; i < 3; i++) {
      if (*p)
        p++;
    }
    for (i = 0; i < 5; i++) {
      if (*p)
        *q++ = *p++;
    }
  }
  *q = '\0';
  return newtime;
}


/** Expunge mail that's marked for deletion.
 * \verbatim
 * This implements @mail/purge.
 * \endverbatim
 * \param player the enactor.
 */
void
do_mail_purge(dbref player)
{
  MAIL *mp, *nextp;

  /* Go through player's mail, and remove anything marked cleared */
  for (mp = find_exact_starting_point(player);
       mp && (mp->to == player); mp = nextp) {
    if ((mp->to == player) && Cleared(mp)) {
      /* Delete this one */
      /* head and tail of the list are special */
      if (mp == HEAD)
        HEAD = mp->next;
      else if (mp == TAIL)
        TAIL = mp->prev;
      /* relink the list */
      if (mp->prev != NULL)
        mp->prev->next = mp->next;
      if (mp->next != NULL)
        mp->next->prev = mp->prev;
      /* save the pointer */
      nextp = mp->next;
      /* then wipe */
      mdb_top--;
      free(mp->subject);
      chunk_delete(mp->msgid);
      slab_free(mail_slab, mp);
    } else {
      nextp = mp->next;
    }
  }
  set_objdata(player, "MAIL", NULL);
  if (command_check_byname(player, "@MAIL"))
    notify(player, T("MAIL: Mailbox purged."));
  return;
}

/** Forward mail messages to someone(s) else.
 * \verbatim
 * This implements @mail/forward.
 * \endverbatim
 * \param player the enactor.
 * \param msglist list of messages to forward.
 * \param tolist list of recipients to forwared to.
 */
void
do_mail_fwd(dbref player, char *msglist, char *tolist)
{
  MAIL *mp;
  MAIL *last;
  struct mail_selector ms;
  int j, num;
  mail_flag folder;
  folder_array i;
  const char *head;
  MAIL *temp;
  dbref target;
  int num_recpts = 0;
  const char **start;
  char *current;
  start = &head;

  if (!parse_msglist(msglist, &ms, player)) {
    return;
  }
  if (!tolist || !*tolist) {
    notify(player, T("MAIL: To whom should I forward?"));
    return;
  }
  folder = AllInFolder(ms) ? player_folder(player) : MSFolder(ms);
  /* Mark the player's last message. This prevents a loop if
   * the forwarding command happens to forward a message back
   * to the player itself 
   */
  last = mp = find_exact_starting_point(player);
  if (!last) {
    notify(player, T("MAIL: You have no messages to forward."));
    return;
  }
  while (last->next && (last->next->to == player))
    last = last->next;

  FA_Init(i, j);
  while (mp && (mp->to == player) && (mp != last-&g