blob: 84e0b78ee1acdcc80e30b8aee790050e955384e2 [file] [log] [blame]
// MorgenGrauen MUDlib
//
// simul_efun.c -- simul efun's
//
// $Id: simul_efun.c 7408 2010-02-06 00:27:25Z Zesstra $
#pragma strict_types,save_types,rtt_checks
#pragma no_clone,no_shadow,no_inherit
#pragma pedantic,range_check,warn_deprecated
#pragma warn_empty_casts,warn_missing_return,warn_function_inconsistent
// Absolute Pfade erforderlich - zum Zeitpunkt, wo der Master geladen
// wird, sind noch keine Include-Pfade da ...
#define SNOOPLOGFILE "SNOOP"
#define ASNOOPLOGFILE "ARCH/SNOOP"
#include "/secure/config.h"
#include "/secure/wizlevels.h"
#include "/sys/snooping.h"
#include "/sys/language.h"
#include "/sys/thing/properties.h"
#include "/sys/wizlist.h"
#include "/sys/erq.h"
#include "/sys/lpctypes.h"
#include "/sys/daemon.h"
#include "/sys/player/base.h"
#include "/sys/thing/description.h"
#include "/sys/container.h"
#include "/sys/defines.h"
#include "/sys/telnet.h"
#include "/sys/objectinfo.h"
#include "/sys/files.h"
#include "/sys/strings.h"
#include "/sys/time.h"
#include "/sys/lpctypes.h"
#include "/sys/notify_fail.h"
#include "/sys/tls.h"
#include "/sys/input_to.h"
#include "/sys/object_info.h"
/* function prototypes
*/
string dtime(int wann);
varargs int log_file(string file, string txt, int size_to_break);
int query_wiz_level(mixed player);
nomask varargs int snoop(object me, object you);
varargs string country(mixed ip, string num);
int query_wiz_grp(mixed wiz);
public varargs object deep_present(mixed what, object ob);
nomask int secure_level();
nomask string secure_euid();
public nomask int process_call();
nomask mixed __create_player_dummy(string name);
varargs string replace_personal(string str, mixed *obs, int caps);
//replacements for dropped efuns in LD
#if !__EFUN_DEFINED__(extract)
varargs string extract(string str, int from, int to);
#endif
#if !__EFUN_DEFINED__(slice_array)
varargs mixed slice_array(mixed array, int from, int to);
#endif
#if !__EFUN_DEFINED__(member_array)
int member_array(mixed item, mixed arraystring);
#endif
// Include the different sub 'modules' of the simul_efun
#include __DIR__"debug_info.c"
#include __DIR__"enable_commands.c"
#include __DIR__"hash.c"
#include __DIR__"object_info.c"
#include __DIR__"query_editing.c"
#include __DIR__"query_idle.c"
#include __DIR__"query_input_pending.c"
#include __DIR__"query_ip_name.c"
#include __DIR__"query_limits.c"
#include __DIR__"query_load_average.c"
#include __DIR__"query_mud_port.c"
#include __DIR__"query_once_interactive.c"
#include __DIR__"query_snoop.c"
#include __DIR__"set_heart_beat.c"
#if __BOOT_TIME__ < 1456261859
#include __DIR__"set_prompt.c"
#endif
#include __DIR__"shadow.c"
#include __DIR__"livings.c"
#include __DIR__"comm.c"
#define TO efun::this_object()
#define TI efun::this_interactive()
#define TP efun::this_player()
#define PO efun::previous_object(0)
#define LEVEL(x) query_wiz_level(x)
#define NAME(x) capitalize(getuid(x))
#define DEBUG(x) if (find_player("zesstra")) \
tell_object(find_player("zesstra"),x)
mixed dtime_cache = ({-1,""});
#ifdef IOSTATS
struct iostat_s {
string oname;
int time;
int size;
};
mixed saveo_stat = ({ 0,allocate(200, 0) });
mixed restoreo_stat = ({ 0,allocate(200,0) });
//mixed writefile_stat = ({ 0,allocate(100,(<iostat_s>)) });
//mixed readfile_stat = ({ 0,allocate(100,(<iostat_s>)) });
//mixed log_stat = ({ 0,allocate(100,(<iostat_s>)) });
mixed ___iostats(int type) {
switch(type) {
case 1:
return saveo_stat;
case 2:
return restoreo_stat;
/* case 3:
return writefile_stat;
case 4:
return readfile_stat;
case 5:
return log_stat;
*/
}
return 0;
}
#endif
// Nicht jeder Magier muss die simul_efun entsorgen koennen.
string NotifyDestruct(object caller) {
if( (caller!=this_object() && !ARCH_SECURITY) || process_call() ) {
return "Du darfst das simul_efun Objekt nicht zerstoeren!\n";
}
return 0;
}
public nomask void remove_interactive( object ob )
{
if ( objectp(ob) && previous_object()
&& object_name(previous_object())[0..7] != "/secure/"
&& ((previous_object() != ob
&& (ob != this_player() || ob != this_interactive()))
|| (previous_object() == ob
&& (this_player() && this_player() != ob
|| this_interactive() && this_interactive() != ob)) ) )
log_file( "PLAYERDEST",
sprintf( "%s: %O ausgeloggt von PO %O, TI %O, TP %O\n",
dtime(time()), ob, previous_object(),
this_interactive(), this_player() ) );
efun::remove_interactive(ob);
}
void ___updmaster()
{
object ob;
//sollte nicht jeder duerfen.
if (process_call() || !ARCH_SECURITY)
raise_error("Illegal use of ___updmaster()!");
write("Removing old master ... ");
foreach(string file:
get_dir("/secure/master/*.c",GETDIR_NAMES|GETDIR_UNSORTED|GETDIR_PATH)) {
if (ob = find_object(file))
efun::destruct(ob);
}
efun::destruct(efun::find_object("/secure/master"));
write("done.\nLoading again ... ");
load_object("/secure/master");
write("done.\n");
}
varargs string country(mixed ip, string num) {
mixed ret;
if(ret = (string)"/p/daemon/iplookup"->country(num || ip)) {
return ret;
} else return "???";
}
// * Snoopen und was dazugehoert
static object find_snooped(object who)
{
object *u;
int i;
for (i=sizeof(u=users())-1;i>=0;i--)
if (who==efun::interactive_info(u[i], II_SNOOP_NEXT))
return u[i];
return 0;
}
private string Lcut(string str) {
return str[5..11]+str[18..];
}
nomask varargs int snoop( object me, object you )
{
int ret;
object snooper0, snooper, snooper2, snooper3;
if( !objectp(me) || me == you || !PO )
return 0;
snooper0 = find_snooped(me);
if(you){
if ( PO != me && query_wiz_grp(me) >= query_wiz_grp(geteuid(PO)) )
return 0;
if ( query_wiz_grp(me) <= query_wiz_grp(you) &&
!(you->QueryAllowSnoop(me)) )
if ( !IS_DEPUTY(me) || IS_ARCH(you) )
return 0;
if ( (snooper = efun::interactive_info(you, II_SNOOP_NEXT)) &&
query_wiz_grp(snooper) >= query_wiz_grp(me) ){
if ( (int)snooper->QueryProp(P_SNOOPFLAGS) & SF_LOCKED )
return 0;
tell_object( snooper, sprintf( "%s snooped jetzt %s.\n",
me->name(WER), you->name(WER) ) );
snooper2 = me;
while ( snooper3 = interactive_info(snooper2, II_SNOOP_NEXT) ){
tell_object( snooper,
sprintf( "%s wird seinerseits von %s gesnooped.\n"
,snooper2->name(WER),
snooper3->name(WEM) ) );
snooper2 = snooper3;
}
efun::snoop( snooper, snooper2 );
if ( efun::interactive_info(snooper2, II_SNOOP_NEXT) != snooper )
tell_object( snooper, sprintf( "Du kannst %s nicht snoopen.\n",
snooper2->name(WEN) ) );
else{
tell_object( snooper, sprintf( "Du snoopst jetzt %s.\n",
snooper2->name(WEN) ) );
if ( !IS_DEPUTY(snooper) ){
log_file( SNOOPLOGFILE, sprintf("%s: %O %O %O\n",
dtime(time()),
snooper,
snooper2,
environment(snooper2) ),
100000 );
if (snooper0)
CHMASTER->send( "Snoop", snooper,
sprintf( "%s *OFF* %s (%O)",
capitalize(getuid(snooper)),
capitalize(getuid(snooper0)),
environment(snooper0) ) );
CHMASTER->send( "Snoop", snooper,
sprintf("%s -> %s (%O)",
capitalize(getuid(snooper)),
capitalize(getuid(snooper2)),
environment(snooper2)));
}
else{
log_file( ASNOOPLOGFILE, sprintf( "%s: %O %O %O\n",
dtime(time()),
snooper,
snooper2,
environment(snooper2) )
,100000 );
}
}
}
else
if (snooper)
if ( !me->QueryProp(P_SNOOPFLAGS) & SF_LOCKED ){
printf( "%s wird bereits von %s gesnooped. Benutze das "
"\"f\"-Flag, wenn du dennoch snoopen willst.\n",
you->name(WER), snooper->name(WEM) );
return 0;
}
ret = efun::snoop( me, you );
if ( !IS_DEPUTY(me) && efun::interactive_info(you, II_SNOOP_NEXT) == me){
log_file( SNOOPLOGFILE, sprintf( "%s: %O %O %O\n",
Lcut(dtime(time())),
me, you, environment(you) ),
100000 );
if (snooper0)
CHMASTER->send( "Snoop", me,
sprintf( "%s *OFF* %s (%O).",
capitalize(getuid(me)),
capitalize(getuid(snooper0)),
environment(snooper0) ) );
CHMASTER->send( "Snoop", me, sprintf( "%s -> %s (%O).",
capitalize(getuid(me)),
capitalize(getuid(you)),
environment(you) ) );
}
else{
if ( efun::interactive_info(you, II_SNOOP_NEXT) == me ){
log_file( ASNOOPLOGFILE, sprintf( "%s: %O %O %O\n",
Lcut(dtime(time())),
me, you, environment(you) ),
100000 );
}
}
if ( ret && query_wiz_grp(me) <= query_wiz_grp(you) &&
!IS_DEPUTY(me) )
tell_object( you, "*** " + NAME(me) + " snoopt Dich!\n" );
return ret;
}
else {
if ( (me == PO ||
query_wiz_grp(geteuid(PO)) > query_wiz_grp(me) ||
(query_wiz_grp(geteuid(PO)) == query_wiz_grp(me) &&
efun::interactive_info(PO, II_SNOOP_NEXT) == me)) && snooper0 ){
if ( !IS_DEPUTY(me) ){
log_file( SNOOPLOGFILE, sprintf( "%s: %O %O %O *OFF*\n",
Lcut(dtime(time())), me,
snooper0,
environment(snooper0) ),
100000 );
CHMASTER->send( "Snoop", me,
sprintf( "%s *OFF* %s (%O).",
capitalize(getuid(me)),
capitalize(getuid(snooper0)),
environment(snooper0) ) );
}
else{
log_file( ASNOOPLOGFILE, sprintf( "%s: %O %O %O *OFF*\n",
Lcut(dtime(time())), me,
snooper0,
environment(snooper0) ),
100000 );
}
return efun::snoop(me);
}
}
return 0;
}
// * Emulation des 'alten' explode durch das neue
string *old_explode(string str, string del) {
int s, t;
string *strs;
if (!stringp(str)) {
set_this_object(previous_object());
raise_error(sprintf(
"Invalid argument 1 to old_explode()! Expected <string>, got: "
"%.30O\n",str));
}
if (!stringp(del)) {
set_this_object(previous_object());
raise_error(sprintf(
"Invalid argument 2 to old_explode()! Expected <string>, got: "
"%.30O\n",del));
}
if(del == "")
return ({str});
strs=efun::explode(str, del);
t=sizeof(strs)-1;
while(s<=t && strs[s++] == "");s--;
while(t>=0 && strs[t--] == "");t++;
if(s<=t)
return strs[s..t];
return ({});
}
int file_time(string path) {
mixed *v;
set_this_object(previous_object());
if (sizeof(v=get_dir(path,GETDIR_DATES))) return v[0];
return(0); //sonst
}
// * Bei 50k Groesse Log-File rotieren
varargs int log_file(string file, string txt, int size_to_break) {
mixed *st;
file="/log/"+file;
file=implode((efun::explode(file,"/")-({".."})),"/");
// tell_object(find_player("jof"),sprintf("LOG FILE: %O -> %O\n",previous_object(),file));
if (!funcall(bind_lambda(#'efun::call_other,PO),"secure/master",//')
"valid_write",file,geteuid(PO),"log_file",PO))
return 0;
if ( size_to_break >= 0 & (
sizeof(st = get_dir(file,2) ) && st[0] >= (size_to_break|MAX_LOG_SIZE)))
catch(rename(file, file + ".old");publish); /* No panic if failure */
return(write_file(file,txt));
}
// * Magier-Level abfragen
int query_wiz_level(mixed player) {
return (int)"/secure/master"->query_wiz_level(player);
}
#ifdef __ALISTS__
// * Element aus Alist loeschen (by key)
mixed *remove_alist(mixed key,mixed *alist)
{
int i,j;
if (!pointerp(alist) || !sizeof(alist))
return alist;
if (!pointerp(alist[0]))
{
if ((i=assoc(key,alist))<0)
return alist;
return alist[0..i-1]+alist[i+1..];
}
i = assoc(key,alist[0]);
if ((i=assoc(key,alist[0]))<0)
return alist;
alist=alist[0..];
for (j=sizeof(alist)-1;j>=0;j--)
alist[j]=alist[j][0..i-1]+alist[j][i+1..];
return alist;
}
// * Element aus Alist loeschen (by pos)
mixed *exclude_alist(int i,mixed *alist)
{
int j;
if (!pointerp(alist) || !sizeof(alist) || i<0)
return alist;
if (!pointerp(alist[0]))
return alist[0..i-1]+alist[i+1..];
alist=alist[0..]; /* Create PHYSICAL copy of alist */
for (j=sizeof(alist)-1;j>=0;j--)
alist[j]=alist[j][0..i-1]+alist[j][i+1..];
return alist; /* order_alist is NOT necessary - see /doc/LPC/alist */
}
#endif // __ALISTS__
// * German version of ctime()
#define TAGE ({"Son","Mon","Die","Mit","Don","Fre","Sam"})
#define MONATE ({"Jan","Feb","Mar","Apr","Mai","Jun","Jul","Aug",\
"Sep","Okt","Nov","Dez"})
string dtime(int wann) {
if (wann == dtime_cache[0])
return(dtime_cache[1]);
int *lt = localtime(wann);
return sprintf("%s, %2d. %s %d, %02d:%02d:%02d",
TAGE[lt[TM_WDAY]], lt[TM_MDAY], MONATE[lt[TM_MON]],
lt[TM_YEAR],lt[TM_HOUR], lt[TM_MIN], lt[TM_SEC]);
}
// wenn strftime im Driver nicht existiert, ist dies hier ein Alias auf dtime(),
// zwar stimmt das Format dann nicht, aber die Mudlib buggt nicht und schreibt
// ein ordentliches Datum/Uhrzeit.
#if !__EFUN_DEFINED__(strftime)
varargs string strftime(mixed fmt, int clock, int localized) {
if (intp(clock) && clock >= 0)
return dtime(clock);
else if (intp(fmt) && fmt >= 0)
return dtime(fmt);
return dtime(time());
}
#endif //!__EFUN_DEFINED__(strftime)
// * Shutdown mit zusaetzlichem logging
nomask int shutdown(string reason)
{
string name;
string obname;
string output;
if (!reason)
return 0;
if ( !ARCH_SECURITY && getuid(previous_object())!=ROOTID &&
object_name(previous_object())!="/obj/shut" )
{
write("You have no permission to shut down the gamedriver!\n");
return 0;
}
if ((this_interactive())&&(name=getuid(this_interactive())))
{
name=capitalize(name);
filter(users(),#'tell_object,//'
capitalize(name)+" faehrt das Spiel herunter!\n");
}
else
name="ANONYMOUS";
if (previous_object()) obname=capitalize(getuid(previous_object()));
output=name;
if (obname && name!=obname) output=output+" ("+obname+")";
if (previous_object()&&object_name(previous_object())=="/obj/shut"){
output+=" faehrt das Spiel via Armageddon herunter.\n";
output=dtime(time())+": "+output;
log_file("GAME_LOG",output+"\n",-1);
efun::shutdown();
return 1;
}
output=ctime(time())+": "+output+" faehrt das Spiel herunter.\n";
output+=" Grund: "+reason;
log_file("GAME_LOG",output+"\n",-1);
efun::shutdown();
return 1;
}
// * lowerchar
int lowerchar(int char) {
if (char<'A' || char>'Z') return char;
return char+32;
}
// * upperstring
string upperstring(string s)
{
#if __EFUN_DEFINED__(upper_case)
return(upper_case(s));
#else
int i;
if (!stringp(s)) return 0;
for (i=sizeof(s)-1;i>=0;i--) s[i]=((s[i]<'a'||s[i]>'z')?s[i]:s[i]-32);
return s;
#endif
}
// * lowerstring
string lowerstring(string s)
{
if (!stringp(s)) return 0;
return lower_case(s);
}
// * GD version
string version()
{
return __VERSION__;
}
// * break_string
// stretch() -- stretch a line to fill a given width
private string stretch(string s, int width) {
int len=sizeof(s);
if (len==width) return s;
// reine Leerzeilen, direkt zurueckgeben
string trimmed=trim(s,TRIM_LEFT," ");
if (trimmed=="") return s;
int start_spaces = len - sizeof(trimmed);
string* words = explode(trimmed, " ");
// der letzte kriegt keine Spaces
int word_count=sizeof(words) - 1;
// wenn Zeile nur aus einem Wort, wird das Wort zurueckgegeben
if (!word_count)
return " "*start_spaces + words[0];
int space_count = width - len;
int space_per_word=(word_count+space_count) / word_count;
// Anz.Woerter mit Zusatz-Space
int rest=(word_count+space_count) % word_count;
// Rest-Spaces Verteilen
foreach (int pos : rest) words[pos]+=" ";
return (" "*start_spaces) + implode( words, " "*space_per_word );
}
// aus Geschwindigkeitsgruenden hat der Blocksatz fuer break_string eine
// eigene Funktion bekommen:
private varargs string block_string(string s, int width, int flags) {
// wenn BS_LEAVE_MY_LFS, aber kein BS_NO_PARINDENT, dann werden Zeilen mit
// einem Leerzeichen begonnen.
// BTW: Wenn !BS_LEAVE_MY_LFS, hat der Aufrufer bereits alle \n durch " "
// ersetzt.
if ( (flags & BS_LEAVE_MY_LFS)
&& !(flags & BS_NO_PARINDENT))
{
s = " "+regreplace(s,"\n","\n ",1);
}
// sprintf fuellt die letzte Zeile auf die Feldbreite (hier also
// Zeilenbreite) mit Fuellzeichen auf, wenn sie NICHT mit \n umgebrochen
// ist. Es wird an die letzte Zeile aber kein Zeilenumbruch angehaengt.
// Eigentlich ist das Auffuellen doof, aber vermutlich ist es unnoetig, es
// wieder rueckgaengig zu machen.
s = sprintf( "%-*=s", width, s);
string *tmp=explode(s, "\n");
// Nur wenn s mehrzeilig ist, Blocksatz draus machen. Die letzte Zeile wird
// natuerlich nicht gedehnt. Sie ist dafuer schon von sprintf() aufgefuellt
// worden. BTW: Die letzte Zeile endet u.U. noch nicht mit einem \n (bzw.
// nur dann, wenn BS_LEAVE_MY_LFS und der uebergebene Text schon nen \n am
// Ende der letzten Zeile hat), das macht der Aufrufer...
if (sizeof(tmp) > 1)
return implode( map( tmp[0..<2], #'stretch/*'*/, width ), "\n" )
+ "\n" + tmp[<1];
return s;
}
public varargs string break_string(string s, int w, mixed indent, int flags)
{
if ( !s || s == "" ) return "";
if ( !w ) w=78;
if( intp(indent) )
indent = indent ? " "*indent : "";
int indentlen=stringp(indent) ? sizeof(indent) : 0;
if (indentlen>w) {
set_this_object(previous_object());
raise_error(sprintf("break_string: indent longer %d than width %d\n",
indentlen,w));
// w=((indentlen/w)+1)*w;
}
if (!(flags & BS_LEAVE_MY_LFS))
s=regreplace( s, "\n", " ", 1 );
if ( flags & BS_SINGLE_SPACE )
s = regreplace( s, "(^|\n| ) *", "\\1", 1 );
string prefix="";
if (indentlen && flags & BS_PREPEND_INDENT) {
if (indentlen+sizeof(s) > w ||
(flags & BS_LEAVE_MY_LFS) && strstr(s,"\n")>-1) {
prefix=indent+"\n";
indent=(flags & BS_NO_PARINDENT) ? "" : " ";
indentlen=sizeof(indent);
}
}
if ( flags & BS_BLOCK ) {
/*
s = implode( map( explode( s, "\n" ),
#'block_string, w, indentlen, flags),
"" );
*/
s = block_string( s , w - indentlen, flags );
}
else {
s = sprintf("%-1.*=s",w-indentlen,s);
}
if ( s[<1] != '\n' ) s += "\n";
if ( !indentlen ) return prefix + s;
string indent2 = ( flags & BS_INDENT_ONCE ) ? (" "*indentlen) :indent;
return prefix + indent +
regreplace( s[0..<2], "\n", "\n"+indent2, 1 ) + "\n";
/*
string *buf;
buf = explode( s, "\n" );
return prefix + indent + implode( buf[0..<2], "\n"+indent2 ) + buf[<1] + "\n";
*/
}
// * Elemente aus mapping loeschen - mapping vorher kopieren
mapping m_copy_delete(mapping m, mixed key) {
return m_delete(copy(m), key);
}
// * times
int last_reboot_time()
{
return __BOOT_TIME__;
}
int first_boot_time()
{
return 701517600;
}
int exist_days()
{
return (((time()-first_boot_time())/8640)+5)/10;
}
// * uptime :)
string uptime()
{
int t;
int tmp;
string s;
t=time()-__BOOT_TIME__;
s="";
if (t>=86400)
s+=sprintf("%d Tag%s, ",tmp=t/86400,(tmp==1?"":"e"));
if (t>=3600)
s+=sprintf("%d Stunde%s, ",tmp=(t=t%86400)/3600,(tmp==1?"":"n"));
if (t>60)
s+=sprintf("%d Minute%s und ",tmp=(t=t%3600)/60,(tmp==1?"":"n"));
return s+sprintf("%d Sekunde%s",t=t%60,(t==1?"":"n"));
}
// * Was tun bei 'dangling' lfun-closures ?
void dangling_lfun_closure() {
raise_error("dangling lfun closure\n");
}
// * Sperren ausser fuer master/simul_efun
#if __EFUN_DEFINED__(set_environment)
nomask void set_environment(object o1, object o2) {
raise_error("Available only for root\n");
}
#endif
nomask void set_this_player(object pl) {
raise_error("Available only for root\n");
}
#if __EFUN_DEFINED__(export_uid)
nomask void export_uid(object ob) {
raise_error("Available only for root\n");
}
#endif
// * Jetzt auch closures
int process_flag;
public nomask int process_call()
{
if (process_flag>0)
return process_flag;
else return(0);
}
private nomask string _process_string(string str,object po) {
set_this_object(po);
return(efun::process_string(str));
}
nomask string process_string( mixed str )
{
string tmp, err;
int flag;
if ( closurep(str) ) {
set_this_object( previous_object() );
return funcall(str);
}
else if (str==0)
return((string)str);
else if ( !stringp(str) ) {
return to_string(str);
}
if ( !(flag = process_flag > time() - 60))
process_flag=time();
err = catch(tmp = funcall(#'_process_string,str,previous_object()); publish);
if ( !flag )
process_flag=0;
if (err) {
// Verarbeitung abbrechen
set_this_object(previous_object());
raise_error(err);
}
return tmp;
}
// 'mkdir -p' - erzeugt eine komplette Hierarchie von Verzeichnissen.
// wenn das Verzeichnis angelegt wurde oder schon existiert, wird 1
// zurueckgeliefert, sonst 0.
// Wirft einen Fehler, wenn das angebene Verzeichnis nicht absolut ist!
public int mkdirp(string dir) {
// wenn es nur keinen fuehrenden / gibt, ist das ein Fehler.
if (strstr(dir, "/") != 0)
raise_error("mkdirp(): Pfad ist nicht absolute.\n");
// cut off trailing /...
if (dir[<1]=='/')
dir = dir[0..<2];
int fstat = file_size(dir);
// wenn es schon existiert, tun wir einfach so, als haetten wir es angelegt.
if (fstat == FSIZE_DIR)
return 1;
// wenn schon ne Datei existiert, geht es nicht.
if (fstat != FSIZE_NOFILE)
return 0;
// wenn es nur einen / gibt (den fuehrenden), dann ist es ein
// toplevel-verzeichnis, was direkt angelegt wird.
if (strrstr(dir,"/")==0) {
return funcall(bind_lambda(#'efun::mkdir, previous_object()), dir);
}
// mkdir() nicht direkt rufen, sondern vorher als closure ans aufrufende
// Objekt binden. Sonst laeuft die Rechtepruefung in valid_write() im Master
// unter der Annahme, dass die simul_efun.c mit ihrer root id was will.
// jetzt rekursiv die Verzeichnishierarchie anlegen. Wenn das erfolgreich
// ist, dann koennen wir jetzt mit mkdir das tiefste Verzeichnis anlegen
if (mkdirp(dir[0..strrstr(dir,"/")-1]) == 1)
return funcall(bind_lambda(#'efun::mkdir, previous_object()), dir);
}
// * Properties ggfs. mitspeichern
mixed save_object(mixed name)
{
mapping properties;
mapping save;
mixed index, res;
int i;
// nur Strings und 0 zulassen
if ((!stringp(name) || !sizeof(name)) &&
(!intp(name) || name!=0)) {
set_this_object(previous_object());
raise_error(sprintf(
"Only non-empty strings and 0 may be used as filename in "
"sefun::save_object()! Argument was %O\n",name));
}
save = m_allocate(0, 2);
properties = (mapping)previous_object()->QueryProperties();
if(mappingp(properties))
{
// delete all entries in mapping properties without SAVE flag!
index = m_indices(properties);
for(i = sizeof(index)-1; i>=0;i--)
{
if(properties[index[i], F_MODE] & SAVE)
{
save[index[i]] = properties[index[i]];
save[index[i], F_MODE] =
properties[index[i], F_MODE] &
(~(SETMNOTFOUND|QUERYMNOTFOUND|QUERYCACHED|SETCACHED));
}
}
}
else save = ([]);
// save object!
previous_object()->_set_save_data(save);
// format: wie definiert in config.h
if (stringp(name))
res = funcall(bind_lambda(#'efun::save_object, previous_object()), name,
__LIB__SAVE_FORMAT_VERSION__);
else
res = funcall(bind_lambda(#'efun::save_object, previous_object()),
__LIB__SAVE_FORMAT_VERSION__);
previous_object()->_set_save_data(0);
#ifdef IOSTATS
// Stats...
struct iostat_s stat = (<iostat_s>);
stat->oname = object_name(previous_object());
stat->time = time();
//stat->size = (int)object_info(previous_object(),OINFO_MEMORY,
// OIM_TOTAL_DATA_SIZE);
if (stringp(name))
stat->size = file_size(name + ".o");
else
stat->sizeof(res);
//debug_message("saveo: "+saveo_stat[0]+"\n");
saveo_stat[1][saveo_stat[0]] = stat;
saveo_stat[0] = (saveo_stat[0] + 1) % sizeof(saveo_stat[1]);
//debug_message("saveo 2: "+saveo_stat[0]+"\n");
#endif
return res;
}
// * Auch Properties laden
int restore_object(string name)
{
int result;
mixed index;
mixed save;
mapping properties;
int i;
closure cl;
// get actual property settings (by create())
properties = (mapping)previous_object()->QueryProperties();
// DEBUG(sprintf("RESTORE %O\n",name));
// restore object
result=funcall(bind_lambda(#'efun::restore_object, previous_object()), name);
//'))
//_get_save_data liefert tatsaechlich mixed zurueck, wenn das auch immer ein
//mapping sein sollte.
save = (mixed)previous_object()->_get_save_data();
if(mappingp(save))
{
index = m_indices(save);
for(i = sizeof(index)-1; i>=0; i--)
{
properties[index[i]] = save[index[i]];
properties[index[i], F_MODE] = save[index[i], F_MODE]
&~(SETCACHED|QUERYCACHED);
}
}
else properties = ([]);
// restore properties
funcall(
bind_lambda(
unbound_lambda(({'arg}), //'})
({#'call_other,({#'this_object}),
"SetProperties",'arg})),//')
previous_object()),properties);
previous_object()->_set_save_data(0);
#ifdef IOSTATS
// Stats...
//debug_message("restoreo: "+restoreo_stat[0]+"\n");
struct iostat_s stat = (<iostat_s>);
stat->oname = object_name(previous_object());
stat->time = time();
//stat->size = (int)object_info(previous_object(),OINFO_MEMORY,
// OIM_TOTAL_DATA_SIZE);
stat->size = file_size(name + ".o");
restoreo_stat[1][restoreo_stat[0]] = stat;
restoreo_stat[0] = (restoreo_stat[0] + 1) % sizeof(restoreo_stat[1]);
#endif
return result;
}
// * HB eines Objektes ein/ausschalten
int set_object_heart_beat(object ob, int flag)
{
if (objectp(ob))
return funcall(bind_lambda(#'efun::configure_object,ob), ob, OC_HEART_BEAT, flag);
}
// * Magierlevelgruppen ermitteln
int query_wiz_grp(mixed wiz)
{
int lev;
lev=query_wiz_level(wiz);
if (lev<SEER_LVL) return 0;
if (lev>=GOD_LVL) return lev;
if (lev>=ARCH_LVL) return ARCH_GRP;
if (lev>=ELDER_LVL) return ELDER_GRP;
if (lev>=LORD_LVL) return LORD_GRP;
if (lev>=SPECIAL_LVL) return SPECIAL_GRP;
if (lev>=DOMAINMEMBER_LVL) return DOMAINMEMBER_GRP;
if (lev>=WIZARD_LVL) return WIZARD_GRP;
if (lev>=LEARNER_LVL) return LEARNER_GRP;
return SEER_GRP;
}
mixed *wizlist_info()
{
if (ARCH_SECURITY || !extern_call())
return efun::wizlist_info();
return 0;
}
// * wizlist ausgeben
varargs void wizlist(string name, int sortkey ) {
if (!name)
{
if (this_player())
name = getuid(this_player());
if (!name)
return;
}
// Schluessel darf nur in einem gueltigen Bereich sein
if (sortkey<WL_NAME || sortkey>=WL_SIZE) sortkey=WL_COST;
mixed** wl = efun::wizlist_info();
// nach <sortkey> sortieren
wl = sort_array(wl, function int (mixed a, mixed b)
{return a[sortkey] < b[sortkey]; } );
// Summe ueber alle Kommandos ermitteln.
int total_cmd, i;
int pos=-1;
foreach(mixed entry : wl)
{
total_cmd += entry[WL_COMMANDS];
if (entry[WL_NAME] == name)
pos = i;
++i;
}
if (pos < 0 && name != "ALL" && name != "TOP100")
return;
if (name == "TOP100")
{
if (sizeof(wl) > 100)
wl = wl[0..100];
else
wl = wl;
}
// um name herum schneiden
else if (name != "ALL")
{
if (sizeof(wl) <= 21)
wl = wl;
else if (pos + 10 < sizeof(wl) && pos - 10 > 0)
wl = wl[pos-10..pos+10];
else if (pos <=21)
wl = wl[0..20];
else if (pos >= sizeof(wl) - 21)
wl = wl[<21..];
else
wl = wl;
}
write("\nWizard top score list\n\n");
if (total_cmd == 0)
total_cmd = 1;
printf("%-20s %-6s %-3s %-17s %-6s %-6s %-6s\n",
"EUID", "cmds", "%", "Costs", "HB", "Arrays","Mapp.");
foreach(mixed e: wl)
{
printf("%-:20s %:6d %:2d%% [%:6dk,%:6dG] %:6d %:6d %:6d\n",
e[WL_NAME], e[WL_COMMANDS], e[WL_COMMANDS] * 100 / total_cmd,
e[WL_COST] / 1000, e[WL_TOTAL_GIGACOST],
e[WL_HEART_BEATS], e[WL_ARRAY_TOTAL], e[WL_MAPPING_TOTAL]
);
}
printf("\nTotal %7d (%d)\n\n", total_cmd, sizeof(wl));
}
// Ab hier folgen Hilfsfunktionen fuer call_out() bzw. fuer deren Begrenzung
// ermittelt das Objekt des Callouts.
private object _call_out_obj( mixed call_out ) {
return pointerp(call_out) ? call_out[0] : 0;
}
private void _same_object( object ob, mapping m ) {
// ist nicht so bloed, wie es aussieht, s. nachfolgede Verwendung von m
if ( m[ob] )
m[ob] += ({ ob });
else
m[ob] = ({ ob });
}
// alle Objekte im Mapping m zusammenfassen, die den gleichen Loadname (Name der
// Blueprint) haben, also alle Clones der BP, die Callouts laufen haben.
// Objekte werden auch mehrfach erfasst, je nach Anzahl ihrer Callouts.
private void _same_path( object key, object *obs, mapping m ) {
string path;
if (!objectp(key) || !pointerp(obs)) return;
path = load_name(key);
if ( m[path] )
m[path] += obs;
else
m[path] = obs;
}
// key kann object oder string sein.
private int _too_many( mixed key, mapping m, int i ) {
return sizeof(m[key]) >= i;
}
// alle Objekte in obs zerstoeren und Fehlermeldung ausgeben. ACHTUNG: Die
// Objekte werden idR zu einer BP gehoeren, muessen aber nicht! In dem Fall
// wird auf der Ebene aber nur ein Objekt in der Fehlermeldung erwaehnt.
private void _destroy( mixed key, object *obs, string text, int uid ) {
if (!pointerp(obs)) return;
// Array mit unique Eintraege erzeugen.
obs = m_indices( mkmapping(obs) );
// Fehlermeldung auf der Ebene ausgeben, im catch() mit publish, damit es
// auf der Ebene direkt scrollt, der backtrace verfuegbar ist (im
// gegensatz zur Loesung mittels Callout), die Ausfuehrung aber weiter
// laeuft.
catch( efun::raise_error(
sprintf( text,
uid ? (string)master()->creator_file(key) : key,
sizeof(obs), object_name(obs[<1]) ) );publish);
// Und weg mit dem Kram...
filter( obs, #'efun::destruct/*'*/ );
}
// Alle Objekt einer UID im Mapping m mit UID als KEys zusammenfassen. Objekt
// sind dabei nicht unique.
private void _same_uid( string key, object *obs, mapping m, closure cf ) {
string uid;
if ( !pointerp(obs) || !sizeof(obs) )
return;
uid = funcall( cf, key );
if ( m[uid] )
m[uid] += obs; // obs ist nen Array
else
m[uid] = obs;
}
private int _log_call_out(mixed co)
{
log_file("TOO_MANY_CALLOUTS",
sprintf("%s::%O (%d)\n",object_name(co[0]),co[1],co[2]),
200000);
return 0;
}
private int last_callout_log=0;
nomask varargs void call_out( varargs mixed *args )
{
mixed tmp, *call_outs;
// Bei >600 Callouts alle Objekte killen, die mehr als 30 Callouts laufen
// haben.
if ( efun::driver_info(DI_NUM_CALLOUTS) > 600
&& geteuid(previous_object()) != ROOTID )
{
// Log erzeugen...
if (last_callout_log <
efun::driver_info(DI_NUM_HEARTBEAT_TOTAL_CYCLES) - 10
&& get_eval_cost() > 200000)
{
last_callout_log = efun::driver_info(DI_NUM_HEARTBEAT_TOTAL_CYCLES);
log_file("TOO_MANY_CALLOUTS",
sprintf("\n%s: ############ Too many callouts: %d ##############\n",
strftime("%y%m%d-%H%M%S"),
efun::driver_info(DI_NUM_CALLOUTS)));
filter(efun::call_out_info(), #'_log_call_out);
}
// Objekte aller Callouts ermitteln
call_outs = map( efun::call_out_info(), #'_call_out_obj );
mapping objectmap = ([]);
filter( call_outs, #'_same_object, &objectmap );
// Master nicht grillen...
efun::m_delete( objectmap, master(1) );
// alle Objekte raussuchen, die zuviele haben...
mapping res = filter_indices( objectmap, #'_too_many, objectmap, 29 );
// und ueber alle Keys gehen, an _destroy() werden Key und Array mit
// Objekten uebergeben (in diesem Fall sind Keys und Array mit
// Objekten jeweils das gleiche Objekt).
if ( sizeof(res) )
walk_mapping(res, #'_destroy, "CALL_OUT overflow by single "
"object [%O]. Destructed %d objects. [%s]\n", 0 );
// Bei (auch nach dem ersten Aufraeumen noch) >800 Callouts alle
// Objekte killen, die mehr als 50 Callouts laufen haben - und
// diesmal zaehlen Clones nicht eigenstaendig! D.h. es werden alle
// Clones einer BP gekillt, die Callouts laufen haben, falls alle
// diese Objekte _zusammen_ mehr als 50 Callouts haben!
if ( efun::driver_info(DI_NUM_CALLOUTS) > 800 ) {
// zerstoerte Objekte von der letzten Aktion sind in objectmap nicht
// mehr drin, da sie dort als Keys verwendet wurden.
mapping pathmap=([]);
// alle Objekt einer BP in res sortieren, BP-Name als Key, Arrays
// von Objekten als Werte.
walk_mapping( objectmap, #'_same_path, &pathmap);
// alle BPs (und ihre Objekte) raussuchen, die zuviele haben...
res = filter_indices( pathmap, #'_too_many/*'*/, pathmap, 50 );
// und ueber alle Keys gehen, an _destroy() werden die Clones
// uebergeben, die Callouts haben.
if ( sizeof(res) )
walk_mapping( res, #'_destroy/*'*/, "CALL_OUT overflow by file "
"'%s'. Destructed %d objects. [%s]\n", 0 );
// Wenn beide Aufraeumarbeiten nichts gebracht haben und immer
// noch >1000 Callouts laufen, werden diesmal alle Callouts
// einer UID zusammengezaehlt.
// Alle Objekte einer UID, die es in Summe aller ihrer Objekt mit
// Callouts auf mehr als 100 Callouts bringt, werden geroestet.
if (efun::driver_info(DI_NUM_CALLOUTS) > 1000)
{
// das nach BP-Namen vorgefilterte Mapping jetzt nach UIDs
// zusammensortieren. Zerstoerte Clones filter _same_uid()
// raus.
mapping uidmap=([]);
walk_mapping( pathmap, #'_same_uid, &uidmap,
symbol_function( "creator_file",
"/secure/master" ) );
// In res nun UIDs als Keys und Arrays von Objekten als Werte.
// Die rausfiltern, die mehr als 100 Objekte (non-unique, d.h.
// 100 Callouts!) haben.
res = filter_indices( uidmap, #'_too_many, uidmap, 100 );
// und erneut ueber die Keys laufen und jeweils die Arrays mit
// den Objekten zur Zerstoerung an _destroy()...
if ( sizeof(res) )
walk_mapping( res, #'_destroy, "CALL_OUT overflow by "
"UID '%s'. Destructed %d objects. [%s]\n",
1 );
}
}
}
// Falls das aufrufende Objekt zerstoert wurde beim Aufraeumen
if ( !previous_object() )
return;
set_this_object( previous_object() );
apply( #'efun::call_out, args );
return;
}
mixed call_out_info() {
object po = previous_object();
mixed coi = efun::call_out_info();
// ungefilterten Output nur fuer bestimmte Objekte, Objekte in /std oder
// /obj haben die BackboneID.
if (query_wiz_level(getuid(po)) >= ARCH_LVL
|| (string)master()->creator_file(load_name(po)) == BACKBONEID ) {
return coi;
}
else {
return filter(coi, function mixed (mixed arr) {
if (pointerp(arr) && arr[0]==po)
return 1;
else return 0; });
}
}
// * Zu einer closure das Objekt, an das sie gebunden ist, suchen
// NICHT das Objekt, was ggf. die lfun definiert!
mixed query_closure_object(closure c) {
return
CLOSURE_IS_UNBOUND_LAMBDA(get_type_info(c, 1)) ?
0 :
(to_object(c) || -1);
}
// * Wir wollen nur EIN Argument ... ausserdem checks fuer den Netztotenraum
varargs void move_object(mixed what, mixed where)
{
object po,tmp;
po=previous_object();
if (!where)
{
where=what;
what=po;
}
if (((stringp(where) && where==NETDEAD_ROOM ) ||
(objectp(where) && where==find_object(NETDEAD_ROOM))) &&
objectp(what) && object_name(what)!="/obj/sperrer")
{
if (!query_once_interactive(what))
{
what->remove();
if (what) destruct(what);
return;
}
if (living(what) || interactive(what))
{
log_file("NDEAD2",sprintf("TRYED TO MOVE TO NETDEAD: %O\n",what));
return;
}
set_object_heart_beat(what,0);
}
tmp=what;
while (tmp=environment(tmp))
// Ja. Man ruft die _set_xxx()-Funktionen eigentlich nicht direkt auf.
// Aber das Lichtsystem ist schon *so* rechenintensiv und gerade der
// P_LAST_CONTENT_CHANGE-Cache wird *so* oft benoetigt, dass es mir
// da um jedes bisschen Rechenzeit geht.
// Der Zweck heiligt ja bekanntlich die Mittel. ;-)
//
// Tiamak
tmp->_set_last_content_change();
funcall(bind_lambda(#'efun::move_object,po),what,where);
if (tmp=what)
while (tmp=environment(tmp))
tmp->_set_last_content_change();
}
void start_simul_efun() {
mixed *info;
// Falls noch nicht getan, extra_wizinfo initialisieren
if ( !pointerp(info = get_extra_wizinfo(0)) )
set_extra_wizinfo(0, info = allocate(BACKBONE_WIZINFO_SIZE));
InitLivingData(info);
set_next_reset(10); // direkt mal aufraeumen
}
protected void reset() {
set_next_reset(7200);
CleanLivingData();
}
#if !__EFUN_DEFINED__(absolute_hb_count)
int absolute_hb_count() {
return efun::driver_info(DI_NUM_HEARTBEAT_TOTAL_CYCLES);
}
#endif
void __set_environment(object ob, mixed target)
{
string path;
object obj;
if (!objectp(ob))
return;
if (!IS_ARCH(geteuid(previous_object())) || !ARCH_SECURITY )
return;
if (objectp(target))
{
efun::set_environment(ob,target);
return;
}
path=(string)MASTER->_get_path(target,this_interactive());
if (stringp(path) && file_size(path+".c")>=0 &&
!catch(load_object(path);publish) )
{
obj=find_object(path);
efun::set_environment(ob,obj);
return;
}
}
void _dump_wizlist(string file, int sortby) {
int i;
mixed *a;
if (!LORD_SECURITY)
return;
if (!master()->valid_write(file,geteuid(previous_object()),"write_file"))
{
write("NO WRITE PERMISSION\n");
return;
}
a = wizlist_info();
a = sort_array(a, lambda( ({'a,'b}),
({#'<,
({#'[,'a,sortby}),
({#'[,'b,sortby})
})));
rm(file);
for (i=sizeof(a)-1;i>=0;i--)
write_file(file,sprintf("%-11s: eval=%-8d cmds=%-6d HBs=%-5d array=%-5d mapping=%-7d\n",
a[i][WL_NAME],a[i][WL_TOTAL_COST],a[i][WL_COMMANDS],a[i][WL_HEART_BEATS],
a[i][WL_ARRAY_TOTAL],a[i][WL_CALL_OUT]));
}
public varargs object deep_present(mixed what, object ob) {
if(!objectp(ob))
ob=previous_object();
// Wenn ein Objekt gesucht wird: Alle Envs dieses Objekts ermitteln und
// schauen, ob in diesen ob vorkommt. Dann ist what in ob enthalten.
if(objectp(what)) {
object *envs=all_environment(what);
// wenn ob kein Environment hat, ist es offensichtlich nicht in what
// enthalten.
if (!pointerp(envs)) return 0;
if (member(envs, ob) != -1) return what;
}
// sonst wirds teurer, ueber alle Objekte im (deep) Inv laufen und per id()
// testen. Dabei muss aber die gewuenschte Nr. ("flasche 3") abgeschnitten
// werden und selber gezaehlt werden, welche das entsprechende Objekt ist.
else if (stringp(what)) {
int cnt;
string newwhat;
if(sscanf(what,"%s %d",newwhat,cnt)!=2)
cnt=1;
else
what=newwhat;
foreach(object invob: deep_inventory(ob)) {
if (invob->id(what) && !--cnt)
return invob;
}
}
else {
set_this_object(previous_object());
raise_error(sprintf("Wrong argument 1 to deep_present(). "
"Expected \"object\" or \"string\", got %.50O.\n",
what));
}
return 0;
}
mapping dump_ip_mapping()
{
return 0;
}
nomask void swap(object obj)
{
write("Your are not allowed to swap objects by hand!\n");
return;
}
nomask varargs void garbage_collection(string str)
{
if(previous_object()==0 || !IS_ARCH(geteuid(previous_object()))
|| !ARCH_SECURITY)
{
write("Call GC now and the mud will crash in 5-6 hours. DONT DO IT!\n");
return;
}
else if (stringp(str))
{
return efun::garbage_collection(str);
}
else
return efun::garbage_collection();
}
varargs void notify_fail(mixed nf, int prio) {
object po,oldo;
int oldprio;
if (!PL || !objectp(po=previous_object())) return;
if (!stringp(nf) && !closurep(nf)) {
set_this_object(po);
raise_error(sprintf(
"Only strings and closures allowed for notify_fail! "
"Argument was: %.50O...\n",nf));
}
// falls ein Objekt bereits nen notify_fail() setzte, Prioritaeten abschaetzen
// und vergleichen.
if (objectp(oldo=query_notify_fail(1)) && po!=oldo) {
if (!prio) {
//Prioritaet dieses notify_fail() 'abschaetzen'
if (po==PL) // Spieler-interne (soul-cmds)
prio=NF_NL_OWN;
else if (living(po))
prio=NF_NL_LIVING;
else if ((int)po->IsRoom())
prio=NF_NL_ROOM;
else
prio=NF_NL_THING;
}
//Prioritaet des alten Setzers abschaetzen
if (oldo==PL)
oldprio=NF_NL_OWN;
else if (living(oldo))
oldprio=NF_NL_LIVING;
else if ((int)oldo->IsRoom())
oldprio=NF_NL_ROOM;
else
oldprio=NF_NL_THING;
}
else // wenn es noch kein Notify_fail gibt:
oldprio=NF_NL_NONE;
//vergleichen und ggf. setzen
if (prio >= oldprio) {
set_this_object(po);
efun::notify_fail(nf);
}
return;
}
void _notify_fail(string str)
{
//query_notify_fail() benutzen, um das Objekt
//des letzten notify_fail() zu ermitteln
object o;
if ((o=query_notify_fail(1)) && o!=previous_object())
return;
//noch kein notify_fail() fuer dieses Kommando gesetzt, auf gehts.
set_this_object(previous_object());
efun::notify_fail(str);
return;
}
string time2string( string format, int zeit )
{
int i,ch,maxunit,dummy;
string *parts, fmt;
int secs = zeit;
int mins = (zeit/60);
int hours = (zeit/3600);
int days = (zeit/86400);
int weeks = (zeit/604800);
int months = (zeit/2419200);
int abbr = 0;
parts = regexplode( format, "\(%\(-|\)[0-9]*[nwdhmsxNWDHMSX]\)|\(%%\)" );
for( i=1; i<sizeof(parts); i+=2 )
{
ch = parts[i][<1];
switch( parts[i][<1] )
{
case 'x': case 'X':
abbr = sscanf( parts[i], "%%%d", dummy ) && dummy==0;
// NO break !
case 'n': case 'N':
maxunit |= 31;
break;
case 'w': case 'W':
maxunit |= 15;
break;
case 'd': case 'D':
maxunit |= 7;
break;
case 'h': case 'H':
maxunit |= 3;
break;
case 'm': case 'M':
maxunit |= 1;
break;
}
}
if( maxunit & 16 ) weeks %= 4;
if( maxunit & 8 ) days %= 7;
if( maxunit & 4 ) hours %= 24;
if( maxunit & 2 ) mins %= 60;
if( maxunit ) secs %= 60;
for( i=1; i<sizeof(parts); i+=2 )
{
fmt = parts[i][0..<2];
ch = parts[i][<1];
if( ch=='x' )
{
if (months > 0) ch='n';
else if( weeks>0 ) ch='w';
else if( days>0 ) ch='d';
else if( hours>0 ) ch='h';
else if(mins > 0) ch = 'm';
else ch = 's';
}
else if( ch=='X' )
{
if (months > 0) ch='N';
else if( weeks>0 ) ch='W';
else if( days>0 ) ch='D';
else if( hours>0 ) ch='H';
else if(mins > 0) ch = 'M';
else ch = 'S';
}
switch( ch )
{
case 'n': parts[i] = sprintf( fmt+"d", months ); break;
case 'w': parts[i] = sprintf( fmt+"d", weeks ); break;
case 'd': parts[i] = sprintf( fmt+"d", days ); break;
case 'h': parts[i] = sprintf( fmt+"d", hours ); break;
case 'm': parts[i] = sprintf( fmt+"d", mins ); break;
case 's': parts[i] = sprintf( fmt+"d", secs ); break;
case 'N':
if(abbr) parts[i] = "M";
else parts[i] = sprintf( fmt+"s", (months==1) ? "Monat" : "Monate" );
break;
case 'W':
if(abbr) parts[i] = "w"; else
parts[i] = sprintf( fmt+"s", (weeks==1) ? "Woche" : "Wochen" );
break;
case 'D':
if(abbr) parts[i] = "d"; else
parts[i] = sprintf( fmt+"s", (days==1) ? "Tag" : "Tage" );
break;
case 'H':
if(abbr) parts[i] = "h"; else
parts[i] = sprintf( fmt+"s", (hours==1) ? "Stunde" : "Stunden" );
break;
case 'M':
if(abbr) parts[i] = "m"; else
parts[i] = sprintf( fmt+"s", (mins==1) ? "Minute" : "Minuten" );
break;
case 'S':
if(abbr) parts[i] = "s"; else
parts[i] = sprintf( fmt+"s", (secs==1) ? "Sekunde" : "Sekunden" );
break;
case '%':
parts[i] = "%";
break;
}
}
return implode( parts, "" );
}
nomask mixed __create_player_dummy(string name)
{
string err;
object ob;
mixed m;
//hat nen Scherzkeks die Blueprint bewegt?
if ((ob=find_object("/secure/login")) && environment(ob))
catch(destruct(ob);publish);
err = catch(ob = clone_object("secure/login");publish);
if (err)
{
write("Fehler beim Laden von /secure/login.c\n"+err+"\n");
return 0;
}
if (objectp(m=(mixed)ob->new_logon(name))) netdead[name]=m;
return m;
}
nomask int secure_level()
{
int *level;
//kette der Caller durchlaufen, den niedrigsten Level in der Kette
//zurueckgeben. Zerstoerte Objekte (Selbstzerstoerer) fuehren zur Rueckgabe
//von 0.
//caller_stack(1) fuegt dem Rueckgabearray this_interactive() hinzu bzw. 0,
//wenn es keinen Interactive gibt. Die 0 fuehrt dann wie bei zerstoerten
//Objekten zur Rueckgabe von 0, was gewuenscht ist, da es hier einen
//INteractive geben muss.
level=map(caller_stack(1),function int (object caller)
{if (objectp(caller))
return(query_wiz_level(geteuid(caller)));
return(0); // kein Objekt da, 0.
} );
return(min(level)); //den kleinsten Wert im Array zurueckgeben (ggf. 0)
}
nomask string secure_euid()
{
string euid;
if (!this_interactive()) // Es muss einen interactive geben
return 0;
euid=geteuid(this_interactive());
// ueber alle Caller iterieren. Wenn eines davon eine andere euid hat als
// der Interactive und diese nicht die ROOTID ist, wird 0 zurueckgeben.
// Ebenso, falls ein Selbstzerstoerer irgendwo in der Kette ist.
foreach(object caller: caller_stack()) {
if (!objectp(caller) ||
(geteuid(caller)!=euid && geteuid(caller)!=ROOTID))
return 0;
}
return euid; // 'sichere' euid zurueckgeben
}
// INPUT_PROMPT und nen Leerprompt hinzufuegen, wenn keins uebergeben wird.
// Das soll dazu dienen, dass alle ggf. ein EOR am Promptende kriegen...
//#if __BOOT_TIME__ < 1360017213
varargs void input_to( mixed fun, int flags, varargs mixed *args )
{
mixed *arr;
int i;
if ( !this_player() || !previous_object() )
return;
// TODO: input_to(...,INPUT_PROMPT, "", ...), wenn kein INPUT_PROMPT
// vorkommt...
if ( flags&INPUT_PROMPT ) {
arr = ({ fun, flags }) + args;
}
else {
// ggf. ein INPUT_PROMPT hinzufuegen und nen Leerstring als Prompt.
flags |= INPUT_PROMPT;
arr = ({ fun, flags, "" }) + args;
}
// Arrays gegen flatten quoten.
for ( i = sizeof(arr) - 1; i > 1; i-- )
if ( pointerp(arr[i]) )
arr[i] = quote(arr[i]);
apply( bind_lambda( unbound_lambda( ({}),
({ #'efun::input_to/*'*/ }) + arr ),
previous_object() ) );
}
//#endif
nomask int set_light(int i)
// erhoeht das Lichtlevel eines Objekts um i
// result: das Lichtlevel innerhalb des Objekts
{
object ob, *inv;
int lall, light, dark, tmp;
if (!(ob=previous_object())) return 0; // ohne das gehts nicht.
// aus kompatibilitaetsgruenden kann man auch den Lichtlevel noch setzen
if (i!=0) ob->SetProp(P_LIGHT, ob->QueryProp(P_LIGHT)+i);
// Lichtberechnung findet eigentlich in der Mudlib statt.
return (int)ob->QueryProp(P_INT_LIGHT);
}
public string iso2ascii( string str )
{
if ( !stringp(str) || !sizeof(str) )
return "";
str = regreplace( str, "ä", "ae", 1 );
str = regreplace( str, "ö", "oe", 1 );
str = regreplace( str, "ü", "ue", 1 );
str = regreplace( str, "Ä", "Ae", 1 );
str = regreplace( str, "Ö", "Oe", 1 );
str = regreplace( str, "Ü", "Ue", 1 );
str = regreplace( str, "ß", "ss", 1 );
str = regreplace( str, "[^ -~]", "?", 1 );
return str;
}
public varargs string CountUp( string *s, string sep, string lastsep )
{
string ret;
if ( !pointerp(s) )
return "";
if (!sep) sep = ", ";
if (!lastsep) lastsep = " und ";
switch (sizeof(s)) {
case 0: ret=""; break;
case 1: ret=s[0]; break;
default:
ret = implode(s[0..<2], sep);
ret += lastsep + s[<1];
}
return ret;
}
nomask varargs int query_next_reset(object ob) {
// Typpruefung: etwas anderes als Objekte oder 0 sollen Fehler sein.
if (ob && !objectp(ob))
raise_error(sprintf("Bad arg 1 to query_next_reset(): got %.20O, "
"expected object.\n",ob));
// Defaultobjekt PO, wenn 0 uebergeben.
if ( !objectp(ob) )
ob = previous_object();
return efun::object_info(ob, OI_NEXT_RESET_TIME);
}
#if !__EFUN_DEFINED__(copy_file)
#define MAXLEN 50000
nomask int copy_file(string source, string dest)
{
int ptr;
string bytes;
set_this_object(previous_object());
if (!sizeof(source)||!sizeof(dest)||source==dest||(file_size(source)==-1)||
(!call_other(master(),"valid_read",source,
getuid(this_interactive()||
previous_object()),"read_file",previous_object()))||
(!call_other(master(),"valid_read",source,
getuid(this_interactive()||
previous_object()),"write_file",previous_object())))
return 1;
switch (file_size(dest))
{
case -1:
break;
case -2:
if (dest[<1]!='/') dest+="/";
dest+=efun::explode(source,"/")[<1];
if (file_size(dest)==-2) return 1;
if (file_size(dest)!=-1) break;
default:
if (!rm(dest)) return 1;
break;
}
do
{
bytes = read_bytes(source, ptr, MAXLEN); ptr += MAXLEN;
if (!bytes) bytes="";
write_file(dest, bytes);
}
while(sizeof(bytes) == MAXLEN);
return 0;
}
#endif //!__EFUN_DEFINED__(copy_file)
// ### Ersatzaufloesung in Strings ###
varargs string replace_personal(string str, mixed *obs, int caps) {
int i;
string *parts;
parts = regexplode(str, "@WE[A-SU]*[0-9]");
i = sizeof(parts);
if (i>1) {
int j, t;
closure *name_cls;
t = j = sizeof(obs);
name_cls = allocate(j);
while (j--)
if (objectp(obs[j]))
name_cls[j] = symbol_function("name", obs[j]);
else if (stringp(obs[j]))
name_cls[j] = obs[j];
while ((i-= 2)>0) {
int ob_nr;
// zu ersetzendes Token in Fall und Objektindex aufspalten
ob_nr = parts[i][<1]-'1';
if (ob_nr<0 || ob_nr>=t) {
set_this_object(previous_object());
raise_error(sprintf("replace_personal: using wrong object index %d\n",
ob_nr));
return implode(parts, "");
}
// casus kann man schon hier entscheiden
int casus;
string part = parts[i];
switch (part[3]) {
case 'R': casus = WER; break;
case 'S': casus = WESSEN; break;
case 'M': casus = WEM; break;
case 'N': casus = WEN; break;
default: continue; // passt schon jetzt nicht in das Hauptmuster
}
// und jetzt die einzelnen Keywords ohne fuehrendes "@WE", beendende Id
mixed tmp;
switch (part[3..<2]) {
case "R": case "SSEN": case "M": case "N": // Name
parts[i] = funcall(name_cls[ob_nr], casus, 1); break;
case "RU": case "SSENU": case "MU": case "NU": // unbestimmt
parts[i] = funcall(name_cls[ob_nr], casus); break;
case "RQP": case "SSENQP": case "MQP": case "NQP": // Pronoun
if (objectp(tmp = obs[ob_nr]))
parts[i] = (string)tmp->QueryPronoun(casus);
break;
case "RQA": case "SSENQA": case "MQA": case "NQA": // Article
if (objectp(tmp = obs[ob_nr]))
tmp = (string)tmp->QueryArticle(casus, 1, 1);
if (stringp(tmp) && !(tmp[<1]^' '))
tmp = tmp[0..<2]; // Extra-Space wieder loeschen
break;
case "RQPPMS": case "SSENQPPMS": case "MQPPMS": case "NQPPMS":
if (objectp(tmp = obs[ob_nr]))
parts[i] = (string)tmp->QueryPossPronoun(MALE, casus, SINGULAR);
break;
case "RQPPFS": case "SSENQPPFS": case "MQPPFS": case "NQPPFS":
if (objectp(tmp = obs[ob_nr]))
parts[i] = (string)tmp->QueryPossPronoun(FEMALE, casus, SINGULAR);
break;
case "RQPPNS": case "SSENQPPNS": case "MQPPNS": case "NQPPNS":
if (objectp(tmp = obs[ob_nr]))
parts[i] = (string)tmp->QueryPossPronoun(NEUTER, casus, SINGULAR);
break;
case "RQPPMP": case "SSENQPPMP": case "MQPPMP": case "NQPPMP":
if (objectp(tmp = obs[ob_nr]))
parts[i] = (string)tmp->QueryPossPronoun(MALE, casus, PLURAL);
break;
case "RQPPFP": case "SSENQPPFP": case "MQPPFP": case "NQPPFP":
if (objectp(tmp = obs[ob_nr]))
parts[i] = (string)tmp->QueryPossPronoun(FEMALE, casus, PLURAL);
break;
case "RQPPNP": case "SSENQPPNP": case "MQPPNP": case "NQPPNP":
if (objectp(tmp = obs[ob_nr]))
parts[i] = (string)tmp->QueryPossPronoun(NEUTER, casus, PLURAL);
break;
default:
continue;
}
// wenn tmp ein String war, weisen wir es hier pauschal zu
if (stringp(tmp))
parts[i] = tmp;
// auf Wunsch wird nach Satzenden gross geschrieben
if (caps)
switch (parts[i-1][<2..]) {
case ". ": case "! ": case "? ":
case ".": case "!": case "?":
case ".\n": case "!\n": case "?\n":
case "\" ": case "\"\n":
parts[i] = capitalize(parts[i]);
break;
}
}
return implode(parts, "");
}
return str;
}
//replacements for dropped efuns in LD
#if !__EFUN_DEFINED__(extract)
deprecated varargs string extract(string str, int from, int to) {
if(!stringp(str)) {
set_this_object(previous_object());
raise_error(sprintf("Bad argument 1 to extract(): %O",str));
}
if (intp(from) && intp(to)) {
if (from>=0 && to>=0)
return(str[from .. to]);
else if (from>=0 && to<0)
return(str[from .. <abs(to)]);
else if (from<0 && to>=0)
return(str[<abs(from) .. to]);
else
return(str[<abs(from) .. <abs(to)]);
}
else if (intp(from)) {
if (from>=0)
return(str[from .. ]);
else
return(str[<abs(from) .. ]);
}
else {
return(str);
}
}
#endif // !__EFUN_DEFINED__(extract)
#if !__EFUN_DEFINED__(slice_array)
deprecated varargs mixed slice_array(mixed array, int from, int to) {
if(!pointerp(array)) {
set_this_object(previous_object());
raise_error(sprintf("Bad argument 1 to slice_array(): %O",array));
}
if (intp(from) && intp(to)) {
if (from>=0 && to>=0)
return(array[from .. to]);
else if (from>=0 && to<0)
return(array[from .. <abs(to)]);
else if (from<0 && to>=0)
return(array[<abs(from) .. to]);
else
return(array[<abs(from) .. <abs(to)]);
}
else if (intp(from)) {
if (from>=0)
return(array[from .. ]);
else
return(array[<abs(from) .. ]);
}
else {
return(array);
}
}
#endif // !__EFUN_DEFINED__(slice_array)
#if !__EFUN_DEFINED__(member_array)
deprecated int member_array(mixed item, mixed arraystring) {
if (pointerp(arraystring)) {
return(efun::member(arraystring,item));
}
else if (stringp(arraystring)) {
return(efun::member(arraystring,to_int(item)));
}
else {
set_this_object(previous_object());
raise_error(sprintf("Bad argument 1 to member_array(): %O",arraystring));
}
}
#endif // !__EFUN_DEFINED__(member_array)
// The digit at the i'th position is the number of bits set in 'i'.
string count_table =
"0112122312232334122323342334344512232334233434452334344534454556";
int broken_count_bits( string s ) {
int i, res;
if( !stringp(s) || !(i=sizeof(s)) ) return 0;
for( ; i-->0; ) {
// We are counting 6 bits at a time using a precompiled table.
res += count_table[(s[i]-' ')&63]-'0';
}
return res;
}
#if !__EFUN_DEFINED__(count_bits)
int count_bits( string s ) {
return(broken_count_bits(s));
}
#endif
// * Teile aus einem Array entfernen *** OBSOLETE
deprecated mixed *exclude_array(mixed *arr,int from,int to)
{
if (to<from)
to = from;
return arr[0..from-1]+arr[to+1..];
}