src/wiz.c File Reference

#include "copyright.h"
#include "config.h"
#include "mudconf.h"
#include "file_c.h"
#include "db.h"
#include "interface.h"
#include "match.h"
#include "externs.h"
#include "command.h"
#include "htab.h"
#include "alloc.h"
#include "attrs.h"
#include "powers.h"

Include dependency graph for wiz.c:

Go to the source code of this file.

Functions
int	recursive_check_contents (dbref victim, dbref destination)
char *	crypt (const char *, const char *)
void	do_teleport (dbref player, dbref cause, int key, char *arg1, char *arg2)
void	do_force_prefixed (dbref player, dbref cause, int key, char *command, char *args[], int nargs)
void	do_force (dbref player, dbref cause, int key, char *what, char *command, char *args[], int nargs)
void	do_toad (dbref player, dbref cause, int key, char *toad, char *newowner)
void	do_newpassword (dbref player, dbref cause, int key, char *name, char *password)
void	do_boot (dbref player, dbref cause, int key, char *name)
void	do_poor (dbref player, dbref cause, int key, char *arg1)
void	do_cut (dbref player, dbref cause, int key, char *thing)
static int	count_quota (dbref player)
static void	mung_quotas (dbref player, int key, int value)
static void	show_quota (dbref player, dbref victim)
void	do_quota (dbref player, dbref cause, int key, char *arg1, char *arg2)
void	do_motd (dbref player, dbref cause, int key, char *message)
void	do_global (dbref player, dbref cause, int key, char *flag)
Variables
NAMETAB	enable_names []

---

Function Documentation

static int count_quota

(

dbref

player

)

[static]

count_quota, mung_quota, show_quota, do_quota: Manage quotas.

Definition at line 584 of file wiz.c.

References DO_WHOLE_DB, confdata::exit_quota, Going, isRoom, mudconf, Owner, confdata::player_quota, confdata::room_quota, confdata::thing_quota, TYPE_EXIT, TYPE_PLAYER, TYPE_ROOM, TYPE_THING, and Typeof.

Referenced by mung_quotas().

{
        int i, q;

        q = 0 - mudconf.player_quota;
        DO_WHOLE_DB(i) {
                if(Owner(i) != player)
                        continue;
                if(Going(i) && (!isRoom(i)))
                        continue;
                switch (Typeof(i)) {
                case TYPE_EXIT:
                        q += mudconf.exit_quota;
                        break;
                case TYPE_ROOM:
                        q += mudconf.room_quota;
                        break;
                case TYPE_THING:
                        q += mudconf.thing_quota;
                        break;
                case TYPE_PLAYER:
                        q += mudconf.player_quota;
                        break;
                }
        }
        return q;
}

char* crypt	(	const char *	,
		const char *
	)

void do_boot	(	dbref	player,
		dbref	cause,
		int	key,
		char *	name
	)

Definition at line 472 of file wiz.c.

References alloc_lbuf, alloc_sbuf, boot_by_port(), boot_off(), BOOT_PORT, BOOT_QUIET, Can_Boot, ENDLOG, free_lbuf, free_sbuf, God, init_match(), is_number(), isPlayer, log_name(), log_name_and_loc(), log_text(), LOG_WIZARD, match_absolute(), match_neighbor(), match_player(), Name(), noisy_match_result(), NOTHING, notify, notify_quiet, safe_str, STARTLOG, tprintf(), and TYPE_PLAYER.

{
        dbref victim;
        char *buf, *bp;
        int count;

        if(!(Can_Boot(player))) {
                notify(player, "Permission denied.");
                return;
        }
        if(key & BOOT_PORT) {
                if(is_number(name)) {
                        victim = atoi(name);
                } else {
                        notify_quiet(player, "That's not a number!");
                        return;
                }
                STARTLOG(LOG_WIZARD, "WIZ", "BOOT") {
                        buf = alloc_sbuf("do_boot.port");
                        sprintf(buf, "Port %d", victim);
                        log_text(buf);
                        log_text((char *) " was @booted by ");
                        log_name(player);
                        free_sbuf(buf);
                        ENDLOG;
        }} else {
                init_match(player, name, TYPE_PLAYER);
                match_neighbor();
                match_absolute();
                match_player();
                if((victim = noisy_match_result()) == NOTHING)
                        return;

                if(God(victim)) {
                        notify_quiet(player, "You cannot boot that player!");
                        return;
                }
                if((!isPlayer(victim) && !God(player)) || (player == victim)) {
                        notify_quiet(player, "You can only boot off other players!");
                        return;
                }
                STARTLOG(LOG_WIZARD, "WIZ", "BOOT") {
                        log_name_and_loc(victim);
                        log_text((char *) " was @booted by ");
                        log_name(player);
                        ENDLOG;
                }
                notify_quiet(player, tprintf("You booted %s off!", Name(victim)));
        }
        if(key & BOOT_QUIET) {
                buf = NULL;
        } else {
                bp = buf = alloc_lbuf("do_boot.msg");
                safe_str(Name(player), buf, &bp);
                safe_str((char *) " gently shows you the door.", buf, &bp);
                *bp = '\0';
        }

        if(key & BOOT_PORT)
                count = boot_by_port(victim, !God(player), buf);
        else
                count = boot_off(victim, buf);
        notify_quiet(player, tprintf("%d connection%s closed.", count,
                                                                 (count == 1 ? "" : "s")));
        if(buf)
                free_lbuf(buf);
}

void do_cut	(	dbref	player,
		dbref	cause,
		int	key,
		char *	thing
	)

Chop off a contents or exits chain after the named item.

Definition at line 563 of file wiz.c.

References AMBIGUOUS, match_controlled(), NOTHING, notify_quiet, and s_Next.

{
        dbref object;

        object = match_controlled(player, thing);
        switch (object) {
        case NOTHING:
                notify_quiet(player, "No match.");
                break;
        case AMBIGUOUS:
                notify_quiet(player, "I don't know which one");
                break;
        default:
                s_Next(object, NOTHING);
                notify_quiet(player, "Cut.");
        }
}

void do_force	(	dbref	player,
		dbref	cause,
		int	key,
		char *	what,
		char *	command,
		char *	args[],
		int	nargs
	)

Force an object to do something.

Definition at line 199 of file wiz.c.

References statedata::global_regs, match_controlled(), mudstate, NOTHING, and wait_que().

Referenced by do_force_prefixed().

{
        dbref victim;

        if((victim = match_controlled(player, what)) == NOTHING)
                return;

        /*
         * force victim to do command 
         */

        wait_que(victim, player, 0, NOTHING, 0, command, args, nargs,
                         mudstate.global_regs);
}

void do_force_prefixed	(	dbref	player,
		dbref	cause,
		int	key,
		char *	command,
		char *	args[],
		int	nargs
	)

Interlude to do_force for the # command

Definition at line 182 of file wiz.c.

References do_force(), and parse_to().

{
        char *cp;

        cp = parse_to(&command, ' ', 0);
        if(!command)
                return;
        while (*command && isspace(*command))
                command++;
        if(*command)
                do_force(player, cause, key, cp, command, args, nargs);
}

void do_global	(	dbref	player,
		dbref	cause,
		int	key,
		char *	flag
	)

Definition at line 868 of file wiz.c.

References confdata::control_flags, enable_names, GLOB_DISABLE, GLOB_ENABLE, mudconf, notify_quiet, Quiet, and search_nametab().

{
        int flagvalue;

        /*
         * Set or clear the indicated flag 
         */

        flagvalue = search_nametab(player, enable_names, flag);
        if(flagvalue < 0) {
                notify_quiet(player, "I don't know about that flag.");
        } else if(key == GLOB_ENABLE) {
                mudconf.control_flags |= flagvalue;
                if(!Quiet(player))
                        notify_quiet(player, "Enabled.");
        } else if(key == GLOB_DISABLE) {
                mudconf.control_flags &= ~flagvalue;
                if(!Quiet(player))
                        notify_quiet(player, "Disabled.");
        } else {
                notify_quiet(player, "Illegal combination of switches.");
        }
}

void do_motd	(	dbref	player,
		dbref	cause,
		int	key,
		char *	message
	)

Wizard-settable message of the day (displayed on connect)

Definition at line 790 of file wiz.c.

References confdata::downmotd_msg, FC_CONN_GUEST, FC_MOTD, FC_WIZMOTD, fcache_send(), confdata::fullmotd_msg, Guest, MOTD_ALL, MOTD_BRIEF, MOTD_DOWN, MOTD_FULL, MOTD_LIST, confdata::motd_msg, MOTD_WIZ, mudconf, notify_quiet, Quiet, StringCopy, tprintf(), Wizard, and confdata::wizmotd_msg.

{
        int is_brief;

        is_brief = 0;
        if(key & MOTD_BRIEF) {
                is_brief = 1;
                key = key & ~MOTD_BRIEF;
                if(key == MOTD_ALL)
                        key = MOTD_LIST;
                else if(key != MOTD_LIST)
                        key |= MOTD_BRIEF;
        }
        switch (key) {
        case MOTD_ALL:
                StringCopy(mudconf.motd_msg, message);
                if(!Quiet(player))
                        notify_quiet(player, "Set: MOTD.");
                break;
        case MOTD_WIZ:
                StringCopy(mudconf.wizmotd_msg, message);
                if(!Quiet(player))
                        notify_quiet(player, "Set: Wizard MOTD.");
                break;
        case MOTD_DOWN:
                StringCopy(mudconf.downmotd_msg, message);
                if(!Quiet(player))
                        notify_quiet(player, "Set: Down MOTD.");
                break;
        case MOTD_FULL:
                StringCopy(mudconf.fullmotd_msg, message);
                if(!Quiet(player))
                        notify_quiet(player, "Set: Full MOTD.");
                break;
        case MOTD_LIST:
                if(Wizard(player)) {
                        if(!is_brief) {
                                notify_quiet(player, "----- motd file -----");
                                fcache_send(player, FC_MOTD);
                                notify_quiet(player, "----- wizmotd file -----");
                                fcache_send(player, FC_WIZMOTD);
                                notify_quiet(player, "----- motd messages -----");
                        }
                        notify_quiet(player, tprintf("MOTD: %s", mudconf.motd_msg));
                        notify_quiet(player, tprintf("Wizard MOTD: %s",
                                                                                 mudconf.wizmotd_msg));
                        notify_quiet(player, tprintf("Down MOTD: %s",
                                                                                 mudconf.downmotd_msg));
                        notify_quiet(player, tprintf("Full MOTD: %s",
                                                                                 mudconf.fullmotd_msg));
                } else {
                        if(Guest(player))
                                fcache_send(player, FC_CONN_GUEST);
                        else
                                fcache_send(player, FC_MOTD);
                        notify_quiet(player, mudconf.motd_msg);
                }
                break;
        default:
                notify_quiet(player, "Illegal combination of switches.");
        }
}

void do_newpassword	(	dbref	player,
		dbref	cause,
		int	key,
		char *	name,
		char *	password
	)

Definition at line 433 of file wiz.c.

References alloc_lbuf, crypt(), ENDLOG, free_lbuf, God, log_name(), log_text(), LOG_WIZARD, lookup_player(), Name(), NOTHING, notify_quiet, ok_password(), s_Pass(), and STARTLOG.

{
        dbref victim;
        char *buf;

        if((victim = lookup_player(player, name, 0)) == NOTHING) {
                notify_quiet(player, "No such player.");
                return;
        }
        if(*password != '\0' && !ok_password(password)) {

                /*
                 * Can set null passwords, but not bad passwords 
                 */
                notify_quiet(player, "Bad password");
                return;
        }
        if(God(victim)) {
                notify_quiet(player, "You cannot change that player's password.");
                return;
        }
        STARTLOG(LOG_WIZARD, "WIZ", "PASS") {
                log_name(player);
                log_text((char *) " changed the password of ");
                log_name(victim);
                ENDLOG;
        }
        /*
         * it's ok, do it 
         */
        s_Pass(victim, crypt((const char *) password, "XX"));
        buf = alloc_lbuf("do_newpassword");
        notify_quiet(player, "Password changed.");
        sprintf(buf, "Your password has been changed by %s.", Name(player));
        notify_quiet(victim, buf);
        free_lbuf(buf);
}

void do_poor	(	dbref	player,
		dbref	cause,
		int	key,
		char *	arg1
	)

Reduce the wealth of anyone over a specified amount.

Definition at line 543 of file wiz.c.

References DO_WHOLE_DB, is_number(), isPlayer, Pennies(), and s_Pennies().

{
        dbref a;
        int amt, curamt;

        if(!is_number(arg1))
                return;
        amt = atoi(arg1);
        DO_WHOLE_DB(a) {
                if(isPlayer(a)) {
                        curamt = Pennies(a);
                        if(amt < curamt)
                                s_Pennies(a, amt);
                }
        }
}

void do_quota	(	dbref	player,
		dbref	cause,
		int	key,
		char *	arg1,
		char *	arg2
	)

Definition at line 699 of file wiz.c.

References DO_WHOLE_DB, ENDLOG, Good_obj, isPlayer, log_name(), log_text(), LOG_WIZARD, lookup_player(), mudconf, mung_quotas(), notify_quiet, Owner, Quota, QUOTA_ALL, QUOTA_FIX, QUOTA_REM, QUOTA_SET, QUOTA_TOT, confdata::quotas, show_quota(), and STARTLOG.

{
        dbref who;
        int set, value, i;

        if(!(mudconf.quotas | Quota(player))) {
                notify_quiet(player, "Quotas are not enabled.");
                return;
        }
        if((key & QUOTA_TOT) && (key & QUOTA_REM)) {
                notify_quiet(player, "Illegal combination of switches.");
                return;
        }
        /*
         * Show or set all quotas if requested 
         */

        value = 0;
        set = 0;
        if(key & QUOTA_ALL) {
                if(arg1 && *arg1) {
                        value = atoi(arg1);
                        set = 1;
                } else if(key & (QUOTA_SET | QUOTA_FIX)) {
                        value = 0;
                        set = 1;
                }
                if(set) {
                        STARTLOG(LOG_WIZARD, "WIZ", "QUOTA") {
                                log_name(player);
                                log_text((char *) " changed everyone's quota");
                                ENDLOG;
                }}
                DO_WHOLE_DB(i) {
                        if(isPlayer(i)) {
                                if(set)
                                        mung_quotas(i, key, value);
                                show_quota(player, i);
                        }
                }
                return;
        }
        /*
         * Find out whose quota to show or set 
         */

        if(!arg1 || *arg1 == '\0') {
                who = Owner(player);
        } else {
                who = lookup_player(player, arg1, 1);
                if(!Good_obj(who)) {
                        notify_quiet(player, "Not found.");
                        return;
                }
        }

        /*
         * Make sure we have permission to do it 
         */

        if(!Quota(player)) {
                if(arg2 && *arg2) {
                        notify_quiet(player, "Permission denied.");
                        return;
                }
                if(Owner(player) != who) {
                        notify_quiet(player, "Permission denied.");
                        return;
                }
        }
        if(arg2 && *arg2) {
                set = 1;
                value = atoi(arg2);
        } else if(key & QUOTA_FIX) {
                set = 1;
                value = 0;
        }
        if(set) {
                STARTLOG(LOG_WIZARD, "WIZ", "QUOTA") {
                        log_name(player);
                        log_text((char *) " changed the quota of ");
                        log_name(who);
                        ENDLOG;
                } mung_quotas(who, key, value);
        }
        show_quota(player, who);
}

void do_teleport	(	dbref	player,
		dbref	cause,
		int	key,
		char *	arg1,
		char *	arg2
	)

Definition at line 40 of file wiz.c.

References A_ATFAIL, A_LTPORT, A_OTFAIL, A_TFAIL, AMBIGUOUS, Controls, could_doit(), Dark, did_it(), Exits, confdata::fascist_tport, Fixed, confdata::fixed_tel_msg, Good_obj, Has_contents, Has_location, HOME, HUSH_ENTER, HUSH_LEAVE, init_match(), insert_first(), isExit, isRoom, Jump_ok, loc, Location, match_everything(), match_result(), move_exit(), move_via_teleport(), mudconf, noisy_match_result(), NOTHING, notify, notify_quiet, NOTYPE, Owner, Quiet, remove_first(), s_Exits, string_compare(), Tel_Anything, Tel_Anywhere, TELEPORT_QUIET, TYPE_EXIT, Typeof, and where_room().

Referenced by fun_tel().

{
        dbref victim, destination, loc, exitloc;
        char *to;
        int hush = 0;

        if(((Fixed(player)) || (Fixed(Owner(player)))) && !(Tel_Anywhere(player))) {
                notify(player, mudconf.fixed_tel_msg);
                return;
        }
        /*
         * get victim 
         */

        if(*arg2 == '\0') {
                victim = player;
                to = arg1;
        } else {
                init_match(player, arg1, NOTYPE);
                match_everything(0);
                victim = noisy_match_result();

                if(victim == NOTHING)
                        return;
                to = arg2;
        }

        /*
         * Validate type of victim 
         */

        if(!Has_location(victim) && Typeof(victim) != TYPE_EXIT) {
                notify_quiet(player, "You can't teleport that.");
                return;
        }
        /*
         * Fail if we don't control the victim or the victim's location 
         */

        if(!Controls(player, victim) && !Controls(player, Location(victim)) &&
           !Tel_Anything(player)) {
                notify_quiet(player, "Permission denied.");
                return;
        }
        /*
         * Check for teleporting home
         * Also, can't teleport exits 'home'
         */

        if(!string_compare(to, "home") && Typeof(victim) != TYPE_EXIT) {
                (void) move_via_teleport(victim, HOME, cause, 0);
                return;
        }
        /*
         * Find out where to send the victim 
         */

        init_match(player, to, NOTYPE);
        match_everything(0);
        destination = match_result();

        switch (destination) {
        case NOTHING:
                notify_quiet(player, "No match.");
                return;
        case AMBIGUOUS:
                notify_quiet(player, "I don't know which destination you mean!");
                return;
        default:
                if(victim == destination) {
                        notify_quiet(player, "Bad destination.");
                        return;
                }
        }

        /*
         * If fascist teleport is on, you must control the victim's ultimate
         * location (after LEAVEing any objects) or it must be JUMP_OK.  
         */

        if(mudconf.fascist_tport) {
                loc = where_room(victim);
                if(!Good_obj(loc) || !isRoom(loc) || (((!Controls(player, loc) &&
                                                                                                !Jump_ok(loc)))
                                                                                          && !Tel_Anywhere(player))) {
                        notify_quiet(player, "Permission denied.");
                        return;
                }
        }
        if(Has_contents(destination)) {

                /*
                 * You must control the destination, or it must be a JUMP_OK
                 * room where you pass its TELEPORT lock. 
                 */

                if(((!Controls(player, destination) && !Jump_ok(destination)) &&
                        !Tel_Anywhere(player)) ||
                   !could_doit(player, destination, A_LTPORT)) {

                        /*
                         * Nope, report failure 
                         */

                        if(player != victim)
                                notify_quiet(player, "Permission denied.");
                        did_it(victim, destination, A_TFAIL,
                                   "You can't teleport there!", A_OTFAIL, 0, A_ATFAIL,
                                   (char **) NULL, 0);
                        return;
                }
                /*
                 * We're OK, do the teleport 
                 */

                if((key & TELEPORT_QUIET) || Dark(victim))
                        hush = HUSH_ENTER | HUSH_LEAVE;

                if(Typeof(victim) == TYPE_EXIT) {
                        exitloc = Exits(victim);
                        s_Exits(exitloc, remove_first(Exits(exitloc), victim));
                        s_Exits(destination, insert_first(Exits(destination), victim));
                        s_Exits(victim, destination);

                        if(!Quiet(player))
                                notify_quiet(player, "Exit teleported.");
                } else if(move_via_teleport(victim, destination, cause, hush)) {
                        if(player != victim && !Quiet(player))
                                notify_quiet(player, "Teleported.");
                }
        } else if(isExit(destination)) {
                if(Exits(destination) == Location(victim)) {
                        move_exit(victim, destination, 0, "You can't go that way.", 0);
                } else {
                        notify_quiet(player, "I can't find that exit.");
                }
        }
}

void do_toad	(	dbref	player,
		dbref	cause,
		int	key,
		char *	toad,
		char *	newowner
	)

Turn a player into an object.

Definition at line 344 of file wiz.c.

References A_ALIAS, alloc_mbuf, atr_pget(), boot_off(), chown_all(), delete_player_name(), ENDLOG, free_lbuf, free_mbuf, HALT, init_match(), isPlayer, loc, Location, log_name(), log_name_and_loc(), log_text(), LOG_WIZARD, match_absolute(), match_neighbor(), match_player(), Name(), No_Destroy, noisy_match_result(), NOTHING, notify_except2(), notify_quiet, s_Flags, s_Flags2, s_Flags3, s_Name(), s_Owner, s_Pennies(), STARTLOG, TOAD_NO_CHOWN, tprintf(), TYPE_PLAYER, and TYPE_THING.

{
        dbref victim, recipient, loc, aowner;
        char *buf;
        int count, aflags;

        init_match(player, toad, TYPE_PLAYER);
        match_neighbor();
        match_absolute();
        match_player();
        if((victim = noisy_match_result()) == NOTHING)
                return;

        if(!isPlayer(victim)) {
                notify_quiet(player, "Try @destroy instead.");
                return;
        }
        if(No_Destroy(victim)) {
                notify_quiet(player, "You can't toad that player.");
                return;
        }
        if((newowner != NULL) && *newowner) {
                init_match(player, newowner, TYPE_PLAYER);
                match_neighbor();
                match_absolute();
                match_player();
                if((recipient = noisy_match_result()) == NOTHING)
                        return;
        } else {
                recipient = player;
        }

        STARTLOG(LOG_WIZARD, "WIZ", "TOAD") {
                log_name_and_loc(victim);
                log_text((char *) " was @toaded by ");
                log_name(player);
                ENDLOG;
        }
        /*
         * Clear everything out 
         */
        if(key & TOAD_NO_CHOWN) {
                count = -1;
        } else {
                count = chown_all(victim, recipient);
                s_Owner(victim, recipient);     /*
                                                                         * you get it 
                                                                         */
        }
        s_Flags(victim, TYPE_THING | HALT);
        s_Flags2(victim, 0);
        s_Flags3(victim, 0);
        s_Pennies(victim, 1);

        /*
         * notify people 
         */

        loc = Location(victim);
        buf = alloc_mbuf("do_toad");
        sprintf(buf, "%s has been turned into a slimy toad!", Name(victim));
        notify_except2(loc, player, victim, player, buf);
        sprintf(buf, "You toaded %s! (%d objects @chowned)", Name(victim),
                        count + 1);
        notify_quiet(player, buf);

        /*
         * Zap the name from the name hash table 
         */

        delete_player_name(victim, Name(victim));
        sprintf(buf, "a slimy toad named %s", Name(victim));
        s_Name(victim, buf);
        free_mbuf(buf);

        /*
         * Zap the alias too 
         */

        buf = atr_pget(victim, A_ALIAS, &aowner, &aflags);
        delete_player_name(victim, buf);
        free_lbuf(buf);

        count =
                boot_off(victim, (char *) "You have been turned into a slimy toad!");
        notify_quiet(player, tprintf("%d connection%s closed.", count,
                                                                 (count == 1 ? "" : "s")));
}

static void mung_quotas	(	dbref	player,
		int	key,
		int	value
	)			[static]

Definition at line 612 of file wiz.c.

References A_QUOTA, A_RQUOTA, atr_add_raw(), atr_get(), count_quota(), free_lbuf, QUOTA_FIX, QUOTA_REM, QUOTA_TOT, and tprintf().

Referenced by do_quota().

{
        dbref aowner;
        int aq, rq, xq, aflags;
        char *buff;

        if(key & QUOTA_FIX) {

                /*
                 * Get value of stuff owned and good value, set other value 
                 * from that. 
                 */

                xq = count_quota(player);
                if(key & QUOTA_TOT) {
                        buff = atr_get(player, A_RQUOTA, &aowner, &aflags);
                        aq = atoi(buff) + xq;
                        atr_add_raw(player, A_QUOTA, tprintf("%d", aq));
                        free_lbuf(buff);
                } else {
                        buff = atr_get(player, A_QUOTA, &aowner, &aflags);
                        rq = atoi(buff) - xq;
                        atr_add_raw(player, A_RQUOTA, tprintf("%d", rq));
                        free_lbuf(buff);
                }
        } else {

                /*
                 * Obtain (or calculate) current relative and absolute quota 
                 */

                buff = atr_get(player, A_QUOTA, &aowner, &aflags);
                if(!*buff) {
                        free_lbuf(buff);
                        buff = atr_get(player, A_RQUOTA, &aowner, &aflags);
                        rq = atoi(buff);
                        free_lbuf(buff);
                        aq = rq + count_quota(player);
                } else {
                        aq = atoi(buff);
                        free_lbuf(buff);
                        buff = atr_get(player, A_RQUOTA, &aowner, &aflags);
                        rq = atoi(buff);
                        free_lbuf(buff);
                }

                /*
                 * Adjust values 
                 */

                if(key & QUOTA_REM) {
                        aq += (value - rq);
                        rq = value;
                } else {
                        rq += (value - aq);
                        aq = value;
                }

                /*
                 * Set both abs and relative quota 
                 */

                atr_add_raw(player, A_QUOTA, tprintf("%d", aq));
                atr_add_raw(player, A_RQUOTA, tprintf("%d", rq));
        }
}

int recursive_check_contents	(	dbref	victim,
		dbref	destination
	)

Definition at line 25 of file wiz.c.

References Contents, and DOLIST.

{
        dbref i;

        DOLIST(i, Contents(victim)) {
                if(destination == i)
                        return 1;
                else if(recursive_check_contents(i, destination))
                        return 1;
        }
        return 0;
}

static void show_quota	(	dbref	player,
		dbref	victim
	)			[static]

Definition at line 679 of file wiz.c.

References A_QUOTA, A_RQUOTA, atr_get(), free_lbuf, Free_Quota, Name(), notify_quiet, and tprintf().

Referenced by do_quota().

{
        dbref aowner;
        int aq, rq, aflags;
        char *buff;

        buff = atr_get(victim, A_QUOTA, &aowner, &aflags);
        aq = atoi(buff);
        free_lbuf(buff);
        buff = atr_get(victim, A_RQUOTA, &aowner, &aflags);
        rq = aq - atoi(buff);
        free_lbuf(buff);
        if(!Free_Quota(victim))
                notify_quiet(player, tprintf("%-16s Quota: %9d  Used: %9d",
                                                                         Name(victim), aq, rq));
        else
                notify_quiet(player, tprintf("%-16s Quota: UNLIMITED  Used: %9d",
                                                                         Name(victim), rq));
}

---

Variable Documentation

NAMETAB enable_names[]

Initial value:

 {
        {(char *) "building", 1, CA_PUBLIC, CF_BUILD},
        {(char *) "checkpointing", 2, CA_PUBLIC, CF_CHECKPOINT},
        {(char *) "cleaning", 2, CA_PUBLIC, CF_DBCHECK},
        {(char *) "dequeueing", 1, CA_PUBLIC, CF_DEQUEUE},
        {(char *) "idlechecking", 2, CA_PUBLIC, CF_IDLECHECK},
        {(char *) "interpret", 2, CA_PUBLIC, CF_INTERP},
        {(char *) "logins", 3, CA_PUBLIC, CF_LOGIN},
        {(char *) "eventchecking", 2, CA_PUBLIC, CF_EVENTCHECK},
        {NULL, 0, 0, 0}
}

Enable or disable global control flags

Definition at line 856 of file wiz.c.

Referenced by do_global(), and do_list().

---