static dbref
make_player(const char *name, const char *password, const char *host,
const char *ip)
{
dbref player;
char temp[SBUF_LEN];
char *flaglist, *flagname;
char flagbuff[BUFFER_LEN];
player = new_object();
/* initialize everything */
set_name(player, name);
Location(player) = PLAYER_START;
Home(player) = PLAYER_START;
Owner(player) = player;
Parent(player) = NOTHING;
Type(player) = TYPE_PLAYER;
Flags(player) = new_flag_bitmask("FLAG");
strcpy(flagbuff, options.player_flags);
flaglist = trim_space_sep(flagbuff, ' ');
if (*flaglist != '\0') {
while (flaglist) {
flagname = split_token(&flaglist, ' ');
twiddle_flag_internal("FLAG", player, flagname, 0);
}
}
if (Suspect_Site(host, player) || Suspect_Site(ip, player))
set_flag_internal(player, "SUSPECT");
set_initial_warnings(player);
/* Modtime tracks login failures */
ModTime(player) = (time_t) 0;
(void) atr_add(player, pword_attr, password_hash(password, NULL), GOD, 0);
giveto(player, START_BONUS); /* starting bonus */
(void) atr_add(player, "LAST", show_time(mudtime, 0), GOD, 0);
(void) atr_add(player, "LASTSITE", host, GOD, 0);
(void) atr_add(player, "LASTIP", ip, GOD, 0);
(void) atr_add(player, "LASTFAILED", " ", GOD, 0);
snprintf(temp, sizeof temp, "%d", START_QUOTA);
(void) atr_add(player, "RQUOTA", temp, GOD, 0);
(void) atr_add(player, "MAILCURF", "0", GOD,
AF_LOCKED | AF_NOPROG | AF_WIZARD);
add_folder_name(player, 0, "inbox");
/* link him to PLAYER_START */
PUSH(player, Contents(PLAYER_START));
add_player(player);
add_lock(GOD, player, Basic_Lock, parse_boolexp(player, "=me", Basic_Lock),
LF_DEFAULT);
add_lock(GOD, player, Enter_Lock, parse_boolexp(player, "=me", Basic_Lock),
LF_DEFAULT);
add_lock(GOD, player, Use_Lock, parse_boolexp(player, "=me", Basic_Lock),
LF_DEFAULT);
current_state.players++;
local_data_create(player);
return player;
}
/*
* vecsum is a microbenchmark which measures the speed of various ways of
* reading from HDFS. It creates a file containing floating-point 'doubles',
* and computes the sum of all the doubles several times. For some CPUs,
* assembly optimizations are used for the summation (SSE, etc).
*/
int main(void)
{
int ret = 1;
struct options *opts = NULL;
struct local_data *cdata = NULL;
struct libhdfs_data *ldata = NULL;
struct stopwatch *watch = NULL;
if (check_byte_size(VECSUM_CHUNK_SIZE, "VECSUM_CHUNK_SIZE") ||
check_byte_size(ZCR_READ_CHUNK_SIZE,
"ZCR_READ_CHUNK_SIZE") ||
check_byte_size(NORMAL_READ_CHUNK_SIZE,
"NORMAL_READ_CHUNK_SIZE")) {
goto done;
}
opts = options_create();
if (!opts)
goto done;
if (opts->ty == VECSUM_LOCAL) {
cdata = local_data_create(opts);
if (!cdata)
goto done;
} else {
ldata = libhdfs_data_create(opts);
if (!ldata)
goto done;
}
watch = stopwatch_create();
if (!watch)
goto done;
switch (opts->ty) {
case VECSUM_LOCAL:
vecsum_local(cdata, opts);
ret = 0;
break;
case VECSUM_LIBHDFS:
ret = vecsum_libhdfs(ldata, opts);
break;
case VECSUM_ZCR:
ret = vecsum_zcr(ldata, opts);
break;
}
if (ret) {
fprintf(stderr, "vecsum failed with error %d\n", ret);
goto done;
}
ret = 0;
done:
fprintf(stderr, "cleaning up...\n");
if (watch && (ret == 0)) {
long long length = vecsum_length(opts, ldata);
if (length >= 0) {
stopwatch_stop(watch, length * opts->passes);
}
}
if (cdata)
local_data_free(cdata);
if (ldata)
libhdfs_data_free(ldata);
if (opts)
options_free(opts);
return ret;
}
/** Create an exit.
* This function opens an exit and optionally links it.
* \param player the enactor.
* \param direction the name of the exit.
* \param linkto the room to link to, as a string.
* \param pseudo a phony location for player if a back exit is needed. This is bpass by do_open() as the source room of the back exit.
* \return dbref of the new exit, or NOTHING.
*/
dbref
do_real_open(dbref player, const char *direction, const char *linkto,
dbref pseudo)
{
dbref loc =
(pseudo !=
NOTHING) ? pseudo : (IsExit(player) ? Source(player) : (IsRoom(player) ?
player :
Location(player)));
dbref new_exit;
char *flaglist, *flagname;
char flagbuff[BUFFER_LEN];
char *name = NULL;
char *alias = NULL;
if (!command_check_byname(player, "@dig")) {
notify(player, T("Permission denied."));
return NOTHING;
}
if ((loc == NOTHING) || (!IsRoom(loc))) {
notify(player, T("Sorry, you can only make exits out of rooms."));
return NOTHING;
}
if (Going(loc)) {
notify(player, T("You can't make an exit in a place that's crumbling."));
return NOTHING;
}
if (!*direction) {
notify(player, T("Open where?"));
return NOTHING;
} else
if (ok_object_name
((char *) direction, player, NOTHING, TYPE_EXIT, &name, &alias) < 1) {
notify(player, T("That's a strange name for an exit!"));
if (name)
mush_free(name, "name.newname");
if (alias)
mush_free(alias, "name.newname");
return NOTHING;
}
if (!Open_Anywhere(player) && !controls(player, loc)) {
notify(player, T("Permission denied."));
} else if (can_pay_fees(player, EXIT_COST)) {
/* create the exit */
new_exit = new_object();
/* initialize everything */
set_name(new_exit, name);
if (alias && *alias != ALIAS_DELIMITER)
atr_add(new_exit, "ALIAS", alias, player, 0);
Owner(new_exit) = Owner(player);
Zone(new_exit) = Zone(player);
Source(new_exit) = loc;
Type(new_exit) = TYPE_EXIT;
Flags(new_exit) = new_flag_bitmask("FLAG");
strcpy(flagbuff, options.exit_flags);
flaglist = trim_space_sep(flagbuff, ' ');
if (*flaglist != '\0') {
while (flaglist) {
flagname = split_token(&flaglist, ' ');
twiddle_flag_internal("FLAG", new_exit, flagname, 0);
}
}
mush_free(name, "name.newname");
if (alias)
mush_free(alias, "name.newname");
/* link it in */
PUSH(new_exit, Exits(loc));
/* and we're done */
notify_format(player, T("Opened exit %s"), unparse_dbref(new_exit));
/* check second arg to see if we should do a link */
if (linkto && *linkto != '\0') {
notify(player, T("Trying to link..."));
if ((loc = check_var_link(linkto)) == NOTHING)
loc = parse_linkable_room(player, linkto);
if (loc != NOTHING) {
if (!payfor(player, LINK_COST)) {
notify_format(player, T("You don't have enough %s to link."), MONIES);
} else {
/* it's ok, link it */
Location(new_exit) = loc;
notify_format(player, T("Linked exit #%d to #%d"), new_exit, loc);
}
}
}
current_state.exits++;
local_data_create(new_exit);
queue_event(player, "OBJECT`CREATE", "%s", unparse_objid(new_exit));
return new_exit;
}
if (name)
mush_free(name, "name.newname");
if (alias)
mush_free(alias, "name.newname");
return NOTHING;
}
/** Create a thing.
* \verbatim
* This is the top-level function for @create.
* \endverbatim
* \param player the enactor.
* \param name name of thing to create.
* \param cost pennies spent in creation.
* \paran newdbref the (unparsed) dbref to give the object, or NULL to use the next free
* \return dbref of new thing, or NOTHING.
*/
dbref
do_create(dbref player, char *name, int cost, char *newdbref)
{
dbref loc;
dbref thing;
char *flaglist, *flagname;
char flagbuff[BUFFER_LEN];
if (*name == '\0') {
notify(player, T("Create what?"));
return NOTHING;
} else if (!ok_name(name, 0)) {
notify(player, T("That's a silly name for a thing!"));
return NOTHING;
} else if (cost < OBJECT_COST) {
cost = OBJECT_COST;
}
if (!make_first_free_wrapper(player, newdbref)) {
return NOTHING;
}
if (can_pay_fees(player, cost)) {
/* create the object */
thing = new_object();
/* initialize everything */
set_name(thing, name);
if (!IsExit(player)) /* Exits shouldn't have contents! */
Location(thing) = player;
else
Location(thing) = Source(player);
Owner(thing) = Owner(player);
Zone(thing) = Zone(player);
s_Pennies(thing, cost);
Type(thing) = TYPE_THING;
Flags(thing) = new_flag_bitmask("FLAG");
strcpy(flagbuff, options.thing_flags);
flaglist = trim_space_sep(flagbuff, ' ');
if (*flaglist != '\0') {
while (flaglist) {
flagname = split_token(&flaglist, ' ');
twiddle_flag_internal("FLAG", thing, flagname, 0);
}
}
/* home is here (if we can link to it) or player's home */
if ((loc = Location(player)) != NOTHING &&
(controls(player, loc) || Abode(loc))) {
Home(thing) = loc; /* home */
} else {
Home(thing) = Home(player); /* home */
}
/* link it in */
if (!IsExit(player))
PUSH(thing, Contents(player));
else
PUSH(thing, Contents(Source(player)));
/* and we're done */
notify_format(player, T("Created: Object %s."), unparse_dbref(thing));
current_state.things++;
local_data_create(thing);
queue_event(player, "OBJECT`CREATE", "%s", unparse_objid(thing));
return thing;
}
return NOTHING;
}
/** Create a room.
* \verbatim
* This is the top-level interface for @dig.
* \endverbatim
* \param player the enactor.
* \param name the name of the room to create.
* \param argv array of additional arguments to command
* (exit forward,exit back,newdbref)
* \param tport if 1, teleport the player to the new room.
* \return dbref of new room, or NOTHING.
*/
dbref
do_dig(dbref player, const char *name, char **argv, int tport)
{
dbref room;
char *flaglist, *flagname;
char flagbuff[BUFFER_LEN];
char *newdbref = NULL;
if (argv[3] && *argv[3]) {
newdbref = argv[3];
}
/* we don't need to know player's location! hooray! */
if (*name == '\0') {
notify(player, T("Dig what?"));
} else if (!ok_name(name, 0)) {
notify(player, T("That's a silly name for a room!"));
} else if (can_pay_fees(player, ROOM_COST)) {
if (!make_first_free_wrapper(player, newdbref)) {
return NOTHING;
}
room = new_object();
/* Initialize everything */
set_name(room, name);
Owner(room) = Owner(player);
Zone(room) = Zone(player);
Type(room) = TYPE_ROOM;
Flags(room) = new_flag_bitmask("FLAG");
strcpy(flagbuff, options.room_flags);
flaglist = trim_space_sep(flagbuff, ' ');
if (*flaglist != '\0') {
while (flaglist) {
flagname = split_token(&flaglist, ' ');
twiddle_flag_internal("FLAG", room, flagname, 0);
}
}
notify_format(player, T("%s created with room number %d."), name, room);
if (argv[1] && *argv[1]) {
char nbuff[MAX_COMMAND_LEN];
sprintf(nbuff, "#%d", room);
do_real_open(player, argv[1], nbuff, NOTHING);
}
if (argv[2] && *argv[2]) {
do_real_open(player, argv[2], "here", room);
}
current_state.rooms++;
local_data_create(room);
if (tport) {
/* We need to use the full command, because we need NO_TEL
* and Z_TEL checking */
char roomstr[MAX_COMMAND_LEN];
sprintf(roomstr, "#%d", room);
do_teleport(player, "me", roomstr, 0, 0); /* if flag, move the player */
}
queue_event(player, "OBJECT`CREATE", "%s", unparse_objid(room));
return room;
}
return NOTHING;
}
