void do_report(dbref executor, dbref caller, dbref enactor, int extra)
{
UNUSED_PARAMETER(caller);
UNUSED_PARAMETER(enactor);
UNUSED_PARAMETER(extra);
char *buff = alloc_mbuf("do_report");
int nBin[NPERIODS];
int i;
for (i = 0; i < NPERIODS; i++)
{
nBin[i] = 0;
}
CLinearTimeAbsolute ltaNow, ltaPlayer;
ltaNow.GetLocal();
const int PeriodInSeconds = 28800;
int iPlayer;
DO_WHOLE_DB(iPlayer)
{
if (isPlayer(iPlayer))
{
int aowner, aflags;
char *player_last = atr_get(iPlayer, A_LAST, &aowner, &aflags);
if (ltaPlayer.SetString(player_last))
{
CLinearTimeDelta ltd(ltaPlayer, ltaNow);
int ltdSeconds = ltd.ReturnSeconds();
int iBin = ltdSeconds / PeriodInSeconds;
if (0 <= iBin && iBin < NPERIODS)
{
nBin[iBin]++;
}
}
free_lbuf(player_last);
}
}
int iHour, nSum = 0;
notify(executor, "Day Hours Players Total");
for (i = 0, iHour = 0; i < NPERIODS; i++, iHour += 8)
{
nSum += nBin[i];
mux_sprintf(buff, MBUF_SIZE, "%3d %03d - %03d: %6d %6d",
iHour/24 + 1, iHour, iHour+8, nBin[i], nSum);
notify(executor, buff);
}
free_mbuf(buff);
}
static bool ValidateHelpFileIndex(int iHelpfile)
{
if ( iHelpfile < 0
|| mudstate.mHelpDesc <= iHelpfile)
{
UTF8 *buf = alloc_mbuf("do_help.LOG");
STARTLOG(LOG_BUGS, "BUG", "HELP");
mux_sprintf(buf, MBUF_SIZE, T("Unknown help file number: %d"), iHelpfile);
log_text(buf);
ENDLOG;
free_mbuf(buf);
return false;
}
return true;
}
/*-#+func----------------------------------------------------------
FUNCTION: *free_mbuf()
PURPOSE: Decrement the reference pointer in an mbuf. If it goes to zero,
free all resources associated with mbuf.
Return pointer to next mbuf in packet chain
SYNTAX: struct mbuf *free_mbuf(register struct mbuf *bp);
DESCRIPTION:
RETURNS:
HISTORY: 940222 V0.1
------------------------------------------------------------------*/
struct mbuf *free_mbuf(register struct mbuf *bp)
{
struct mbuf *bpnext;
if(bp == NULLBUF)
return NULLBUF;
bpnext = bp->next;
if(bp->dup != NULLBUF){
free_mbuf(bp->dup); /* Follow indirection */
bp->dup = NULLBUF;
}
/* Decrement reference count. If it has gone to zero, free it. */
if(--bp->refcnt <= 0)
free((char *)bp);
return bpnext;
}
void
do_link(dbref player, dbref cause, int key, char *what, char *where)
{
dbref thing, room;
char *buff;
int nomtest;
if ( (key & SIDEEFFECT) && !SideFX(player) ) {
notify(player, "#-1 FUNCTION DISABLED");
return;
}
/* Find the thing to link */
init_match(player, what, TYPE_EXIT);
match_everything(0);
thing = noisy_match_result();
if (thing == NOTHING)
return;
nomtest = ((NoMod(thing) && !WizMod(player)) || (DePriv(player,Owner(thing),DP_MODIFY,POWER7,NOTHING) && (Owner(thing) != Owner(player))) || (Backstage(player) && NoBackstage(thing) && !Immortal(player)));
/* Allow unlink if where is not specified */
if (!where || !*where) {
if (!nomtest)
do_unlink(player, cause, key, what);
else
notify(player,"Permission denied.");
return;
}
switch (Typeof(thing)) {
case TYPE_EXIT:
/* Set destination */
room = parse_linkable_room(player, where);
if (room != NOTHING) {
if (!nomtest)
link_exit(player, thing, room, key);
else
notify(player,"Permission denied.");
}
break;
case TYPE_PLAYER:
case TYPE_THING:
/* Set home */
if (!Controls(player, thing) || nomtest) {
notify_quiet(player, "Permission denied.");
break;
}
init_match(player, where, NOTYPE);
match_everything(MAT_NO_EXITS);
room = noisy_match_result();
if (!Good_obj(room))
break;
if (!Has_contents(room)) {
notify_quiet(player, "Can't link to an exit.");
break;
}
if (!can_set_home(player, thing, room) ||
!could_doit(player, room, A_LLINK, 1, 0)) {
notify_quiet(player, "Permission denied.");
} else if (room == HOME) {
notify_quiet(player, "Can't set home to home.");
} else {
s_Home(thing, room);
if (!(Quiet(player) || (key & SIDEEFFECT)) )
notify_quiet(player, "Home set.");
}
break;
case TYPE_ROOM:
/* Set dropto */
if (!Controls(player, thing) || nomtest) {
notify_quiet(player, "Permission denied.");
break;
}
room = parse_linkable_room(player, where);
if (!Good_obj(room) && (room != HOME)) {
notify_quiet(player, "Permission denied.");
break;
}
if ((room != HOME) && !isRoom(room)) {
notify_quiet(player, "That is not a room!");
} else if ((room != HOME) &&
((!controls(player, room) && !Link_ok(room)) ||
!could_doit(player, room, A_LLINK, 1, 0))) {
notify_quiet(player, "Permission denied.");
} else {
s_Dropto(thing, room);
if (!Quiet(player))
notify_quiet(player, "Dropto set.");
}
break;
default:
STARTLOG(LOG_BUGS, "BUG", "OTYPE")
buff = alloc_mbuf("do_link.LOG.badtype");
sprintf(buff, "Strange object type: object #%d = %d",
thing, Typeof(thing));
log_text(buff);
free_mbuf(buff);
ENDLOG
}
}
int empire_init(DESC *d, int nargs, char *args[], int id)
{
int sock_req;
char buf[1024], buf2[80];
char *pt, *pt2, *country, *password;
// get country and password
if ((nargs != 2) || (*args[0] == '\0') || (*args[1] == '\0')) {
queue_string(d,"Bad arguments to empire door.");
return -1;
}
country = args[0];
password = args[1];
sprintf(buf2, "%s %s", "localhost", "1665");
/*pt = doorparm("empire"); */
pt = buf2;
if (*pt == '\0') {
queue_string(desc_in_use, "Read of door parameters failed.\r\n");
return -1;
}
pt2 = strchr(pt,' ');
if (pt2 == NULL) {
queue_string(desc_in_use, "Bad format in door parameters file.\r\n");
return -1;
}
*pt2 = '\0';
sock_req = door_tcp_connect(pt,pt2+1, d, id);
if (sock_req < 0) {
queue_string(desc_in_use, "Connection to empire server failed.\r\n");
return -1;
}
if (!expect(sock_req, C_INIT, buf)) {
queue_string(desc_in_use, "Login to empire server failed (stage 1).\r\n");
close(sock_req);
return -1;
}
strcpy(buf,Name(desc_in_use->player));
strcat(buf,"@");
strcat(buf,mudconf.mud_name);
if (!sendcmd(sock_req, USER, buf)) {
queue_string(desc_in_use, "Login to empire server failed (stage 2).\r\n");
goto abort;
}
if (!expect(sock_req, C_CMDOK, buf)) {
queue_string(desc_in_use, "Login to empire server failed (stage 3).\r\n");
goto abort;
}
if (!sendcmd(sock_req, COUN, country)) {
queue_string(desc_in_use, "Login to empire server failed (stage 4).\r\n");
goto abort;
}
if (!expect(sock_req, C_CMDOK, buf)) {
queue_string(desc_in_use, "Login to empire server failed. Posible bad country name. (stage 5).\r\n");
goto abort;
}
if (!sendcmd(sock_req, PASS, password)) {
queue_string(desc_in_use, "Login to empire server failed (stage 6).\r\n");
goto abort;
}
if (!expect(sock_req, C_CMDOK, buf)) {
queue_string(desc_in_use, "Login to empire server failed. Posible bad password. (stage 7).\r\n");
goto abort;
}
if (!sendcmd(sock_req, PLAY, (char *)0)) {
queue_string(desc_in_use, "Login to empire server failed (stage 8).\r\n");
goto abort;
}
if (!expect(sock_req, C_INIT, buf)) {
queue_string(desc_in_use, buf);
queue_string(desc_in_use, "\r\n");
queue_string(desc_in_use, "Login to empire server failed. (stage 9).\r\n");
goto abort;
}
queue_string(desc_in_use, "\r\n\t-=O=-\r\n");
process_output(desc_in_use);
return 1;
abort:
free_lbuf(d->door_lbuf);
free_mbuf(d->door_mbuf);
close(sock_req);
return -1;
}
int fcache_read(FBLOCK ** cp, char *filename)
{
int n, nmax, tchars, fd;
char *buff;
FBLOCK *fp, *tfp;
/*
* Free a prior buffer chain
*/
fp = *cp;
while (fp != NULL) {
tfp = fp->hdr.nxt;
free_mbuf(fp);
fp = tfp;
}
*cp = NULL;
/*
* Read the text file into a new chain
*/
if ((fd = tf_open(filename, O_RDONLY)) == -1) {
/*
* Failure: log the event
*/
log_write(LOG_PROBLEMS, "FIL", "OPEN", "Couldn't open file '%s'.", filename);
tf_close(fd);
return -1;
}
buff = alloc_lbuf("fcache_read.temp");
/*
* Set up the initial cache buffer to make things easier
*/
fp = (FBLOCK *) alloc_mbuf("fcache_read.first");
fp->hdr.nxt = NULL;
fp->hdr.nchars = 0;
*cp = fp;
tchars = 0;
/*
* Process the file, one lbuf at a time
*/
nmax = read(fd, buff, LBUF_SIZE);
while (nmax > 0) {
for (n = 0; n < nmax; n++) {
switch (buff[n]) {
case '\n':
fp = fcache_fill(fp, '\r');
fp = fcache_fill(fp, '\n');
tchars += 2;
case '\0':
case '\r':
break;
default:
fp = fcache_fill(fp, buff[n]);
tchars++;
}
}
nmax = read(fd, buff, LBUF_SIZE);
}
free_lbuf(buff);
tf_close(fd);
/*
* If we didn't read anything in, toss the initial buffer
*/
if (fp->hdr.nchars == 0) {
*cp = NULL;
free_mbuf(fp);
}
return tchars;
}
// ---------------------------------------------------------------------------
// do_ps: tell executor what commands they have pending in the queue
//
void do_ps(dbref executor, dbref caller, dbref enactor, int eval, int key, char *target)
{
UNUSED_PARAMETER(caller);
UNUSED_PARAMETER(enactor);
UNUSED_PARAMETER(eval);
char *bufp;
dbref executor_targ, obj_targ;
// Figure out what to list the queue for.
//
if ((key & PS_ALL) && !See_Queue(executor))
{
notify(executor, NOPERM_MESSAGE);
return;
}
if (!target || !*target)
{
obj_targ = NOTHING;
if (key & PS_ALL)
{
executor_targ = NOTHING;
}
else
{
executor_targ = Owner(executor);
if (!isPlayer(executor))
{
obj_targ = executor;
}
}
}
else
{
executor_targ = Owner(executor);
obj_targ = match_controlled(executor, target);
if (obj_targ == NOTHING)
{
return;
}
if (key & PS_ALL)
{
notify(executor, "Can't specify a target and /all");
return;
}
if (isPlayer(obj_targ))
{
executor_targ = obj_targ;
obj_targ = NOTHING;
}
}
key = key & ~PS_ALL;
switch (key)
{
case PS_BRIEF:
case PS_SUMM:
case PS_LONG:
break;
default:
notify(executor, "Illegal combination of switches.");
return;
}
Show_lsaNow.GetUTC();
Total_SystemTasks = 0;
Total_RunQueueEntry = 0;
Shown_RunQueueEntry = 0;
Total_SemaphoreTimeout = 0;
Shown_SemaphoreTimeout = 0;
Show_Player_Target = executor_targ;
Show_Object_Target = obj_targ;
Show_Key = key;
Show_Player = executor;
Show_bFirstLine = true;
scheduler.TraverseOrdered(CallBack_ShowWait);
Show_bFirstLine = true;
scheduler.TraverseOrdered(CallBack_ShowSemaphore);
#ifdef QUERY_SLAVE
Show_bFirstLine = true;
scheduler.TraverseOrdered(CallBack_ShowSQLQueries);
#endif // QUERY_SLAVE
if (Wizard(executor))
{
notify(executor, "----- System Queue -----");
scheduler.TraverseOrdered(CallBack_ShowDispatches);
}
// Display stats.
//
bufp = alloc_mbuf("do_ps");
#ifdef QUERY_SLAVE
mux_sprintf(bufp, MBUF_SIZE, "Totals: Wait Queue...%d/%d Semaphores...%d/%d SQL %d/%d",
Shown_RunQueueEntry, Total_RunQueueEntry,
Shown_SemaphoreTimeout, Total_SemaphoreTimeout,
Shown_SQLTimeout, Total_SQLTimeout);
#else
mux_sprintf(bufp, MBUF_SIZE, "Totals: Wait Queue...%d/%d Semaphores...%d/%d",
Shown_RunQueueEntry, Total_RunQueueEntry,
Shown_SemaphoreTimeout, Total_SemaphoreTimeout);
#endif // QUERY_SLAVE
notify(executor, bufp);
if (Wizard(executor))
{
mux_sprintf(bufp, MBUF_SIZE, " System Tasks.....%d", Total_SystemTasks);
notify(executor, bufp);
}
free_mbuf(bufp);
}
void exec(char *buff, char **bufc, int tflags, dbref player, dbref cause,
int eval, char **dstr, char *cargs[], int ncargs)
{
#define NFARGS 30
char *fargs[NFARGS];
char *preserve[MAX_GLOBAL_REGS];
char *tstr, *tbuf, *tbufc, *savepos, *atr_gotten, *start, *oldp, *savestr;
char savec, ch, *str;
char *realbuff = NULL, *realbp = NULL;
dbref aowner;
int at_space, nfargs, gender, i, j, alldone, feval; long aflags;
int is_trace, is_top, save_count;
int ansi;
FUN *fp;
UFUN *ufp;
static const char *subj[5] = { "", "it", "she", "he", "they" };
static const char *poss[5] = { "", "its", "her", "his", "their" };
static const char *obj[5] = { "", "it", "her", "him", "them" };
static const char *absp[5] = { "", "its", "hers", "his", "theirs" };
if(*dstr == NULL)
return;
// dprintk("%d/%s", player, *dstr);
at_space = 1;
gender = -1;
alldone = 0;
ansi = 0;
is_trace = Trace(player) && !(eval & EV_NOTRACE);
is_top = 0;
/* Extend the buffer if we need to. */
if(((*bufc) - buff) > (LBUF_SIZE - SBUF_SIZE)) {
realbuff = buff;
realbp = *bufc;
buff = (char *) malloc(LBUF_SIZE);
*bufc = buff;
}
oldp = start = *bufc;
/*
* If we are tracing, save a copy of the starting buffer
*/
savestr = NULL;
if(is_trace) {
is_top = tcache_empty();
savestr = alloc_lbuf("exec.save");
StringCopy(savestr, *dstr);
}
while (**dstr && !alldone) {
switch (**dstr) {
case ' ':
/*
* A space. Add a space if not compressing or if * *
*
* * * * previous char was not a space
*/
if(!(mudconf.space_compress && at_space) ||
(eval & EV_NO_COMPRESS)) {
safe_chr(' ', buff, bufc);
at_space = 1;
}
break;
case '\\':
/*
* General escape. Add the following char without *
* * * * special processing
*/
at_space = 0;
(*dstr)++;
if(**dstr)
safe_chr(**dstr, buff, bufc);
else
(*dstr)--;
break;
case '[':
/*
* Function start. Evaluate the contents of the * *
* * * square brackets as a function. If no closing
* * * * * bracket, insert the [ and continue.
*/
at_space = 0;
tstr = (*dstr)++;
if(eval & EV_NOFCHECK) {
safe_chr('[', buff, bufc);
*dstr = tstr;
break;
}
tbuf = parse_to(dstr, ']', 0);
if(*dstr == NULL) {
safe_chr('[', buff, bufc);
*dstr = tstr;
} else {
str = tbuf;
exec(buff, bufc, 0, player, cause,
(eval | EV_FCHECK | EV_FMAND), &str, cargs, ncargs);
(*dstr)--;
}
break;
case '{':
/*
* Literal start. Insert everything up to the * * *
* * terminating } without parsing. If no closing *
* * * * brace, insert the { and continue.
*/
at_space = 0;
tstr = (*dstr)++;
tbuf = parse_to(dstr, '}', 0);
if(*dstr == NULL) {
safe_chr('{', buff, bufc);
*dstr = tstr;
} else {
if(!(eval & EV_STRIP)) {
safe_chr('{', buff, bufc);
}
/*
* Preserve leading spaces (Felan)
*/
if(*tbuf == ' ') {
safe_chr(' ', buff, bufc);
tbuf++;
}
str = tbuf;
exec(buff, bufc, 0, player, cause,
(eval & ~(EV_STRIP | EV_FCHECK)), &str, cargs, ncargs);
if(!(eval & EV_STRIP)) {
safe_chr('}', buff, bufc);
}
(*dstr)--;
}
break;
case '%':
/*
* Percent-replace start. Evaluate the chars * * *
* following * and perform the appropriate * * *
* substitution.
*/
at_space = 0;
(*dstr)++;
savec = **dstr;
savepos = *bufc;
switch (savec) {
case '\0': /*
* Null - all done
*/
(*dstr)--;
break;
case '|': /* piped command output */
safe_str(mudstate.pout, buff, bufc);
break;
case '%': /*
* Percent - a literal %
*/
safe_chr('%', buff, bufc);
break;
case 'c':
case 'C':
(*dstr)++;
if(!**dstr)
(*dstr)--;
ansi = 1;
switch (**dstr) {
case 'h': /*
* hilite
*/
safe_str(ANSI_HILITE, buff, bufc);
break;
case 'i': /*
* inverse
*/
safe_str(ANSI_INVERSE, buff, bufc);
break;
case 'f': /*
* flash
*/
safe_str(ANSI_BLINK, buff, bufc);
break;
case 'u': /* underline */
safe_str(ANSI_UNDER, buff, bufc);
break;
case 'n': /*
* normal
*/
safe_str(ANSI_NORMAL, buff, bufc);
ansi = 0;
break;
case 'x': /*
* black fg
*/
safe_str(ANSI_BLACK, buff, bufc);
break;
case 'r': /*
* red fg
*/
safe_str(ANSI_RED, buff, bufc);
break;
case 'g': /*
* green fg
*/
safe_str(ANSI_GREEN, buff, bufc);
break;
case 'y': /*
* yellow fg
*/
safe_str(ANSI_YELLOW, buff, bufc);
break;
case 'b': /*
* blue fg
*/
safe_str(ANSI_BLUE, buff, bufc);
break;
case 'm': /*
* magenta fg
*/
safe_str(ANSI_MAGENTA, buff, bufc);
break;
case 'c': /*
* cyan fg
*/
safe_str(ANSI_CYAN, buff, bufc);
break;
case 'w': /*
* white fg
*/
safe_str(ANSI_WHITE, buff, bufc);
break;
case 'X': /*
* black bg
*/
safe_str(ANSI_BBLACK, buff, bufc);
break;
case 'R': /*
* red bg
*/
safe_str(ANSI_BRED, buff, bufc);
break;
case 'G': /*
* green bg
*/
safe_str(ANSI_BGREEN, buff, bufc);
break;
case 'Y': /*
* yellow bg
*/
safe_str(ANSI_BYELLOW, buff, bufc);
break;
case 'B': /*
* blue bg
*/
safe_str(ANSI_BBLUE, buff, bufc);
break;
case 'M': /*
* magenta bg
*/
safe_str(ANSI_BMAGENTA, buff, bufc);
break;
case 'C': /*
* cyan bg
*/
safe_str(ANSI_BCYAN, buff, bufc);
break;
case 'W': /*
* white bg
*/
safe_str(ANSI_BWHITE, buff, bufc);
break;
default:
safe_chr(**dstr, buff, bufc);
}
break;
case 'r': /*
* Carriage return
*/
case 'R':
safe_str((char *) "\r\n", buff, bufc);
break;
case 't': /*
* Tab
*/
case 'T':
safe_chr('\t', buff, bufc);
break;
case 'B': /*
* Blank
*/
case 'b':
safe_chr(' ', buff, bufc);
break;
case '0': /*
* Command argument number N
*/
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
i = (**dstr - '0');
if((i < ncargs) && (cargs[i] != NULL))
safe_str(cargs[i], buff, bufc);
break;
case 'V': /*
* Variable attribute
*/
case 'v':
(*dstr)++;
ch = ToUpper(**dstr);
if(!**dstr)
(*dstr)--;
if((ch < 'A') || (ch > 'Z'))
break;
i = 100 + ch - 'A';
atr_gotten = atr_pget(player, i, &aowner, &aflags);
safe_str(atr_gotten, buff, bufc);
free_lbuf(atr_gotten);
break;
case 'Q':
case 'q':
(*dstr)++;
i = (**dstr - '0');
if((i >= 0) && (i <= 9) && mudstate.global_regs[i]) {
safe_str(mudstate.global_regs[i], buff, bufc);
}
if(!**dstr)
(*dstr)--;
break;
case 'O': /*
* Objective pronoun
*/
case 'o':
if(gender < 0)
gender = get_gender(cause);
if(!gender)
tbuf = Name(cause);
else
tbuf = (char *) obj[gender];
safe_str(tbuf, buff, bufc);
break;
case 'P': /*
* Personal pronoun
*/
case 'p':
if(gender < 0)
gender = get_gender(cause);
if(!gender) {
safe_str(Name(cause), buff, bufc);
safe_chr('s', buff, bufc);
} else {
safe_str((char *) poss[gender], buff, bufc);
}
break;
case 'S': /*
* Subjective pronoun
*/
case 's':
if(gender < 0)
gender = get_gender(cause);
if(!gender)
tbuf = Name(cause);
else
tbuf = (char *) subj[gender];
safe_str(tbuf, buff, bufc);
break;
case 'A': /*
* Absolute posessive
*/
case 'a': /*
* idea from Empedocles
*/
if(gender < 0)
gender = get_gender(cause);
if(!gender) {
safe_str(Name(cause), buff, bufc);
safe_chr('s', buff, bufc);
} else {
safe_str((char *) absp[gender], buff, bufc);
}
break;
case '#': /*
* Invoker DB number
*/
tbuf = alloc_sbuf("exec.invoker");
sprintf(tbuf, "#%ld", cause);
safe_str(tbuf, buff, bufc);
free_sbuf(tbuf);
break;
case '!': /*
* Executor DB number
*/
tbuf = alloc_sbuf("exec.executor");
sprintf(tbuf, "#%ld", player);
safe_str(tbuf, buff, bufc);
free_sbuf(tbuf);
break;
case 'N': /*
* Invoker name
*/
case 'n':
safe_str(Name(cause), buff, bufc);
break;
case 'L': /*
* Invoker location db#
*/
case 'l':
if(!(eval & EV_NO_LOCATION)) {
tbuf = alloc_sbuf("exec.exloc");
sprintf(tbuf, "#%ld", where_is(cause));
safe_str(tbuf, buff, bufc);
free_sbuf(tbuf);
}
break;
default: /*
* Just copy
*/
safe_chr(**dstr, buff, bufc);
}
if(isupper(savec))
*savepos = ToUpper(*savepos);
break;
case '(':
/*
* Arglist start. See if what precedes is a function. If so,
* execute it if we should.
*/
at_space = 0;
if(!(eval & EV_FCHECK)) {
safe_chr('(', buff, bufc);
break;
}
/*
* Load an sbuf with an uppercase version of the func name, and
* see if the func exists. Trim trailing spaces from the name
* if configured.
*/
**bufc = '\0';
tbufc = tbuf = alloc_sbuf("exec.tbuf");
safe_sb_str(oldp, tbuf, &tbufc);
*tbufc = '\0';
if(mudconf.space_compress) {
while ((--tbufc >= tbuf) && isspace(*tbufc));
tbufc++;
*tbufc = '\0';
}
for(tbufc = tbuf; *tbufc; tbufc++)
*tbufc = ToLower(*tbufc);
fp = (FUN *) hashfind(tbuf, &mudstate.func_htab);
/*
* If not a builtin func, check for global func
*/
ufp = NULL;
if(fp == NULL) {
ufp = (UFUN *) hashfind(tbuf, &mudstate.ufunc_htab);
}
/*
* Do the right thing if it doesn't exist
*/
if(!fp && !ufp) {
if(eval & EV_FMAND) {
*bufc = oldp;
safe_str((char *) "#-1 FUNCTION (", buff, bufc);
safe_str(tbuf, buff, bufc);
safe_str((char *) ") NOT FOUND", buff, bufc);
alldone = 1;
} else {
safe_chr('(', buff, bufc);
}
free_sbuf(tbuf);
eval &= ~EV_FCHECK;
break;
}
free_sbuf(tbuf);
/*
* Get the arglist and count the number of args * Neg
*
* * * * * * # of args means catenate subsequent
* args
*/
if(ufp)
nfargs = NFARGS;
else if(fp->nargs < 0)
nfargs = -fp->nargs;
else
nfargs = NFARGS;
tstr = *dstr;
if(fp && (fp->flags & FN_NO_EVAL))
feval = (eval & ~EV_EVAL) | EV_STRIP_ESC;
else
feval = eval;
*dstr =
parse_arglist(player, cause, *dstr + 1, ')', feval, fargs,
nfargs, cargs, ncargs);
/*
* If no closing delim, just insert the '(' and * * *
*
* * continue normally
*/
if(!*dstr) {
*dstr = tstr;
safe_chr(**dstr, buff, bufc);
for(i = 0; i < nfargs; i++)
if(fargs[i] != NULL)
free_lbuf(fargs[i]);
eval &= ~EV_FCHECK;
break;
}
/*
* Count number of args returned
*/
(*dstr)--;
j = 0;
for(i = 0; i < nfargs; i++)
if(fargs[i] != NULL)
j = i + 1;
nfargs = j;
/*
* If it's a user-defined function, perform it now.
*/
if(ufp) {
mudstate.func_nest_lev++;
if(!check_access(player, ufp->perms)) {
safe_str("#-1 PERMISSION DENIED", buff, &oldp);
*bufc = oldp;
} else {
tstr = atr_get(ufp->obj, ufp->atr, &aowner, &aflags);
if(ufp->flags & FN_PRIV)
i = ufp->obj;
else
i = player;
str = tstr;
if(ufp->flags & FN_PRES) {
for(j = 0; j < MAX_GLOBAL_REGS; j++) {
if(!mudstate.global_regs[j])
preserve[j] = NULL;
else {
preserve[j] = alloc_lbuf("eval_regs");
StringCopy(preserve[j],
mudstate.global_regs[j]);
}
}
}
exec(buff, &oldp, 0, i, cause, feval, &str, fargs,
nfargs);
*bufc = oldp;
if(ufp->flags & FN_PRES) {
for(j = 0; j < MAX_GLOBAL_REGS; j++) {
if(preserve[j]) {
if(!mudstate.global_regs[j])
mudstate.global_regs[j] =
alloc_lbuf("eval_regs");
StringCopy(mudstate.global_regs[j],
preserve[j]);
free_lbuf(preserve[j]);
} else {
if(mudstate.global_regs[j])
*(mudstate.global_regs[i]) = '\0';
}
}
}
free_lbuf(tstr);
}
/*
* Return the space allocated for the args
*/
mudstate.func_nest_lev--;
for(i = 0; i < nfargs; i++)
if(fargs[i] != NULL)
free_lbuf(fargs[i]);
eval &= ~EV_FCHECK;
break;
}
/*
* If the number of args is right, perform the func.
* Otherwise return an error message. Note
* that parse_arglist returns zero args as one
* null arg, so we have to handle that case
* specially.
*/
if((fp->nargs == 0) && (nfargs == 1)) {
if(!*fargs[0]) {
free_lbuf(fargs[0]);
fargs[0] = NULL;
nfargs = 0;
}
}
if((nfargs == fp->nargs) || (nfargs == -fp->nargs) ||
(fp->flags & FN_VARARGS)) {
/*
* Check recursion limit
*/
mudstate.func_nest_lev++;
mudstate.func_invk_ctr++;
if(mudstate.func_nest_lev >= mudconf.func_nest_lim) {
safe_str("#-1 FUNCTION RECURSION LIMIT EXCEEDED", buff,
bufc);
} else if(mudstate.func_invk_ctr == mudconf.func_invk_lim) {
safe_str("#-1 FUNCTION INVOCATION LIMIT EXCEEDED",
buff, bufc);
} else if(!check_access(player, fp->perms)) {
safe_str("#-1 PERMISSION DENIED", buff, &oldp);
*bufc = oldp;
} else if(mudstate.func_invk_ctr < mudconf.func_invk_lim) {
fp->fun(buff, &oldp, player, cause, fargs, nfargs,
cargs, ncargs);
*bufc = oldp;
} else {
**bufc = '\0';
}
mudstate.func_nest_lev--;
} else {
*bufc = oldp;
tstr = alloc_sbuf("exec.funcargs");
sprintf(tstr, "%d", fp->nargs);
safe_str((char *) "#-1 FUNCTION (", buff, bufc);
safe_str((char *) fp->name, buff, bufc);
safe_str((char *) ") EXPECTS ", buff, bufc);
safe_str(tstr, buff, bufc);
safe_str((char *) " ARGUMENTS", buff, bufc);
free_sbuf(tstr);
}
/*
* Return the space allocated for the arguments
*/
for(i = 0; i < nfargs; i++)
if(fargs[i] != NULL)
free_lbuf(fargs[i]);
eval &= ~EV_FCHECK;
break;
default:
/*
* A mundane character. Just copy it
*/
at_space = 0;
safe_chr(**dstr, buff, bufc);
}
(*dstr)++;
}
/*
* If we're eating spaces, and the last thing was a space, eat it
* up. Complicated by the fact that at_space is initially
* true. So check to see if we actually put something in the
* buffer, too.
*/
if(mudconf.space_compress && at_space && !(eval & EV_NO_COMPRESS)
&& (start != *bufc))
(*bufc)--;
/*
* The ansi() function knows how to take care of itself. However,
* if the player used a %c sub in the string, and hasn't yet
* terminated the color with a %cn yet, we'll have to do it for
* them.
*/
if(ansi == 1)
safe_str(ANSI_NORMAL, buff, bufc);
**bufc = '\0';
/*
* Report trace information
*/
if(realbuff) {
**bufc = '\0';
*bufc = realbp;
safe_str(buff, realbuff, bufc);
free(buff);
buff = realbuff;
}
if(is_trace) {
tcache_add(savestr, start);
save_count = tcache_count - mudconf.trace_limit;;
if(is_top || !mudconf.trace_topdown)
tcache_finish(player);
if(is_top && (save_count > 0)) {
tbuf = alloc_mbuf("exec.trace_diag");
sprintf(tbuf, "%d lines of trace output discarded.", save_count);
notify(player, tbuf);
free_mbuf(tbuf);
}
}
}