mux/src/walkdb.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"
#include "misc.h"
#include "attrs.h"
#include "command.h"

Include dependency graph for walkdb.cpp:

Go to the source code of this file.

Defines
#define	ANY_OWNER   -2
Functions
static void	bind_and_queue (dbref executor, dbref caller, dbref enactor, char *action, char *argstr, char *cargs[], int ncargs, int number)
void	do_dolist (dbref executor, dbref caller, dbref enactor, int key, char *list, char *command, char *cargs[], int ncargs)
void	do_find (dbref executor, dbref caller, dbref enactor, int key, char *name)
bool	get_stats (dbref player, dbref who, STATS *info)
void	do_stats (dbref executor, dbref caller, dbref enactor, int key, char *name)
int	chown_all (dbref from_player, dbref to_player, dbref acting_player, int key)
void	do_chownall (dbref executor, dbref caller, dbref enactor, int key, int nargs, char *from, char *to)
static void	er_mark_disabled (dbref player)
bool	search_setup (dbref player, char *searchfor, SEARCH *parm)
void	search_perform (dbref executor, dbref caller, dbref enactor, SEARCH *parm)
static void	search_mark (dbref player, int key)
void	do_search (dbref executor, dbref caller, dbref enactor, int key, char *arg)
void	do_markall (dbref executor, dbref caller, dbref enactor, int key)
void	do_apply_marked (dbref executor, dbref caller, dbref enactor, int key, char *command, char *cargs[], int ncargs)
void	olist_push (void)
void	olist_pop (void)
void	olist_add (dbref item)
dbref	olist_first (void)
dbref	olist_next (void)

---

Define Documentation

#define ANY_OWNER   -2

Definition at line 372 of file walkdb.cpp.

Referenced by search_perform(), and search_setup().

---

Function Documentation

static void bind_and_queue	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		char *	action,
		char *	argstr,
		char *	cargs[],
		int	ncargs,
		int	number
	)			[static]

Definition at line 18 of file walkdb.cpp.

References free_lbuf, statedata::global_regs, mudstate, mux_ltoa_t(), NOTHING, replace_tokens(), and wait_que().

Referenced by do_apply_marked(), and do_dolist().

{
    char *command = replace_tokens(action, argstr, mux_ltoa_t(number), NULL);
    CLinearTimeAbsolute lta;
    wait_que(executor, caller, enactor, false, lta, NOTHING, 0, command,
        cargs, ncargs, mudstate.global_regs);
    free_lbuf(command);
}

int chown_all	(	dbref	from_player,
		dbref	to_player,
		dbref	acting_player,
		int	key
	)

Definition at line 244 of file walkdb.cpp.

References add_quota(), CHOWN_NOZONE, CHOWN_OK, DO_WHOLE_DB, confdata::exit_quota, FLAG_WORD1, Flags, God, HALT, INHERIT, isPlayer, mudconf, NOTHING, notify, Owner, confdata::player_quota, confdata::room_quota, s_Flags, s_Owner, s_Zone, confdata::thing_quota, TYPE_EXIT, TYPE_PLAYER, TYPE_ROOM, TYPE_THING, and Typeof.

Referenced by destroy_player(), do_chownall(), and do_toad().

{
    if (!isPlayer(from_player))
    {
        from_player = Owner(from_player);
    }
    if (!isPlayer(to_player))
    {
        to_player = Owner(to_player);
    }
    int count     = 0;
    if (  God(from_player)
       && !God(acting_player))
    {
        notify(acting_player, "Permission denied.");
    }
    else
    {
        int i;
        int quota_out = 0;
        int quota_in  = 0;
        DO_WHOLE_DB(i)
        {
            if (  Owner(i) == from_player
               && Owner(i) != i)
            {
                switch (Typeof(i))
                {
                case TYPE_PLAYER:

                    s_Owner(i, i);
                    quota_out += mudconf.player_quota;
                    break;

                case TYPE_THING:

                    s_Owner(i, to_player);
                    quota_out += mudconf.thing_quota;
                    quota_in -= mudconf.thing_quota;
                    break;

                case TYPE_ROOM:

                    s_Owner(i, to_player);
                    quota_out += mudconf.room_quota;
                    quota_in -= mudconf.room_quota;
                    break;

                case TYPE_EXIT:

                    s_Owner(i, to_player);
                    quota_out += mudconf.exit_quota;
                    quota_in -= mudconf.exit_quota;
                    break;

                default:

                    s_Owner(i, to_player);
                }
                s_Flags(i, FLAG_WORD1,
                    (Flags(i) & ~(CHOWN_OK | INHERIT)) | HALT);

                if (key & CHOWN_NOZONE)
                {
                    s_Zone(i, NOTHING);
                }
                count++;
            }
        }
        add_quota(from_player, quota_out);
        add_quota(to_player, quota_in);
    }
    return count;
}

void do_apply_marked	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	command,
		char *	cargs[],
		int	ncargs
	)

Definition at line 1120 of file walkdb.cpp.

References alloc_sbuf, bind_and_queue(), CF_DBCHECK, confdata::control_flags, DO_WHOLE_DB, er_mark_disabled(), free_sbuf, Marked, mudconf, mux_ltoa(), notify, Quiet, and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(key);

    if (mudconf.control_flags & CF_DBCHECK)
    {
        er_mark_disabled(executor);
        return;
    }
    char *buff = alloc_sbuf("do_apply_marked");
    int i;
    int number = 0;
    DO_WHOLE_DB(i)
    {
        if (Marked(i))
        {
            buff[0] = '#';
            mux_ltoa(i, buff+1);
            number++;
            bind_and_queue(executor, caller, enactor, command, buff,
                cargs, ncargs, number);
        }
    }
    free_sbuf(buff);
    if (!Quiet(executor))
    {
        notify(executor, "Done.");
    }
}

void do_chownall	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		int	nargs,
		char *	from,
		char *	to
	)

Definition at line 320 of file walkdb.cpp.

References chown_all(), init_match(), isPlayer, match_absolute(), match_neighbor(), match_player(), noisy_match_result(), NOTHING, notify, Quiet, tprintf(), TYPE_PLAYER, and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);
    UNUSED_PARAMETER(nargs);

    init_match(executor, from, TYPE_PLAYER);
    match_neighbor();
    match_absolute();
    match_player();

    dbref victim = noisy_match_result();
    if (NOTHING == victim)
    {
        return;
    }
    else if (!isPlayer(victim))
    {
        notify(executor, "Victim must be a player.");
        return;
    }

    dbref recipient = executor;
    if (  NULL  != to
       && to[0] != '\0')
    {
        init_match(executor, to, TYPE_PLAYER);
        match_neighbor();
        match_absolute();
        match_player();
        recipient = noisy_match_result();
        if (NOTHING == recipient)
        {
            return;
        }
    }

    int count = chown_all(victim, recipient, executor, key);
    if (!Quiet(executor))
    {
        notify(executor, tprintf("%d objects @chowned.", count));
    }
}

void do_dolist	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	list,
		char *	command,
		char *	cargs[],
		int	ncargs
	)

Definition at line 35 of file walkdb.cpp.

References A_SEMAPHORE, alloc_lbuf, bind_and_queue(), DOLIST_DELIMIT, DOLIST_NOTIFY, EV_STRIP_CURLY, free_lbuf, statedata::global_regs, mudstate, NOTHING, notify, parse_to(), and wait_que().

{
    if (!list || *list == '\0')
    {
        notify(executor, "That's terrific, but what should I do with the list?");
        return;
    }
    char *objstring, delimiter = ' ';
    int number = 0;
    char *curr = list;

    if (key & DOLIST_DELIMIT)
    {
        char *tempstr = parse_to(&curr, ' ', EV_STRIP_CURLY);
        if (strlen(tempstr) > 1)
        {
            notify(executor, "The delimiter must be a single character!");
            return;
        }
        delimiter = *tempstr;
    }
    while (curr && *curr)
    {
        while (*curr == delimiter)
        {
            curr++;
        }
        if (*curr)
        {
            number++;
            objstring = parse_to(&curr, delimiter, EV_STRIP_CURLY);
            bind_and_queue(executor, caller, enactor, command, objstring,
                cargs, ncargs, number);
        }
    }
    if (key & DOLIST_NOTIFY)
    {
        char *tbuf = alloc_lbuf("dolist.notify_cmd");
        strcpy(tbuf, "@notify/quiet me");
        CLinearTimeAbsolute lta;
        wait_que(executor, caller, enactor, false, lta, NOTHING, A_SEMAPHORE,
            tbuf, cargs, ncargs, mudstate.global_regs);
        free_lbuf(tbuf);
    }
}

void do_find	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	name
	)

Definition at line 84 of file walkdb.cpp.

References Controls, free_lbuf, confdata::many_coins, mudconf, notify, notify_quiet, parse_range(), payfor(), PureName(), confdata::searchcost, string_match(), tprintf(), TYPE_EXIT, Typeof, unparse_object(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);
    UNUSED_PARAMETER(key);

    char *buff;

    if (!payfor(executor, mudconf.searchcost))
    {
        buff = tprintf("You don't have enough %s.", mudconf.many_coins);
        notify_quiet(executor, buff);
        return;
    }

    dbref i, low_bound, high_bound;
    parse_range(&name, &low_bound, &high_bound);
    for (i = low_bound; i <= high_bound; i++)
    {
        if (  (Typeof(i) != TYPE_EXIT)
           && Controls(executor, i)
           && (!*name || string_match(PureName(i), name)))
        {
            buff = unparse_object(executor, i, false);
            notify(executor, buff);
            free_lbuf(buff);
        }
    }
    notify(executor, "***End of List***");
}

void do_markall	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key
	)

Definition at line 1091 of file walkdb.cpp.

References CF_DBCHECK, confdata::control_flags, er_mark_disabled(), Mark_all, MARK_CLEAR, MARK_SET, mudconf, notify, Quiet, Unmark_all, and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    int i;

    if (mudconf.control_flags & CF_DBCHECK)
    {
        er_mark_disabled(executor);
        return;
    }
    if (key == MARK_SET)
    {
        Mark_all(i);
    }
    else if (key == MARK_CLEAR)
    {
        Unmark_all(i);
    }
    if (!Quiet(executor))
    {
        notify(executor, "Done.");
    }
}

void do_search	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	arg
	)

Definition at line 897 of file walkdb.cpp.

References alloc_lbuf, CF_DBCHECK, confdata::control_flags, er_mark_disabled(), Exits, free_lbuf, Location, mudconf, NOTHING, notify, NOTYPE, olist_first(), olist_next(), olist_pop(), olist_push(), Owner, search_type::s_rst_type, search_type::s_wizard, safe_chr, safe_str, search_mark(), search_perform(), search_setup(), SRCH_SEARCH, TYPE_EXIT, TYPE_PLAYER, TYPE_ROOM, TYPE_THING, Typeof, and unparse_object().

{
    char *buff, *outbuf, *bp;
    dbref thing, from, to;
    SEARCH searchparm;

    if ((key != SRCH_SEARCH) && (mudconf.control_flags & CF_DBCHECK))
    {
        er_mark_disabled(executor);
        return;
    }
    if (!search_setup(executor, arg, &searchparm))
    {
        return;
    }
    olist_push();
    search_perform(executor, caller, enactor, &searchparm);
    bool destitute = true;
    bool flag;

    // If we are doing a @mark command, handle that here.
    //
    if (key != SRCH_SEARCH)
    {
        search_mark(executor, key);
        olist_pop();
        return;
    }
    outbuf = alloc_lbuf("do_search.outbuf");

    int rcount = 0;
    int ecount = 0;
    int tcount = 0;
    int pcount = 0;

    // Room search.
    //
    if (  searchparm.s_rst_type == TYPE_ROOM
       || searchparm.s_rst_type == NOTYPE)
    {
        flag = true;
        for (thing = olist_first(); thing != NOTHING; thing = olist_next())
        {
            if (Typeof(thing) != TYPE_ROOM)
            {
                continue;
            }
            if (flag)
            {
                flag = false;
                destitute = false;
                notify(executor, "\nROOMS:");
            }
            buff = unparse_object(executor, thing, false);
            notify(executor, buff);
            free_lbuf(buff);
            rcount++;
        }
    }

    // Exit search.
    //
    if (  searchparm.s_rst_type == TYPE_EXIT
       || searchparm.s_rst_type == NOTYPE)
    {
        flag = true;
        for (thing = olist_first(); thing != NOTHING; thing = olist_next())
        {
            if (Typeof(thing) != TYPE_EXIT)
            {
                continue;
            }
            if (flag)
            {
                flag = false;
                destitute = false;
                notify(executor, "\nEXITS:");
            }
            from = Exits(thing);
            to = Location(thing);

            bp = outbuf;
            buff = unparse_object(executor, thing, false);
            safe_str(buff, outbuf, &bp);
            free_lbuf(buff);

            safe_str(" [from ", outbuf, &bp);
            buff = unparse_object(executor, from, false);
            safe_str(((from == NOTHING) ? "NOWHERE" : buff), outbuf, &bp);
            free_lbuf(buff);

            safe_str(" to ", outbuf, &bp);
            buff = unparse_object(executor, to, false);
            safe_str(((to == NOTHING) ? "NOWHERE" : buff), outbuf, &bp);
            free_lbuf(buff);

            safe_chr(']', outbuf, &bp);
            *bp = '\0';
            notify(executor, outbuf);
            ecount++;
        }
    }

    // Object search
    //
    if (  searchparm.s_rst_type == TYPE_THING
       || searchparm.s_rst_type == NOTYPE)
    {
        flag = true;
        for (thing = olist_first(); thing != NOTHING; thing = olist_next())
        {
            if (Typeof(thing) != TYPE_THING)
            {
                continue;
            }
            if (flag)
            {
                flag = false;
                destitute = false;
                notify(executor, "\nOBJECTS:");
            }
            bp = outbuf;
            buff = unparse_object(executor, thing, false);
            safe_str(buff, outbuf, &bp);
            free_lbuf(buff);

            safe_str(" [owner: ", outbuf, &bp);
            buff = unparse_object(executor, Owner(thing), false);
            safe_str(buff, outbuf, &bp);
            free_lbuf(buff);

            safe_chr(']', outbuf, &bp);
            *bp = '\0';
            notify(executor, outbuf);
            tcount++;
        }
    }

    // Player search
    //
    if (  searchparm.s_rst_type == TYPE_PLAYER
       || searchparm.s_rst_type == NOTYPE)
    {
        flag = true;
        for (thing = olist_first(); thing != NOTHING; thing = olist_next())
        {
            if (Typeof(thing) != TYPE_PLAYER)
            {
                continue;
            }
            if (flag)
            {
                flag = false;
                destitute = false;
                notify(executor, "\nPLAYERS:");
            }
            bp = outbuf;
            buff = unparse_object(executor, thing, 0);
            safe_str(buff, outbuf, &bp);
            free_lbuf(buff);
            if (searchparm.s_wizard)
            {
                safe_str(" [location: ", outbuf, &bp);
                buff = unparse_object(executor, Location(thing), false);
                safe_str(buff, outbuf, &bp);
                free_lbuf(buff);
                safe_chr(']', outbuf, &bp);
            }
            *bp = '\0';
            notify(executor, outbuf);
            pcount++;
        }
    }

    // If nothing found matching search criteria.
    //
    if (destitute)
    {
        notify(executor, "Nothing found.");
    }
    else
    {
        sprintf(outbuf,
            "\nFound:  Rooms...%d  Exits...%d  Objects...%d  Players...%d",
            rcount, ecount, tcount, pcount);
        notify(executor, outbuf);
    }
    free_lbuf(outbuf);
    olist_pop();
}

void do_stats	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	name
	)

Definition at line 186 of file walkdb.cpp.

References statedata::db_top, statedata::freelist, get_stats(), lookup_player(), mudstate, NOTHING, notify, Owner, stats_type::s_exits, stats_type::s_garbage, stats_type::s_players, stats_type::s_rooms, stats_type::s_things, stats_type::s_total, STAT_ALL, STAT_ME, STAT_PLAYER, tprintf(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    dbref owner;

    switch (key)
    {
    case STAT_ALL:

        owner = NOTHING;
        break;

    case STAT_ME:

        owner = Owner(executor);
        break;

    case STAT_PLAYER:

        if (!(name && *name))
        {
            int nNextFree = mudstate.freelist;
            if (mudstate.freelist == NOTHING)
            {
                nNextFree = mudstate.db_top;
            }
            notify(executor, tprintf("The universe contains %d objects (next free is #%d).",
                mudstate.db_top, nNextFree));
            return;
        }
        owner = lookup_player(executor, name, true);
        if (owner == NOTHING)
        {
            notify(executor, "Not found.");
            return;
        }
        break;

    default:

        notify(executor, "Illegal combination of switches.");
        return;
    }

    STATS statinfo;
    if (!get_stats(executor, owner, &statinfo))
    {
        return;
    }
    notify(executor, tprintf(
     "%d objects = %d rooms, %d exits, %d things, %d players. (%d garbage)",
               statinfo.s_total, statinfo.s_rooms, statinfo.s_exits,
               statinfo.s_things, statinfo.s_players,
               statinfo.s_garbage));
}

static void er_mark_disabled

(

dbref

player

)

[static]

Definition at line 374 of file walkdb.cpp.

References notify.

Referenced by do_apply_marked(), do_markall(), and do_search().

{
    notify(player,
     "The mark commands are not allowed while DB cleaning is enabled.");
    notify(player,
     "Use the '@disable cleaning' command to disable automatic cleaning.");
    notify(player,
     "Remember to '@unmark_all' before re-enabling automatic cleaning.");
}

bool get_stats	(	dbref	player,
		dbref	who,
		STATS *	info
	)

Definition at line 118 of file walkdb.cpp.

References Controls, DO_WHOLE_DB, Going, Good_obj, info(), confdata::many_coins, mudconf, NOPERM_MESSAGE, NOTHING, notify, Owner, payfor(), confdata::searchcost, Stat_Any, tprintf(), TYPE_EXIT, TYPE_PLAYER, TYPE_ROOM, TYPE_THING, and Typeof.

Referenced by do_stats(), and FUNCTION().

{
    // Do we have permission?
    //
    if (Good_obj(who) && !Controls(player, who) && !Stat_Any(player))
    {
        notify(player, NOPERM_MESSAGE);
        return false;
    }

    // Can we afford it?
    //
    if (!payfor(player, mudconf.searchcost))
    {
        notify(player, tprintf("You don't have enough %s.", mudconf.many_coins));
        return false;
    }
    info->s_total = 0;
    info->s_rooms = 0;
    info->s_exits = 0;
    info->s_things = 0;
    info->s_players = 0;
    info->s_garbage = 0;

    dbref i;
    DO_WHOLE_DB(i)
    {
        if ((who == NOTHING) || (who == Owner(i)))
        {
            info->s_total++;
            if (Going(i) && (Typeof(i) != TYPE_ROOM))
            {
                info->s_garbage++;
                continue;
            }
            switch (Typeof(i))
            {
            case TYPE_ROOM:

                info->s_rooms++;
                break;

            case TYPE_EXIT:

                info->s_exits++;
                break;

            case TYPE_THING:

                info->s_things++;
                break;

            case TYPE_PLAYER:

                info->s_players++;
                break;

            default:

                info->s_garbage++;
            }
        }
    }
    return true;
}

void olist_add

(

dbref

item

)

Definition at line 1189 of file walkdb.cpp.

References alloc_lbuf, objlist_stack::count, objlist_block::data, objlist_stack::head, mudstate, objlist_block::next, OBLOCK_SIZE, statedata::olist, and objlist_stack::tail.

Referenced by find_wild_attrs(), and search_perform().

{
    OBLOCK *op;

    if (!mudstate.olist->head)
    {
        op = (OBLOCK *) alloc_lbuf("olist_add.first");
        mudstate.olist->head = mudstate.olist->tail = op;
        mudstate.olist->count = 0;
        op->next = NULL;
    }
    else if (mudstate.olist->count >= OBLOCK_SIZE)
    {
        op = (OBLOCK *) alloc_lbuf("olist_add.next");
        mudstate.olist->tail->next = op;
        mudstate.olist->tail = op;
        mudstate.olist->count = 0;
        op->next = NULL;
    }
    else
    {
        op = mudstate.olist->tail;
    }
    op->data[mudstate.olist->count++] = item;
}

dbref olist_first

(

void

)

Definition at line 1217 of file walkdb.cpp.

References objlist_stack::cblock, objlist_stack::citm, objlist_stack::count, objlist_block::data, objlist_stack::head, mudstate, NOTHING, statedata::olist, and objlist_stack::tail.

Referenced by do_decomp(), do_edit(), do_search(), do_wipe(), exam_wildattrs(), FUNCTION(), grep_util(), lattr_handler(), and search_mark().

{
    if (!mudstate.olist->head)
    {
        return NOTHING;
    }
    if (  (mudstate.olist->head == mudstate.olist->tail)
       && (mudstate.olist->count == 0))
    {
        return NOTHING;
    }
    mudstate.olist->cblock = mudstate.olist->head;
    mudstate.olist->citm = 0;
    return mudstate.olist->cblock->data[mudstate.olist->citm++];
}

dbref olist_next

(

void

)

Definition at line 1233 of file walkdb.cpp.

References objlist_stack::cblock, objlist_stack::citm, objlist_stack::count, objlist_block::data, mudstate, objlist_block::next, NOTHING, OBLOCK_SIZE, statedata::olist, and objlist_stack::tail.

Referenced by do_decomp(), do_edit(), do_search(), do_wipe(), exam_wildattrs(), FUNCTION(), grep_util(), lattr_handler(), and search_mark().

{
    if (!mudstate.olist->cblock)
    {
        return NOTHING;
    }
    if (  (mudstate.olist->cblock == mudstate.olist->tail)
       && (mudstate.olist->citm >= mudstate.olist->count))
    {
        return NOTHING;
    }
    dbref thing = mudstate.olist->cblock->data[mudstate.olist->citm++];
    if (mudstate.olist->citm >= OBLOCK_SIZE)
    {
        mudstate.olist->cblock = mudstate.olist->cblock->next;
        mudstate.olist->citm = 0;
    }
    return thing;
}

void olist_pop

(

void

)

Definition at line 1174 of file walkdb.cpp.

References free_lbuf, objlist_stack::head, MEMFREE, mudstate, objlist_block::next, objlist_stack::next, and statedata::olist.

Referenced by do_decomp(), do_edit(), do_examine(), do_search(), do_wipe(), FUNCTION(), grep_util(), lattr_handler(), and CGuests::WipeAttrs().

{
    OLSTK *ol = mudstate.olist->next;
    OBLOCK *op, *onext;
    for (op = mudstate.olist->head; op != NULL; op = onext)
    {
        onext = op->next;
        free_lbuf(op);
    }
    MEMFREE(mudstate.olist);
    mudstate.olist = ol;
}

void olist_push

(

void

)

Definition at line 1158 of file walkdb.cpp.

References objlist_stack::cblock, objlist_stack::citm, objlist_stack::count, objlist_stack::head, ISOUTOFMEMORY, MEMALLOC, mudstate, objlist_stack::next, statedata::olist, and objlist_stack::tail.

Referenced by do_decomp(), do_edit(), do_examine(), do_search(), do_wipe(), FUNCTION(), grep_util(), lattr_handler(), and CGuests::WipeAttrs().

{
    OLSTK *ol = (OLSTK *)MEMALLOC(sizeof(OLSTK));
    ISOUTOFMEMORY(ol);
    ol->next = mudstate.olist;
    mudstate.olist = ol;

    ol->head = NULL;