Added public files
Roughly added all public files. Probably missed some, though.
diff --git a/secure/master.c b/secure/master.c
new file mode 100644
index 0000000..0574cdf
--- /dev/null
+++ b/secure/master.c
@@ -0,0 +1,1254 @@
+// MorgenGrauen MUDlib
+//
+// master.c -- master object
+//
+// $Id: master.c 9530 2016-03-17 19:59:01Z Zesstra $
+#pragma strict_types
+#pragma no_clone
+#pragma no_shadow
+#pragma no_inherit
+#pragma verbose_errors
+#pragma combine_strings
+#pragma pedantic
+#pragma range_check
+#pragma warn_deprecated
+
+#include "/sys/files.h"
+#include "/sys/interactive_info.h"
+#include "/sys/driver_info.h"
+
+inherit "/secure/master/misc";
+inherit "/secure/master/userinfo";
+inherit "/secure/master/network";
+inherit "/secure/master/domain";
+inherit "/secure/master/guild";
+inherit "/secure/master/file_access";
+inherit "/secure/master/players_deny";
+
+#include "/secure/master.h"
+
+//for limited, set_limit(), etc. Abs. Pfad noetig, da noch kein Include-Hook
+#include "/sys/rtlimits.h"
+#include "/sys/debug_info.h"
+#include "/sys/debug_message.h"
+#include "/sys/configuration.h"
+#include "/sys/regexp.h"
+
+// Module des Master einfuegen. Per #include, damits geringfuegig schneller.
+// Da die Module ja nirgendwo sonst geerbt werden koennten, ist dies
+// ausnahmsweise OK. ;)
+#include "/secure/master/destruct.c"
+#include "/secure/master/autoinclude.c"
+
+// Fuer Logfile(-Rotation)
+#define RESETINT 3600 // jede Stunde
+#define LOGROTATE (24*2) // alle 48h
+#define LOGFILEAGE (RESETINT*LOGROTATE) // alle 2 tage wechseln
+#define LOGNUM 3 // Anzahl der Logfiles
+
+private nosave int logrotate_counter; //READ_FILE alle LOGROTATE Resets rotieren
+// Wird gerade versucht, die simul_efuns zu laden? Wenn ja, duerfen keine
+// sefuns gerufen werden.
+private nosave int loading_simul_efuns;
+// wird gerade ein Fehler bearbeitet? Dient zur Erkennung von Rekursionen in
+// der Fehlerbehandlung
+private nosave int handling_error;
+
+// #####################
+//######################## Start des Masters ############################
+// #####################
+
+// Initialisierung des Masters
+//arg==0: Mud startet gerade, arg==1: Master wurde reaktiviert,
+//arg==2: Master reaktiviert (Variablen weg), arg==3: Master wurde
+//neugeladen.
+protected void inaugurate_master(int arg) {
+
+ set_driver_hook(H_REGEXP_PACKAGE, RE_TRADITIONAL);
+
+ seteuid(ROOTID);
+ userinfo::create();
+ LoadPLDenylists();
+
+ // Was soll vor jede Datei geschrieben werden?
+ set_driver_hook(H_AUTO_INCLUDE, #'autoincludehook);
+
+ //div. Listen einlesen
+ ReloadBanishFile();
+ ReloadDeputyFile();
+ ReloadInsecureFile();
+
+ // Bei Neustart wizinfo initialisieren
+ if (!arg)
+ set_extra_wizinfo(0, allocate(BACKBONE_WIZINFO_SIZE));
+
+ //simul_efun.c nach inaugurate_master() starten und initialisieren,
+ //(so richtig seh ich den Sinn hier momentan nicht ein...
+ //call_out("start_simul_efun",0);
+
+ // Reset festsetzen (1h)
+ set_next_reset(RESETINT);
+
+ // Driver konfigurieren
+ // Lagerkennung erst ne Minute spaeter, waehrend preload darfs momentan
+ // ruhig laggen (Zeit: vorlaeufig 1min)
+ call_out(#'configure_driver, 60, DC_LONG_EXEC_TIME, 100000);
+
+ // Hooks setzen
+
+ // Standardincludeverzeichnisse fuer #include <>
+ set_driver_hook(H_INCLUDE_DIRS, ({"/secure/","/sys/"}) );
+
+ //Nach dem Laden/Clonen create() im Objekt rufen
+ set_driver_hook(H_CREATE_CLONE, "create");
+ set_driver_hook(H_CREATE_OB, "create");
+ set_driver_hook(H_CREATE_SUPER, "create_super");
+
+ // Bei Reset reset() im Objekt aufrufen
+ set_driver_hook(H_RESET, "reset");
+
+ // Zum Aufraeumen clean_up() im Objekt aufrufen
+ set_driver_hook(H_CLEAN_UP, "clean_up");
+
+ // Jede Eingabe wird ueber modify_command gelenkt
+ set_driver_hook(H_MODIFY_COMMAND, "modify_command");
+ // Dieser Hook ist mandatory, aber wird nur benutzt, wenn via
+ // set_modify_command() aktiviert - was wir nicht (mehr) tun. Insofern ist
+ // das Relikt aus alten Zeiten.
+ //set_driver_hook(H_MODIFY_COMMAND_FNAME, "modify_command");
+
+ // Standard-Fehlermeldung
+ //set_driver_hook(H_NOTIFY_FAIL, "Wie bitte?\n");
+ set_driver_hook(H_NOTIFY_FAIL, function string (string cmd, object tp)
+ {if (stringp(cmd=(string)tp->QueryProp(P_DEFAULT_NOTIFY_FAIL)))
+ return(cmd);
+ return("Wie bitte?\n");});
+
+ // Was machen bei telnet_neg
+ set_driver_hook(H_TELNET_NEG,"telnet_neg");
+ // set_driver_hook(H_TELNET_NEG,0);
+
+ // Promptbehandlung: Defaultprompt setzen und dafuer sorgen, dass alle
+ // Promptausgaben durch print_prompt im Interactive laufen, damit das EOR
+ // angehaengt wird.
+ set_driver_hook(H_PRINT_PROMPT, "print_prompt");
+ set_driver_hook(H_DEFAULT_PROMPT, "> ");
+
+ // EUID und UID muessen neue Objekte auch noch kriegen, Hooks dafuer setzen
+ set_driver_hook(H_LOAD_UIDS, #'load_uid_hook);
+ set_driver_hook(H_CLONE_UIDS, #'clone_uid_hook);
+
+ // Meldung bei vollem Mud
+ set_driver_hook(H_NO_IPC_SLOT, "Momentan sind leider zuviele Spieler im "
+ +MUDNAME+" eingeloggt.\nBitte komm doch etwas spaeter nochmal "
+ "vorbei!\n");
+
+ // Nun der beruechtigte Move-Hook ...
+ // (bewegt objekt und ruft alle notwendigen inits auf)
+ // Hier wird H_MOVE_OBJECT0 benutzt, d.h. die lambda wird an das aktuelle
+ // Objekt vor Ausfuehrung gebunden, nicht an 'item', was move_objet()
+ // uebergeben wurde.
+ set_driver_hook(H_MOVE_OBJECT0,
+ unbound_lambda(({'item,'dest}),
+ ({#',, // item!=this_object?
+ ({#'?,({#'!=,'item,({#'this_object})}),
+ ({#'raise_error, // ->Fehler!
+ "Illegal to move other object than this_object()\n"}) }),
+ ({#'efun::set_environment,'item,'dest}), // item nach dest bewegen
+ ({#'?,
+ ({#'living,'item}), // living(item)?
+ ({#',,
+ ({#'efun::set_this_player,'item}), // set_this_player(item)
+ ({#'call_other,'dest,"init"}), // dest->init()
+ ({#'?!,
+ ({#'&&, // !objectp(item)||
+ ({#'objectp, 'item}), // env(item)!=dest?
+ ({#'==,({#'environment, 'item}),'dest})}),
+ ({#'return})})})}), // -> fertig
+ ({#'=,'others,({#'-,({#'all_inventory,'dest}),({#'({,'item})})}),
+#ifdef EMACS_NERV
+ }) // Emacs kann ({#'({ nicht parsen // others=all_inv(dest)-
+#endif // ({item})
+ ({#'filter,'others,lambda(({'ob,'item}),
+ ({#'?,
+ ({#'&&,
+ ({#'objectp,'item}), // objectp(item)&&
+ ({#'living,'ob}), // living(ob)&&
+ ({#'==,({#'environment,'item}),({#'environment,'ob})})}),
+ ({#',, // env(item)==env(ob)?
+ ({#'efun::set_this_player, 'ob}), // set_this_player(ob)
+ ({#'call_other,'item, "init"}) // item->init()
+ })})),'item}),
+ ({#'?,
+ ({#'living,'item}), // living(item)?
+ ({#',,
+ ({#'efun::set_this_player,'item}), // set_this_player(item)
+ ({#'filter,'others,lambda(({'ob,'item}),
+ ({#'?,
+ ({#'&&,
+ ({#'objectp,'item}), // objectp(item)&&
+ ({#'objectp,'ob}), // objectp(ob)&&
+ ({#'==,({#'environment,'item}),({#'environment,'ob})})
+ }), // env(item)==env(ob)?
+ ({#'call_other,'ob,"init"}) // ob->init()
+ })),'item})})}),
+ ({#'?,
+ ({#'&&,
+ ({#'objectp,'item}), // objectp(item)&&
+ ({#'living,'dest}), // living(dest)&&
+ ({#'==,({#'environment,'item}),'dest})// env(item)==dest?
+ }),
+ ({#',,
+ ({#'efun::set_this_player,'dest}), // set_this_player(dest)
+ ({#'call_other,'item,"init"})})})})));// item->init()
+ DEBUG("Master inaugurated");
+ return;
+}
+
+// epilog() gibt die Dateien zurueck, die vorgeladen werden muessen
+protected string *epilog(int eflag) {
+ string *files, *domains;
+ int i;
+
+ seteuid(ROOTID);
+ ReloadBanishFile();
+ ReloadDeputyFile();
+ ReloadInsecureFile();
+
+ if (eflag) {
+ write("-e angegeben -> Preloading unterdrueckt ...\n");
+ return 0;
+ }
+
+ printf("Preloading gestartet: %s\n\n",ctime(time()));
+
+ //Files fuers Preloading und Regionen holen
+ files=explode_files("/std/preload_file") + explode_files("/d/preload_file");
+ domains=get_domains() + ({"erzmagier"}); // EM haben auch ein Preload File
+
+ for (i=sizeof(domains);i--;)
+ files+=explode_files("/d/"+domains[i]+"/preload_file");
+
+ write("\n");
+
+ return files;
+}
+
+// preload() wird fuer jeder Datei im Preload einmal durchlaufen
+protected void preload(string file) {
+ string err;
+ string name;
+ int *res, zeit;
+
+ // Kein richtiger Dateiname: fertig
+ if(!file || !file[0] || file[0] == ';' || file_size(file+".c") < 0) return;
+
+ // Kein Besitzer -> Meldung ausgeben, fertig
+ if (!(name=creator_file(file)))
+ {
+ printf("Kein Besitzer gefunden fuer Datei %s.\n",file);
+ return;
+ }
+
+ // Datei und Besitzer ausgeben
+ printf("%-50s%-15s",file,name);
+
+ // Euid kann nicht geaendert werden -> Meldung, fertig
+ if (!seteuid(name))
+ {
+ printf("\nEuid konnte nicht auf %s gesetzt werden\n"+
+ "Sie ist nun %s.\n",name,geteuid(TO));
+ return;
+ }
+
+ // Dann mal laden .. dabei Zeit messen
+ zeit = apply(#'+,rusage()[0..1]);
+
+ // Waehrend des Preloads sind 1.5MTicks leider nicht soviel, insb. wenn
+ // sowas wie der channeld jede menge Objekte laden muss, die wiederum erst
+ // das ganze Geraffel aus /std/ laden. Daher hier einfach mal fuers Preload
+ // die Grenze hoch.
+ err = catch(limited(#'load_object,({5000000}),file));
+
+ if (err != 0)
+ printf("\nFehler beim Laden von %s:\n%s\n",file,err);
+ else
+ {
+ zeit=apply(#'+,rusage()[0..1])-zeit;
+ printf("(%2d.%:02d s)\n",zeit/1000,zeit%1000);
+ }
+
+ // Noch EUID zuruecksetzen
+ seteuid(ROOTID);
+
+ return;
+}
+
+//simul_efun.c laden oder die spare_simul_efun.c als Fallback
+//es ist moeglich, hier ein Array von strings zurueckzugeben. Die
+//nachfolgenden gelten als Backup-Objekte, falls eine sefun im Hauptobjekt
+//nicht gefunden wird.
+protected string *get_simul_efun() {
+ string err;
+
+ ++loading_simul_efuns;
+
+ if (!(err=catch(SIMUL_EFUN_FILE->start_simul_efun())) ) {
+ --loading_simul_efuns;
+ return ({SIMUL_EFUN_FILE});
+ }
+
+ write("Failed to load simul efun " + SIMUL_EFUN_FILE + "\n");
+ debug_message("Failed to load simul efun " + SIMUL_EFUN_FILE +
+ " " + err, DMSG_STDOUT | DMSG_LOGFILE);
+
+ if (!(err=catch(SPARE_SIMUL_EFUN_FILE->start_simul_efun())) ) {
+ --loading_simul_efuns;
+ return ({SPARE_SIMUL_EFUN_FILE});
+ }
+
+ write("Failed to load spare simul efun" + SPARE_SIMUL_EFUN_FILE + "\n");
+ debug_message("Failed to load spare simul efun " + SPARE_SIMUL_EFUN_FILE +
+ " " + err, DMSG_STDOUT | DMSG_LOGFILE);
+
+
+ efun::shutdown();
+
+ return 0;
+}
+
+protected mixed call_sefun(string sefun, varargs mixed args) {
+ if (!loading_simul_efuns)
+ return apply(symbol_function(sefun), args);
+ else {
+ switch(sefun) {
+ case "log_file":
+ case "secure_level":
+ case "secure_euid":
+ case "find_player":
+ case "find_netdead":
+ case "find_living":
+ case "process_call":
+ case "replace_personal":
+ case "file_time":
+ return 0;
+ case "dtime":
+ if (pointerp(args) && sizeof(args))
+ return strftime("%a %d. %b %Y, %H:%M:%S",args[0]);
+ else
+ return strftime("%a %d. %b %Y, %H:%M:%S");
+ case "uptime":
+ return to_string(time()-__BOOT_TIME__) + " Sekunden";
+ }
+ }
+ return 0;
+}
+
+
+// Preload manuell wiederholen; Keine GD-Funktion
+void redo_preload()
+{
+ string *to_preload;
+ int i,j;
+
+ to_preload=epilog(0);
+ j=sizeof(to_preload);
+ for (i=0;i<j;i++)
+ catch(preload(to_preload[i]));
+ return;
+}
+
+// ##################
+//########################## Standard-Lfuns #############################
+// ##################
+
+// Keine GD-Funktion, aber sinnvoll.
+public varargs int remove(int silent)
+{
+ write("Der Master will aber nicht zerstoert werden!\n");
+ return 0;
+}
+
+// Einige repetitiven Taetigkeiten kann der Reset erledigen
+protected void reset()
+{
+ int i, *date;
+ mixed *wl;
+
+ //Darf nicht von Hand aufgerufen werden!
+ if (TI||TP) return;
+
+ // Naechsten Reset setzen
+ set_next_reset(RESETINT);
+
+ // Userinfo aufraeumen
+ _cleanup_uinfo();
+
+ // Projekt-Cache loeschen
+ _cleanup_projects();
+
+ // Wenn Zeit abgelaufen, dann READ_FILE-Log rotieren
+ if (!logrotate_counter--)
+ {
+ i=time()/LOGFILEAGE;
+ date=get_dir(sprintf("%s.%d", READ_FILE,i%LOGNUM), GETDIR_DATES);
+ if (pointerp(date)&&sizeof(date)&&
+ (date[0]/LOGFILEAGE)==i) return;
+ if (file_size(READ_FILE)>0)
+ rename(READ_FILE, sprintf("%s.%d", READ_FILE,i%LOGNUM));
+ logrotate_counter=LOGROTATE;
+ }
+ // einmal am Tag die UIDAliase resetten. Hierzu wird der logrotate_counter
+ // missbraucht.
+ if (!(logrotate_counter%24)) {
+ ResetUIDAliase();
+#ifdef _PUREFTPD_
+ expire_ftp_user();
+#endif
+ }
+
+ // Wizlist altert
+ wl = wizlist_info();
+ for (i=sizeof(wl); i--; )
+ set_extra_wizinfo(wl[i][WL_NAME], wl[i][WL_EXTRA] * 99 / 100);
+
+ // Dann noch Mails bearbeiten
+ mails_last_hour=0;
+ mailread();
+
+ return;
+}
+
+
+// #################
+//########################## ID-Management ##############################
+// #################
+
+// Magier-ID fuer Datei str (als Objekt oder als String) ermitteln
+string creator_file(mixed str) {
+ string *strs,tmp;
+ int s;
+
+ // full_path_array nach strs
+ // TODO: was ist mit clones?
+ if(objectp(str))
+ strs=full_path_array(object_name(str), 0);
+ else if(stringp(str))
+ strs=full_path_array(str, 0);
+ else return NOBODY;
+
+ // absolute Pfade interessieren hier gerade nicht.
+ strs -= ({""});
+
+ s=sizeof(strs);
+ if(s<2) return NOBODY;
+
+ switch(strs[0]) {
+ case DOMAINDIR:
+ // Fuer Nicht-Magier bzw. "Pseudo-"Magier die Regionskennung
+ if( s==2 || WIZLVLS[strs[2]] || !IS_LEARNER(strs[2]) )
+ return strs[1];
+
+ // in /d/erzmagier gibt es Magier-IDs
+ if (strs[1]=="erzmagier") return strs[2];
+
+ // Ansonsten d.region.magiername
+ return sprintf("d.%s.%s", strs[1], strs[2]);
+
+ case PROJECTDIR:
+ // In p.service gibt es ids mit uid
+ if (s>2 && strs[1]=="service") return "p.service."+strs[2];
+
+ // Ansonsten nur p.projekt (p.service ist auch hier drin)
+ return "p."+strs[1];
+
+ case WIZARDDIR:
+ if (s>2)
+ return strs[1];
+ if (s==2 && file_size(strs[0]+"/"+strs[1])==FSIZE_DIR)
+ return strs[1];
+ return NOBODY;
+
+ case SECUREDIR:
+ return ROOTID;
+
+ case GUILDDIR:
+ case SPELLBOOKDIR:
+ tmp=strs[1];
+ if (tmp[<2..<2]==".") tmp=tmp[0..<3];
+ if ((s=member(tmp,'.'))>0) tmp=tmp[s+1..];
+ return "GUILD."+tmp;
+
+ case LIBROOMDIR:
+ return ROOMID;
+
+ case STDDIR:
+ case LIBOBJDIR:
+ return BACKBONEID;
+
+ case DOCDIR:
+ return DOCID;
+
+ case MAILDIR:
+ return MAILID;
+ case NEWSDIR:
+ return NEWSID;
+
+ case LIBITEMDIR:
+ return ITEMID;
+
+ /* Fall-Through */
+ default:
+ return NOBODY;
+
+ }
+ return NOBODY; //should never be reached.
+}
+
+// UID und EUID an Objekt geben (oder eben nicht)
+// Keine GD-Funktion, aber von Hooks aufgerufen
+protected mixed give_uid_to_object(string datei,object po)
+{
+ string creator,pouid;
+
+ // Parameter testen
+ if (!stringp(datei)||!objectp(po)) return 1;
+
+ // Keine Objekte in /log, /open oder /data
+ if (strstr(datei, "/"LIBDATADIR"/") == 0
+ || strstr(datei, "/"LIBLOGDIR"/") == 0
+ || strstr(datei, "/"FTPDIR"/") == 0
+ )
+ return 1;
+
+ // Datei muss Besitzer haben
+ if (!(creator=creator_file(datei))) return 1;
+
+ // Hack, damit simul_efun geladen werden kann
+ if (creator==ROOTID && po==TO) return ROOTID;
+
+ // Keine euid, kein Laden ...
+ if (!(pouid=geteuid(po))) return 1; // Disallow if no euid in po
+
+ // Root generiert keine Root-Objekte ;-)
+ // Nur UID setzen
+ if (pouid==ROOTID)
+ return ({creator,NOBODY}); // root does not create root objects!
+
+ // EUID mitsetzen, wenn PO==creator oder creator==BACKBONEID
+ if (creator==pouid || creator==BACKBONEID)
+ return pouid;
+
+ return ({creator,NOBODY});
+}
+
+// Die System-IDs muessen bekannt sein
+string get_master_uid() { return ROOTID;}
+string get_bb_uid() { return BACKBONEID; }
+// TODO: Bei get_wiz_name koennte man - so moeglich - auf 'wirkliche'
+// Magiernamen gehen (Idee von mandragon)
+string get_wiz_name(string file) { return creator_file(file);}
+
+// ##########################
+//###################### Sonstige GD-Funktionen #########################
+// ##########################
+
+// Spieler hat sich eingeloggt
+protected object connect()
+{
+ string err;
+ int errno;
+ object ob,bp;
+
+#if defined(SSLPORT) && __EFUN_DEFINED__(tls_available)
+ if (efun::interactive_info(this_player(), II_MUD_PORT) == SSLPORT) {
+ // reject connection of TLS is not available
+ if (!tls_available())
+ return 0;
+ // establish TLS
+ errno=tls_init_connection();
+ if (errno < 0) {
+ // Fehler im Vebindungsaufbau
+ printf("Can't establish a TLS/SSL encrypted connection: %s\n",
+ tls_error(errno));
+ return 0; // this will close the connection to the client.
+ }
+ }
+#endif
+
+ // Blueprint im Environment? Das geht nun wirklich nicht ...
+ if ((bp=find_object("/secure/login")) && environment(bp))
+ catch(destruct(bp);publish);
+
+ // Login-Shell clonen
+ err = catch(ob = clone_object("secure/login"); publish);
+
+ if (errno == 0 && err)
+ write("Fehler beim Laden von /secure/login.c\n"+err+"\n");
+
+ return ob;
+}
+
+// Was machen bei disconnect?
+protected void disconnect(object who, string remaining) {
+ who->NetDead(); return;
+}
+
+// Es gibt kein File 'filename'. VC aktivieren so vorhanden ...
+protected object compile_object(string filename)
+{
+ object ret;
+ string *str;
+ string compiler;
+
+ if (!sizeof(filename)) return 0;
+ str=efun::explode(filename,"/");
+
+ if(sizeof(str)<2) return 0;
+ compiler=implode(str[0..<2],"/")+"/virtual_compiler";
+
+ if (find_object(compiler)
+ || file_size(compiler+".c")>0)
+ {
+ if(catch(
+ ret=(object)call_other(compiler,"compile_object",str[<1]); publish))
+ return 0;
+ }
+ else
+ return(0);
+
+ if ( objectp(ret) && efun::explode(creator_file(filename), ".")[<1] !=
+ REAL_EUID(ret) ){
+ funcall( symbol_function('log_file/*'*/), "ARCH/VC_MISSBRAUCH",
+ sprintf( "%s: %s versucht per VC %s zu %s umzubenennen!\n",
+ funcall( symbol_function('dtime/*'*/), time() ),
+ (this_interactive() ? getuid(this_interactive()):
+ object_name(previous_object())), object_name(ret),
+ filename) );
+
+ return 0;
+ }
+ return ret;
+}
+
+// ############
+//############################ Shutdown #################################
+// ############
+
+// Spieler bei Shutdown entfernen
+protected void remove_player(object victim)
+{
+ catch(victim->quit());
+ if (victim) catch(victim->remove());
+ if (victim) destruct(victim);
+ return;
+}
+
+// Langsamer Shutdown
+protected void slow_shut_down(int minutes)
+{
+ //sollte nur vom GD gerufen werden. Oder allenfalls Master selbst
+ filter(users(),#'tell_object,
+ "Der Gamedriver ruft: Der Speicher wird knapp ! Bereitet euch auf das Ende vor !\n");
+ "/obj/shut"->shut(minutes);
+ return;
+}
+
+
+// In LD varargs void notify_shutdown(string crash_reason)
+protected varargs void notify_shutdown (string crash_reason) {
+
+ if (PO && PO != TO)
+ return;
+ if (crash_reason) {
+ //Uhoh... Verdammter Crash. :-( Zumindest mal mitloggen,
+ //was der Driver sagt...
+ write_file(CRASH_LOG,sprintf(
+ "\n%s: The driver crashed! Reason: %s\n",
+ ctime(time()),crash_reason));
+ }
+
+ filter(users(), #'tell_object,
+ "Game driver shouts: LDmud shutting down immediately.\n");
+ save_wiz_file();
+ return;
+}
+
+// ##################
+//########################## Berechtigungen #############################
+// ##################
+
+// Darf Verbindung durch name von obfrom nach ob gelegt werden?
+
+//int valid_exec(string name) {return 1;}
+
+int valid_exec(string name, object ob, object obfrom)
+{
+ // Ungueltige Parameter oder Aufruf durch process_string -> Abbruch
+ if (!objectp(ob) || !objectp(obfrom)
+ || !stringp(name) || !sizeof(name)
+ || funcall(symbol_function('process_call)) )
+ return 0;
+
+ // renew_player_object() darf ...
+ if (name=="/secure/master/misc.c"
+ || name=="secure/master/misc.c")
+ return 1;
+
+ // Ansonsten darf sich nur die Shell selber aendern ...
+ if (previous_object() != obfrom) return 0;
+
+ // Die Login-Shell zu jedem Objekt ...
+ if (name=="/secure/login.c"
+ || name=="secure/login.c")
+ return 1;
+
+ // Magier per exec nur, wenn sie damit keine Fremde uid/euid bekommen
+ if (this_interactive() == obfrom && getuid(obfrom) == getuid(ob)
+ && geteuid(obfrom) == geteuid(ob))
+ return 1;
+
+ // Sonst darf niemand was
+ return 0;
+}
+
+
+// Darf me you snoopen?
+int valid_snoop(object me, object you) {
+ return getuid(PO) == ROOTID;
+}
+
+// Darf wiz wissen, ob er gesnoopt wird?
+int valid_query_snoop(object wiz) {
+ return getuid(PO) == ROOTID;
+}
+
+// Darf ob seine EUID auf neweuid setzen?
+int valid_seteuid(object ob, string neweuid)
+{
+ return (ob==this_object() ||
+ getuid(ob) == ROOTID ||
+ getuid(ob) == neweuid ||
+ creator_file(object_name(ob)) == neweuid);
+}
+
+// Darf getraced werden?
+int valid_trace(string what, mixed arg) {
+ return IS_ARCH(TI);
+}
+
+
+// valid_write() und
+// valid_read() befinden sich in file_access.c
+
+
+// Darf PO ob shadowen?
+int query_allow_shadow(object ob)
+{
+ // ROOT darf nicht geshadowed werden
+ if(getuid(ob) == ROOTID)
+ return 0;
+
+ // Access-Rights auch nicht
+ if (efun::explode(object_name(ob),"#")[0][<14..]=="/access_rights")
+ return 0;
+
+ // Ansonsten query_prevent_shadow fragen ...
+ return !(int)ob->query_prevent_shadow(PO);
+}
+
+
+/* privilege_violation is called when objects try to do illegal things,
+ * or files being compiled request a privileged efun.
+ *
+ * return values:
+ * 1: The caller/file is allowed to use the privilege.
+ * 0: The caller was probably misleaded; try to fix the error.
+ * -1: A real privilege violation. Handle it as error.
+ */
+int privilege_violation(string op, mixed who, mixed arg1, mixed arg2)
+{
+
+ if (objectp(who) &&
+ (who==this_object() || geteuid(who)==ROOTID))
+ return 1;
+
+ switch(op)
+ {
+ case "call_out_info":
+ return -1;
+ case "send_udp":
+ return 1;
+
+ case "nomask simul_efun":
+ // <who> ist in diesem Fall ein string (Filename) und damit von dem
+ // Check da oben nicht abgedeckt. Daher explizite Behandlung hier.
+ // Ausserdem hat der Pfad (zur Zeit noch) keinen fuehrenden '/'.
+ // Falls das jemand einschraenken will: der Kram fuer die simul_efuns
+ // muss das duerfen!
+ if (stringp(who)
+ && strstr(who,"secure/") == 0)
+ return 1;
+ return 0; // alle andere nicht.
+
+ case "get_extra_wizinfo":
+ // benutzt von /secure/memory.c und /secure/simul_efun.c
+ case "set_extra_wizinfo":
+ // wird benutzt von simul_efun.c, welche aber als ROOT-Objekt implizit
+ // erlaubt ist (s.o.)
+ return -1; // fuer allen nicht erlaubt.
+
+ case "rename_object":
+ if (object_name(who)=="/secure/impfetch" ||
+ BLUE_NAME(who)=="/secure/login")
+ return 1;
+ return(-1);
+
+ case "configure_driver":
+ return call_sefun("secure_level") >= ARCH_LVL;
+
+ case "limited":
+ // Spielershells duerfen sich zusaetzliche Ticks fuer den Aufruf von
+ // ::die() beschaffen, damit der Tod nicht wegen wenig Ticks buggt.
+ if (strstr(load_name(who), "/std/shells/") == 0
+ && get_type_info(arg1, 2) == who
+ && get_type_info(arg1, 3) == "/std/living/life"
+// && get_type_info(arg1, 4) == "die"
+ && arg2[LIMIT_EVAL] <= 10000000 ) {
+ return 1;
+ }
+ //DEBUG(sprintf("%O, %O, %O", who, arg1, arg2));
+ int *limits=efun::driver_info(DI_CURRENT_RUNTIME_LIMITS);
+ // LIMIT_EVAL darf verringert werden. Alle anderen Limits duerfen nicht
+ // geaendert werden. Achja, LIMIT_EVAL darf nicht 0 (LIMIT_UNLIMITED)
+ // sein. *g*
+ // LIMIT_COST darf entweder 0 oder -100 sein.
+ if (arg2[LIMIT_EVAL]>1000 && (arg2[LIMIT_EVAL] < get_eval_cost())-500
+ && arg2[LIMIT_ARRAY] == limits[LIMIT_ARRAY]
+ && arg2[LIMIT_MAPPING_KEYS] == limits[LIMIT_MAPPING_KEYS]
+ && arg2[LIMIT_MAPPING_SIZE] == limits[LIMIT_MAPPING_SIZE]
+ && arg2[LIMIT_BYTE] == limits[LIMIT_BYTE]
+ && arg2[LIMIT_FILE] == limits[LIMIT_FILE]
+ && arg2[LIMIT_CALLOUTS] == limits[LIMIT_CALLOUTS]
+ && (arg2[LIMIT_COST] == 0 || arg2[LIMIT_COST] == -100) )
+ return(1);
+ //sonst verweigern.
+ return(-1);
+
+ case "sqlite_pragma":
+ return 1;
+ case "attach_erq_demon":
+ case "bind_lambda":
+ case "configure_interactive":
+ case "configure_object":
+ case "execute_command":
+ case "erq":
+ case "input_to":
+ case "mysql":
+ case "net_connect":
+ case "pgsql":
+ case "set_driver_hook":
+ case "set_this_object":
+ case "shadow_add_action":
+ case "symbol_variable":
+ case "variable_list":
+ case "wizlist_info":
+ default:
+ return(-1);
+ }
+ return -1;
+}
+
+// ####################
+//######################## Fehlerbehandlung #############################
+// ####################
+
+// Behandlung von Fehler im Heart_Beat
+protected int heart_beat_error( object culprit, string error, string program,
+ string current_object, int line, int caught)
+{
+ if (!objectp(culprit)) return 0;
+ if (interactive(culprit))
+ {
+ tell_object(culprit,"Der GameDriver teilt Dir mit: "
+ "Dein Herzschlag hat ausgesetzt!\n");
+ if (IS_LEARNER(culprit))
+ tell_object(culprit,
+ sprintf("Fehler: %sProgamm: %s, CurrObj: %s, Zeile: %d, "
+ "the error was %scaught at higher level.\n",
+ error,program,current_object,line,
+ caught ? "" : "not"));
+ }
+
+ if (efun::object_info(culprit, OI_ONCE_INTERACTIVE))
+ call_out("restart_heart_beat", 5, culprit);
+ else
+ catch(culprit->make_immortal(); publish);
+ return 0;
+}
+
+// Ausgabe einer Meldung an Spieler mit Level >= minlevel. Wird genutzt, um
+// Magier ueber Fehler zu informieren, die nicht normal behandelt werden
+// (z.B. rekursive Fehler, d.h. Fehler in der Fehlerbehandlung)
+private void tell_players(string msg, int minlevel) {
+ msg = efun::sprintf("%=-78s","Master: " + msg); // umbrechen
+ efun::filter(efun::users(), function int (object pl)
+ {
+ if (query_wiz_level(pl) >= minlevel)
+ efun::tell_object(pl, msg);
+ return 0;
+ } );
+}
+
+/**
+ * \brief Error handling fuer Fehler beim Compilieren.
+ *
+ * log_error() wird vom GameDriver aufgerufen, wenn zur Compile-Zeit ein
+ * Fehler auftrat. Die Fehlermeldung wird unter /log/error geloggt.
+ * Falls this_interactive() ein Magier ist, bekommt er die Fehlermeldung
+ * direkt angezeigt.
+ * Sollte das Logfile 50kB ueberschreiten, wird es rotiert. Auf [Entwicklung]
+ * wird dann eine Fehlermeldung abgesetzt.
+ *
+ * @param file Die Datei, in der der Fehler auftrat.
+ * @param message Die Fehlermeldung.
+ * @param warn Warnung (warn!=0) oder Fehler (warn==0)?
+ * */
+
+protected void log_error(string file, string message, int warn) {
+ string lfile;
+ string cr;
+ mixed *lfile_size;
+
+ if (handling_error == efun::time()) {
+ // Fehler im Verlauf einer Fehlerbehandlung: Fehlerbehandlung minimieren,
+ // nur Meldung an eingeloggte Erzmagier.
+ tell_players("log_error(): Rekursiver Fehler in Fehlerbehandlung. "
+ "Bitte Debuglog beachten. Aktueller Fehler in " + file + ": "
+ + message, ARCH_LVL);
+ return;
+ }
+ handling_error = efun::time();
+
+ //Fehlerdaten an den Errord zur Speicherung weitergeben, falls wir sowas
+ //haben.
+#ifdef ERRORD
+ // Only call the errord if we are _not_ compiling the sefuns. It uses sefuns
+ // and it will cause a recursing call to get_simul_efuns() which is bound to
+ // fail.
+ if (!loading_simul_efuns) {
+ catch(limited(#'call_other,({200000}),ERRORD,"LogCompileProblem",
+ file,message,warn);publish );
+ }
+#endif // ERRORD
+
+ // Logfile bestimmen
+ cr=creator_file(file);
+ if (!cr) lfile="NOBODY.err";
+ else if (cr==ROOTID) lfile="ROOT";
+ else if (efun::member(cr,' ')!=-1) lfile="STD";
+ else lfile=cr;
+ //je nach Warnung oder Fehler Verzeichnis und Suffix bestimmen
+ if (warn) {
+ lfile="/log/warning/" + lfile + ".warn";
+ }
+ else {
+ lfile="/log/error/" + lfile + ".err";
+ }
+
+ // Bei Bedarf Rotieren des Logfiles
+ if ( !loading_simul_efuns
+ && sizeof(lfile_size = get_dir(lfile,2))
+ && lfile_size[0] >= MAX_ERRLOG_SIZE )
+ {
+ catch(rename(lfile, lfile + ".old"); publish); /* No panic if failure */
+ if (!loading_simul_efuns)
+ {
+ catch(send_channel_msg("Entwicklung","<MasteR>",
+ "Logfile rotiert: "+lfile+"."));
+ }
+ }
+
+ efun::write_file(lfile,message);
+
+ // Magier bekommen die Fehlermeldung angezeigt
+ if (IS_LEARNER(TI)) efun::tell_object(TI, message);
+
+ handling_error = 0;
+}
+
+/* Gegenmassnahme gegen 'too long eval' im Handler vom runtime error:
+ Aufsplitten des Handlers und Nutzung von limited() */
+//keine GD-Funktion
+private void handle_runtime_error(string err, string prg, string curobj,
+ int line, mixed culprit, int caught, object po, int issueid)
+{
+ string code;
+ string debug_txt;
+ object ob, titp;
+
+ //DEBUG(sprintf("Callerstack: (handle_runtime_error()): %O\n",
+ // caller_stack(1)));
+ // Fehlermeldung bauen
+ if (!stringp(err)) err="<NULL>";
+ if (!stringp(prg)) prg="<NULL>";
+ if (!stringp(curobj)) curobj="<NULL>";
+ debug_txt=efun::sprintf("Fehler: %O, Objekt: %s, Programm: %O, Zeile %O (%s), "
+ "ID: %d",
+ err[0..<2], curobj, (prg[0]!='<'?"/":"")+prg, line,
+ (TI?efun::capitalize(efun::getuid(TI)):"<Unbekannt>"),
+ issueid);
+
+ titp = TI || TP;
+ // Fehlermeldung an Kanaele schicken, aber nur wenn der aktuelle Fehler
+ // nicht waehrend des ladens der simulefuns auftrat, bei der Ausgabe der
+ // Meldung ueber die Kaenaele wieder sefuns genutzt werden.
+ if (!loading_simul_efuns) {
+ if (titp && (IS_LEARNER(titp) || (titp->QueryProp(P_TESTPLAYER))))
+ {
+ catch(send_channel_msg("Entwicklung",
+ capitalize(objectp(po) ? REAL_UID(po) : ""),
+ debug_txt));
+ }
+ else
+ {
+ catch(send_channel_msg("Debug",
+ capitalize(objectp(po) ? REAL_UID(po) : ""),
+ debug_txt));
+ }
+ }
+
+ if (!titp) return;
+
+ // Fehlermeldung an Benutzer
+ if (IS_LEARNER(titp))
+ efun::tell_object(titp,
+ efun::sprintf("%'-'78.78s\nfile: %s line: %d object: %s\n" +
+ "%serror: %s%'-'78.78s\n","",prg,line,curobj,
+ (prg&&(code=efun::read_file("/"+prg,line,1))?
+ "\n"+code+"\n":""),err,""));
+ else
+ efun::tell_object(titp, "Du siehst einen Fehler im Raum-Zeit-Gefuege.\n");
+}
+
+//Keine GD-Funktion, limitiert die Kosten fuer den handler
+private void call_runtime_error(string err, string prg, string curobj,
+ int line, mixed culprit, int caught, object po)
+{
+ if (handling_error == efun::time())
+ {
+ // Fehler im Verlauf einer Fehlerbehandlung: Fehlerbehandlung minimieren,
+ // nur Meldung an eingeloggte Regionsmagier.
+ tell_players("call_runtime_error(): Rekursiver Fehler in "
+ "Fehlerbehandlung. Bitte Debuglog beachten. Aktueller Fehler in "
+ + curobj + ": " + err, LORD_LVL);
+ return;
+ }
+ handling_error = efun::time();
+
+ //Fehlerdaten an den Errord zur Speicherung weitergeben, falls wir sowas
+ //haben.
+#ifdef ERRORD
+ int issueid;
+ // Wenn die sefuns gerade geladen werden, erfolgt keine Weitergabe an den
+ // ErrorD, da dabei wieder sefuns gerufen werden, was zu einer Rekursion
+ // fuehrt.
+ if (!loading_simul_efuns) {
+ catch(issueid=efun::limited(#'call_other,({200000}),ERRORD,"LogError",
+ err,prg,curobj,line,culprit,caught);publish);
+ }
+#endif // ERRORD
+
+ //eigenen Errorhandler laufzeitbegrenzt rufen
+ efun::limited(#'handle_runtime_error, ({ 200000 }), err, prg, curobj,
+ line,culprit,caught, po, issueid);
+
+ handling_error = 0;
+}
+
+// Laufzeitfehlerbehandlung, hebt Evalcost-Beschraenkung auf und reicht weiter
+// an call_runtime_error, die die Grenze wieder auf einen bestimmten Wert
+// festlegt.
+protected void runtime_error(string err ,string prg, string curobj, int line,
+ mixed culprit, int caught) {
+
+ //DEBUG(sprintf("Callerstack: (runtime_error()): %O\nPO: %O\nPO(0): %O\n",
+ // caller_stack(1),previous_object(),previous_object(0)));
+
+ limited(#'call_runtime_error, ({ LIMIT_UNLIMITED }),
+ err,prg,curobj,line,culprit,caught,previous_object());
+}
+
+//Warnungen mitloggen
+protected void runtime_warning( string msg, string curobj, string prog, int line,
+ int inside_catch)
+{
+ string code;
+ string debug_txt;
+ object titp;
+
+ //DEBUG(sprintf("Callerstack: in runtime_warning(): %O\nPO(0): %O\n",
+ // caller_stack(1),previous_object(0)));
+
+ //Daten der Warnung an den Errord zur Speicherung weitergeben, falls wir
+ //sowas haben.
+ int issueid;
+#ifdef ERRORD
+ catch(issueid=limited(#'call_other,({200000}),ERRORD,"LogWarning",
+ msg,prog,curobj,line,inside_catch); publish);
+#endif // ERRORD
+
+ // Fehlermeldung bauen
+ if (!stringp(msg)) msg="<NULL>";
+ if (!stringp(prog)) prog="<NULL>";
+ if (!stringp(curobj)) curobj="<NULL>";
+ debug_txt=sprintf("Warnung: %O, Objekt: %s, Programm: %O, Zeile %O (%s) "
+ "ID: %d",
+ msg[0..<2], curobj, (prog[0]!='<'?"/":"")+prog, line,
+ (TI?capitalize(getuid(TI)):"<Unbekannt>"),
+ issueid);
+
+ //Fehlermeldungen an -warnungen schicken
+ catch(send_channel_msg("Warnungen",
+ capitalize(objectp(previous_object()) ?
+ REAL_UID(previous_object()) : ""),
+ debug_txt));
+
+ titp = TI || TP;
+
+ if (!titp) return;
+
+ // Fehlermeldung an Benutzer
+ if (IS_LEARNER(titp))
+ tell_object(titp,
+ sprintf("%'-'78.78s\nfile: %s line: %d object: %s\n" +
+ "%sWarnung: %s%'-'78.78s\n","",prog,line,curobj,
+ (prog&&(code=read_file("/"+prog,line,1))?
+ "\n"+code+"\n":""),msg,""));
+ return;
+}
+
+
+// #####################
+//######################## Einrichten des ED ############################
+// #####################
+
+// Setup speichern
+protected int save_ed_setup(object who, int code)
+{
+ string file;
+
+ if (!intp(code)) return 0;
+ file = sprintf("/players/%s/.edrc",geteuid(who));
+ rm(file);
+ return write_file(file,(string)code);
+}
+
+// Setup einladen
+protected int retrieve_ed_setup(object who)
+{
+ string file;
+
+ file = sprintf("/players/%s/.edrc",getuid(who));
+ if (file_size(file)<1) return 0;
+ return (int)read_file(file);
+}
+
+// Wo werden Dateien gespeichert?
+string get_ed_buffer_save_file_name(string file)
+{
+ return sprintf("/players/%s/.dead_ed_files/%s",
+ getuid(this_player()),efun::explode(file, "/")[<1]);
+}
+
+// ################################
+//################### Ungenutzte Pflichtfunktionen ######################
+// ################################
+
+// Nichts zu tun beim Master-Neustart
+protected void external_master_reload() { return; }
+
+// Keine externen Master-Flags
+protected void flag(string str) { return; }
+
+// Wird benoetigt, falls ERQ angeschlossen ist
+protected void stale_erq(closure callback) { return; }
+
+// Zerstoerten Master wiederbeleben ...
+// nicht viel zu tun, wenn flag gesetzt ist. Wenn aber nicht, sind alle
+// Variablen auf 0. Nach dieser Funktion wird wieder inaugurate_master()
+// gerufen.
+protected void reactivate_destructed_master(int flag) {
+ if (flag) {
+ //re-init
+ //was machen? TODO
+ }
+ return;
+}
+
+// Kein Quota-Demon (potentielles TODO)
+//Handle quotas in times of memory shortage.
+//is called during the final phase of a garbage collection, if the user
+//reserve could not be re-allocated. Last (!) Chance to free (active) objects
+//from the system and prevent call to slow_shut_down()!
+protected void quota_demon() {
+ //was kann man machen?
+ //uebervolle Seherhaeuser leeren?
+ return;
+}
+
+// Keine Prepositionen in parse_command
+//string *parse_command_prepos_list() { return ({}); }
+
+// Wie lautet das Wort fuer 'alle' ?
+//string *parse_command_all_word() { return ({}); }
+
+
+// Keine Besonderen Objektnamen
+string printf_obj_name(object ob) { return 0; }
+
+// ###################
+//######################### Sonstiges/Hooks #############################
+// ###################
+
+//TODO: save_wiz_file in shutdown() integrieren?
+// Wizliste speichern: Zeile generieren
+static string _save_wiz_file_loop(mixed *a)
+{
+ return sprintf("%s %d %d\n",a[WL_NAME],a[WL_COMMANDS],a[WL_EXTRA]);
+}
+
+// Wizliste speichern
+protected void save_wiz_file()
+{
+ rm("/WIZLIST");
+ write_file("/WIZLIST",implode(
+ map(wizlist_info(),#'_save_wiz_file_loop),""));
+}
+
+// TODO: macht der telnet_neg-hook ueberhaupt was?
+void telnet_neg(mixed cmd,mixed opt,mixed args)
+{
+ if (opt==34 && cmd==251)
+ binary_message(({255,250,34,1,1,255,240}));
+}
+
+// EUID und UID werden von give_uid_to_object() vergeben, diese sind in
+// inaugurate_master() als driver hooks angemeldet.
+
+/*load_uid_hook() sollte machen, was diese Lambda machte...
+ unbound_lambda( ({'printf_obj_name}),
+ ({#'give_uid_to_object,'printf_obj_name,
+ ({#'previous_object}),0}))); */
+protected mixed load_uid_hook(string datei) {
+ return(give_uid_to_object(datei,previous_object()));
+}
+
+/* clone_uid_hook sollte machen, was diese Lambda machte...
+ unbound_lambda( ({'blueprint, 'new_name}),
+ ({#'give_uid_to_object,'new_name,
+ ({#'previous_object}),1}))); */
+protected mixed clone_uid_hook(string blueprint,string new_name) {
+ return(give_uid_to_object(new_name,previous_object()));
+}
+