root/1.8.3/trunk/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_s