src/cque.c File Reference

#include "copyright.h"
#include "config.h"
#include <signal.h>
#include "mudconf.h"
#include "db.h"
#include "htab.h"
#include "interface.h"
#include "match.h"
#include "externs.h"
#include "attrs.h"
#include "flags.h"
#include "powers.h"
#include "command.h"
#include "alloc.h"
#include "functions.h"
#include "cque.h"
#include "mmdb.h"

Include dependency graph for cque.c:

Go to the source code of this file.

Functions
int	a_Queue (dbref, int)
void	s_Queue (dbref, int)
int	QueueMax (dbref)
static int	objqe_compare (dbref left, dbref right, void *arg)
int	cque_init ()
static OBJQE *	cque_find (dbref player)
static BQUE *	cque_peek (dbref player)
static BQUE *	cque_deque (dbref player)
static void	cque_enqueue (dbref player, BQUE *cmd)
static void	wakeup_wait_que (int fd, short event, void *arg)
static int	dump_bqe (struct mmdb_t *mmdb, BQUE *bqe)
static int	dump_objqe (void *key, void *data, int depth, void *arg)
void	cque_dump_restart (struct mmdb_t *mmdb)
static void	load_bqe (struct mmdb_t *mmdb)
static void	load_objqe (struct mmdb_t *mmdb)
void	cque_load_restart (struct mmdb_t *mmdb)
static int	add_to (dbref player, int am, int attrnum)
static int	que_want (BQUE *entry, dbref ptarg, dbref otarg)
int	halt_que (dbref player, dbref object)
void	do_halt (dbref player, dbref cause, int key, char *target)
int	nfy_que (dbref sem, int attr, int key, int count)
void	do_notify (dbref player, dbref cause, int key, char *what, char *count)
static BQUE *	setup_que (dbref player, dbref cause, char *command, char *args[], int nargs, char *sargs[])
void	wait_que (dbref player, dbref cause, int wait, dbref sem, int attr, char *command, char *args[], int nargs, char *sargs[])
void	do_wait (dbref player, dbref cause, int key, char *event, char *cmd, char *cargs[], int ncargs)
void	do_second (void)
int	do_top (int ncmds)
static void	show_que (dbref player, int key, BQUE *queue, int *qent, const char *header)
void	do_ps (dbref player, dbref cause, int key, char *target)
void	do_queue (dbref player, dbref cause, int key, char *arg)
Variables
static rbtree	obq = NULL

---

Function Documentation

int a_Queue	(	dbref	,
		int
	)

Definition at line 153 of file player_c.c.

References OwnsOthers, pcache_find(), and player_cache::queue.

Referenced by do_top(), halt_que(), nfy_que(), and setup_que().

{
        PCACHE *pp;

        if(OwnsOthers(player)) {
                pp = pcache_find(player);
                if(pp)
                        pp->queue += adj;
                return pp->queue;
        }
        return 0;
}

static int add_to	(	dbref	player,
		int	am,
		int	attrnum
	)			[static]

Definition at line 317 of file cque.c.

References atr_add_raw(), atr_get(), and free_lbuf.

Referenced by do_second(), do_wait(), halt_que(), and nfy_que().

{
        int num, aflags;
        dbref aowner;
        char buff[20];
        char *atr_gotten;

        num = atoi(atr_gotten = atr_get(player, attrnum, &aowner, &aflags));
        free_lbuf(atr_gotten);
        num += am;
        if(num)
                sprintf(buff, "%d", num);
        else
                *buff = '\0';
        atr_add_raw(player, attrnum, buff);
        return (num);
}

static BQUE* cque_deque

(

dbref

player

)

[static]

Definition at line 75 of file cque.c.

References objqe::cque, cque_find(), objqe::ctail, dassert, and bque::next.

Referenced by do_top(), and halt_que().

{
        OBJQE *tmp;
        BQUE *cmd;

        tmp = cque_find(player);
        if(!tmp)
                return NULL;

        dassert(tmp);

        if(!tmp->cque)
                return NULL;

        cmd = tmp->cque;
        if(!cmd->next) {
                tmp->cque = tmp->ctail = NULL;
        } else {
                tmp->cque = cmd->next;
        }
        return cmd;
}

void cque_dump_restart

(

struct mmdb_t *

mmdb

)

Definition at line 220 of file cque.c.

References cque_init(), dump_bqe(), dump_objqe(), mmdb_write_uint32(), mudstate, obq, statedata::qsemfirst, statedata::qwait, rb_size(), rb_walk(), and WALK_INORDER.

Referenced by dump_restart_db_xdr().

                                            {
    if(obq == NULL) {
        cque_init();
    }
    mmdb_write_uint32(mmdb, rb_size(obq));
    if(rb_size(obq) > 0) {
        rb_walk(obq, WALK_INORDER, dump_objqe, mmdb);
    }
    dump_bqe(mmdb, mudstate.qwait);
    dump_bqe(mmdb, mudstate.qsemfirst);
}

static void cque_enqueue	(	dbref	player,
		BQUE *	cmd
	)			[static]

Definition at line 98 of file cque.c.

References cque_find(), dassert, bque::ev, mudstate, objqe::next, bque::next, NOTHING, statedata::now, statedata::qhead, statedata::qsemfirst, statedata::qsemlast, statedata::qtail, objqe::queued, statedata::qwait, bque::sem, and bque::waittime.

Referenced by do_second(), load_bqe(), nfy_que(), wait_que(), and wakeup_wait_que().

{
    BQUE *point, *trail;
        OBJQE *current, *blocker;
        struct timeval tv;
    OBJQE *tmp;

    cmd->next = NULL;
    
    tv.tv_sec = cmd->waittime - mudstate.now;
    tv.tv_usec = 0;

    if(cmd->sem == NOTHING) {
        /*
         * No semaphore, put on wait queue if wait value specified.
         * Otherwise put on the normal queue. 
         */

        if(cmd->waittime <= mudstate.now) {
            cmd->waittime = 0;
            tmp = cque_find(player);

            dassert(tmp);

            if(!tmp->ctail) {
                tmp->cque = tmp->ctail = cmd;
                cmd->next = NULL;
            } else {
                tmp->ctail->next = cmd;
                tmp->ctail = cmd;
                tmp->ctail->next = NULL;
            }

            if(!tmp->queued) {
                if(!mudstate.qhead) {
                    mudstate.qhead = mudstate.qtail = tmp;
                    tmp->next = NULL;
                } else {
                    mudstate.qtail->next = tmp;
                    mudstate.qtail = tmp;
                    mudstate.qtail->next = NULL;
                }
                tmp->queued = 1;
            }
        } else {
            evtimer_add(&cmd->ev, &tv);
            for(point = mudstate.qwait, trail = NULL;
                    point && point->waittime <= cmd->waittime;
                    point = point->next) {
                trail = point;
            }
            cmd->next = point;
            if(trail != NULL)
                trail->next = cmd;
            else
                mudstate.qwait = cmd;
        }
    } else {
        cmd->next = NULL;
        if(mudstate.qsemlast != NULL)
            mudstate.qsemlast->next = cmd;
        else
            mudstate.qsemfirst = cmd;
        mudstate.qsemlast = cmd;
    }
}

static OBJQE* cque_find

(

dbref

player

)

[static]

Definition at line 43 of file cque.c.

References objqe::cque, cque_init(), objqe::ctail, Good_obj, objqe::next, objqe::obj, obq, objqe::pending_que, objqe::queued, rb_find(), rb_insert(), and objqe::wait_que.

Referenced by cque_deque(), cque_enqueue(), cque_peek(), do_ps(), halt_que(), and load_objqe().

{
        OBJQE *tmp = NULL;

        if(obq == NULL) {
                cque_init();
        }

        tmp = rb_find(obq, (void *) player);

        if(!tmp && Good_obj(player)) {
                tmp = malloc(sizeof(OBJQE));
                tmp->obj = player;
                tmp->cque = NULL;
                tmp->ctail = NULL;
                tmp->next = NULL;
                tmp->queued = 0;
                tmp->wait_que = NULL;
                tmp->pending_que = NULL;
                rb_insert(obq, (void *) player, tmp);
        }

        return tmp;
}

int cque_init

(

)

Definition at line 37 of file cque.c.

References objqe_compare(), obq, and rb_init().

Referenced by cque_dump_restart(), and cque_find().

{
        obq = rb_init((void *) objqe_compare, NULL);
        return 1;
};

void cque_load_restart

(

struct mmdb_t *

mmdb

)

Definition at line 283 of file cque.c.

References load_bqe(), load_objqe(), and mmdb_read_uint32().

Referenced by load_restart_db_xdr().

                                            {
    int count;
    count = mmdb_read_uint32(mmdb);
    for(int i = 0; i < count; i++) {
        load_objqe(mmdb);
    }
    load_bqe(mmdb); // wait q
    load_bqe(mmdb); // sem q
}

static BQUE* cque_peek

(

dbref

player

)

[static]

Definition at line 68 of file cque.c.

References objqe::cque, and cque_find().

{
        OBJQE *tmp;
        tmp = cque_find(player);
        return tmp->cque;
}

void do_halt	(	dbref	player,
		dbref	cause,
		int	key,
		char *	target
	)

Definition at line 439 of file cque.c.

References Can_Halt, HALT_ALL, halt_que(), match_controlled(), match_thing(), NOTHING, notify, notify_printf(), Owner, Quiet, TYPE_PLAYER, and Typeof.

{
        dbref player_targ, obj_targ;
        int numhalted;

        if((key & HALT_ALL) && !(Can_Halt(player))) {
                notify(player, "Permission denied.");
                return;
        }
        /*
         * Figure out what to halt 
         */

        if(!target || !*target) {
                obj_targ = NOTHING;
                if(key & HALT_ALL) {
                        player_targ = NOTHING;
                } else {
                        player_targ = Owner(player);
                        if(Typeof(player) != TYPE_PLAYER)
                                obj_targ = player;
                }
        } else {
                if(Can_Halt(player))
                        obj_targ = match_thing(player, target);
                else
                        obj_targ = match_controlled(player, target);

                if(obj_targ == NOTHING)
                        return;
                if(key & HALT_ALL) {
                        notify(player, "Can't specify a target and /all");
                        return;
                }
                if(Typeof(obj_targ) == TYPE_PLAYER) {
                        player_targ = obj_targ;
                        obj_targ = NOTHING;
                } else {
                        player_targ = NOTHING;
                }
        }

        numhalted = halt_que(player_targ, obj_targ);
        if(Quiet(player))
                return;
        if(numhalted == 1)
                notify(Owner(player), "1 queue entries removed.");
        else
                notify_printf(Owner(player), "%d queue entries removed.", numhalted);
}

void do_notify	(	dbref	player,
		dbref	cause,
		int	key,
		char *	what,
		char *	count
	)

Definition at line 568 of file cque.c.

References A_SEMAPHORE, atr_pget_info(), atr_str(), controls, init_match(), Link_ok, match_everything(), NFY_DRAIN, nfy_que(), noisy_match_result(), notify, notify_quiet, NOTYPE, attr::number, parse_to(), Quiet, and Set_attr.

{
        dbref thing, aowner;
        int loccount, attr = -1, aflags;
        ATTR *ap;
        char *obj;

        obj = parse_to(&what, '/', 0);
        init_match(player, obj, NOTYPE);
        match_everything(0);

        if((thing = noisy_match_result()) < 0) {
                notify(player, "No match.");
        } else if(!controls(player, thing) && !Link_ok(thing)) {
                notify(player, "Permission denied.");
        } else {
                if(!what || !*what) {
                        ap = NULL;
                } else {
                        ap = atr_str(what);
                }

                if(!ap) {
                        attr = A_SEMAPHORE;
                } else {
                        /* Do they have permission to set this attribute? */
                        atr_pget_info(thing, ap->number, &aowner, &aflags);
                        if(Set_attr(player, thing, ap, aflags)) {
                                attr = ap->number;
                        } else {
                                notify_quiet(player, "Permission denied.");
                                return;
                        }
                }

                if(count && *count)
                        loccount = atoi(count);
                else
                        loccount = 1;
                if(loccount > 0) {
                        nfy_que(thing, attr, key, loccount);
                        if(!(Quiet(player) || Quiet(thing))) {
                                if(key == NFY_DRAIN)
                                        notify_quiet(player, "Drained.");
                                else
                                        notify_quiet(player, "Notified.");
                        }
                }
        }
}

void do_ps	(	dbref	player,
		dbref	cause,
		int	key,
		char *	target
	)

Definition at line 1084 of file cque.c.

References objqe::cque, cque_find(), match_controlled(), mudstate, objqe::next, NOTHING, notify, notify_printf(), Owner, PS_ALL, PS_BRIEF, PS_LONG, PS_SUMM, statedata::qhead, statedata::qsemfirst, statedata::qwait, See_Queue, show_que(), TYPE_PLAYER, and Typeof.

{
        char *bufp;
        dbref player_targ, obj_targ;
        int pqent, pqtot, pqdel, oqent, oqtot, oqdel, wqent, wqtot, sqent,
                sqtot, i;
        OBJQE *objq;
        int tempkey;

        /*
         * Figure out what to list the queue for 
         */

        if((key & PS_ALL) && !(See_Queue(player))) {
                notify(player, "Permission denied.");
                return;
        }
        if(!target || !*target) {
                obj_targ = NOTHING;
                if(key & PS_ALL) {
                        player_targ = NOTHING;
                } else {
                        player_targ = Owner(player);
                        if(Typeof(player) != TYPE_PLAYER)
                                obj_targ = player;
                }
        } else {
                player_targ = Owner(player);
                obj_targ = match_controlled(player, target);
                if(obj_targ == NOTHING)
                        return;
                if(key & PS_ALL) {
                        notify(player, "Can't specify a target and /all");
                        return;
                }
                if(Typeof(obj_targ) == TYPE_PLAYER) {
                        player_targ = obj_targ;
                        obj_targ = NOTHING;
                }
        }
        tempkey = key;
        key = key & ~PS_ALL;
        switch (key) {
        case PS_BRIEF:
        case PS_SUMM:
        case PS_LONG:
                break;
        default:
                notify(player, "Illegal combination of switches.");
                return;
        }

        /*
         * Go do it 
         */
        pqtot = 0;
        if(player_targ == NOTHING) {
                objq = mudstate.qhead;
                while (objq && (objq = objq->next) != NULL) {
                        pqent = 0;
                        show_que(player, tempkey, objq->cque, &pqent, "PLAYAH");
                        pqtot += pqent;
                }
        } else {
                pqent = 0;
                objq = cque_find(player_targ);
                if(objq) {
                        show_que(player, tempkey, objq->cque, &pqent, "PLAYAH");
                }
        }

        wqent = 0;
        sqent = 0;
        wqtot = 0;
        sqtot = 0;
        show_que(player, tempkey, mudstate.qwait, &wqent, "Wait");
        show_que(player, tempkey, mudstate.qsemfirst, &sqent, "Semaphore");

        /*
         * Display stats 
         */

        if(See_Queue(player))
                notify_printf(player,
                                          "Totals: Player...%d/%d  Wait...%d/%d  Semaphore...%d/%d",
                                          pqent, pqtot, wqent, wqtot, sqent, sqtot);
        else
                notify_printf(player,
                                          "Totals: Player...%d/%d  Wait...%d/%d  Semaphore...%d/%d",
                                          pqent, pqtot, wqent, wqtot, sqent, sqtot);
}

void do_queue	(	dbref	player,
		dbref	cause,
		int	key,
		char *	arg
	)

Definition at line 1181 of file cque.c.

References CF_DEQUEUE, confdata::control_flags, do_second(), do_top(), dprintk, mudconf, mudstate, bque::next, notify, notify_printf(), statedata::qsemfirst, QUEUE_KICK, QUEUE_WARP, Quiet, and bque::waittime.

Referenced by do_timewarp().

{
        BQUE *point;
        int i, ncmds, was_disabled;

        dprintk("WTF?");
        was_disabled = 0;
        if(key == QUEUE_KICK) {
                i = atoi(arg);
                if((mudconf.control_flags & CF_DEQUEUE) == 0) {
                        was_disabled = 1;
                        mudconf.control_flags |= CF_DEQUEUE;
                        notify(player, "Warning: automatic dequeueing is disabled.");
                }
                ncmds = do_top(i);
                if(was_disabled)
                        mudconf.control_flags &= ~CF_DEQUEUE;
                if(!Quiet(player))
                        notify_printf(player, "%d commands processed.", ncmds);
        } else if(key == QUEUE_WARP) {
                i = atoi(arg);
                if((mudconf.control_flags & CF_DEQUEUE) == 0) {
                        was_disabled = 1;
                        mudconf.control_flags |= CF_DEQUEUE;
                        notify(player, "Warning: automatic dequeueing is disabled.");
                }

                /*
                 * Handle the semaphore queue 
                 */

                for(point = mudstate.qsemfirst; point; point = point->next) {
                        if(point->waittime > 0) {
                                point->waittime -= i;
                                if(point->waittime <= 0)
                                        point->waittime = -1;
                        }
                }

                do_second();
                if(was_disabled)
                        mudconf.control_flags &= ~CF_DEQUEUE;
                if(Quiet(player))
                        return;
                if(i > 0)
                        notify_printf(player, "WaitQ timer advanced %d seconds.", i);
                else if(i < 0)
                        notify_printf(player, "WaitQ timer set back %d seconds.", i);
                else
                        notify(player, "Object queue appended to player queue.");

        }
}

void do_second

(

void

)

Definition at line 862 of file cque.c.

References add_to(), bque::attr, CF_DEQUEUE, bque::comm, confdata::control_flags, cque_enqueue(), statedata::debug_cmd, mudconf, mudstate, bque::next, NOTHING, statedata::now, bque::player, printk, statedata::qsemfirst, statedata::qsemlast, bque::sem, and bque::waittime.

Referenced by dispatch(), do_queue(), and process_preload().

{
        BQUE *trail, *point, *next;
        char *cmdsave;

        /*
         * move contents of low priority queue onto end of normal one this
         * helps to keep objects from getting out of control since
         * its affects on other objects happen only after one
         * second  this should allow @halt to be type before
         * getting blown away  by scrolling text 
         */

        if((mudconf.control_flags & CF_DEQUEUE) == 0)
                return;

        cmdsave = mudstate.debug_cmd;
        mudstate.debug_cmd = (char *) "< do_second >";

        /*
         * Note: the point->waittime test would be 0 except the command is
         * being put in the low priority queue to be done in one
         * second anyways 
         */

        /*
         * Check the semaphore queue for expired timed-waits 
         */

        for(point = mudstate.qsemfirst, trail = NULL; point; point = next) {
                if(point->waittime == 0) {
                        next = (trail = point)->next;
                        continue;                       /*
                                                                 * Skip if not timed-wait 
                                                                 */
                }
                if(point->waittime <= mudstate.now) {
                        if(trail != NULL)
                                trail->next = next = point->next;
                        else
                                mudstate.qsemfirst = next = point->next;
                        if(point == mudstate.qsemlast)
                                mudstate.qsemlast = trail;
                        add_to(point->sem, -1, point->attr);
                        point->sem = NOTHING;
            point->waittime = 0;
                        printk("promoting, %d/%s", point->player, point->comm);
                        cque_enqueue(point->player, point);
                } else
                        next = (trail = point)->next;
        }
        mudstate.debug_cmd = cmdsave;
        return;
}

int do_top

(

int

ncmds

)

Definition at line 922 of file cque.c.

References a_Queue(), alloc_lbuf, bque::cause, CF_DEQUEUE, choke_player(), bque::comm, Connected, confdata::control_flags, objqe::cque, cque_deque(), statedata::curr_enactor, statedata::curr_player, dassert, statedata::debug_cmd, bque::env, free_lbuf, free_qentry, giveto(), statedata::global_regs, Going, Halted, statedata::inpipe, isPlayer, MAX_GLOBAL_REGS, mudconf, mudstate, bque::nargs, objqe::next, objqe::obj, Owner, parse_to(), statedata::pout, statedata::poutbufc, statedata::poutnew, statedata::poutobj, process_command(), statedata::qhead, statedata::qtail, objqe::queued, release_player(), bque::scr, StringCopy, bque::text, and confdata::waitcost.

Referenced by do_queue(), process_preload(), and runqueues().

{
        BQUE *tmp, *walk;
        OBJQE *current_object;
        dbref object, player, last_player;
        int count, i;
        char *command, *cp, *cmdsave;

        if((mudconf.control_flags & CF_DEQUEUE) == 0)
                return 0;

        cmdsave = mudstate.debug_cmd;
        mudstate.debug_cmd = (char *) "< do_top >";

        if(!mudstate.qhead)
                return 0;

        current_object = mudstate.qhead;
        count = 0;

        while (count < ncmds && mudstate.qhead) {
                if(!mudstate.qhead)
                        break;

                object = mudstate.qhead->obj;
                tmp = cque_deque(object);

                if(!mudstate.qhead->cque) {
                        mudstate.qhead->queued = 0;
                        mudstate.qhead = mudstate.qhead->next;
                        if(mudstate.qhead == NULL)
                                mudstate.qtail = NULL;
                } else {
                        mudstate.qtail->next = mudstate.qhead;
                        mudstate.qtail = mudstate.qtail->next;
                        mudstate.qhead = mudstate.qhead->next;
                        mudstate.qtail->next = NULL;
                }
                if(!tmp)
                        continue;

                dassert(tmp);
                count++;
                if((object >= 0) && !Going(object)) {
                        giveto(object, mudconf.waitcost);
                        mudstate.curr_enactor = tmp->cause;
                        mudstate.curr_player = object;
                        a_Queue(Owner(object), -1);
                        if(!Halted(object)) {
                                for(i = 0; i < MAX_GLOBAL_REGS; i++) {
                                        if(tmp->scr[i]) {
                                                StringCopy(mudstate.global_regs[i], tmp->scr[i]);
                                        } else {
                                                *mudstate.global_regs[i] = '\0';
                                        }
                                }

                                command = tmp->comm;

                                if(command) {
                                        if(isPlayer(object) && Connected(object))
                                                choke_player(object);
                                        while (command) {
                                                cp = parse_to(&command, ';', 0);
                                                if(cp && *cp) {
                                                        while (command && (*command == '|')) {
                                                                command++;
                                                                mudstate.inpipe = 1;
                                                                mudstate.poutnew =
                                                                        alloc_lbuf("process_command.pipe");
                                                                mudstate.poutbufc = mudstate.poutnew;
                                                                mudstate.poutobj = object;
                                                                process_command(object, tmp->cause, 0, cp,
                                                                                                tmp->env, tmp->nargs);
                                                                if(mudstate.pout) {
                                                                        free_lbuf(mudstate.pout);
                                                                        mudstate.pout = NULL;
                                                                }

                                                                *mudstate.poutbufc = '\0';
                                                                mudstate.pout = mudstate.poutnew;
                                                                cp = parse_to(&command, ';', 0);
                                                        }
                                                        mudstate.inpipe = 0;
                                                        process_command(object, tmp->cause, 0,
                                                                                        cp, tmp->env, tmp->nargs);
                                                        if(mudstate.pout) {
                                                                free_lbuf(mudstate.pout);
                                                                mudstate.pout = NULL;
                                                        }
                                                }
                                        }
                                        if(isPlayer(object) && Connected(object))
                                                release_player(object);
                                }
                        }
                }
                free(tmp->text);
                free_qentry(tmp);
        }

        for(i = 0; i < MAX_GLOBAL_REGS; i++)
                *mudstate.global_regs[i] = '\0';
        mudstate.debug_cmd = cmdsave;
        return count;
}

void do_wait	(	dbref	player,
		dbref	cause,
		int	key,
		char *	event,
		char *	cmd,
		char *	cargs[],
		int	ncargs
	)

Definition at line 777 of file cque.c.

References A_SEMAPHORE, add_to(), atr_num(), atr_pget_info(), atr_str(), controls, statedata::global_regs, Good_obj, init_match(), is_number(), Link_ok, match_everything(), mkattr(), mudstate, noisy_match_result(), NOTHING, notify, notify_quiet, NOTYPE, attr::number, parse_to(), Set_attr, and wait_que().

{
        dbref thing, aowner;
        int howlong, num, attr, aflags;
        char *what;
        ATTR *ap;

        /*
         * If arg1 is all numeric, do simple (non-sem) timed wait. 
         */

        if(is_number(event)) {
                howlong = atoi(event);
                wait_que(player, cause, howlong, NOTHING, 0, cmd, cargs, ncargs,
                                 mudstate.global_regs);
                return;
        }
        /*
         * Semaphore wait with optional timeout 
         */

        what = parse_to(&event, '/', 0);
        init_match(player, what, NOTYPE);
        match_everything(0);

        thing = noisy_match_result();
        if(!Good_obj(thing)) {
                notify(player, "No match.");
        } else if(!controls(player, thing) && !Link_ok(thing)) {
                notify(player, "Permission denied.");
        } else {

                /*
                 * Get timeout, default 0 
                 */

                if(event && *event && is_number(event)) {
                        attr = A_SEMAPHORE;
                        howlong = atoi(event);
                } else {
                        attr = A_SEMAPHORE;
                        howlong = 0;
                }

                if(event && *event && !is_number(event)) {
                        ap = atr_str(event);
                        if(!ap) {
                                attr = mkattr(event);
                                if(attr <= 0) {
                                        notify_quiet(player, "Invalid attribute.");
                                        return;
                                }
                                ap = atr_num(attr);
                        }
                        atr_pget_info(thing, ap->number, &aowner, &aflags);
                        if(attr && Set_attr(player, thing, ap, aflags)) {
                                attr = ap->number;
                                howlong = 0;
                        } else {
                                notify_quiet(player, "Permission denied.");
                                return;
                        }
                }

                num = add_to(thing, 1, attr);
                if(num <= 0) {

                        /*
                         * thing over-notified, run the command immediately 
                         */

                        thing = NOTHING;
                        howlong = 0;
                }
                wait_que(player, cause, howlong, thing, attr, cmd, cargs, ncargs,
                                 mudstate.global_regs);
        }
}

static int dump_bqe	(	struct mmdb_t *	mmdb,
		BQUE *	bqe
	)			[static]

Definition at line 185 of file cque.c.

References bque::attr, bque::cause, bque::comm, bque::env, mmdb_write_string(), mmdb_write_uint32(), mudstate, bque::nargs, bque::next, statedata::now, NUM_ENV_VARS, bque::player, bque::scr, bque::sem, bque::text, and bque::waittime.

Referenced by cque_dump_restart(), and dump_objqe().

                                                    {
    if(bqe == NULL) {
        mmdb_write_uint32(mmdb, 0);
        return 1;
    }
    mmdb_write_uint32(mmdb, 1);
    mmdb_write_uint32(mmdb, bqe->player);
    mmdb_write_uint32(mmdb, bqe->cause);
    mmdb_write_uint32(mmdb, bqe->sem);
    mmdb_write_uint32(mmdb, bqe->waittime-mudstate.now);
    mmdb_write_uint32(mmdb, bqe->attr);
    mmdb_write_string(mmdb, bqe->text);
    mmdb_write_string(mmdb, bqe->comm);
    mmdb_write_uint32(mmdb, NUM_ENV_VARS);
    for(int i = 0; i < NUM_ENV_VARS; i++) {
        mmdb_write_string(mmdb, bqe->env[i]);
    }
    mmdb_write_uint32(mmdb, NUM_ENV_VARS);
    for(int i = 0; i < NUM_ENV_VARS; i++) {
        mmdb_write_string(mmdb, bqe->scr[i]);
    }
    mmdb_write_uint32(mmdb, bqe->nargs);
    dump_bqe(mmdb, bqe->next);
    return 1;
}

static int dump_objqe	(	void *	key,
		void *	data,
		int	depth,
		void *	arg
	)			[static]

Definition at line 211 of file cque.c.

References objqe::cque, dump_bqe(), mmdb_write_uint32(), and objqe::obj.

Referenced by cque_dump_restart().

                                                                   {
    struct mmdb_t *mmdb = (struct mmdb_t *)arg;
    OBJQE *coq = (OBJQE *)data;
    mmdb_write_uint32(mmdb, coq->obj);
    dump_bqe(mmdb, coq->cque);
    return 1;
}

int halt_que	(	dbref	player,
		dbref	object
	)

Definition at line 354 of file cque.c.

References a_Queue(), add_to(), objqe::cque, cque_deque(), cque_find(), free_qentry, giveto(), mudconf, mudstate, bque::next, NOTHING, Owner, statedata::qsemfirst, statedata::qsemlast, que_want(), statedata::qwait, s_Queue(), bque::text, and confdata::waitcost.

Referenced by check_dead_refs(), destroy_obj(), destroy_player(), do_chown(), do_halt(), do_kill(), and setup_que().

{
        BQUE *trail, *point, *next;
        OBJQE *pque;

        int numhalted;

        numhalted = 0;

        /* Player's que */
        // XXX: nuke queu

        pque = cque_find(player);
        if(pque && pque->cque) {
                while ((point = cque_deque(player)) != NULL) {
                        free(point->text);
                        point->text = NULL;
                        free_qentry(point);
                        point = NULL;
                        numhalted++;
                }
        }
        pque = cque_find(object);
        if(pque && pque->cque) {
                while ((point = cque_deque(object)) != NULL) {
                        free(point->text);
                        point->text = NULL;
                        free_qentry(point);
                        point = NULL;
                        numhalted++;
                }
        }

        /*
         * Wait queue 
         */

        for(point = mudstate.qwait, trail = NULL; point; point = next)
                if(que_want(point, player, object)) {
                        numhalted++;
                        if(trail)
                                trail->next = next = point->next;
                        else
                                mudstate.qwait = next = point->next;
                        if(evtimer_pending(&point->ev, NULL))
                                evtimer_del(&point->ev);
                        free(point->text);
                        free_qentry(point);
                } else
                        next = (trail = point)->next;

        /*
         * Semaphore queue 
         */

        for(point = mudstate.qsemfirst, trail = NULL; point; point = next)
                if(que_want(point, player, object)) {
                        numhalted++;
                        if(trail)
                                trail->next = next = point->next;
                        else
                                mudstate.qsemfirst = next = point->next;
                        if(point == mudstate.qsemlast)
                                mudstate.qsemlast = trail;
                        add_to(point->sem, -1, point->attr);
                        free(point->text);
                        free_qentry(point);
                } else
                        next = (trail = point)->next;

        if(player == NOTHING)
                player = Owner(object);
        giveto(player, (mudconf.waitcost * numhalted));
        if(object == NOTHING)
                s_Queue(player, 0);
        else
                a_Queue(player, -numhalted);
        return numhalted;
}

static void load_bqe

(

struct mmdb_t *

mmdb

)

[static]

Definition at line 232 of file cque.c.

References cque_enqueue(), mmdb_read_string(), mmdb_read_uint32(), mudstate, statedata::now, NUM_ENV_VARS, printk, and wakeup_wait_que().

Referenced by cque_load_restart(), and load_objqe().

                                          {
    int exists, count;
    struct timeval tv;
    BQUE *tmp;
    exists = mmdb_read_uint32(mmdb);
    if(!exists)
        return;
    tmp = malloc(sizeof(BQUE));
    memset(tmp, 0, sizeof(BQUE));
    
    evtimer_set(&tmp->ev, wakeup_wait_que, tmp);

    tmp->player = mmdb_read_uint32(mmdb);
    tmp->cause = mmdb_read_uint32(mmdb);
    tmp->sem = mmdb_read_uint32(mmdb);
    tmp->waittime = mudstate.now + mmdb_read_uint32(mmdb);
    tmp->attr = mmdb_read_uint32(mmdb);
    tmp->text = mmdb_read_string(mmdb);
    tmp->comm = mmdb_read_string(mmdb);
    count = mmdb_read_uint32(mmdb);
    if(count != NUM_ENV_VARS)
        printk("brain damage, count(%d) != NUM_ENV_VARS(%d)", count, NUM_ENV_VARS);
    for(int i = 0; i < count; i++) {
        if(i < NUM_ENV_VARS)
            tmp->env[i] = mmdb_read_string(mmdb);
        else 
            free(mmdb_read_string(mmdb));
    }
    count = mmdb_read_uint32(mmdb);
    if(count != NUM_ENV_VARS)
        printk("brain damage, count(%d) != NUM_ENV_VARS(%d)", count, NUM_ENV_VARS);
    for(int i = 0; i < count; i++) {
        if(i < NUM_ENV_VARS)
            tmp->scr[i] = mmdb_read_string(mmdb);
        else 
            free(mmdb_read_string(mmdb));
    }
    tmp->nargs = mmdb_read_uint32(mmdb);
    cque_enqueue(tmp->player, tmp);
    load_bqe(mmdb);
}

static void load_objqe

(

struct mmdb_t *

mmdb

)

[static]

Definition at line 274 of file cque.c.

References cque_find(), load_bqe(), and mmdb_read_uint32().

Referenced by cque_load_restart().

                                            {
    int object;
    OBJQE *coq;
    object = mmdb_read_uint32(mmdb);
    coq = cque_find(object);
    load_bqe(mmdb);
}

int nfy_que	(	dbref	sem,
		int	attr,
		int	key,
		int	count
	)

Definition at line 495 of file cque.c.

References a_Queue(), add_to(), atr_clr(), atr_get(), bque::attr, cque_enqueue(), free_lbuf, free_qentry, giveto(), mudconf, mudstate, bque::next, NFY_DRAIN, NFY_NFY, NOTHING, Owner, bque::player, statedata::qsemfirst, statedata::qsemlast, bque::sem, bque::text, confdata::waitcost, and bque::waittime.

Referenced by destroy_obj(), and do_notify().

{
        BQUE *point, *trail, *next;
        int num, aflags;
        dbref aowner;
        char *str;

        if(attr) {
                str = atr_get(sem, attr, &aowner, &aflags);
                num = atoi(str);
                free_lbuf(str);
        } else {
                num = 1;
        }

        if(num > 0) {
                num = 0;
                for(point = mudstate.qsemfirst, trail = NULL; point; point = next) {
                        if((point->sem == sem) && ((point->attr == attr) || !attr)) {
                                num++;
                                if(trail)
                                        trail->next = next = point->next;
                                else
                                        mudstate.qsemfirst = next = point->next;
                                if(point == mudstate.qsemlast)
                                        mudstate.qsemlast = trail;

                                /*
                                 * Either run or discard the command 
                                 */

                                if(key != NFY_DRAIN) {
                    point->sem = NOTHING;
                    point->waittime = 0;
                                        cque_enqueue(point->player, point);
                                } else {
                                        giveto(point->player, mudconf.waitcost);
                                        a_Queue(Owner(point->player), -1);
                                        free(point->text);
                                        free_qentry(point);
                                }
                        } else {
                                next = (trail = point)->next;
                        }

                        /*
                         * If we've notified enough, exit 
                         */

                        if((key == NFY_NFY) && (num >= count))
                                next = NULL;
                }
        } else {
                num = 0;
        }

        /*
         * Update the sem waiters count 
         */

        if(key == NFY_NFY)
                add_to(sem, -count, attr);
        else
                atr_clr(sem, attr);

        return num;
}

static int objqe_compare	(	dbref	left,
		dbref	right,
		void *	arg
	)			[static]

Definition at line 32 of file cque.c.

Referenced by cque_init().

{
        return (right - left);
}

static int que_want	(	BQUE *	entry,
		dbref	ptarg,
		dbref	otarg
	)			[static]

Definition at line 340 of file cque.c.

References NOTHING, Owner, and bque::player.

Referenced by halt_que().

{
        if((ptarg != NOTHING) && (ptarg != Owner(entry->player)))
                return 0;
        if((otarg != NOTHING) && (otarg != entry->player))
                return 0;
        return 1;
}

int QueueMax

(

dbref

)

Definition at line 177 of file player_c.c.

References statedata::db_top, mudconf, mudstate, OwnsOthers, pcache_find(), player_cache::qmax, and confdata::queuemax.

Referenced by setup_que().

{
        PCACHE *pp;
        int m;

        m = 0;
        if(OwnsOthers(player)) {
                pp = pcache_find(player);
                if(pp) {
                        if(pp->qmax >= 0) {
                                m = pp->qmax;
                        } else {
                                m = mudstate.db_top + 1;
                                if(m < mudconf.queuemax)
                                        m = mudconf.queuemax;
                        }
                }
        }
        return m;
}

void s_Queue	(	dbref	,
		int
	)

Definition at line 166 of file player_c.c.

References OwnsOthers, pcache_find(), and player_cache::queue.

Referenced by halt_que().

{
        PCACHE *pp;

        if(OwnsOthers(player)) {
                pp = pcache_find(player);
                if(pp)
                        pp->queue = val;
        }
}

static BQUE* setup_que	(	dbref	player,
		dbref	cause,
		char *	command,
		char *	args[],
		int	nargs,
		char *	sargs[]
	)			[static]

Definition at line 624 of file cque.c.

References a_Queue(), bque::attr, bque::cause, bque::comm, bque::env, bque::ev, halt_que(), Halted, confdata::machinecost, MAX_GLOBAL_REGS, mudconf, bque::nargs, bque::next, NOTHING, notify, NUM_ENV_VARS, Owner, payfor(), bque::player, QueueMax(), random, s_Halted, bque::scr, bque::sem, StringCopy, bque::text, confdata::waitcost, bque::waittime, and wakeup_wait_que().

Referenced by wait_que().

{
        int a, tlen;
        BQUE *tmp;
        char *tptr;

        /*
         * Can we run commands at all? 
         */

        if(Halted(player))
                return NULL;

        /*
         * make sure player can afford to do it 
         */

        a = mudconf.waitcost;
        if(mudconf.machinecost && ((random() % mudconf.machinecost) == 0))
                a++;
        if(!payfor(player, a)) {
                notify(Owner(player), "Not enough money to queue command.");
                return NULL;
        }
        /*
         * Wizards and their objs may queue up to db_top+1 cmds. Players are
         * * * * * * * limited to QUEUE_QUOTA. -mnp 
         */

        a = QueueMax(Owner(player));
        if(a_Queue(Owner(player), 1) > a) {
                notify(Owner(player),
                           "Run away objects: too many commands queued.  Halted.");
                halt_que(Owner(player), NOTHING);

                /*
                 * halt also means no command execution allowed 
                 */
                s_Halted(player);
                return NULL;
        }
        /*
         * We passed all the tests 
         */

        /*
         * Calculate the length of the save string 
         */

        tlen = 0;
        if(command)
                tlen = strlen(command) + 1;
        if(nargs > NUM_ENV_VARS)
                nargs = NUM_ENV_VARS;
        for(a = 0; a < nargs; a++) {
                if(args[a])
                        tlen += (strlen(args[a]) + 1);
        }
        if(sargs) {
                for(a = 0; a < NUM_ENV_VARS; a++) {
                        if(sargs[a])
                                tlen += (strlen(sargs[a]) + 1);
                }
        }
        /*
         * Create the qeue entry and load the save string 
         */

        tmp = malloc(sizeof(BQUE));
    memset(tmp, 0, sizeof(BQUE));
    tmp->comm = NULL;
        for(a = 0; a < NUM_ENV_VARS; a++) {
                tmp->env[a] = NULL;
        }
        for(a = 0; a < MAX_GLOBAL_REGS; a++) {
                tmp->scr[a] = NULL;
        }

        tptr = tmp->text = (char *) malloc(tlen);
        if(command) {
                StringCopy(tptr, command);
                tmp->comm = tptr;
                tptr += (strlen(command) + 1);
        }
        for(a = 0; a < nargs; a++) {
                if(args[a]) {
                        StringCopy(tptr, args[a]);
                        tmp->env[a] = tptr;
                        tptr += (strlen(args[a]) + 1);
                }
        }
        if(sargs) {
                for(a = 0; a < MAX_GLOBAL_REGS; a++) {
                        if(sargs[a]) {
                                StringCopy(tptr, sargs[a]);
                                tmp->scr[a] = tptr;
                                tptr += (strlen(sargs[a]) + 1);
                        }
                }
        }
        /*
         * Load the rest of the queue block 
         */

        evtimer_set(&tmp->ev, wakeup_wait_que, tmp);

        tmp->player = player;
        tmp->waittime = 0;
        tmp->next = NULL;
        tmp->sem = NOTHING;
        tmp->attr = 0;
        tmp->cause = cause;
        tmp->nargs = nargs;
        return tmp;
}

static void show_que	(	dbref	player,
		int	key,
		BQUE *	queue,
		int *	qent,
		const char *	header
	)			[static]

Definition at line 1034 of file cque.c.

References bque::cause, bque::comm, bque::env, free_lbuf, Good_obj, mudstate, bque::nargs, bque::next, notify_printf(), statedata::now, Owner, bque::player, PS_ALL, PS_LONG, PS_SUMM, safe_chr, safe_str, bque::sem, unparse_object(), and bque::waittime.

Referenced by do_ps().

{
        BQUE *tmp;
        char *bp, *bufp;
        int i;

        for(tmp = queue; tmp; tmp = tmp->next) {
                (*qent)++;
                if(key == PS_SUMM)
                        continue;
                if(*qent == 1)
                        notify_printf(player, "----- %s Queue -----", header);

                bufp = unparse_object(player, tmp->player, 0);
                if ( !(key & PS_ALL) )
                        if((player != Owner(tmp->player))) 
                                continue;
                if((tmp->waittime > 0) && (Good_obj(tmp->sem)))
                        notify_printf(player, "[#%d/%d]%s:%s", tmp->sem,
                                                  tmp->waittime-mudstate.now, bufp, tmp->comm);
                else if(tmp->waittime > 0)
                        notify_printf(player, "[%d]%s:%s", tmp->waittime-mudstate.now,
                                                  bufp, tmp->comm);
                else if(Good_obj(tmp->sem))
                        notify_printf(player, "[#%d]%s:%s", tmp->sem, bufp, tmp->comm);
                else
                        notify_printf(player, "%s:%s", bufp, tmp->comm);

                bp = bufp;
                if(key == PS_LONG) {
                        for(i = 0; i < (tmp->nargs); i++) {
                                if(tmp->env[i] != NULL) {
                                        safe_str((char *) "; Arg", bufp, &bp);
                                        safe_chr(i + '0', bufp, &bp);
                                        safe_str((char *) "='", bufp, &bp);
                                        safe_str(tmp->env[i], bufp, &bp);
                                        safe_chr('\'', bufp, &bp);
                                }
                        }
                        *bp = '\0';
                        bp = unparse_object(player, tmp->cause, 0);
                        notify_printf(player, "   Enactor: %s%s", bp, bufp);
                        free_lbuf(bp);
                }
                free_lbuf(bufp);
        }
        return;
}

void wait_que	(	dbref	player,
		dbref	cause,
		int	wait,
		dbref	sem,
		int	attr,
		char *	command,
		char *	args[],
		int	nargs,
		char *	sargs[]
	)

Definition at line 746 of file cque.c.

References bque::attr, CF_INTERP, confdata::control_flags, cque_enqueue(), mudconf, mudstate, statedata::now, bque::sem, setup_que(), and bque::waittime.

Referenced by announce_connect(), announce_disconnect(), atr_match1(), bind_and_queue(), did_it(), do_force(), do_postpend(), do_prepend(), do_switch(), do_wait(), handle_prog(), and process_cmdent().

{
        BQUE *cmd;
        if(mudconf.control_flags & CF_INTERP)
                cmd = setup_que(player, cause, command, args, nargs, sargs);
        else
                cmd = NULL;

        if(cmd == NULL) {
                return;
        }

    if(wait > 0) {
        cmd->waittime = mudstate.now + wait;
    } else {
        cmd->waittime = 0;
    }

    cmd->sem = sem;
    cmd->attr = attr;

    cque_enqueue(player, cmd);
}

static void wakeup_wait_que	(	int	fd,
		short	event,
		void *	arg
	)			[static]

Definition at line 165 of file cque.c.

References cque_enqueue(), mudstate, bque::next, bque::player, statedata::qwait, and bque::waittime.

Referenced by load_bqe(), and setup_que().

{
        BQUE *pending = (BQUE *) arg;
        BQUE *point, trail;

        if(mudstate.qwait == pending) {
                mudstate.qwait = pending->next;
        } else {
                for(point = mudstate.qwait; point; point = point->next) {
                        if(point->next == pending) {
                                point->next = point->next->next;
                                break;
                        }
                }
        }
    
    pending->waittime = 0;
        cque_enqueue(pending->player, pending);
}

---

Variable Documentation

rbtree obq = NULL [static]

Definition at line 30 of file cque.c.

Referenced by cque_dump_restart(), cque_find(), cque_init(), and dump_restart_db().

---