mux/src/mail.cpp

Go to the documentation of this file.

// mail.cpp
//
// $Id: mail.cpp,v 1.55 2007/03/07 00:27:59 sdennis Exp $
//
// This code was taken from Kalkin's DarkZone code, which was
// originally taken from PennMUSH 1.50 p10, and has been heavily modified
// since being included in MUX.
//

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"

#include <sys/types.h>

#include "attrs.h"
#include "command.h"
#include "powers.h"
#include "mail.h"

#define SIZEOF_MALIAS 13
#define WIDTHOF_MALIASDESC 40
#define SIZEOF_MALIASDESC (WIDTHOF_MALIASDESC*2)

#define MAX_MALIAS_MEMBERSHIP 100
struct malias
{
    int owner;
    char *name;
    char *desc;
    int desc_width; // The visual width of the Mail Alias Description.
    int numrecep;
    dbref list[MAX_MALIAS_MEMBERSHIP];
};

static int ma_size = 0;
static int ma_top = 0;

static struct malias **malias   = NULL;
static MAILBODY      *mail_list = NULL;

// Handling functions for the database of mail messages.
//

// mail_db_grow - We keep a database of mail text, so if we send a
// message to more than one player, we won't have to duplicate the
// text.
//
#define MAIL_FUDGE 1
static void mail_db_grow(int newtop)
{
    if (newtop <= mudstate.mail_db_top)
    {
        return;
    }
    if (mudstate.mail_db_size <= newtop)
    {
        // We need to make the mail bag bigger.
        //
        int newsize = mudstate.mail_db_size + 100;
        if (newtop > newsize)
        {
            newsize = newtop;
        }

        MAILBODY *newdb = (MAILBODY *)MEMALLOC((newsize + MAIL_FUDGE) * sizeof(MAILBODY));
        ISOUTOFMEMORY(newdb);
        if (mail_list)
        {
            mail_list -= MAIL_FUDGE;
            memcpy( newdb,
                    mail_list,
                    (mudstate.mail_db_top + MAIL_FUDGE) * sizeof(MAILBODY));
            MEMFREE(mail_list);
            mail_list = NULL;
        }
        mail_list = newdb + MAIL_FUDGE;
        newdb = NULL;
        mudstate.mail_db_size = newsize;
    }

    // Initialize new parts of the mail bag.
    //
    for (int i = mudstate.mail_db_top; i < newtop; i++)
    {
        mail_list[i].m_nRefs = 0;
        mail_list[i].m_pMessage = NULL;
    }
    mudstate.mail_db_top = newtop;
}

// MessageReferenceInc - Increments the reference count for any
// particular message.
//
static DCL_INLINE void MessageReferenceInc(int number)
{
    mail_list[number].m_nRefs++;
}

// MessageReferenceCheck - Checks whether the reference count for
// any particular message indicates that the message body should be
// freed. Also checks that if a message point is null, that the
// reference count is zero.
//
static void MessageReferenceCheck(int number)
{
    MAILBODY &m = mail_list[number];
    if (m.m_nRefs <= 0)
    {
        if (m.m_pMessage)
        {
            MEMFREE(m.m_pMessage);
            m.m_pMessage = NULL;
        }
    }
    if (m.m_pMessage == NULL)
    {
        m.m_nRefs = 0;
    }
}

// MessageReferenceDec - Decrements the reference count for a message, and
// will also delete the message if the counter reaches 0.
//
static void MessageReferenceDec(int number)
{
    mail_list[number].m_nRefs--;
    MessageReferenceCheck(number);
}

// MessageFetch - returns the text for a particular message number. This
// text should not be modified.
//
static const char *MessageFetch(int number)
{
    MessageReferenceCheck(number);
    if (mail_list[number].m_pMessage)
    {
        return mail_list[number].m_pMessage;
    }
    else
    {
        return "MAIL: This mail message does not exist in the database. Please alert your admin.";
    }
}

// This function returns a reference to the message and the the
// reference count is increased to reflect that.
//
static int MessageAdd(char *pMessage)
{
    if (!mail_list)
    {
        mail_db_grow(1);
    }

    int i;
    MAILBODY *pm;
    bool bFound = false;
    for (i = 0; i < mudstate.mail_db_top; i++)
    {
        pm = &mail_list[i];
        if (pm->m_pMessage == NULL)
        {
            pm->m_nRefs = 0;
            bFound = true;
            break;
        }
    }
    if (!bFound)
    {
        mail_db_grow(i + 1);
    }

    pm = &mail_list[i];
    pm->m_pMessage = StringClone(pMessage);
    MessageReferenceInc(i);
    return i;
}

// add_mail_message - adds a new text message to the mail database, and returns
// a unique number for that message.
//
// IF return value is !NOTHING, you have a reference to the message,
// and the reference count reflects that.
//
static int add_mail_message(dbref player, char *message)
{
    if (!mux_stricmp(message, "clear"))
    {
        notify(player, "MAIL: You probably did not intend to send a @mail saying 'clear'.");
        return NOTHING;
    }

    // Evaluate signature.
    //
    int   aflags;
    dbref aowner;
    char *bp = alloc_lbuf("add_mail_message");
    char *atrstr = atr_get(player, A_SIGNATURE, &aowner, &aflags);
    char *execstr = bp;
    char *str = atrstr;
    mux_exec(execstr, &bp, player, player, player,
             EV_STRIP_CURLY | EV_FCHECK | EV_EVAL, &str, (char **)NULL, 0);
    *bp = '\0';

    // Save message body and return a reference to it.
    //
    int number = MessageAdd(tprintf("%s %s", message, execstr));
    free_lbuf(atrstr);
    free_lbuf(execstr);
    return number;
}

// This function is -only- used from reading from the disk, and so
// it does -not- manage the reference counts.
//
static bool MessageAddWithNumber(int i, char *pMessage)
{
    mail_db_grow(i+1);

    MAILBODY *pm = &mail_list[i];
    pm->m_pMessage = StringClone(pMessage);
    return true;
}

// new_mail_message - used for reading messages in from disk which
// already have a number assigned to them.
//
// This function is -only- used from reading from the disk, and so
// it does -not- manage the reference counts.
//
static void new_mail_message(char *message, int number)
{
    bool bTruncated = false;
    if (strlen(message) > LBUF_SIZE-1)
    {
        bTruncated = true;
        message[LBUF_SIZE-1] = '\0';
    }
    MessageAddWithNumber(number, message);
    if (bTruncated)
    {
        STARTLOG(LOG_BUGS, "BUG", "MAIL");
        log_text(tprintf("new_mail_message: Mail message %d truncated.", number));
        ENDLOG;
    }
}

/*-------------------------------------------------------------------------*
 *   User mail functions (these are called from game.c)
 *
 * do_mail - cases
 * 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_reply - reply to a message
 * do_mail_count - count messages
 * do_mail_purge - purge cleared messages
 * do_mail_change_folder - change current folder
 *-------------------------------------------------------------------------*/

static void set_player_folder(dbref player, int fnum)
{
    // Set a player's folder to fnum.
    //
    char *tbuf1 = alloc_lbuf("set_player_folder");
    mux_ltoa(fnum, tbuf1);
    ATTR *a = atr_num(A_MAILCURF);
    if (a)
    {
        atr_add(player, A_MAILCURF, tbuf1, GOD, a->flags);
    }
    else
    {
        // Shouldn't happen, but...
        //
        atr_add(player, A_MAILCURF, tbuf1, GOD, AF_ODARK | AF_WIZARD | AF_NOPROG | AF_LOCK);
    }
    free_lbuf(tbuf1);
}

static void add_folder_name(dbref player, int fld, char *name)
{
    // Fetch current list of folders
    //
    int aflags;
    size_t nFolders;
    dbref aowner;
    char *aFolders = alloc_lbuf("add_folder_name.str");
    atr_get_str_LEN(aFolders, player, A_MAILFOLDERS, &aowner, &aflags,
        &nFolders);

    // Build new record ("%d:%s:%d", fld, uppercase(name), fld);
    //
    char *aNew = alloc_lbuf("add_folder_name.new");
    char *q = aNew;
    q += mux_ltoa(fld, q);
    *q++ = ':';
    char *p = name;
    while (*p)
    {
        *q++ = mux_toupper(*p);
        p++;
    }
    *q++ = ':';
    q += mux_ltoa(fld, q);
    *q = '\0';
    size_t nNew = q - aNew;

    if (nFolders != 0)
    {
        // Build pattern ("%d:", fld)
        //
        char *aPattern = alloc_lbuf("add_folder_name.pat");
        q = aPattern;
        q += mux_ltoa(fld, q);
        *q++ = ':';
        *q = '\0';
        size_t nPattern = q - aPattern;

        BMH_State bmhs;
        BMH_Prepare(&bmhs, nPattern, aPattern);
        for (;;)
        {
            int i = BMH_Execute(&bmhs, nPattern, aPattern, nFolders, aFolders);
            if (i < 0)
            {
                break;
            }

            // Remove old record.
            //
            q = aFolders + i;
            p = q + nPattern;

            // Eat leading spaces.
            //
            while (  aFolders < q
                  && mux_isspace(q[-1]))
            {
                q--;
            }

            // Skip past old record and trailing spaces.
            //
            while (  *p
                  && *p != ':')
            {
                p++;
            }
            while (  *p
                  && !mux_isspace(*p))
            {
                p++;
            }
            while (mux_isspace(*p))
            {
                p++;
            }

            if (q != aFolders)
            {
                *q++ = ' ';
            }
            while (*p)
            {
                *q++ = *p++;
            }
            *q = '\0';
            nFolders = q - aFolders;
        }
        free_lbuf(aPattern);
    }
    if (nFolders + 1 + nNew < LBUF_SIZE)
    {
        // It will fit. Append new record.
        //
        q = aFolders + nFolders;
        if (nFolders)
        {
            *q++ = ' ';
        }
        memcpy(q, aNew, nNew);
        q += nNew;
        *q = '\0';

        atr_add(player, A_MAILFOLDERS, aFolders, player,
            AF_MDARK | AF_WIZARD | AF_NOPROG | AF_LOCK);
    }
    free_lbuf(aFolders);
    free_lbuf(aNew);
}

static char *get_folder_name(dbref player, int fld)
{
    // Get the name of the folder, or return "unnamed".
    //
    int aflags;
    size_t nFolders;
    dbref aowner;
    static char aFolders[LBUF_SIZE];
    atr_get_str_LEN(aFolders, player, A_MAILFOLDERS, &aowner, &aflags,
        &nFolders);
    char *p;
    if (nFolders != 0)
    {
        char *aPattern = alloc_lbuf("get_folder_name");
        p = aPattern;
        p += mux_ltoa(fld, p);
        *p++ = ':';
        *p = '\0';
        size_t nPattern = p - aPattern;

        int i = BMH_StringSearch(nPattern, aPattern, nFolders, aFolders);
        free_lbuf(aPattern);

        if (0 <= i)
        {
            p = aFolders + i + nPattern;
            char *q = p;
            while (  *q
                  && *q != ':')
            {
                q++;
            }
            *q = '\0';
            return p;
        }
    }
    p = "unnamed";
    return p;
}

static int get_folder_number(dbref player, char *name)
{
    // Look up a folder name and return the corresponding folder number.
    //
    int aflags;
    size_t nFolders;
    dbref aowner;
    char *aFolders = alloc_lbuf("get_folder_num_str");
    atr_get_str_LEN(aFolders, player, A_MAILFOLDERS, &aowner, &aflags,
        &nFolders);
    if (nFolders != 0)
    {
        char *aPattern = alloc_lbuf("get_folder_num_pat");
        char *q = aPattern;
        *q++ = ':';
        char *p = name;
        while (*p)
        {
            *q++ = mux_toupper(*p);
            p++;
        }
        *q++ = ':';
        *q = '\0';
        size_t nPattern = q - aPattern;

        int i = BMH_StringSearch(nPattern, aPattern, nFolders, aFolders);
        free_lbuf(aPattern);
        if (0 <= i)
        {
            p = aFolders + i + nPattern;
            q = p;
            while (  *q
                  && !mux_isspace(*q))
            {
                q++;
            }
            *q = '\0';
            i = mux_atol(p);
            free_lbuf(aFolders);
            return i;
        }
    }
    free_lbuf(aFolders);
    return -1;
}

static int parse_folder(dbref player, char *folder_string)
{
    // Given a string, return a folder #, or -1.
    //
    if (  !folder_string
       || !*folder_string)
    {
        return -1;
    }
    if (mux_isdigit(*folder_string))
    {
        int fnum = mux_atol(folder_string);
        if (  fnum < 0
           || fnum > MAX_FOLDERS)
        {
            return -1;
        }
        else
        {
            return fnum;
        }
    }

    // Handle named folders here
    //
    return get_folder_number(player, folder_string);
}

#define MAIL_INVALID_RANGE  0
#define MAIL_INVALID_NUMBER 1
#define MAIL_INVALID_AGE    2
#define MAIL_INVALID_DBREF  3
#define MAIL_INVALID_PLAYER 4
#define MAIL_INVALID_SPEC   5
#define MAIL_INVALID_PLAYER_OR_USING_MALIAS 6

static char *mailmsg[] =
{
    "MAIL: Invalid message range",
    "MAIL: Invalid message number",
    "MAIL: Invalid age",
    "MAIL: Invalid dbref #",
    "MAIL: Invalid player",
    "MAIL: Invalid message specification",
    "MAIL: Invalid player or trying to send @mail to a @malias without a subject",
};

static bool parse_msglist(char *msglist, struct mail_selector *ms, dbref player)
{
    // Take a message list, and return the appropriate mail_selector setup.
    // For now, msglists are quite restricted. That'll change once all this
    // is working. Returns 0 if couldn't parse, and also notifies the player
    // why.

    // Initialize the mail selector - this matches all messages.
    //
    ms->low = 0;
    ms->high = 0;
    ms->flags = 0x0FFF | M_MSUNREAD;
    ms->player = 0;
    ms->days = -1;
    ms->day_comp = 0;

    // Now, parse the message list.
    //
    if (!msglist || !*msglist)
    {
        // All messages
        //
        return true;
    }

    char *p = msglist;
    while (mux_isspace(*p))
    {
        p++;
    }

    if (*p == '\0')
    {
        return true;
    }

    if (mux_isdigit(*p))
    {
        // Message or range.
        //
        char *q = strchr(p, '-');
        if (q)
        {
            // We have a subrange, split it up and test to see if it is valid.
            //
            q++;
            ms->low = mux_atol(p);
            if (ms->low <= 0)
            {
                notify(player, mailmsg[MAIL_INVALID_RANGE]);
                return false;
            }
            if (*q == '\0')
            {
                // Unbounded range.
                //
                ms->high = 0;
            }
            else
            {
                ms->high = mux_atol(q);
                if (ms->low > ms->high)
                {
                    notify(player, mailmsg[MAIL_INVALID_RANGE]);
                    return false;
                }
            }
        }
        else
        {
            // A single message.
            //
            ms->low = ms->high = mux_atol(p);
            if (ms->low <= 0)
            {
                notify(player, mailmsg[MAIL_INVALID_NUMBER]);
                return false;
            }
        }
    }
    else
    {
        switch (mux_toupper(*p))
        {
        case '-':

            // Range with no start.
            //
            p++;
            if (*p == '\0')
            {
                notify(player, mailmsg[MAIL_INVALID_RANGE]);
                return false;
            }
            ms->high = mux_atol(p);
            if (ms->high <= 0)
            {
                notify(player, mailmsg[MAIL_INVALID_RANGE]);
                return false;
            }
            break;

        case '~':

            // Exact # of days old.
            //
            p++;
            if (*p == '\0')
            {
                notify(player, mailmsg[MAIL_INVALID_AGE]);
                return false;
            }
            ms->day_comp = 0;
            ms->days = mux_atol(p);
            if (ms->days < 0)
            {
                notify(player, mailmsg[MAIL_INVALID_AGE]);
                return false;
            }
            break;

        case '<':

            // Less than # of days old.
            //
            p++;
            if (*p == '\0')
            {
                notify(player, mailmsg[MAIL_INVALID_AGE]);
                return false;
            }
            ms->day_comp = -1;
            ms->days = mux_atol(p);
            if (ms->days < 0)
            {
                notify(player, mailmsg[MAIL_INVALID_AGE]);
                return false;
            }
            break;

        case '>':

            // Greater than # of days old.
            //
            p++;
            if (*p == '\0')
            {
                notify(player, mailmsg[MAIL_INVALID_AGE]);
                return false;
            }
            ms->day_comp = 1;
            ms->days = mux_atol(p);
            if (ms->days < 0)
            {
                notify(player, mailmsg[MAIL_INVALID_AGE]);
                return false;
            }
            break;

        case '#':

            // From db#.
            //
            p++;
            if (*p == '\0')
            {
                notify(player, mailmsg[MAIL_INVALID_DBREF]);
                return false;
            }
            ms->player = mux_atol(p);
            if (!Good_obj(ms->player) || !(ms->player))
            {
                notify(player, mailmsg[MAIL_INVALID_DBREF]);
                return false;
            }
            break;

        case '*':

            // From player name.
            //
            p++;
            if (*p == '\0')
            {
                notify(player, mailmsg[MAIL_INVALID_PLAYER]);
                return false;
            }
            ms->player = lookup_player(player, p, true);
            if (ms->player == NOTHING)
            {
                notify(player, mailmsg[MAIL_INVALID_PLAYER_OR_USING_MALIAS]);
                return false;
            }
            break;

        case 'A':

            // All messages, all folders
            //
            p++;
            switch (mux_toupper(*p))
            {
            case '\0':
                notify(player, "MAIL: A isn't enough (all?)");
                return false;

            case 'L':

                // All messages, all folders
                //
                p++;
                switch (mux_toupper(*p))
                {
                case '\0':
                    notify(player, "MAIL: AL isn't enough (all?)");
                    return false;

                case 'L':

                    // All messages, all folders
                    //
                    p++;
                    if (*p == '\0')
                    {
                        ms->flags = M_ALL;
                    }
                    else
                    {
                        notify(player, mailmsg[MAIL_INVALID_SPEC]);
                        return false;
                    }
                    break;

                default:

                    // Bad
                    //
                    notify(player, mailmsg[MAIL_INVALID_SPEC]);
                    return false;
                }
                break;

            default:

                // Bad
                //
                notify(player, mailmsg[MAIL_INVALID_SPEC]);
                return false;
            }
            break;

        case 'U':

            // Urgent, Unread
            //
            p++;
            if (*p == '\0')
            {
                notify(player, "MAIL: U is ambiguous (urgent or unread?)");
                return false;
            }
            switch (mux_toupper(*p))
            {
            case 'R':

                // Urgent
                //
                ms->flags = M_URGENT;
                break;

            case 'N':

                // Unread
                //
                ms->flags = M_MSUNREAD;
                break;

            default:

                // Bad
                //
                notify(player, mailmsg[MAIL_INVALID_SPEC]);
                return false;
            }
            break;

        case 'R':

            // Read
            //
            ms->flags = M_ISREAD;
            break;

        case 'C':

            // Cleared.
            //
            ms->flags = M_CLEARED;
            break;

        case 'T':

            // Tagged.
            //
            ms->flags = M_TAG;
            break;

        case 'M':

            // Mass, me.
            //
            p++;
            if (*p == '\0')
            {
                notify(player, "MAIL: M is ambiguous (mass or me?)");
                return false;
            }
            switch (mux_toupper(*p))
            {
            case 'A':

                ms->flags = M_MASS;
                break;

            case 'E':

                ms->player = player;
                break;

            default:

                notify(player, mailmsg[MAIL_INVALID_SPEC]);
                return false;
            }
            break;

        default:

            // Bad news.
            //
            notify(player, mailmsg[MAIL_INVALID_SPEC]);
            return false;
        }
    }
    return true;
}

static int player_folder(dbref player)
{
    // Return the player's current folder number. If they don't have one, set
    // it to 0.
    //
    int flags;
    char *atrstr = atr_pget(player, A_MAILCURF, &player, &flags);
    if (!*atrstr)
    {
        free_lbuf(atrstr);
        set_player_folder(player, 0);
        return 0;
    }
    int number = mux_atol(atrstr);
    free_lbuf(atrstr);
    return number;
}

// Change or rename a folder
//
static void do_mail_change_folder(dbref player, char *fld, char *newname)
{
    int pfld;

    if (!fld || !*fld)
    {
        // Check mail in all folders
        //
        for (pfld = 0; pfld <= MAX_FOLDERS; pfld++)
        {
            check_mail(player, pfld, true);
        }
        pfld = player_folder(player);
        notify(player, tprintf("MAIL: Current folder is %d [%s].",
                       pfld, get_folder_name(player, pfld)));
        return;
    }
    pfld = parse_folder(player, fld);
    if (pfld < 0)
    {
        notify(player, "MAIL: What folder is that?");
        return;
    }
    if (newname && *newname)
    {
        // We're changing a folder name here
        //
        if (strlen(newname) > FOLDER_NAME_LEN)
        {
            notify(player, "MAIL: Folder name too long");
            return;
        }
        char *p;
        for (p = newname; mux_isalnum(*p); p++) ;
        if (*p != '\0')
        {
            notify(player, "MAIL: Illegal folder name");
            return;
        }

        add_folder_name(player, pfld, newname);
        notify(player, tprintf("MAIL: Folder %d now named '%s'", pfld, newname));
    }
    else
    {
        // Set a new folder
        //
        set_player_folder(player, pfld);
        notify(player, tprintf("MAIL: Current folder set to %d [%s].",
                       pfld, get_folder_name(player, pfld)));
    }
}

static int sign(int x)
{
    if (x == 0)
    {
        return 0;
    }
    else if (x < 0)
    {
        return -1;
    }
    else
    {
        return 1;
    }
}

static bool mail_match(struct mail *mp, struct mail_selector ms, int num)
{
    // Does a piece of mail match the mail_selector?
    //
    if (ms.low && num < ms.low)
    {
        return false;
    }
    if (ms.high && ms.high < num)
    {
        return false;
    }
    if (ms.player && mp->from != ms.player)
    {
        return false;
    }

    mail_flag mpflag = Read(mp)
        ? (mp->read | M_ALL)
        : (mp->read | M_ALL | M_MSUNREAD);

    if ((ms.flags & mpflag) == 0)
    {
        return false;
    }

    if (ms.days == -1)
    {
        return true;
    }

    // Get the time now, subtract mp->time, and compare the results with
    // ms.days (in manner of ms.day_comp)
    //
    CLinearTimeAbsolute ltaNow;
    ltaNow.GetLocal();

    const char *pMailTimeStr = mp->time;

    CLinearTimeAbsolute ltaMail;
    if (ltaMail.SetString(pMailTimeStr))
    {
        CLinearTimeDelta ltd(ltaMail, ltaNow);
        int iDiffDays = ltd.ReturnDays();
        if (sign(iDiffDays - ms.days) == ms.day_comp)
        {
            return true;
        }
    }
    return false;
}

// Adjust the flags of a set of messages.
// If negate is true, clear the flag.
static void do_mail_flags(dbref player, char *msglist, mail_flag flag, bool negate)
{
    struct mail_selector ms;

    if (!parse_msglist(msglist, &ms, player))
    {
        return;
    }
    int i = 0, j = 0;
    int folder = player_folder(player);

    MailList ml(player);
    struct mail *mp;
    for (mp = ml.FirstItem(); !ml.IsEnd(); mp = ml.NextItem())
    {
        if (  All(ms)
           || Folder(mp) == folder)
        {
            i++;
            if (mail_match(mp, ms, i))
            {
                j++;
                if (negate)
                {
                    mp->read &= ~flag;
                }
                else
                {
                    mp->read |= flag;
                }

                switch (flag)
                {
                case M_TAG:
                    notify(player, tprintf("MAIL: Msg #%d %s.", i, negate ? "untagged" : "tagged"));
                    break;

                case M_CLEARED:
                    if (Unread(mp) && !negate)
                    {
                        notify(player, tprintf("MAIL: Unread Msg #%d cleared! Use @mail/unclear %d to recover.", i, i));
                    }
                    else
                    {
                        notify(player, tprintf("MAIL: Msg #%d %s.", i, negate ? "uncleared" : "cleared"));
                    }
                    break;

                case M_SAFE:
                    notify(player, tprintf("MAIL: Msg #%d marked safe.", i));
                    break;
                }
            }
        }
    }

    if (!j)
    {
        // Ran off the end of the list without finding anything.
        //
        notify(player, "MAIL: You don't have any matching messages!");
    }
}

static void do_mail_tag(dbref player, char *msglist)
{
    do_mail_flags(player, msglist, M_TAG, false);
}

static void do_mail_safe(dbref player, char *msglist)
{
    do_mail_flags(player, msglist, M_SAFE, false);
}

void do_mail_clear(dbref player, char *msglist)
{
    do_mail_flags(player, msglist, M_CLEARED, false);
}

static void do_mail_untag(dbref player, char *msglist)
{
    do_mail_flags(player, msglist, M_TAG, true);
}

static void do_mail_unclear(dbref player, char *msglist)
{
    do_mail_flags(player, msglist, M_CLEARED, true);
}

// Change a message's folder.
//
static void do_mail_file(dbref player, char *msglist, char *folder)
{
    struct mail_selector ms;
    if (!parse_msglist(msglist, &ms, player))
    {
        return;
    }
    int foldernum;
    if ((foldernum = parse_folder(player, folder)) == -1)
    {
        notify(player, "MAIL: Invalid folder specification");
        return;
    }
    int i = 0, j = 0;
    int origfold = player_folder(player);

    MailList ml(player);
    struct mail *mp;
    for (mp = ml.FirstItem(); !ml.IsEnd(); mp = ml.NextItem())
    {
        if (  All(ms)
           || (Folder(mp) == origfold))
        {
            i++;
            if (mail_match(mp, ms, i))
            {
                j++;

                // Clear the folder.
                //
                mp->read &= M_FMASK;
                mp->read |= FolderBit(foldernum);
                notify(player, tprintf("MAIL: Msg %d filed in folder %d", i, foldernum));
            }
        }
    }

    if (!j)
    {
        // Ran off the end of the list without finding anything.
        //
        notify(player, "MAIL: You don't have any matching messages!");
    }
}

// A mail alias can be any combination of upper-case letters, lower-case
// letters, and digits. No leading digits. No symbols. No ANSI. Length is
// limited to SIZEOF_MALIAS-1. Case is preserved.
//
static char *MakeCanonicalMailAlias
(
    char *pMailAlias,
    int *pnValidMailAlias,
    bool *pbValidMailAlias
)
{
    static char Buffer[SIZEOF_MALIAS];
    size_t nLeft = sizeof(Buffer)-1;
    char *q = Buffer;
    char *p = pMailAlias;

    if (  !p
       || !mux_isalpha(*p))
    {
        *pnValidMailAlias = 0;
        *pbValidMailAlias = false;
        return NULL;
    }
    *q++ = *p++;
    nLeft--;

    while (  *p
          && nLeft)
    {
        if (  !mux_isalpha(*p)
           && !mux_isdigit(*p)
           && *p != '_')
        {
            break;
        }
        *q++ = *p++;
        nLeft--;
    }
    *q = '\0';

    *pnValidMailAlias = q - Buffer;
    *pbValidMailAlias = true;
    return Buffer;
}

#define GMA_NOTFOUND    1
#define GMA_FOUND       2
#define GMA_INVALIDFORM 3

static struct malias *get_malias(dbref player, char *alias, int *pnResult)
{
    *pnResult = GMA_INVALIDFORM;
    if (!alias)
    {
        return NULL;
    }
    if (alias[0] == '#')
    {
        if (ExpMail(player))
        {
            int x = mux_atol(alias + 1);
            if (x < 0 || x >= ma_top)
            {
                *pnResult = GMA_NOTFOUND;
                return NULL;
            }
            *pnResult = GMA_FOUND;
            return malias[x];
        }
    }
    else if (alias[0] == '*')
    {
        int  nValidMailAlias;
        bool bValidMailAlias;
        char *pValidMailAlias = MakeCanonicalMailAlias
                                (   alias+1,
                                    &nValidMailAlias,
                                    &bValidMailAlias
                                );

        if (bValidMailAlias)
        {
            for (int i = 0; i < ma_top; i++)
            {
                struct malias *m = malias[i];
                if (  m->owner == player
                   || m->owner == GOD
                   || ExpMail(player))
                {
                    if (!strcmp(pValidMailAlias, m->name))
                    {
                        // Found it!
                        //
                        *pnResult = GMA_FOUND;
                        return m;
                    }
                }
            }
            *pnResult = GMA_NOTFOUND;
        }
    }
    if (*pnResult == GMA_INVALIDFORM)
    {