void outside_message(string str) {
string who, what, where;
object sword, player;
str = ANSI_D->strip_colors(str);
str = lowercase(str);
if (sscanf(str, "%s gives %s to you.", who, what) == 2) {
player = this_environment()->present(who);
sword = this_object()->present("orc slayer");
if (sword) {
destruct_object(sword);
if (!player->is_completed_quest("Orc Slayer")) {
player->add_completed_quest("Orc Slayer");
player->increase_expr(200);
player->message("Congratulations!!! You have just completed the " +
"Orc Slayer quest.\n");
}
}
} else if (sscanf(str, "%s says: %s",who,what) == 2) {
if (strstr(what[0..3], "hello") == 0 ||
strstr(what[0..1], "hi") == 0) {
player = this_environment()->present(who);
this_object()->respond("say Welcome " + who + ".");
give_castle(who);
}
} else if (sscanf(str, "%s says:%scastle%s",who, what, where) == 3) {
give_castle(who);
}
}
void _open(mixed * tls) {
if (SITEBAN_D->is_banned(query_ip_number(this_object()))) {
/* site is banned */
LOG_D->write_log("logins", ctime(time()) + "\t" +
query_ip_number(this_object()) + "\t" + "Banned Site\n");
send_message("\nYour site is under an access restriction.\n" +
"Please email " + ADMIN_EMAIL + " about access from your site.\n");
destruct_object(this_object());
}
send_message("Welcome to " + MUD_NAME + ".\n");
send_message("Running " + LIB_NAME + " " + LIB_VERSION + " on " +
status()[ST_VERSION] + ".\n");
send_message("\n");
send_message(TELNET_D->query_banner());
send_message("\nEnter your name (or 'who' for a list of players): ");
send_message(1);
timeout_handle = call_out("login_timeout", 600);
player = clone_object(PLAYER_OB);
player->set_user(this_object());
player->initialize_cmd_path();
player->initialize_alias();
player->set_long("A boring player without a description.");
LOG_D->write_log("logins", ctime(time()) + "\t" +
query_ip_number(this_object()) + "\t" + "opening connection\n");
player->input_to_object(this_object(), "input_name");
}
void
dest(string f)
{
if(catch( destruct_object(find_object( XML_DIR + f)) )) {
SYSLOG("failed to destruct '" + XML_DIR + f + "'...\n");
return;
}
}
void destructed(int clone) {
int i, n;
if(SYSTEM() && clone) {
if(children) {
for(i = 0, n = sizeof(children); i < n; i++)
destruct_object(children[i]);
}
}
}
void parse(string str) {
if (str == "go away" || str == "die" || str == "dismissed") {
remove_call_out(nFollow);
respond("say It seems " + master_name + " no longer has a need for me.");
this_environment()->remove_object(this_object());
destruct_object(this_object());
} else {
respond(str);
}
}
void logout(int quit)
{
ACCESS_CHECK(previous_program() == LIB_CONN
|| calling_object() == this_object());
close(nil, quit);
if (quit) {
destruct_object(this_object());
}
}
static mixed* load_file_with_dtd(string file_path, string dtd_path) {
string file_tmp, dtd_tmp;
object dtd;
mixed* dtd_unq;
dtd_tmp = read_file(dtd_path);
file_tmp = read_file(file_path);
dtd = clone_object(UNQ_DTD);
dtd->load(dtd_tmp);
dtd_unq = UNQ_PARSER->unq_parse_with_dtd(file_tmp, dtd, file_path);
destruct_object(dtd);
return dtd_unq;
}
static void _close(mixed * tls, int ld) {
string ip;
ip = query_ip_number(this_object());
if (!ip) {
ip = "<NO IP>";
}
if (ld == 0) {
player->set_linkdead(1);
LOG_D->write_log("logins", ctime(time()) + "\t" + ip +
"\t\t" + this_object()->query_name() + " disconnects\n");
} else {
if (player) {
destruct_object(player);
}
}
}
void quit(void) {
string str;
player->save_me();
LAST_D->add_entry(user_name, 0);
USER_D->user_offline(user_name, this_object());
if (query_ip_number(this_object())) {
LOG_D->write_log("logins", ctime(time()) + "\t" +
query_ip_number(this_object()) +
"\t" + this_object()->query_name() + " quits\n");
} else {
LOG_D->write_log("logins", ctime(time()) + "\t" +
"\t\t" + this_object()->query_name() + " LD quits\n");
}
player->destruct();
destruct_object(this_object());
}
/* Read and parse config.unq according to config.dtd. Then call
config_from_unq to load the data into the Game Driver. */
static void config_unq_file(void) {
object config_dtd;
string config_dtd_file, config_file;
mixed* unq_data;
config_dtd_file = read_file("/usr/game/config.dtd");
config_dtd = clone_object(UNQ_DTD);
config_dtd->load(config_dtd_file);
config_dtd_file = nil; /* Free the data */
config_file = read_file("/usr/game/config.unq");
unq_data = UNQ_PARSER->unq_parse_with_dtd(config_file, config_dtd);
configure_from_unq(unq_data);
destruct_object(config_dtd);
}
void
remove_all_objects()
{
extern struct object *master_ob, *vbfc_object, *auto_ob, *simul_efun_ob;
struct gdexception exception_frame;
struct object *ob;
int n;
exception_frame.e_exception = NULL;
exception_frame.e_catch = 0;
for (;;) {
ob = obj_list;
n = 0;
while (ob == master_ob ||
ob == vbfc_object ||
ob == auto_ob ||
ob == simul_efun_ob) {
ob = ob->next_all;
if (n++ > 3)
break;
}
if (n > 3 || ob == 0)
break;
if (setjmp(exception_frame.e_context))
clear_state();
else {
exception = &exception_frame;
ob->prog->flags &= ~PRAGMA_RESIDENT;
destruct_object(ob);
exception = NULL;
}
}
/*
* In case we have objects referenced through
* closure cache
*/
clear_closure_cache();
/*
* Remove VBFC object
*/
force_remove_object(vbfc_object);
free_object(vbfc_object, "remove_all_objects");
vbfc_object = NULL;
/*
* Remove master object
*/
force_remove_object(master_ob);
free_object(master_ob, "remove_all_objects");
master_ob = NULL;
/*
* Remove simul_efun object
*/
force_remove_object(simul_efun_ob);
free_object(simul_efun_ob, "remove_all_objects");
simul_efun_ob = NULL;
/*
* Remove auto object
*/
force_remove_object(auto_ob);
free_object(auto_ob, "remove_all_objects");
auto_ob = NULL;
}
void follow_master(void) {
object *objs;
int i;
int nMasterHere;
nMasterHere = 0;
objs = query_environment()->query_inventory();
for (i = 0; i < sizeof(objs); i++) {
if (objs[i] == master) {
nMasterHere = 1;
}
}
if (nMasterHere == 0) {
if (!master) {
remove_call_out(nFollow);
respond("say It seems " + master_name +
" no longer has a need for me.");
die();
destruct_object(this_object());
return;
}
if (query_environment() != master->query_environment()) {
switch (random(10)) {
case 0:
query_environment()->tell_room(nil, my_name + " leaves.");
break;
case 1:
query_environment()->tell_room(nil, my_name +
" tries to follow his master.");
break;
case 2:
query_environment()->tell_room(nil,
my_name + " follows his master.");
break;
case 3:
query_environment()->tell_room(nil, my_name +
" disappears in a cloud of smoke.");
break;
case 4:
query_environment()->tell_room(nil,
my_name + " suddenly vanishes.");
break;
case 5:
query_environment()->tell_room(nil,
my_name + " fades out of view.");
break;
case 6:
query_environment()->tell_room(nil, my_name +
" runs off after his master.");
break;
case 7:
query_environment()->tell_room(nil, my_name +
" suddenly notices that his master has left, and runs off.");
break;
case 8:
query_environment()->tell_room(nil, my_name +
" fades into the shadows, and is gone.");
break;
case 9:
query_environment()->tell_room(nil, my_name +
" snaps his fingers, and is gone.");
break;
}
move(master->query_environment()->base_name());
switch (random(10)) {
case 0:
query_environment()->tell_room(nil, my_name +
" follows the light of his life.");
break;
case 1:
query_environment()->tell_room(nil, my_name +
" follows in his masters footsteps.");
break;
case 2:
query_environment()->tell_room(nil, my_name +
" appears next to his master in a cloud of smoke.");
break;
case 3:
query_environment()->tell_room(nil, my_name + " enters.");
break;
case 4:
query_environment()->tell_room(nil, my_name + " appears.");
break;
case 5:
query_environment()->tell_room(nil, my_name +
" arrives shortly after his master.");
break;
case 6:
query_environment()->tell_room(nil, my_name +
" comes running, tying to keep up with his master.");
break;
case 7:
query_environment()->tell_room(nil, "A humble page enters.");
break;
case 8:
query_environment()->tell_room(nil,
"A humble person wearing a robe enters.");
break;
case 9:
query_environment()->tell_room(nil, my_name +
" catches up with his master.");
break;
}
}
}
nFollow = call_out("follow_master", 2);
}
void login_timeout(void) {
send_message("\nTimeout.\n");
destruct_object(player);
destruct_object(this_object());
}
void close(varargs int force) {
if (read_callback == "FTP_stor")
call_other(prev, "FTP_write");
connected = 0;
destruct_object(this_object());
}
struct svalue *
debug_command(char *debcmd, int argc, struct svalue *argv)
{
static struct svalue retval;
int dbnum, dbi, il;
char buff[200];
for (dbi = -1, dbnum = 0; debc[dbnum]; dbnum++)
{
if (strcmp(debcmd, debc[dbnum]) == 0)
dbi = dbnum;
}
if (dbi < 0)
{
retval.type = T_NUMBER;
retval.u.number = 0;
return &retval;
}
switch (dbi)
{
case 0: /* index */
retval.type = T_POINTER;
retval.u.vec = allocate_array(dbnum);
for (il = 0; il < dbnum; il++)
{
retval.u.vec->item[il].type = T_STRING;
retval.u.vec->item[il].string_type = STRING_CSTRING;
retval.u.vec->item[il].u.string = debc[il];
}
return &retval;
case 1: /* malloc */
retval.type = T_STRING;
retval.string_type = STRING_MSTRING;
retval.u.string = make_mstring((char *)dump_malloc_data());
return &retval;
case 2: /* status */
case 3: /* status tables */
retval.type = T_STRING;
retval.string_type = STRING_MSTRING;
retval.u.string = (char *)get_gamedriver_info(debc[dbi]);
return &retval;
case 4: /* mudstatus on/off eval_lim time_lim */
if (argc < 3 ||
argv[0].type != T_STRING ||
argv[1].type != T_NUMBER ||
argv[2].type != T_NUMBER)
break;
if (strcmp(argv[0].u.string, "on") == 0)
mudstatus_set(1, argv[1].u.number, argv[2].u.number);
else if (strcmp(argv[0].u.string, "off") == 0)
mudstatus_set(0, argv[1].u.number, argv[2].u.number);
else
break;
retval.type = T_NUMBER;
retval.u.number = 1;
return &retval;
case 5: /* functionlist object */
if (argc < 1 || argv[0].type != T_OBJECT)
break;
retval.type = T_POINTER;
retval.u.vec = allocate_array(argv[0].u.ob->prog->num_functions);
for (il = 0; il < (int)argv[0].u.ob->prog->num_functions; il++)
{
retval.u.vec->item[il].type = T_STRING;
retval.u.vec->item[il].string_type = STRING_SSTRING;
retval.u.vec->item[il].u.string =
reference_sstring(argv[0].u.ob->prog->functions[il].name);
}
return &retval;
case 6: /* rusage */
{
#ifdef RUSAGE /* Only defined if we compile GD with RUSAGE */
char buff[500];
struct rusage rus;
long utime, stime;
long maxrss;
if (getrusage(RUSAGE_SELF, &rus) < 0)
buff[0] = 0;
else {
utime = rus.ru_utime.tv_sec * 1000 + rus.ru_utime.tv_usec / 1000;
stime = rus.ru_stime.tv_sec * 1000 + rus.ru_stime.tv_usec / 1000;
maxrss = rus.ru_maxrss;
(void)sprintf(buff, "%ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld",
utime, stime, maxrss, rus.ru_ixrss, rus.ru_idrss,
rus.ru_isrss, rus.ru_minflt, rus.ru_majflt, rus.ru_nswap,
rus.ru_inblock, rus.ru_oublock, rus.ru_msgsnd,
rus.ru_msgrcv, rus.ru_nsignals, rus.ru_nvcsw,
rus.ru_nivcsw);
}
retval.type = T_STRING;
retval.string_type = STRING_MSTRING;
retval.u.string = make_mstring(buff);
return &retval;
#else
retval.type = T_STRING;
retval.string_type = STRING_CSTRING;
retval.u.string = "Only valid if GD compiled with RUSAGE flag.\n";
return &retval;
#endif
}
#if defined(PROFILE_LPC)
case 7: /* top_ten_cpu */
{
#define NUMBER_OF_TOP_TEN 100
struct program *p[NUMBER_OF_TOP_TEN];
struct vector *v;
struct program *prog;
int i, j;
for(i = 0; i < NUMBER_OF_TOP_TEN; i++)
p[i] = (struct program *)0L;
prog = prog_list;
do
{
for(i = NUMBER_OF_TOP_TEN-1; i >= 0; i--)
{
if ( p[i] && (prog->cpu <= p[i]->cpu))
break;
}
if (i < (NUMBER_OF_TOP_TEN - 1))
for (j = 0; j <= i; j++)
if (strcmp(p[j]->name,prog->name) == 0)
{
i = NUMBER_OF_TOP_TEN-1;
break;
}
if (i < (NUMBER_OF_TOP_TEN - 1))
{
j = NUMBER_OF_TOP_TEN - 2;
while(j > i)
{
p[j + 1] = p[j];
j--;
}
p[i + 1] = prog;
}
} while (prog_list != (prog = prog->next_all));
v = make_cpu_array(NUMBER_OF_TOP_TEN, p);
if (v)
{
retval.type = T_POINTER;
retval.u.vec = v;
return &retval;
}
break;
#undef NUMBER_OF_TOP_TEN
}
#else
case 7:
retval.type = T_STRING;
retval.string_type = STRING_CSTRING;
retval.u.string = "Only valid if GD compiled with PROFILE_LPC flag.\n";
return &retval;
#endif
case 8: /* object_cpu object */
{
long long c_num;
if (argc && (argv[0].type == T_OBJECT))
{
#if defined(PROFILE_LPC)
c_num = argv[0].u.ob->prog->cpu * 1e6;
#else
retval.type = T_STRING;
retval.string_type = STRING_CSTRING;
retval.u.string = "Only valid if GD compiled with PROFILE_LPC flag.\n";
return &retval;
#endif
}
else
{
#ifdef RUSAGE
struct rusage rus;
if (getrusage(RUSAGE_SELF, &rus) < 0)
{
c_num = -1;
}
else
{
c_num = (long long)rus.ru_utime.tv_sec * 1000000 +
rus.ru_utime.tv_usec +
(long long)rus.ru_stime.tv_sec * 1000000 +
rus.ru_stime.tv_usec;
}
#else
retval.type = T_STRING;
retval.string_type = STRING_CSTRING;
retval.u.string = "Only valid if GD compiled with RUSAGE flag.\n";
return &retval;
#endif
}
retval.type = T_NUMBER;
retval.u.number = c_num;
return &retval;
}
case 9: /* swap, object */
#if 0 /* can not swap while executing */
if (argc && (argv[0].type == T_OBJECT))
(void)swap(argv[0].u.ob);
#endif
retval = const1;
return &retval;
case 10: /* version, */
{
char buff[64];
(void)snprintf(buff, sizeof(buff), "%6.6s%02d %s %s", GAME_VERSION, PATCH_LEVEL, __DATE__, __TIME__);
retval.type = T_STRING;
retval.string_type = STRING_MSTRING;
retval.u.string = make_mstring(buff);
return &retval;
}
case 11: /* wizlist, wizname */
/*
* Prints information, will be changed
*/
retval = const1;
return &retval;
case 12: /* trace, bitmask */
{
int ot = -1;
extern struct object *current_interactive;
if (current_interactive && current_interactive->interactive)
{
if (argc && (argv[0].type == T_NUMBER))
{
ot = current_interactive->interactive->trace_level;
current_interactive->interactive->trace_level = argv[0].u.number;
}
}
retval.type = T_NUMBER;
retval.u.number = ot;
return &retval;
}
case 13: /* traceprefix, pathstart */
{
char *old = 0;
extern struct object *current_interactive;
if (current_interactive && current_interactive->interactive)
{
if (argc)
{
old = current_interactive->interactive->trace_prefix;
if (argv[0].type == T_STRING)
{
current_interactive->interactive->trace_prefix =
make_sstring(argv[0].u.string);
}
else
current_interactive->interactive->trace_prefix = 0;
}
}
if (old)
{
retval.type = T_STRING;
retval.string_type = STRING_SSTRING;
retval.u.string = old;
}
else
retval = const0;
return &retval;
}
case 14: /* call_out_info, */
{
extern struct vector *get_calls(struct object *);
if (argv[0].type != T_OBJECT)
break;
retval.type = T_POINTER;
retval.u.vec = get_calls(argv[0].u.ob);
return &retval;
}
case 15: /* inherit_list, object */
if (argc && (argv[0].type == T_OBJECT))
{
retval.type = T_POINTER;
retval.u.vec = inherit_list(argv[0].u.ob);
return &retval;
}
else
{
retval = const0;
return &retval;
}
case 16: /* load_average, */
retval.type = T_STRING;
retval.string_type = STRING_MSTRING;
retval.u.string = make_mstring(query_load_av());
return &retval;
case 17: /* shutdown, */
startshutdowngame(0);
retval = const1;
return &retval;
case 18: /* "object_info", num object */
{
struct object *ob;
char db_buff[1024], tdb[200];
int i;
if (argc < 2 || argv[0].type != T_NUMBER || argv[1].type != T_OBJECT)
break;
if (argv[0].u.number == 0)
{
int flags;
struct object *obj2;
if ( argv[1].type != T_OBJECT)
break;
ob = argv[1].u.ob;
flags = ob->flags;
(void)sprintf(db_buff,"O_ENABLE_COMMANDS : %s\nO_CLONE : %s\nO_DESTRUCTED : %s\nO_SWAPPED : %s\nO_ONCE_INTERACTIVE: %s\nO_CREATED : %s\n",
flags&O_ENABLE_COMMANDS ?"TRUE":"FALSE",
flags&O_CLONE ?"TRUE":"FALSE",
flags&O_DESTRUCTED ?"TRUE":"FALSE",
flags&O_SWAPPED ?"TRUE":"FALSE",
flags&O_ONCE_INTERACTIVE?"TRUE":"FALSE",
flags&O_CREATED ?"TRUE":"FALSE");
(void)sprintf(tdb,"time_of_ref : %d\n", ob->time_of_ref);
(void)strcat(db_buff, tdb);
(void)sprintf(tdb,"ref : %d\n", ob->ref);
(void)strcat(db_buff, tdb);
#ifdef DEBUG
(void)sprintf(tdb,"extra_ref : %d\n", ob->extra_ref);
(void)strcat(db_buff, tdb);
#endif
(void)sprintf(tdb,"swap_num : %d\n", ob->swap_num);
(void)strcat(db_buff, tdb);
(void)snprintf(tdb, sizeof(tdb), "name : '%s'\n", ob->name);
(void)strcat(db_buff, tdb);
(void)snprintf(tdb, sizeof(tdb), "next_all : OBJ(%s)\n",
ob->next_all?ob->next_all->name: "NULL");
(void)strcat(db_buff, tdb);
if (obj_list == ob)
{
(void)strcat(db_buff, "This object is the head of the object list.\n");
}
obj2 = obj_list;
i = 1;
do
if (obj2->next_all == ob)
{
(void)snprintf(tdb, sizeof(tdb), "Previous object in object list: OBJ(%s)\n",
obj2->name);
(void)strcat(db_buff, tdb);
(void)sprintf(tdb, "position in object list:%d\n",i);
(void)strcat(db_buff, tdb);
}
while (obj_list != (obj2 = obj2->next_all));
}
else if (argv[0].u.number == 1)
{
if (argv[1].type != T_OBJECT)
break;
ob = argv[1].u.ob;
(void)sprintf(db_buff,"program ref's %d\n", ob->prog->ref);
(void)snprintf(tdb, sizeof(tdb), "Name %s\n", ob->prog->name);
(void)strcat(db_buff, tdb);
(void)sprintf(tdb,"program size %d\n", ob->prog->program_size);
(void)strcat(db_buff, tdb);
(void)sprintf(tdb, "num func's %u (%u) \n", ob->prog->num_functions
,ob->prog->num_functions * (unsigned) sizeof(struct function));
(void)strcat(db_buff, tdb);
(void)sprintf(tdb,"sizeof rodata %d\n", ob->prog->rodata_size);
(void)strcat(db_buff, tdb);
(void)sprintf(tdb,"num vars %u (%u)\n", ob->prog->num_variables
,ob->prog->num_variables * (unsigned) sizeof(struct variable));
(void)strcat(db_buff, tdb);
(void)sprintf(tdb,"num inherits %u (%u)\n", ob->prog->num_inherited
,ob->prog->num_inherited * (unsigned) sizeof(struct inherit));
(void)strcat(db_buff, tdb);
(void)sprintf(tdb,"total size %d\n", ob->prog->total_size);
(void)strcat(db_buff, tdb);
}
else
{
(void)sprintf(db_buff, "Bad number argument to object_info: %lld\n",
argv[0].u.number);
}
retval.type = T_STRING;
retval.string_type = STRING_MSTRING;
retval.u.string = make_mstring(db_buff);
return &retval;
}
case 19: /* opcdump, 19 */
{
#ifdef OPCPROF
opcdump();
retval = const1;
return &retval;
#else
retval.type = T_STRING;
retval.string_type = STRING_CSTRING;
retval.u.string = "Only valid if GD compiled with OPCPROF flag.\n";
return &retval;
#endif
}
case 20: /* send_udp, 20 host, port, msg */
{
#ifdef CATCH_UDP_PORT
extern udpsvc_t *udpsvc;
#endif
if (argc < 3 ||
argv[0].type != T_STRING ||
argv[1].type != T_NUMBER ||
argv[2].type != T_STRING)
break;
#ifdef CATCH_UDP_PORT
tmp = udpsvc_send(udpsvc, argv[0].u.string, argv[1].u.number, argv[2].u.string);
if (tmp)
retval = const1;
else
#endif
retval = const0;
return &retval;
}
case 21: /* mud_port, 21 */
{
extern int port_number;
retval.type = T_NUMBER;
retval.u.number = port_number;
return &retval;
}
case 22: /* udp_port, 22 */
{
#ifdef CATCH_UDP_PORT
extern int udp_port;
retval.u.number = udp_port;
#else
retval.u.number = -1;
#endif
retval.type = T_NUMBER;
return &retval;
}
case 23: /* set_wizard, object */
if (argc && (argv[0].type == T_OBJECT))
{
retval = const1;
return &retval;
}
else
{
retval = const0;
return &retval;
}
case 24: /* ob_flags, 24 ob */
{
if (argc && (argv[0].type == T_OBJECT))
{
retval.type = T_NUMBER;
retval.u.number = argv[0].u.ob->flags;
return &retval;
}
retval = const0;
return &retval;
}
case 25: /* get_variables, 25 object NULL/string */
{
struct svalue get_variables(struct object *);
struct svalue get_variable(struct object *, char *);
switch (argc)
{
case 1:
if ( argv[0].type != T_OBJECT)
{
retval = const0;
return &retval;
}
retval = get_variables(argv[0].u.ob);
return &retval;
case 2:
if ( argv[0].type != T_OBJECT || argv[1].type != T_STRING)
{
retval = const0;
return &retval;
}
retval = get_variable(argv[0].u.ob, argv[1].u.string);
return &retval;
case 3:
if ( argv[0].type == T_OBJECT && argv[1].type == T_STRING)
{
retval = get_variable(argv[0].u.ob, argv[1].u.string);
return &retval;
}
if ( argv[0].type == T_OBJECT)
{
retval = get_variables(argv[0].u.ob);
return &retval;
}
retval = const0;
return &retval;
default:
retval = const0;
return &retval;
}
}
case 26: /* get_eval_cost, 26 */
{
extern int eval_cost;
retval.type = T_NUMBER;
retval.u.number = eval_cost;
return &retval;
}
case 27: /* debug malloc, 27 */
{
retval = const1;
return &retval;
}
case 28: /* getprofile, 28 object */
{
int format = 0;
#ifndef PROFILE_LPC
retval.type = T_STRING;
retval.string_type = STRING_CSTRING;
retval.u.string = "Only valid if GD compiled with PROFILE_LPC flag.\n";
return &retval;
#else
if (argc < 1 || argv[0].type != T_OBJECT)
break;
if (argc >= 2 && argv[1].type == T_NUMBER)
format = argv[1].u.number;
if (format == 0) {
retval.type = T_POINTER;
retval.u.vec = allocate_array(argv[0].u.ob->prog->num_functions);
for (il = 0; il < (int)argv[0].u.ob->prog->num_functions; il++)
{
(void)snprintf(buff, sizeof(buff), "%016lld:%020lld: %s",
(long long)argv[0].u.ob->prog->functions[il].num_calls,
(long long)(argv[0].u.ob->prog->functions[il].time_spent * 1e6),
argv[0].u.ob->prog->functions[il].name);
retval.u.vec->item[il].type = T_STRING;
retval.u.vec->item[il].string_type = STRING_MSTRING;
retval.u.vec->item[il].u.string = make_mstring(buff);
}
} else if (format == 1) {
retval.type = T_POINTER;
retval.u.vec = allocate_array(argv[0].u.ob->prog->num_functions);
double now = current_cpu();
struct program *prog = argv[0].u.ob->prog;
for (il = 0; il < (int)prog->num_functions; il++)
{
struct function *func = prog->functions + il;
struct vector *res = allocate_array(7);
update_func_profile(func, now, 0.0, 0.0, 0);
res->item[0].type = T_STRING;
res->item[0].string_type = STRING_MSTRING;
res->item[0].u.string = make_mstring(func->name);
res->item[1].type = T_FLOAT;
res->item[1].u.real = func->time_spent * 1e6;
res->item[2].type = T_FLOAT;
res->item[2].u.real = func->tot_time_spent * 1e6;
res->item[3].type = T_FLOAT;
res->item[3].u.real = func->num_calls;
res->item[4].type = T_FLOAT;
res->item[4].u.real = func->avg_time * 1e6;
res->item[5].type = T_FLOAT;
res->item[5].u.real = func->avg_tot_time * 1e6;
res->item[6].type = T_FLOAT;
res->item[6].u.real = func->avg_calls;
retval.u.vec->item[il].type = T_POINTER;
retval.u.vec->item[il].u.vec = res;
}
} else {
retval.type = T_STRING;
retval.string_type = STRING_CSTRING;
retval.u.string = "Unknown format.\n";
}
return &retval;
#endif
}
case 29: /* get_avg_response, 29 */
{
extern int get_msecs_response(int);
extern int msr_point;
int sum, num, tmp;
if (msr_point >=0)
{
sum = 0;
num = 0;
for (il = 0; il < 100; il++)
{
if ((tmp = get_msecs_response(il)) >=0)
{
sum += tmp;
num++;
}
}
retval.type = T_NUMBER;
retval.u.number = (num > 0) ? sum / num : 0;
return &retval;
}
break;
}
case 30: /* destruct, 30 */
case 31: /* destroy, 31 */
{
extern void destruct_object(struct object *);
if (argc && argv[0].type == T_OBJECT &&
!(argv[0].u.ob->flags & O_DESTRUCTED))
destruct_object(argv[0].u.ob);
break;
}
case 32: /* update snoops, 31 */
#ifdef SUPER_SNOOP
update_snoop_file();
#else
retval.type = T_STRING;
retval.string_type = STRING_CSTRING;
retval.u.string = "Only valid if GD compiled with SUPER_SNOOP flag.\n";
#endif
break;
case 33: /* call_warnings, int 0 = off, 1 = on */
if (argc && (argv[0].type == T_STRING))
{
if (strcmp(argv[0].u.string, "on") == 0)
call_warnings++;
else
call_warnings = call_warnings > 0 ? call_warnings - 1 : 0;
retval.type = T_NUMBER;
retval.u.number = call_warnings;
return &retval;
}
else
{
retval.type = T_NUMBER;
retval.u.number = -1;
return &retval;
}
case 34: /* dump objects */
{
FILE *ufile;
struct object *ob;
if ((ufile = fopen(OBJECT_DUMP_FILE, "w")) == NULL)
{
retval.type = T_NUMBER;
retval.u.number = -1;
return &retval;
}
fputs("Array (size), Mapping (size), String (size), Objs, Ints, Floats, Inventory, Callouts, Environment, Name\n", ufile);
ob = obj_list;
do
{
mem_variables(ufile, ob);
}
while (obj_list != (ob = ob->next_all));
(void)fclose(ufile);
break;
}
case 35: /* query_debug_ob */
if (!argc || argv[0].type != T_OBJECT)
break;
retval.type = T_NUMBER;
retval.u.number = argv[0].u.ob->debug_flags;
return &retval;
case 36: /* set_debug_ob */
if (!argc || argv[0].type != T_OBJECT || argv[1].type != T_NUMBER)
break;
retval.type = T_NUMBER;
retval.u.number = argv[0].u.ob->debug_flags;
argv[0].u.ob->debug_flags = argv[1].u.number;
return &retval;
case 37: /* set_swap */
retval.type = T_STRING;
retval.string_type = STRING_CSTRING;
retval.u.string = "Obsolete function.\n";
return &retval;
case 38: /* query_swap */
retval.type = T_STRING;
retval.string_type = STRING_CSTRING;
retval.u.string = "Obsolete function.\n";
return &retval;
case 39: /* query_debug_prog */
if (!argc || argv[0].type != T_OBJECT)
break;
retval.type = T_NUMBER;
retval.u.number = argv[0].u.ob->prog->debug_flags;
return &retval;
case 40: /* set_debug_prog */
if (argc < 2 || argv[0].type != T_OBJECT || argv[1].type != T_NUMBER)
break;
retval.type = T_NUMBER;
retval.u.number = argv[0].u.ob->prog->debug_flags;
argv[0].u.ob->prog->debug_flags = argv[1].u.number;
return &retval;
#ifdef FUNCDEBUG
case 41:
dumpfuncs();
retval = const0;
return &retval;
#endif
case 42: /* inhibitcallouts */
if (argc && (argv[0].type == T_STRING))
{
extern int inhibitcallouts;
int old;
old = inhibitcallouts;
if (strcmp(argv[0].u.string, "on") == 0)
inhibitcallouts = 1;
else
inhibitcallouts = 0;
retval.type = T_NUMBER;
retval.u.number = old;
return &retval;
}
else
{
retval.type = T_NUMBER;
retval.u.number = -1;
return &retval;
}
case 43: /* inhibitcallouts */
if (argc && (argv[0].type == T_STRING))
{
extern int warnobsoleteflag;
int old;
old = warnobsoleteflag;
if (strcmp(argv[0].u.string, "on") == 0)
warnobsoleteflag = 1;
else
warnobsoleteflag = 0;
retval.type = T_NUMBER;
retval.u.number = old;
return &retval;
}
else
{
retval.type = T_NUMBER;
retval.u.number = -1;
return &retval;
}
case 44: /* shared_strings */
#ifdef DEBUG
dump_sstrings();
retval = const0;
#else
retval.type = T_STRING;
retval.string_type = STRING_CSTRING;
retval.u.string = "Only valid if GD compiled with DEBUG flag.\n";
#endif
return &retval;
case 45: /* dump_alarms */
{
int c;
FILE *ufile;
if ((ufile = fopen(ALARM_DUMP_FILE, "w")) == NULL)
{
retval.type = T_NUMBER;
retval.u.number = -1;
return &retval;
}
c = dump_callouts(ufile);
fclose(ufile);
retval.type = T_NUMBER;
retval.u.number = c;
return &retval;
}
#ifdef PROFILE_LPC
case 46: /* top_ten_cpu */
{
#define NUMBER_OF_TOP_TEN 100
struct program *p[NUMBER_OF_TOP_TEN];
struct program *prog;
struct vector *v;
int i, j;
double now = current_cpu();
for(i = 0; i < NUMBER_OF_TOP_TEN; i++)
p[i] = (struct program *)0L;
prog = prog_list;
do
{
update_prog_profile(prog, now, 0.0, 0.0);
for(i = NUMBER_OF_TOP_TEN-1; i >= 0; i--)
{
if ( p[i] && (prog->cpu_avg <= p[i]->cpu_avg))
break;
}
if (i < (NUMBER_OF_TOP_TEN - 1))
for (j = 0; j <= i; j++)
if (strcmp(p[j]->name,prog->name) == 0)
{
i = NUMBER_OF_TOP_TEN-1;
break;
}
if (i < (NUMBER_OF_TOP_TEN - 1))
{
j = NUMBER_OF_TOP_TEN - 2;
while(j > i)
{
p[j + 1] = p[j];
j--;
}
p[i + 1] = prog;
}
} while (prog_list != (prog = prog->next_all));
v = make_cpu_array2(NUMBER_OF_TOP_TEN, p);
if (v)
{
retval.type = T_POINTER;
retval.u.vec = v;
return &retval;
}
break;
#undef NUMBER_OF_TOP_TEN
}
#else
case 46:
retval.type = T_STRING;
retval.string_type = STRING_CSTRING;
retval.u.string = "Only valid if GD compiled with PROFILE_LPC flag.\n";
return &retval;
#endif
case 47: /* object_cpu_avg object */
{
#if defined(PROFILE_LPC)
if (argc < 1 || (argv[0].type != T_OBJECT))
break;
update_prog_profile(argv[0].u.ob->prog, current_cpu(), 0.0, 0.0);
retval.type = T_FLOAT;
retval.u.number =argv[0].u.ob->prog->cpu_avg * 1e6;
return &retval;
#else
retval.type = T_STRING;
retval.string_type = STRING_CSTRING;
retval.u.string = "Only valid if GD compiled with PROFILE_LPC flag.\n";
return &retval;
#endif
}
case 48: /* getprofile_avg, 28 object */
{
#if defined(PROFILE_LPC)
if (argc < 1 || argv[0].type != T_OBJECT)
break;
retval.type = T_POINTER;
retval.u.vec = allocate_array(argv[0].u.ob->prog->num_functions);
double now = current_cpu();
struct program *prog = argv[0].u.ob->prog;
for (il = 0; il < (int)prog->num_functions; il++)
{
struct function *func = prog->functions + il;
struct vector *res = allocate_array(3);
update_func_profile(func, now, 0.0, 0.0, 0);
res->item[0].type = T_STRING;
res->item[0].string_type = STRING_MSTRING;
res->item[0].u.string = make_mstring(func->name);
res->item[1].type = T_FLOAT;
res->item[1].u.real = func->avg_time * 1e6;
res->item[2].type = T_FLOAT;
res->item[2].u.real = func->avg_calls;
retval.u.vec->item[il].type = T_POINTER;
retval.u.vec->item[il].u.vec = res;
}
return &retval;
#else
retval.type = T_STRING;
retval.string_type = STRING_CSTRING;
retval.u.string = "Only valid if GD compiled with PROFILE_LPC flag.\n";
return &retval;
#endif
}
case 49: /* profile_timebase */
{
#if defined(PROFILE_LPC)
if (argc < 1) { /* Return current value */
retval.type = T_FLOAT;
retval.u.real = get_profile_timebase();
return &retval;
}
/* Update using old timebase */
double now = current_cpu();
struct program *prog = prog_list;
do
{
update_prog_profile(prog, now, 0.0, 0.0);
for (int i = 0; i < prog->num_functions; i++)
{
struct function *func = prog->functions + i;
update_func_profile(func, now, 0.0, 0.0, 0);
}
} while (prog_list != (prog = prog->next_all));
/* Set the new value */
if (argv[0].type == T_NUMBER && argv[0].u.number > 0)
set_profile_timebase(argv[0].u.number);
else if (argv[0].type == T_FLOAT && argv[0].u.real > 1e-3)
set_profile_timebase(argv[0].u.real);
else
break;
retval = const1;
return &retval;
#else
retval.type = T_STRING;
retval.string_type = STRING_CSTRING;
retval.u.string = "Only valid if GD compiled with PROFILE_LPC flag.\n";
return &retval;
#endif
}
case 50:
{
#ifdef PROFILE_LPC
extern int trace_calls;
extern FILE *trace_calls_file;
if (argc < 1 || argv[0].type != T_NUMBER)
break;
if (!trace_calls && argv[0].u.number) {
if ((trace_calls_file = fopen(TRACE_CALLS_FILE, "w")) == 0)
break;
setvbuf(trace_calls_file, 0, _IOFBF, 1<<20); /* Set a 1MB buffer */
trace_calls = 1;
} else if (trace_calls && !argv[0].u.number) {
fclose(trace_calls_file);
trace_calls_file = 0;
trace_calls = 0;
}
retval = const1;
return &retval;
#else
retval.type = T_STRING;
retval.string_type = STRING_CSTRING;
retval.u.string = "Only valid if GD compiled with PROFILE_LPC.\n";
return &retval;
#endif
}
case 51:
{
#if defined(PROFILE_LPC)
long long num_top, criteria, num_items = 0;
double now = current_cpu(), crit_val;
struct program *prog;
struct {
struct program *prog;
double crit_val;
unsigned short func_index;
} *result;
if (argc < 2 ||
argv[0].type != T_NUMBER ||
argv[1].type != T_NUMBER)
break;
num_top = argv[0].u.number;
criteria = argv[1].u.number;
if (num_top < 0 || num_top > 1000) {
retval.type = T_STRING;
retval.string_type = STRING_CSTRING;
retval.u.string = "The number of itmes must be >= 0 and <= 1000.";
break;
}
if (criteria < 0 || criteria > 9) {
retval.type = T_STRING;
retval.string_type = STRING_CSTRING;
retval.u.string = "The criteria must be >= 0 and <= 9.";
break;
}
if (num_top == 0) {
retval.type = T_POINTER;
retval.u.vec = allocate_array(0);
return &retval;
}
result = xalloc(sizeof(*result) * (num_top + 1));
memset(result, 0, sizeof(*result) * (num_top + 1));
prog = prog_list;
do
{
update_prog_profile(prog, now, 0.0, 0.0);
for (int i = 0; i < prog->num_functions; i++)
{
struct function *func = prog->functions + i;
update_func_profile(func, now, 0.0, 0.0, 0);
crit_val = get_top_func_criteria(func, criteria);
if (num_items == num_top &&
result[num_items - 1].crit_val >= crit_val)
continue;
if (num_items == 0 || (num_items < num_top &&
result[num_items - 1].crit_val >= crit_val)) {
result[num_items].prog = prog;
result[num_items].func_index = i;
result[num_items].crit_val = crit_val;
num_items++;
} else {
int insert = num_items;
while (insert > 0 &&
result[insert - 1].crit_val < crit_val)
insert--;
memmove(&result[insert + 1], &result[insert],
sizeof(*result) * (num_items - insert));
result[insert].prog = prog;
result[insert].func_index = i;
result[insert].crit_val = crit_val;
if (num_items < num_top)
num_items++;
}
}
} while ((prog = prog->next_all) != prog_list);
retval.type = T_POINTER;
retval.u.vec = allocate_array(num_items);
for (int i = 0; i < num_items; i++) {
struct vector *val = allocate_array(9);
prog = result[i].prog;
struct function *func = &prog->functions[result[i].func_index];
crit_val = result[i].crit_val;
val->item[0].type = T_STRING;
val->item[0].string_type = STRING_MSTRING;
val->item[0].u.string = make_mstring(prog->name);
val->item[1].type = T_STRING;
val->item[1].string_type = STRING_SSTRING;
val->item[1].u.string = func->name;
reference_sstring(func->name);
val->item[2].type = T_FLOAT;
val->item[2].u.real = crit_val;
val->item[3].type = T_FLOAT;
val->item[3].u.real = func->time_spent;
val->item[4].type = T_FLOAT;
val->item[4].u.real = func->avg_time;
val->item[5].type = T_FLOAT;
val->item[5].u.real = func->tot_time_spent;
val->item[6].type = T_FLOAT;
val->item[6].u.real = func->avg_tot_time;
val->item[7].type = T_FLOAT;
val->item[7].u.real = func->num_calls;
val->item[8].type = T_FLOAT;
val->item[8].u.real = func->avg_calls;
retval.u.vec->item[i].type = T_POINTER;
retval.u.vec->item[i].u.vec = val;
}
free(result);
return &retval;
#else
retval.type = T_STRING;
retval.string_type = STRING_CSTRING;
retval.u.string = "Only valid if GD compiled with PROFILE_LPC.\n";
return &retval;
#endif
}
}
retval = const0;
return &retval;
}
void self_destruct()
{
destruct_object(this_object());
}
void delete_account()
{
SECRETD->remove_file("accounts/" + name);
destruct_object(this_object());
}
void self_destruct()
{
ACCESS_CHECK(BIGSTRUCT());
destruct_object(this_object());
}