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;
}
/** Check to see if an object has a good zone lock set.
* If it doesn't have a lock at all, set one of '=Zone'.
* \param player The object responsible for having the lock checked.
* \param zone the object whose lock needs to be checked.
* \param noisy if 1, notify player of automatic locking
*/
void
check_zone_lock(dbref player, dbref zone, int noisy)
{
boolexp key = getlock(zone, Zone_Lock);
if (key == TRUE_BOOLEXP) {
add_lock(GOD, zone, Zone_Lock, parse_boolexp(zone, "=me", Zone_Lock), -1);
if (noisy)
notify_format(player,
T
("Unlocked zone %s - automatically zone-locking to itself"),
unparse_object(player, zone));
} else if (eval_lock(Location(player), zone, Zone_Lock)) {
/* Does #0 and #2 pass it? If so, probably trivial elock */
if (eval_lock(PLAYER_START, zone, Zone_Lock) &&
eval_lock(MASTER_ROOM, zone, Zone_Lock)) {
if (noisy)
notify_format(player,
T("Zone %s really should have a more secure zone-lock."),
unparse_object(player, zone));
} else /* Probably inexact zone lock */
notify_format(player,
T
("Warning: Zone %s may have loose zone lock. Lock zones to =player, not player"),
unparse_object(player, zone));
}
}
/** Set/lock a lock (user interface).
* \verbatim
* This implements @lock.
* \endverbatim
* \param player the enactor.
* \param name name of object to lock.
* \param keyname key to lock the lock to, as a string.
* \param type type of lock to lock.
*/
void
do_lock(dbref player, const char *name, const char *keyname, lock_type type)
{
lock_type real_type;
dbref thing;
boolexp key;
/* check for '@lock <object>/<atr>' */
if (strchr(name, '/')) {
do_atrlock(player, name, "on");
return;
}
if (!keyname || !*keyname) {
do_unlock(player, name, type);
return;
}
switch (thing = match_result(player, name, NOTYPE, MAT_EVERYTHING)) {
case NOTHING:
notify(player, T("I don't see what you want to lock!"));
return;
case AMBIGUOUS:
notify(player, T("I don't know which one you want to lock!"));
return;
default:
if (!controls(player, thing)) {
notify(player, T("You can't lock that!"));
return;
}
if (IsGarbage(thing)) {
notify(player, T("Why would you want to lock garbage?"));
return;
}
break;
}
key = parse_boolexp(player, keyname, type);
/* do the lock */
if (key == TRUE_BOOLEXP) {
notify(player, T("I don't understand that key."));
} else {
if ((real_type = check_lock_type(player, thing, type)) != NULL) {
/* everything ok, do it */
if (add_lock(player, thing, real_type, key, LF_DEFAULT)) {
if (!AreQuiet(player, thing))
notify_format(player, T("%s(%s) - %s locked."),
AName(thing, AN_SYS, NULL), unparse_dbref(thing),
real_type);
if (!IsPlayer(thing))
ModTime(thing) = mudtime;
} else {
notify(player, T("Permission denied."));
/* Done by a failed add_lock() // free_boolexp(key); */
}
} else
free_boolexp(key);
}
}
/** Copy the locks from one object to another.
* \param player the enactor.
* \param orig the source object.
* \param clone the destination object.
*/
void
clone_locks(dbref player, dbref orig, dbref clone)
{
lock_list *ll;
for (ll = Locks(orig); ll; ll = ll->next) {
if (!(L_FLAGS(ll) & LF_NOCLONE))
add_lock(player, clone, L_TYPE(ll), dup_bool(L_KEY(ll)), L_FLAGS(ll));
}
}
// Can be used to set a type of lock on an object
void CHSInterface::SetLock(int objnum, int lockto, HS_LOCKTYPE lock)
{
#ifdef PENNMUSH // No change in code between versions
char tmp[32];
sprintf_s(tmp, "#%d", lockto);
switch (lock)
{
case LOCK_USE:
add_lock(GOD, objnum, Use_Lock, parse_boolexp(lockto, tmp, Use_Lock),
-1);
break;
case LOCK_ZONE:
add_lock(GOD, objnum, Zone_Lock,
parse_boolexp(lockto, tmp, Zone_Lock), -1);
break;
case LOCK_NORMAL:
default:
break;
}
#endif
#if defined(TM3) || defined(MUX)
char tmp[SBUF_SIZE];
BOOLEXP *key;
snprintf(tmp, SBUF_SIZE - 1, "#%d", lockto);
key = parse_boolexp(objnum, tmp, 1);
switch (lock)
{
case LOCK_USE:
atr_add_raw(objnum, A_LUSE, unparse_boolexp_quiet(objnum, key));
break;
case LOCK_ZONE:
atr_add_raw(objnum, A_LCONTROL, unparse_boolexp_quiet(objnum, key));
case LOCK_NORMAL:
break;
}
free_boolexp(key);
#endif
}
// build a map of JavaThread to all its owned AbstractOwnableSynchronizer
void ConcurrentLocksDump::build_map(GrowableArray<oop>* aos_objects) {
int length = aos_objects->length();
for (int i = 0; i < length; i++) {
oop o = aos_objects->at(i);
oop owner_thread_obj = java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(o);
if (owner_thread_obj != NULL) {
JavaThread* thread = java_lang_Thread::thread(owner_thread_obj);
assert(o->is_instance(), "Must be an instanceOop");
add_lock(thread, (instanceOop) o);
}
}
}
/** Set/lock a lock (user interface).
* \verbatim
* This implements @lock.
* \endverbatim
* \param player the enactor.
* \param name name of object to lock.
* \param keyname key to lock the lock to, as a string.
* \param type type of lock to lock.
*/
void
do_lock(dbref player, const char *name, const char *keyname, lock_type type)
{
lock_type real_type;
dbref thing;
boolexp key;
char *sp;
/* check for '@lock <object>/<atr>' */
sp = strchr(name, '/');
if (sp) {
do_atrlock(player, name, keyname, 0);
return;
}
if (!keyname || !*keyname) {
do_unlock(player, name, type);
return;
}
switch (thing = match_result(player, name, NOTYPE, MAT_EVERYTHING)) {
case NOTHING:
notify(player, T("I don't see what you want to lock!"));
return;
case AMBIGUOUS:
notify(player, T("I don't know which one you want to lock!"));
return;
default:
if (!controls(player, thing)) {
notify(player, T("You can't lock that!"));
return;
}
if (IsGarbage(thing)) {
notify(player, T("Why would you want to lock garbage?"));
return;
}
break;
}
key = parse_boolexp(player, keyname, type);
/* do the lock */
if (key == TRUE_BOOLEXP) {
notify(player, T("I don't understand that key."));
} else {
if ((real_type = check_lock_type(player, thing, type)) != NULL) {
/* everything ok, do it */
if (add_lock(player, thing, real_type, key, -1)) {
if (!AreQuiet(player, thing))
notify_format(player, T("%s(%s) - %s locked."), Name(thing),
unparse_dbref(thing), real_type);
if (!IsPlayer(thing)) {
char lmbuf[1024];
ModTime(thing) = mudtime;
snprintf(lmbuf, 1023, "%s lock[#%d]", real_type, player);
lmbuf[strlen(lmbuf)+1] = '\0';
set_lmod(thing, lmbuf);
}
} else {
notify(player, T("Permission denied."));
free_boolexp(key);
}
} else
free_boolexp(key);
}
}
void chkpt_t::deserialize_binary(ifstream& ifs)
{
if(!ifs.is_open()) {
cerr << "Could not open input stream for chkpt file" << endl;;
W_FATAL(fcINTERNAL);
}
ifs.read((char*)&highest_tid, sizeof(tid_t));
size_t buf_tab_size;
ifs.read((char*)&buf_tab_size, sizeof(size_t));
for(uint i=0; i<buf_tab_size; i++) {
PageID pid;
ifs.read((char*)&pid, sizeof(PageID));
buf_tab_entry_t entry;
ifs.read((char*)&entry, sizeof(buf_tab_entry_t));
DBGOUT1(<<"pid[]="<<pid<< " , " <<
"rec_lsn[]="<<entry.rec_lsn<< " , " <<
"page_lsn[]="<<entry.page_lsn);
// buf_tab[pid] = entry;
mark_page_dirty(pid, entry.page_lsn, entry.rec_lsn);
}
size_t xct_tab_size;
ifs.read((char*)&xct_tab_size, sizeof(size_t));
for(uint i=0; i<xct_tab_size; i++) {
tid_t tid;
ifs.read((char*)&tid, sizeof(tid_t));
xct_tab_entry_t entry;
ifs.read((char*)&entry.state, sizeof(smlevel_0::xct_state_t));
ifs.read((char*)&entry.last_lsn, sizeof(lsn_t));
ifs.read((char*)&entry.first_lsn, sizeof(lsn_t));
DBGOUT1(<<"tid[]="<<tid<<" , " <<
"state[]="<<entry.state<< " , " <<
"last_lsn[]="<<entry.last_lsn<<" , " <<
"first_lsn[]="<<entry.first_lsn);
if (entry.state != smlevel_0::xct_ended) {
mark_xct_active(tid, entry.first_lsn, entry.last_lsn);
if (is_xct_active(tid)) {
size_t lock_tab_size;
ifs.read((char*)&lock_tab_size, sizeof(size_t));
for(uint j=0; j<lock_tab_size; j++) {
lock_info_t lock_entry;
ifs.read((char*)&lock_entry, sizeof(lock_info_t));
// entry.locks.push_back(lock_entry);
add_lock(tid, lock_entry.lock_mode, lock_entry.lock_hash);
DBGOUT1(<< " lock_mode[]="<<lock_entry.lock_mode
<< " , lock_hash[]="<<lock_entry.lock_hash);
}
}
// xct_tab[tid] = entry;
}
}
void chkpt_t::acquire_lock(logrec_t& r)
{
w_assert1(is_xct_active(r.tid()));
w_assert1(!r.is_single_sys_xct());
w_assert1(!r.is_multi_page());
w_assert1(!r.is_cpsn());
w_assert1(r.is_page_update());
switch (r.type())
{
case logrec_t::t_btree_insert:
case logrec_t::t_btree_insert_nonghost:
{
btree_insert_t* dp = (btree_insert_t*) r.data();
w_keystr_t key;
key.construct_from_keystr(dp->data, dp->klen);
okvl_mode mode = btree_impl::create_part_okvl(okvl_mode::X, key);
lockid_t lid (r.stid(), (const unsigned char*) key.buffer_as_keystr(),
key.get_length_as_keystr());
add_lock(r.tid(), mode, lid.hash());
}
break;
case logrec_t::t_btree_update:
{
btree_update_t* dp = (btree_update_t*) r.data();
w_keystr_t key;
key.construct_from_keystr(dp->_data, dp->_klen);
okvl_mode mode = btree_impl::create_part_okvl(okvl_mode::X, key);
lockid_t lid (r.stid(), (const unsigned char*) key.buffer_as_keystr(),
key.get_length_as_keystr());
add_lock(r.tid(), mode, lid.hash());
}
break;
case logrec_t::t_btree_overwrite:
{
btree_overwrite_t* dp = (btree_overwrite_t*) r.data();
w_keystr_t key;
key.construct_from_keystr(dp->_data, dp->_klen);
okvl_mode mode = btree_impl::create_part_okvl(okvl_mode::X, key);
lockid_t lid (r.stid(), (const unsigned char*) key.buffer_as_keystr(),
key.get_length_as_keystr());
add_lock(r.tid(), mode, lid.hash());
}
break;
case logrec_t::t_btree_ghost_mark:
{
btree_ghost_t* dp = (btree_ghost_t*) r.data();
for (size_t i = 0; i < dp->cnt; ++i) {
w_keystr_t key (dp->get_key(i));
okvl_mode mode = btree_impl::create_part_okvl(okvl_mode::X, key);
lockid_t lid (r.stid(), (const unsigned char*) key.buffer_as_keystr(),
key.get_length_as_keystr());
add_lock(r.tid(), mode, lid.hash());
}
}
break;
case logrec_t::t_btree_ghost_reserve:
{
btree_ghost_reserve_t* dp = (btree_ghost_reserve_t*) r.data();
w_keystr_t key;
key.construct_from_keystr(dp->data, dp->klen);
okvl_mode mode = btree_impl::create_part_okvl(okvl_mode::X, key);
lockid_t lid (r.stid(), (const unsigned char*) key.buffer_as_keystr(),
key.get_length_as_keystr());
add_lock(r.tid(), mode, lid.hash());
}
break;
default:
w_assert0(r.type() == logrec_t::t_page_img_format);
break;
}
return;
}
