const char *
mfn_rand(MFUNARGS)
{
int num = 0;
dbref trg = (dbref) 0, obj = what;
const char *pname, *ptr;
int blessed = 0;
pname = argv[0];
if (argc == 2) {
obj = mesg_dbref(descr, player, what, perms, argv[1], mesgtyp);
}
if (obj == PERMDENIED)
ABORT_MPI("RAND", "Permission denied.");
if (obj == UNKNOWN || obj == AMBIGUOUS || obj == NOTHING || obj == HOME)
ABORT_MPI("RAND", "Match failed.");
num = get_list_count(what, obj, perms, (char *)pname, mesgtyp, &blessed);
if (!num)
ABORT_MPI("RAND", "Failed list read.");
ptr = get_list_item(what, obj, perms, (char *)pname, (((RANDOM() / 256) % num) + 1), mesgtyp, &blessed);
if (!ptr)
ABORT_MPI("RAND", "Failed list read.");
trg = what;
if (blessed) {
mesgtyp |= MPI_ISBLESSED;
} else {
mesgtyp &= ~MPI_ISBLESSED;
}
if (Prop_ReadOnly(ptr) || Prop_Private(ptr) || Prop_SeeOnly(ptr) || Prop_Hidden(ptr))
trg = obj;
ptr = mesg_parse(descr, player, obj, trg, ptr, buf, BUFFER_LEN, mesgtyp);
CHECKRETURN(ptr, "RAND", "listval");
return ptr;
}
int
safeputprop(dbref obj, dbref perms, char *buf, char *val, int mesgtyp)
{
char *ptr;
if (!buf)
return 0;
while (*buf == PROPDIR_DELIMITER)
buf++;
if (!*buf)
return 0;
/* disallow CR's and :'s in prop names. */
for (ptr = buf; *ptr; ptr++)
if (*ptr == '\r' || *ptr == PROP_DELIMITER)
return 0;
if (Prop_System(buf))
return 0;
if (!(mesgtyp & MPI_ISBLESSED)) {
if (Prop_Hidden(buf))
return 0;
if (Prop_SeeOnly(buf))
return 0;
if (string_prefix(buf, "_msgmacs/"))
return 0;
}
if (val == NULL) {
remove_property(obj, buf, 0);
} else {
add_property(obj, buf, val, 0);
}
return 1;
}
const char *
mfn_lexec(MFUNARGS)
{
dbref trg = (dbref) 0, obj = what;
char *pname;
const char *ptr;
int blessed = 0;
pname = argv[0];
if (argc == 2) {
obj = mesg_dbref(descr, player, what, perms, argv[1], mesgtyp);
}
if (obj == PERMDENIED)
ABORT_MPI("LEXEC", "Permission denied.");
if (obj == UNKNOWN || obj == AMBIGUOUS || obj == NOTHING || obj == HOME)
ABORT_MPI("LEXEC", "Match failed.");
while (*pname == PROPDIR_DELIMITER)
pname++;
ptr = get_concat_list(player, what, perms, obj, (char *)pname, buf, BUFFER_LEN, 2, mesgtyp, &blessed);
if (!ptr)
ptr = "";
trg = what;
if (blessed) {
mesgtyp |= MPI_ISBLESSED;
} else {
mesgtyp &= ~MPI_ISBLESSED;
}
if (Prop_ReadOnly(pname) || Prop_Private(pname) || Prop_SeeOnly(pname) || Prop_Hidden(pname))
trg = obj;
ptr = mesg_parse(descr, player, obj, trg, ptr, buf, BUFFER_LEN, mesgtyp);
CHECKRETURN(ptr, "LEXEC", "listval");
return ptr;
}
int
safeputprop(dbref obj, dbref perms, char *buf, char *val)
{
char *ptr;
if (!buf) return 0;
while (*buf == PROPDIR_DELIMITER) buf++;
if (!*buf) return 0;
if (tp_db_readonly) return 0;
/* disallow CR's and :'s in prop names. */
for (ptr = buf; *ptr; ptr++)
if (*ptr == '\r' || *ptr == PROP_DELIMITER) return 0;
if (!Archperms(perms)) {
if (Prop_Hidden(buf)) return 0;
}
if (!Wizperms(perms)) {
if (Prop_SeeOnly(buf)) return 0;
}
if (!val) {
remove_property(obj, buf);
} else {
add_property(obj, buf, val, 0);
}
return 1;
}
const char *
mfn_showlist(MFUNARGS)
{
dbref obj;
const char *m = NULL;
int lines=0;
if(argc > 1) {
obj = mesg_dbref_mage(player, what, perms, argv[1]);
if (obj == AMBIGUOUS || obj == UNKNOWN || obj == NOTHING || obj == HOME)
ABORT_MPI("SHOWLIST","Match failed");
if (obj == PERMDENIED)
ABORT_MPI("SHOWLIST",NOPERM_MESG);
} else obj = what;
if (Prop_Hidden(argv[0]) && (Permlevel(perms) < tp_hidden_prop_mlevel))
ABORT_MPI("SHOWLIST",NOPERM_MESG);
while ( (lines < MAX_MFUN_LIST_LEN) && (!lines || (m && *m)) ) {
sprintf(buf, "%s#/%d", argv[0], ++lines);
m = safegetprop_strict(player, obj, perms, buf);
if( m && *m ) {
notify_nolisten(player, m, 1);
}
}
buf[0] = '\0';
return buf;
}
int
prop_write_perms(dbref player, dbref obj, const char *name, int mlev)
{
if (Prop_System(name))
return 0;
if (mlev < 3) {
if (!permissions(player, obj)) {
if (Prop_Private(name))
return 0;
if (Prop_ReadOnly(name))
return 0;
if (!string_compare(name, "sex"))
return 0;
}
if (string_prefix(name, "_msgmacs/"))
return 0;
}
if (mlev < 4) {
if (Prop_SeeOnly(name))
return 0;
if (Prop_Hidden(name))
return 0;
}
return 1;
}
const char *
safegetprop_strict(dbref player, dbref what, dbref perms, const char *inbuf)
{
const char *ptr;
char bbuf[BUFFER_LEN];
static char vl[32];
if (!inbuf) {
notify_nolisten(player, "PropFetch: Propname required.", 1);
return NULL;
}
while (*inbuf == PROPDIR_DELIMITER)
inbuf++;
if (!*inbuf) {
notify_nolisten(player, "PropFetch: Propname required.", 1);
return NULL;
}
strcpy(bbuf, inbuf);
ptr = get_property_class(what, bbuf);
if (!ptr) {
int i;
i = get_property_value(what, bbuf);
if (!i) {
dbref dd;
dd = get_property_dbref(what, bbuf);
if (dd == NOTHING) {
*vl = '\0';
ptr = vl;
return ptr;
} else {
sprintf(vl, "#%d", dd);
ptr = vl;
}
} else {
sprintf(vl, "%d", i);
ptr = vl;
}
}
#ifdef COMPRESS
ptr = uncompress(ptr);
#endif
if (!Wizperms(perms)) {
if (Prop_Hidden(bbuf)) {
notify_nolisten(player, "PropFetch: Permission denied.", 1);
return NULL;
}
// if (Prop_Private(bbuf) && OWNER(perms) != OWNER(what)) {
if (Prop_Private(bbuf) && !controls_nowizperm(OWNER(perms), what)) {
notify_nolisten(player, "PropFetch: Permission denied.", 1);
return NULL;
}
}
return ptr;
}
int
blessprops_wildcard(dbref player, dbref thing, const char *dir, const char *wild, int blessp)
{
char propname[BUFFER_LEN];
char wld[BUFFER_LEN];
char buf[BUFFER_LEN];
char buf2[BUFFER_LEN];
char *ptr, *wldcrd = wld;
PropPtr propadr, pptr;
int i, cnt = 0;
int recurse = 0;
#ifdef GOD_PRIV
if(tp_strict_god_priv && !God(player) && God(OWNER(thing))) {
notify(player,"Only God may touch what is God's.");
return 0;
}
#endif
strcpyn(wld, sizeof(wld), wild);
i = strlen(wld);
if (i && wld[i - 1] == PROPDIR_DELIMITER)
strcatn(wld, sizeof(wld), "*");
for (wldcrd = wld; *wldcrd == PROPDIR_DELIMITER; wldcrd++) ;
if (!strcmp(wldcrd, "**"))
recurse = 1;
for (ptr = wldcrd; *ptr && *ptr != PROPDIR_DELIMITER; ptr++) ;
if (*ptr)
*ptr++ = '\0';
propadr = first_prop(thing, (char *) dir, &pptr, propname, sizeof(propname));
while (propadr) {
if (equalstr(wldcrd, propname)) {
snprintf(buf, sizeof(buf), "%s%c%s", dir, PROPDIR_DELIMITER, propname);
if (!Prop_System(buf) && ((!Prop_Hidden(buf) && !(PropFlags(propadr) & PROP_SYSPERMS))
|| Wizard(OWNER(player)))) {
if (!*ptr || recurse) {
cnt++;
if (blessp) {
set_property_flags(thing, buf, PROP_BLESSED);
snprintf(buf2, sizeof(buf2), "Blessed %s", buf);
} else {
clear_property_flags(thing, buf, PROP_BLESSED);
snprintf(buf2, sizeof(buf2), "Unblessed %s", buf);
}
notify(player, buf2);
}
if (recurse)
ptr = "**";
cnt += blessprops_wildcard(player, thing, buf, ptr, blessp);
}
}
propadr = next_prop(pptr, propadr, propname, sizeof(propname));
}
return cnt;
}
int
prop_read_perms(dbref player, dbref obj, const char *name, int mlev)
{
if (Prop_System(name))
return 0;
if ((mlev < 3) && Prop_Private(name) && !permissions(player, obj))
return 0;
if ((mlev < 4) && Prop_Hidden(name))
return 0;
return 1;
}
const char *
mfn_dirprops(MFUNARGS)
{
char propname[BUFFER_LEN];
PropPtr propadr, pptr;
char buf2[BUFFER_LEN];
int list_limit = MAX_MFUN_LIST_LEN;
dbref obj;
int outlen, nextlen;
if(argc > 1) {
obj = mesg_dbref_local(player, what, perms, argv[1]);
if (obj == AMBIGUOUS || obj == UNKNOWN || obj == NOTHING || obj == HOME)
ABORT_MPI("DIRPROPS","Match failed");
if (obj == PERMDENIED)
ABORT_MPI("DIRPROPS",NOPERM_MESG);
} else obj = what;
buf[0] = '\0';
outlen = 0;
#ifdef DISKBASE
fetchprops(obj);
#endif
propadr = first_prop(obj, argv[0], &pptr, propname);
while ((propadr > 0) && *propname) {
if ( ( !Prop_Hidden(propname) && !(PropFlags(propadr) & PROP_SYSPERMS))
|| (Permlevel(perms) >= tp_hidden_prop_mlevel)) {
sprintf(buf2, "%s", propname);
nextlen = strlen(buf2);
if ((outlen + nextlen) >= (BUFFER_LEN - 3))
break;
if (outlen) strcat((buf+(outlen++)), "\r");
strcat((buf + outlen), buf2);
outlen += nextlen;
list_limit--;
}
propadr = next_prop(pptr, propadr, propname);
}
return buf;
}
const char *
mfn_timesub(MFUNARGS)
{
int num = 0;
dbref trg = (dbref) 0, obj = what;
const char *pname, *ptr;
int period = 0, offset = 0;
int blessed = 0;
period = atoi(argv[0]);
offset = atoi(argv[1]);
pname = argv[2];
if (argc == 4) {
obj = mesg_dbref(descr, player, what, perms, argv[3], mesgtyp);
}
if (obj == PERMDENIED)
ABORT_MPI("TIMESUB", "Permission denied.");
if (obj == UNKNOWN || obj == AMBIGUOUS || obj == NOTHING || obj == HOME)
ABORT_MPI("TIMESUB", "Match failed.");
num = get_list_count(what, obj, perms, (char *)pname, mesgtyp, &blessed);
if (!num)
ABORT_MPI("TIMESUB", "Failed list read.");
if (period < 1)
ABORT_MPI("TIMESUB", "Time period too short.");
offset = (int)((((long) time(NULL) + offset) % period) * num) / period;
if (offset < 0)
offset = -offset;
ptr = get_list_item(what, obj, perms, (char *)pname, offset + 1, mesgtyp, &blessed);
if (!ptr)
ABORT_MPI("TIMESUB", "Failed list read.");
trg = what;
if (blessed) {
mesgtyp |= MPI_ISBLESSED;
} else {
mesgtyp &= ~MPI_ISBLESSED;
}
if (Prop_ReadOnly(ptr) || Prop_Private(ptr) || Prop_SeeOnly(ptr) || Prop_Hidden(ptr))
trg = obj;
ptr = mesg_parse(descr, player, obj, trg, ptr, buf, BUFFER_LEN, mesgtyp);
CHECKRETURN(ptr, "TIMESUB", "listval");
return ptr;
}
const char *
mfn_indexbang(MFUNARGS)
{
dbref trg = (dbref) 0, obj = what;
dbref tmpobj = (dbref) 0;
const char *pname, *ptr;
int blessed = 0;
pname = argv[0];
if (argc == 2) {
obj = mesg_dbref(descr, player, what, perms, argv[1], mesgtyp);
}
if (obj == UNKNOWN || obj == AMBIGUOUS || obj == NOTHING || obj == HOME)
ABORT_MPI("INDEX!", "Match failed.");
if (obj == PERMDENIED)
ABORT_MPI("INDEX!", "Permission denied.");
tmpobj = obj;
ptr = safegetprop_strict(player, obj, perms, pname, mesgtyp, &blessed);
if (!ptr)
ABORT_MPI("INDEX!", "Failed read.");
if (!*ptr)
return "";
obj = tmpobj;
ptr = safegetprop_strict(player, obj, perms, ptr, mesgtyp, &blessed);
if (!ptr)
ABORT_MPI("INDEX!", "Failed read.");
trg = what;
if (blessed) {
mesgtyp |= MPI_ISBLESSED;
} else {
mesgtyp &= ~MPI_ISBLESSED;
}
if (Prop_ReadOnly(ptr) || Prop_Private(ptr) || Prop_SeeOnly(ptr) || Prop_Hidden(ptr))
trg = obj;
ptr = mesg_parse(descr, player, obj, trg, ptr, buf, BUFFER_LEN, mesgtyp);
CHECKRETURN(ptr, "INDEX!", "listval");
return ptr;
}
void
remove_proplist_item(dbref player, PropPtr p, int allp)
{
const char *ptr;
/* if( tp_db_readonly ) return; *//* Why did we remove this? */
if (!p)
return;
ptr = PropName(p);
if (!allp) {
if (Prop_SeeOnly(ptr))
return;
if (Prop_Hidden(ptr))
return;
if (ptr[0] == '_' && ptr[1] == '\0')
return;
if (PropFlags(p) & PROP_SYSPERMS)
return;
}
/* notify(player, ptr); *//* Why did we put this here? */
remove_property(player, ptr);
}
const char *
mfn_listprops(MFUNARGS)
{
dbref obj = what;
char *ptr, *pname;
char *endbuf, *pattern;
char tmpbuf[BUFFER_LEN];
char patbuf[BUFFER_LEN];
char pnamebuf[BUFFER_LEN];
int flag;
strcpyn(pnamebuf, sizeof(pnamebuf), argv[0]);
pname = pnamebuf;
if (argc > 1) {
obj = mesg_dbref(descr, player, what, perms, argv[1], mesgtyp);
}
if (obj == UNKNOWN || obj == AMBIGUOUS || obj == NOTHING || obj == HOME)
ABORT_MPI("LISTPROPS", "Match failed.");
if (obj == PERMDENIED)
ABORT_MPI("LISTPROPS", "Permission denied.");
if (argc > 2) {
pattern = argv[2];
} else {
pattern = NULL;
}
endbuf = pname + strlen(pname);
if (endbuf != pname) {
endbuf--;
}
if (*endbuf != PROPDIR_DELIMITER && (endbuf - pname) < (BUFFER_LEN - 2)) {
if (*endbuf != '\0')
endbuf++;
*endbuf++ = PROPDIR_DELIMITER;
*endbuf++ = '\0';
}
*buf = '\0';
endbuf = buf;
do {
ptr = next_prop_name(obj, tmpbuf, (int) sizeof(tmpbuf), pname);
if (ptr && *ptr) {
flag = 1;
if (Prop_System(ptr)) {
flag = 0;
} else if (!(mesgtyp & MPI_ISBLESSED)) {
if (Prop_Hidden(ptr)) {
flag = 0;
}
if (Prop_Private(ptr) && OWNER(what) != OWNER(obj)) {
flag = 0;
}
if (obj != player && OWNER(obj) != OWNER(what)) {
flag = 0;
}
}
if ((flag != 0) && (pattern != NULL)) {
char *nptr;
nptr = rindex(ptr, PROPDIR_DELIMITER);
if (nptr && *nptr) {
strcpyn(patbuf, sizeof(patbuf), ++nptr);
if (!equalstr(pattern, patbuf)) {
flag = 0;
}
}
}
if (flag) {
int entrylen = strlen(ptr);
if ((endbuf - buf) + entrylen + 2 < BUFFER_LEN) {
if (*buf != '\0') {
*endbuf++ = '\r';
}
strcpyn(endbuf, BUFFER_LEN - (endbuf - buf), ptr);
endbuf += entrylen;
}
}
}
pname = ptr;
} while (ptr && *ptr);
return buf;
}
const char *
safegetprop_strict(dbref player, dbref what, dbref perms, const char *inbuf, int mesgtyp, int* blessed)
{
const char *ptr;
char bbuf[BUFFER_LEN];
static char vl[32];
*blessed = 0;
if (!inbuf) {
notify_nolisten(player, "PropFetch: Propname required.", 1);
return NULL;
}
while (*inbuf == PROPDIR_DELIMITER)
inbuf++;
if (!*inbuf) {
notify_nolisten(player, "PropFetch: Propname required.", 1);
return NULL;
}
strcpyn(bbuf, sizeof(bbuf), inbuf);
if (Prop_System(bbuf))
{
notify_nolisten(player, "PropFetch: Permission denied.", 1);
return NULL;
}
if (!(mesgtyp & MPI_ISBLESSED)) {
if (Prop_Hidden(bbuf)) {
notify_nolisten(player, "PropFetch: Permission denied.", 1);
return NULL;
}
if (Prop_Private(bbuf) && OWNER(perms) != OWNER(what)) {
notify_nolisten(player, "PropFetch: Permission denied.", 1);
return NULL;
}
}
ptr = get_property_class(what, bbuf);
if (!ptr) {
int i;
i = get_property_value(what, bbuf);
if (!i) {
dbref dd;
dd = get_property_dbref(what, bbuf);
if (dd == NOTHING) {
*vl = '\0';
ptr = vl;
return ptr;
} else {
snprintf(vl, sizeof(vl), "#%d", dd);
ptr = vl;
}
} else {
snprintf(vl, sizeof(vl), "%d", i);
ptr = vl;
}
}
if (ptr) {
if (Prop_Blessed(what, bbuf)) {
*blessed = 1;
}
}
return ptr;
}
