mux/src/db.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"
#include "attrs.h"
#include "command.h"
#include "comsys.h"
#include "interface.h"
#include "powers.h"
#include "vattr.h"
#include "ansi.h"

Include dependency graph for db.cpp:

Go to the source code of this file.

Data Structures
struct	atrcount
Defines
#define	O_ACCMODE   (O_RDONLY|O_WRONLY|O_RDWR)
#define	SIZE_HACK   1
#define	STATE_START   0
#define	STATE_HAVE_ESC   1
Typedefs
typedef atrcount	ATRCOUNT
Functions
void	fwdlist_set (dbref thing, FWDLIST *ifp)
void	fwdlist_clr (dbref thing)
int	fwdlist_load (FWDLIST *fp, dbref player, char *atext)
int	fwdlist_rewrite (FWDLIST *fp, char *atext)
bool	fwdlist_ck (dbref player, dbref thing, int anum, char *atext)
FWDLIST *	fwdlist_get (dbref thing)
const char *	Name (dbref thing)
const char *	PureName (dbref thing)
const char *	Moniker (dbref thing)
void	s_Name (dbref thing, const char *s)
void	s_Moniker (dbref thing, const char *s)
void	s_Pass (dbref thing, const char *s)
void	do_attribute (dbref executor, dbref caller, dbref enactor, int key, int nargs, char *aname, char *value)
void	do_fixdb (dbref executor, dbref caller, dbref enactor, int key, int nargs, char *arg1, char *arg2)
char *	MakeCanonicalAttributeName (const char *pName, int *pnName, bool *pbValid)
char *	MakeCanonicalAttributeCommand (const char *pName, int *pnName, bool *pbValid)
void	init_attrtab (void)
ATTR *	atr_str (char *s)
void	anum_extend (int newtop)
ATTR *	atr_num (int anum)
static void	SetupThrottle (dbref executor)
static void	SetupGlobalThrottle (void)
bool	ThrottlePlayerCreate (void)
bool	ThrottleAttributeNames (dbref executor)
bool	ThrottleMail (dbref executor)
int	mkattr (dbref executor, char *buff)
static int	al_decode (char **app)
static char *	al_code (char *ap, int atrnum)
bool	Commer (dbref thing)
static void	al_extend (char **buffer, size_t *bufsiz, size_t len, bool copy)
void	al_store (void)
static char *	al_fetch (dbref thing)
static bool	al_add (dbref thing, int attrnum)
static void	al_delete (dbref thing, int attrnum)
static DCL_INLINE void	makekey (dbref thing, int atr, Aname *abuff)
static char *	atr_encode (char *iattr, dbref thing, dbref owner, int flags, int atr)
static const char *	atr_decode_flags_owner (const char *iattr, dbref *owner, int *flags)
static void	atr_decode_LEN (const char *iattr, int nLen, char *oattr, dbref thing, dbref *owner, int *flags, size_t *pLen)
void	atr_clr (dbref thing, int atr)
void	atr_add_raw_LEN (dbref thing, int atr, const char *szValue, int nValue)
void	atr_add_raw (dbref thing, int atr, const char *szValue)
void	atr_add (dbref thing, int atr, char *buff, dbref owner, int flags)
void	atr_set_flags (dbref thing, int atr, dbref flags)
int	get_atr (char *name)
const char *	atr_get_raw_LEN (dbref thing, int atr, size_t *pLen)
const char *	atr_get_raw (dbref thing, int atr)
char *	atr_get_str_LEN (char *s, dbref thing, int atr, dbref *owner, int *flags, size_t *pLen)
char *	atr_get_str (char *s, dbref thing, int atr, dbref *owner, int *flags)
char *	atr_get_LEN (dbref thing, int atr, dbref *owner, int *flags, size_t *pLen)
char *	atr_get_real (dbref thing, int atr, dbref *owner, int *flags, const char *file, const int line)
bool	atr_get_info (dbref thing, int atr, dbref *owner, int *flags)
char *	atr_pget_str_LEN (char *s, dbref thing, int atr, dbref *owner, int *flags, size_t *pLen)
char *	atr_pget_str (char *s, dbref thing, int atr, dbref *owner, int *flags)
char *	atr_pget_LEN (dbref thing, int atr, dbref *owner, int *flags, size_t *pLen)
char *	atr_pget_real (dbref thing, int atr, dbref *owner, int *flags, const char *file, const int line)
bool	atr_pget_info (dbref thing, int atr, dbref *owner, int *flags)
void	atr_free (dbref thing)
void	atr_cpy (dbref dest, dbref source, bool bInternal)
void	atr_chown (dbref obj)
int	atr_next (char **attrp)
void	atr_push (void)
void	atr_pop (void)
int	atr_head (dbref thing, char **attrp)
static void	initialize_objects (dbref first, dbref last)
void	db_grow (dbref newtop)
void	db_free (void)
void	db_make_minimal (void)
dbref	parse_dbref (const char *s)
void	putref (FILE *f, dbref ref)
char *	getstring_noalloc (FILE *f, int new_strings)
void	putstring (FILE *f, const char *pRaw)
int	getref (FILE *f)
void	free_boolexp (BOOLEXP *b)
static BOOLEXP *	dup_bool (BOOLEXP *b)
int	init_dbfile (char *game_dir_file, char *game_pag_file, int nCachePages)
bool	check_zone_handler (dbref player, dbref thing, bool bPlayerCheck)
void	ReleaseAllResources (dbref obj)
void	dump_restart_db (void)
void	load_restart_db (void)
int	ReplaceFile (char *old_name, char *new_name)
void	RemoveFile (char *name)
Variables
OBJ *	db = NULL
ATTR	attr []
char *	aszSpecialDBRefNames [1-NOPERM]
ATTR **	anum_table = NULL
int	anum_alc_top = 0
static const unsigned char	decode_table [256]
static const int	action_table [2][8]
static const unsigned char	encode_table [256]

---

Define Documentation

#define O_ACCMODE   (O_RDONLY|O_WRONLY|O_RDWR)

Definition at line 23 of file db.cpp.

#define SIZE_HACK   1

Definition at line 2517 of file db.cpp.

Referenced by db_free(), and db_grow().

#define STATE_HAVE_ESC   1

Definition at line 2775 of file db.cpp.

Referenced by getstring_noalloc().

#define STATE_START   0

Definition at line 2774 of file db.cpp.

Referenced by getstring_noalloc().

---

Typedef Documentation

typedef struct atrcount ATRCOUNT

Definition at line 28 of file db.cpp.

---

Function Documentation

static bool al_add	(	dbref	thing,
		int	attrnum
	)			[static]

Definition at line 1525 of file db.cpp.

References al_code(), al_decode(), al_extend(), al_fetch(), ATR_BUF_INCR, LBUF_SIZE, statedata::mod_alist, statedata::mod_alist_len, statedata::mod_size, and mudstate.

Referenced by atr_add_raw_LEN().

{
    char *abuf = al_fetch(thing);
    char *cp = abuf;
    int anum;

    // See if attr is in the list.  If so, exit (need not do anything).
    //
    while (*cp)
    {
        anum = al_decode(&cp);
        if (anum == attrnum)
        {
            return true;
        }
    }

    // The attribute isn't there, so we need to try to add it.
    //
    int iPosition = cp - abuf;

    // If we are too large for an attribute
    //
    if (iPosition + ATR_BUF_INCR >= LBUF_SIZE)
    {
        return false;
    }

    // Extend it.
    //
    al_extend(&mudstate.mod_alist, &mudstate.mod_size, (iPosition + ATR_BUF_INCR), true);
    if (mudstate.mod_alist != abuf)
    {
        // extend returned different buffer, re-position the end
        //
        cp = mudstate.mod_alist + iPosition;
    }

    // Add the new attribute on to the end.
    //
    cp = al_code(cp, attrnum);
    *cp = '\0';
    mudstate.mod_alist_len = cp - mudstate.mod_alist;
    return true;
}

static char* al_code	(	char *	ap,
		int	atrnum
	)			[static]

Definition at line 1332 of file db.cpp.

Referenced by al_add(), and al_delete().

{
    int bits;
    for (;;)
    {
        bits = atrnum & 0x7F;
        if (atrnum <= 0x7F)
        {
            break;
        }
        atrnum >>= 7;
        bits |= 0x80;
        *ap++ = (char)bits;
    }
    *ap++ = (char)bits;
    return ap;
}

static int al_decode

(

char **

app

)

[static]

Definition at line 1300 of file db.cpp.

Referenced by al_add(), al_delete(), and atr_next().

{
    char *ap = *app;

    int atrnum = 0, atrshft = 0;
    for (;;)
    {
        int ch = *ap++;
        int bits = ch & 0x7F;

        if (atrshft > 0)
            atrnum |= (bits << atrshft);
        else
            atrnum = bits;

        if ((ch & 0x80) == 0)
        {
            *app = ap;
            return atrnum;
        }
        atrshft += 7;
    }
}

static void al_delete	(	dbref	thing,
		int	attrnum
	)			[static]

Definition at line 1573 of file db.cpp.

References A_LIST, al_code(), al_decode(), al_fetch(), statedata::mod_alist, statedata::mod_alist_len, and mudstate.

Referenced by atr_clr().

{
    int anum;
    char *abuf, *cp, *dp;

    // If trying to modify List attrib, return.  Otherwise, get the attribute list.
    //
    if (attrnum == A_LIST)
    {
        return;
    }
    abuf = al_fetch(thing);
    if (!abuf)
    {
        return;
    }

    cp = abuf;
    while (*cp)
    {
        dp = cp;
        anum = al_decode(&cp);
        if (anum == attrnum)
        {
            while (*cp)
            {
                anum = al_decode(&cp);
                dp = al_code(dp, anum);
            }
            *dp = '\0';
            mudstate.mod_alist_len = dp - mudstate.mod_alist;
            return;
        }
    }
    return;
}

static void al_extend	(	char **	buffer,
		size_t *	bufsiz,
		size_t	len,
		bool	copy
	)			[static]

Definition at line 1452 of file db.cpp.

References ATR_BUF_CHUNK, ISOUTOFMEMORY, MEMALLOC, and MEMFREE.

Referenced by al_add(), al_fetch(), and atr_head().

{
    if (len > *bufsiz)
    {
        int newsize = len + ATR_BUF_CHUNK;
        char *tbuff = (char *)MEMALLOC(newsize);
        ISOUTOFMEMORY(tbuff);
        if (*buffer)
        {
            if (copy)
            {
                memcpy(tbuff, *buffer, *bufsiz);
            }
            MEMFREE(*buffer);
            *buffer = NULL;
        }
        *buffer = tbuff;
        *bufsiz = newsize;
    }
}

static char* al_fetch

(

dbref

thing

)

[static]

Definition at line 1493 of file db.cpp.

References A_LIST, al_extend(), al_store(), atr_get_raw_LEN(), statedata::mod_al_id, statedata::mod_alist, statedata::mod_alist_len, statedata::mod_size, and mudstate.

Referenced by al_add(), and al_delete().

{
    // We only need fetch if we change things.
    //
    if (mudstate.mod_al_id == thing)
    {
        return mudstate.mod_alist;
    }

    // Save old list, then fetch and set up the attribute list.
    //
    al_store();
    size_t len;
    const char *astr = atr_get_raw_LEN(thing, A_LIST, &len);
    if (astr)
    {
        al_extend(&mudstate.mod_alist, &mudstate.mod_size, len+1, false);
        memcpy(mudstate.mod_alist, astr, len+1);
        mudstate.mod_alist_len = len;
    }
    else
    {
        al_extend(&mudstate.mod_alist, &mudstate.mod_size, 1, false);
        *mudstate.mod_alist = '\0';
        mudstate.mod_alist_len = 0;
    }
    mudstate.mod_al_id = thing;
    return mudstate.mod_alist;
}

void al_store

(

void

)

Definition at line 1475 of file db.cpp.

References A_LIST, atr_add_raw_LEN(), atr_clr(), statedata::mod_al_id, statedata::mod_alist, statedata::mod_alist_len, mudstate, and NOTHING.

Referenced by al_fetch(), atr_free(), dbconvert(), do_dbclean(), do_restart(), do_shutdown(), dump_database(), fork_and_dump(), and sighandler().

{
    if (mudstate.mod_al_id != NOTHING)
    {
        if (mudstate.mod_alist_len)
        {
            atr_add_raw_LEN(mudstate.mod_al_id, A_LIST, mudstate.mod_alist, mudstate.mod_alist_len);
        }
        else
        {
            atr_clr(mudstate.mod_al_id, A_LIST);
        }
    }
    mudstate.mod_al_id = NOTHING;
}

void anum_extend

(

int

newtop

)

Definition at line 1112 of file db.cpp.

References anum_table, statedata::bStandAlone, confdata::init_size, ISOUTOFMEMORY, MEMALLOC, MEMFREE, mudconf, and mudstate.

Referenced by init_attrtab(), vattr_alloc_LEN(), and vattr_define_LEN().

{
    ATTR **anum_table2;
    int delta, i;

    if (mudstate.bStandAlone)
    {
        delta = 1000;
    }
    else
    {
        delta = mudconf.init_size;
    }
    if (newtop <= anum_alc_top)
    {
        return;
    }
    if (newtop < anum_alc_top + delta)
    {
        newtop = anum_alc_top + delta;
    }
    if (anum_table == NULL)
    {
        anum_table = (ATTR **) MEMALLOC((newtop + 1) * sizeof(ATTR *));
        ISOUTOFMEMORY(anum_table);
        for (i = 0; i <= newtop; i++)
        {
            anum_table[i] = NULL;
        }
    }
    else
    {
        anum_table2 = (ATTR **) MEMALLOC((newtop + 1) * sizeof(ATTR *));
        ISOUTOFMEMORY(anum_table2);
        for (i = 0; i <= anum_alc_top; i++)
        {
            anum_table2[i] = anum_table[i];
        }
        for (i = anum_alc_top + 1; i <= newtop; i++)
        {
            anum_table2[i] = NULL;
        }
        MEMFREE((char *)anum_table);
        anum_table = anum_table2;
    }
    anum_alc_top = newtop;
}

void atr_add	(	dbref	thing,
		int	atr,
		char *	buff,
		dbref	owner,
		int	flags
	)

Definition at line 2008 of file db.cpp.

References AMATCH_CMD, AMATCH_LISTEN, atr_add_raw(), atr_clr(), atr_encode(), statedata::bfCommands, statedata::bfListens, statedata::bfNoCommands, statedata::bfNoListens, CBitField::Clear(), mudstate, and set_modified().

Referenced by add_folder_name(), atr_chown(), atr_cpy(), atr_set_flags(), check_dead_refs(), do_alias(), do_chanlog(), do_chown(), do_edit(), do_edit_msg(), do_forwardlist(), do_mvattr(), SendChannelMessage(), set_attr_internal(), and set_player_folder().

{
    set_modified(thing);

    if (!buff || !*buff)
    {
        atr_clr(thing, atr);
    }
    else
    {
        switch (buff[0])
        {
        case AMATCH_LISTEN:

            // Since this could be a ^-Command, we no longer assert that the
            // object has none.
            //
            mudstate.bfNoListens.Clear(thing);
            break;

        case AMATCH_CMD:

            // Since this could be a $-Command, we no longer assert that the
            // object has none.
            //
            mudstate.bfNoCommands.Clear(thing);
            break;
        }

        // Since this could overwrite an existing ^-Command or $-Command, we
        // longer assert that the object has one.
        //
        mudstate.bfListens.Clear(thing);
        mudstate.bfCommands.Clear(thing);

        char *tbuff = atr_encode(buff, thing, owner, flags, atr);
        atr_add_raw(thing, atr, tbuff);
    }
}

void atr_add_raw	(	dbref	thing,
		int	atr,
		const char *	szValue
	)

Definition at line 2003 of file db.cpp.

References atr_add_raw_LEN().

Referenced by add_quota(), atr_add(), connect_player(), create_obj(), db_read(), dbclean_RenumberAttributes(), did_it(), do_destroy(), do_expmail_start(), do_icmd(), do_lock(), do_mail_cc(), do_mail_fwd(), do_mail_reply(), do_page(), do_pcreate(), do_postpend(), do_prepend(), do_prog(), get_list(), get_slave_result(), mung_quotas(), pay_quota(), pcache_save(), record_login(), s_Moniker(), s_Name(), s_Pass(), s_Pennies(), s_PenniesDirect(), set_modified(), and shutdownsock().

{
    atr_add_raw_LEN(thing, atr, szValue, szValue ? strlen(szValue) : 0);
}

void atr_add_raw_LEN	(	dbref	thing,
		int	atr,
		const char *	szValue,
		int	nValue
	)

Definition at line 1843 of file db.cpp.

References A_DAILY, A_FORWARDLIST, A_LIST, A_LISTEN, A_QUEUEMAX, A_STARTUP, A_TIMEOUT, al_add(), atr_clr(), ATRLIST_CHUNK, cache_put(), db, desc_reload(), FLAG_WORD1, FLAG_WORD2, object::fs, HAS_DAILY, HAS_FWDLIST, HAS_LISTEN, HAS_STARTUP, INITIAL_ATRLIST_SIZE, ISOUTOFMEMORY, LBUF_SIZE, makekey(), MEMALLOC, MEMFREE, pcache_reload(), StringCloneLen(), and flagset::word.

Referenced by add_to(), al_store(), atr_add_raw(), and put_ConnectionInfoFields().

{
    if (  !szValue
       || '\0' == szValue[0])
    {
        atr_clr(thing, atr);
        return;
    }

#ifdef MEMORY_BASED
    ATRLIST *list;
    bool found = false;
    int hi, lo, mid;
    char *text = StringCloneLen(szValue, nValue);

    if (!db[thing].pALHead)
    {
        db[thing].nALAlloc = INITIAL_ATRLIST_SIZE;
        list = (ATRLIST *)MEMALLOC(db[thing].nALAlloc*sizeof(ATRLIST));
        ISOUTOFMEMORY(list);
        db[thing].pALHead  = list;
        db[thing].nALUsed  = 1;
        list[0].number = atr;
        list[0].data = text;
        list[0].size = nValue + 1;
        found = true;
    }
    else
    {
        // Binary search for the attribute
        //
        lo = 0;
        hi = db[thing].nALUsed - 1;

        list = db[thing].pALHead;
        while (lo <= hi)
        {
            mid = ((hi - lo) >> 1) + lo;
            if (list[mid].number > atr)
            {
                hi = mid - 1;
            }
            else if (list[mid].number < atr)
            {
                lo = mid + 1;
            }
            else // if (list[mid].number == atr)
            {
                MEMFREE(list[mid].data);
                list[mid].data = text;
                list[mid].size = nValue + 1;
                found = true;
                break;
            }
        }

        if (!found)
        {
            // We didn't find it, and lo == hi + 1.  The attribute should be
            // inserted between (0,hi) and (lo,nALUsed-1).
            //
            if (db[thing].nALUsed < db[thing].nALAlloc)
            {
                memmove( list + lo + 1,
                         list + lo,
                         (db[thing].nALUsed - lo) * sizeof(ATRLIST));
            }
            else
            {
                // Expand the list.
                //
                db[thing].nALAlloc += ATRLIST_CHUNK;
                list = (ATRLIST *)MEMALLOC(db[thing].nALAlloc
                     * sizeof(ATRLIST));
                ISOUTOFMEMORY(list);

                // Copy bottom part.
                //
                if (lo > 0)
                {
                    memcpy(list, db[thing].pALHead, lo * sizeof(ATRLIST));
                }
    
                // Copy top part.
                //
                if (lo < db[thing].nALUsed)
                {
                    memcpy( list + lo + 1,
                            db[thing].pALHead + lo,
                            (db[thing].nALUsed - lo) * sizeof(ATRLIST));
                }
                MEMFREE(db[thing].pALHead);
                db[thing].pALHead = list;
            }
            db[thing].nALUsed++;
            list[lo].data = text;
            list[lo].number = atr;
            list[lo].size = nValue + 1;
        }
    }

#else // MEMORY_BASED

    if (nValue > LBUF_SIZE-1)
    {
        nValue = LBUF_SIZE-1;
    }

    Aname okey;
    makekey(thing, atr, &okey);
    if (atr == A_LIST)
    {
        // A_LIST is never compressed and it's never listed within itself.
        //
        cache_put(&okey, szValue, nValue+1);
    }
    else
    {
        if (!al_add(thing, atr))
        {
            return;
        }
        cache_put(&okey, szValue, nValue+1);
    }
#endif // MEMORY_BASED

    switch (atr)
    {
    case A_STARTUP:

        db[thing].fs.word[FLAG_WORD1] |= HAS_STARTUP;
        break;

    case A_DAILY:

        db[thing].fs.word[FLAG_WORD2] |= HAS_DAILY;
        break;

    case A_FORWARDLIST:

        db[thing].fs.word[FLAG_WORD2] |= HAS_FWDLIST;
        break;

    case A_LISTEN:

        db[thing].fs.word[FLAG_WORD2] |= HAS_LISTEN;
        break;

    case A_TIMEOUT:

        desc_reload(thing);
        break;

    case A_QUEUEMAX:

        pcache_reload(thing);
        break;
    }
}

void atr_chown

(

dbref

obj

)

Definition at line 2359 of file db.cpp.

References AF_LOCK, atr_add(), atr_get, atr_head(), atr_next(), atr_pop(), atr_push(), free_lbuf, and Owner.

Referenced by do_chown().

{
    dbref owner = Owner(obj);

    char *as;
    atr_push();
    for (int atr = atr_head(obj, &as); atr; atr = atr_next(&as))
    {
        int   aflags;
        dbref aowner;
        char *buf = atr_get(obj, atr, &aowner, &aflags);
        if (  aowner != owner
           && !(aflags & AF_LOCK))
        {
            atr_add(obj, atr, buf, owner, aflags);
        }
        free_lbuf(buf);
    }
    atr_pop();
}

void atr_clr	(	dbref	thing,
		int	atr
	)

Definition at line 1739 of file db.cpp.

References A_DAILY, A_FORWARDLIST, A_LISTEN, A_QUEUEMAX, A_STARTUP, A_TIMEOUT, al_delete(), statedata::bfCommands, statedata::bfListens, statedata::bStandAlone, cache_del(), CBitField::Clear(), db, desc_reload(), FLAG_WORD1, FLAG_WORD2, object::fs, fwdlist_clr(), HAS_DAILY, HAS_FWDLIST, HAS_LISTEN, HAS_STARTUP, makekey(), MEMFREE, mudstate, mux_assert, pcache_reload(), and flagset::word.

Referenced by al_store(), atr_add(), atr_add_raw_LEN(), atr_free(), dbclean_CheckALISTtoAT(), dbclean_CheckALISTtoDB(), do_alias(), do_chanlog(), do_expmail_start(), do_forwardlist(), do_icmd(), do_mvattr(), do_unlock(), do_wipe(), nfy_que(), shutdownsock(), and CGuests::WipeAttrs().

{
#ifdef MEMORY_BASED

    if (  !db[thing].nALUsed
       || !db[thing].pALHead)
    {
        return;
    }

    mux_assert(0 <= db[thing].nALUsed);

    // Binary search for the attribute.
    //
    int lo = 0;
    int mid;
    int hi = db[thing].nALUsed - 1;
    ATRLIST *list = db[thing].pALHead;
    while (lo <= hi)
    {
        mid = ((hi - lo) >> 1) + lo;
        if (list[mid].number > atr)
        {
            hi = mid - 1;
        }
        else if (list[mid].number < atr)
        {
            lo = mid + 1;
        }
        else // (list[mid].number == atr)
        {
            MEMFREE(list[mid].data);
            list[mid].data = NULL;
            db[thing].nALUsed--;
            if (mid != db[thing].nALUsed)
            {
                memmove( list + mid,
                         list + mid + 1,
                         (db[thing].nALUsed - mid) * sizeof(ATRLIST));
            }
            break;
        }
    }
#else // MEMORY_BASED
    Aname okey;

    makekey(thing, atr, &okey);
    cache_del(&okey);
    al_delete(thing, atr);
#endif // MEMORY_BASED

    switch (atr)
    {
    case A_STARTUP:

        db[thing].fs.word[FLAG_WORD1] &= ~HAS_STARTUP;
        break;

    case A_DAILY:

        db[thing].fs.word[FLAG_WORD2] &= ~HAS_DAILY;
        break;

    case A_FORWARDLIST:

        db[thing].fs.word[FLAG_WORD2] &= ~HAS_FWDLIST;
        if (!mudstate.bStandAlone)
        {
            // We should clear the hashtable, too.
            //
            fwdlist_clr(thing);
        }
        break;

    case A_LISTEN:

        db[thing].fs.word[FLAG_WORD2] &= ~HAS_LISTEN;
        break;

    case A_TIMEOUT:

        desc_reload(thing);
        break;

    case A_QUEUEMAX:

        pcache_reload(thing);
        break;

    default:

        // Since this could overwrite an existing ^-Command or $-Command, we
        // longer assert that the object has one.
        //
        mudstate.bfListens.Clear(thing);
        mudstate.bfCommands.Clear(thing);
        break;
    }
}

void atr_cpy	(	dbref	dest,
		dbref	source,
		bool	bInternal
	)

Definition at line 2310 of file db.cpp.

References AF_GOD, AF_INTERNAL, AF_LOCK, AF_NOCLONE, AF_WIZARD, atr_add(), atr_get, atr_head(), atr_next(), atr_num(), atr_pop(), atr_push(), Controls, attr::flags, free_lbuf, God, Owner, and Wizard.

Referenced by CGuests::Create(), do_clone(), and CGuests::MakeGuestChar().

{
    dbref owner = Owner(dest);

    char *as;
    atr_push();
    for (int atr = atr_head(source, &as); atr; atr = atr_next(&as))
    {
        int   aflags;
        dbref aowner;
        char *buf = atr_get(source, atr, &aowner, &aflags);

        if (!(aflags & AF_LOCK))
        {
            // Change owner.
            //
            aowner = owner;
        }

        ATTR *at = atr_num(atr);
        if (  atr
           && at)
        {
            if (  !(at->flags & (AF_INTERNAL|AF_NOCLONE))
               && (  bInternal
                  || God(owner)
                  || (  !God(dest)
                     && !(aflags & AF_LOCK)
                     && (  (  Controls(owner, dest)
                           && !(at->flags & (AF_WIZARD|AF_GOD))
                           && !(aflags & (AF_WIZARD|AF_GOD)))
                        || (  Wizard(owner)
                           && !(at->flags & AF_GOD))))))
            {
                // Only set attrs that owner has perm to set.
                //
                atr_add(dest, atr, buf, aowner, aflags);
            }
        }
        free_lbuf(buf);
    }
    atr_pop();
}

static const char* atr_decode_flags_owner	(	const char *	iattr,
		dbref *	owner,
		int *	flags
	)			[static]

Definition at line 1642 of file db.cpp.

References ATR_INFO_CHAR, mux_isdigit, and NOTHING.

Referenced by atr_decode_LEN().

{
    // See if the first char of the attribute is the special character
    //
    *flags = 0;
    if (*iattr != ATR_INFO_CHAR)
    {
        return iattr;
    }

    // It has the special character, crack the attr apart.
    //
    const char *cp = iattr + 1;

    // Get the attribute owner
    //
    bool neg = false;
    if (*cp == '-')
    {
        neg = true;
        cp++;
    }
    int tmp_owner = 0;
    unsigned int ch = *cp;
    while (mux_isdigit(ch))
    {
        cp++;
        tmp_owner = 10*tmp_owner + (ch-'0');
        ch = *cp;
    }
    if (neg)
    {
        tmp_owner = -tmp_owner;
    }

    // If delimiter is not ':', just return attribute
    //<