blob: 0574cdf877f14711268086ce8f9a74630e7469cd [file] [log] [blame]
MG Mud User88f12472016-06-24 23:31:02 +02001// MorgenGrauen MUDlib
2//
3// master.c -- master object
4//
5// $Id: master.c 9530 2016-03-17 19:59:01Z Zesstra $
6#pragma strict_types
7#pragma no_clone
8#pragma no_shadow
9#pragma no_inherit
10#pragma verbose_errors
11#pragma combine_strings
12#pragma pedantic
13#pragma range_check
14#pragma warn_deprecated
15
16#include "/sys/files.h"
17#include "/sys/interactive_info.h"
18#include "/sys/driver_info.h"
19
20inherit "/secure/master/misc";
21inherit "/secure/master/userinfo";
22inherit "/secure/master/network";
23inherit "/secure/master/domain";
24inherit "/secure/master/guild";
25inherit "/secure/master/file_access";
26inherit "/secure/master/players_deny";
27
28#include "/secure/master.h"
29
30//for limited, set_limit(), etc. Abs. Pfad noetig, da noch kein Include-Hook
31#include "/sys/rtlimits.h"
32#include "/sys/debug_info.h"
33#include "/sys/debug_message.h"
34#include "/sys/configuration.h"
35#include "/sys/regexp.h"
36
37// Module des Master einfuegen. Per #include, damits geringfuegig schneller.
38// Da die Module ja nirgendwo sonst geerbt werden koennten, ist dies
39// ausnahmsweise OK. ;)
40#include "/secure/master/destruct.c"
41#include "/secure/master/autoinclude.c"
42
43// Fuer Logfile(-Rotation)
44#define RESETINT 3600 // jede Stunde
45#define LOGROTATE (24*2) // alle 48h
46#define LOGFILEAGE (RESETINT*LOGROTATE) // alle 2 tage wechseln
47#define LOGNUM 3 // Anzahl der Logfiles
48
49private nosave int logrotate_counter; //READ_FILE alle LOGROTATE Resets rotieren
50// Wird gerade versucht, die simul_efuns zu laden? Wenn ja, duerfen keine
51// sefuns gerufen werden.
52private nosave int loading_simul_efuns;
53// wird gerade ein Fehler bearbeitet? Dient zur Erkennung von Rekursionen in
54// der Fehlerbehandlung
55private nosave int handling_error;
56
57// #####################
58//######################## Start des Masters ############################
59// #####################
60
61// Initialisierung des Masters
62//arg==0: Mud startet gerade, arg==1: Master wurde reaktiviert,
63//arg==2: Master reaktiviert (Variablen weg), arg==3: Master wurde
64//neugeladen.
65protected void inaugurate_master(int arg) {
66
67 set_driver_hook(H_REGEXP_PACKAGE, RE_TRADITIONAL);
68
69 seteuid(ROOTID);
70 userinfo::create();
71 LoadPLDenylists();
72
73 // Was soll vor jede Datei geschrieben werden?
74 set_driver_hook(H_AUTO_INCLUDE, #'autoincludehook);
75
76 //div. Listen einlesen
77 ReloadBanishFile();
78 ReloadDeputyFile();
79 ReloadInsecureFile();
80
81 // Bei Neustart wizinfo initialisieren
82 if (!arg)
83 set_extra_wizinfo(0, allocate(BACKBONE_WIZINFO_SIZE));
84
85 //simul_efun.c nach inaugurate_master() starten und initialisieren,
86 //(so richtig seh ich den Sinn hier momentan nicht ein...
87 //call_out("start_simul_efun",0);
88
89 // Reset festsetzen (1h)
90 set_next_reset(RESETINT);
91
92 // Driver konfigurieren
93 // Lagerkennung erst ne Minute spaeter, waehrend preload darfs momentan
94 // ruhig laggen (Zeit: vorlaeufig 1min)
95 call_out(#'configure_driver, 60, DC_LONG_EXEC_TIME, 100000);
96
97 // Hooks setzen
98
99 // Standardincludeverzeichnisse fuer #include <>
100 set_driver_hook(H_INCLUDE_DIRS, ({"/secure/","/sys/"}) );
101
102 //Nach dem Laden/Clonen create() im Objekt rufen
103 set_driver_hook(H_CREATE_CLONE, "create");
104 set_driver_hook(H_CREATE_OB, "create");
105 set_driver_hook(H_CREATE_SUPER, "create_super");
106
107 // Bei Reset reset() im Objekt aufrufen
108 set_driver_hook(H_RESET, "reset");
109
110 // Zum Aufraeumen clean_up() im Objekt aufrufen
111 set_driver_hook(H_CLEAN_UP, "clean_up");
112
113 // Jede Eingabe wird ueber modify_command gelenkt
114 set_driver_hook(H_MODIFY_COMMAND, "modify_command");
115 // Dieser Hook ist mandatory, aber wird nur benutzt, wenn via
116 // set_modify_command() aktiviert - was wir nicht (mehr) tun. Insofern ist
117 // das Relikt aus alten Zeiten.
118 //set_driver_hook(H_MODIFY_COMMAND_FNAME, "modify_command");
119
120 // Standard-Fehlermeldung
121 //set_driver_hook(H_NOTIFY_FAIL, "Wie bitte?\n");
122 set_driver_hook(H_NOTIFY_FAIL, function string (string cmd, object tp)
123 {if (stringp(cmd=(string)tp->QueryProp(P_DEFAULT_NOTIFY_FAIL)))
124 return(cmd);
125 return("Wie bitte?\n");});
126
127 // Was machen bei telnet_neg
128 set_driver_hook(H_TELNET_NEG,"telnet_neg");
129 // set_driver_hook(H_TELNET_NEG,0);
130
131 // Promptbehandlung: Defaultprompt setzen und dafuer sorgen, dass alle
132 // Promptausgaben durch print_prompt im Interactive laufen, damit das EOR
133 // angehaengt wird.
134 set_driver_hook(H_PRINT_PROMPT, "print_prompt");
135 set_driver_hook(H_DEFAULT_PROMPT, "> ");
136
137 // EUID und UID muessen neue Objekte auch noch kriegen, Hooks dafuer setzen
138 set_driver_hook(H_LOAD_UIDS, #'load_uid_hook);
139 set_driver_hook(H_CLONE_UIDS, #'clone_uid_hook);
140
141 // Meldung bei vollem Mud
142 set_driver_hook(H_NO_IPC_SLOT, "Momentan sind leider zuviele Spieler im "
143 +MUDNAME+" eingeloggt.\nBitte komm doch etwas spaeter nochmal "
144 "vorbei!\n");
145
146 // Nun der beruechtigte Move-Hook ...
147 // (bewegt objekt und ruft alle notwendigen inits auf)
148 // Hier wird H_MOVE_OBJECT0 benutzt, d.h. die lambda wird an das aktuelle
149 // Objekt vor Ausfuehrung gebunden, nicht an 'item', was move_objet()
150 // uebergeben wurde.
151 set_driver_hook(H_MOVE_OBJECT0,
152 unbound_lambda(({'item,'dest}),
153 ({#',, // item!=this_object?
154 ({#'?,({#'!=,'item,({#'this_object})}),
155 ({#'raise_error, // ->Fehler!
156 "Illegal to move other object than this_object()\n"}) }),
157 ({#'efun::set_environment,'item,'dest}), // item nach dest bewegen
158 ({#'?,
159 ({#'living,'item}), // living(item)?
160 ({#',,
161 ({#'efun::set_this_player,'item}), // set_this_player(item)
162 ({#'call_other,'dest,"init"}), // dest->init()
163 ({#'?!,
164 ({#'&&, // !objectp(item)||
165 ({#'objectp, 'item}), // env(item)!=dest?
166 ({#'==,({#'environment, 'item}),'dest})}),
167 ({#'return})})})}), // -> fertig
168 ({#'=,'others,({#'-,({#'all_inventory,'dest}),({#'({,'item})})}),
169#ifdef EMACS_NERV
170 }) // Emacs kann ({#'({ nicht parsen // others=all_inv(dest)-
171#endif // ({item})
172 ({#'filter,'others,lambda(({'ob,'item}),
173 ({#'?,
174 ({#'&&,
175 ({#'objectp,'item}), // objectp(item)&&
176 ({#'living,'ob}), // living(ob)&&
177 ({#'==,({#'environment,'item}),({#'environment,'ob})})}),
178 ({#',, // env(item)==env(ob)?
179 ({#'efun::set_this_player, 'ob}), // set_this_player(ob)
180 ({#'call_other,'item, "init"}) // item->init()
181 })})),'item}),
182 ({#'?,
183 ({#'living,'item}), // living(item)?
184 ({#',,
185 ({#'efun::set_this_player,'item}), // set_this_player(item)
186 ({#'filter,'others,lambda(({'ob,'item}),
187 ({#'?,
188 ({#'&&,
189 ({#'objectp,'item}), // objectp(item)&&
190 ({#'objectp,'ob}), // objectp(ob)&&
191 ({#'==,({#'environment,'item}),({#'environment,'ob})})
192 }), // env(item)==env(ob)?
193 ({#'call_other,'ob,"init"}) // ob->init()
194 })),'item})})}),
195 ({#'?,
196 ({#'&&,
197 ({#'objectp,'item}), // objectp(item)&&
198 ({#'living,'dest}), // living(dest)&&
199 ({#'==,({#'environment,'item}),'dest})// env(item)==dest?
200 }),
201 ({#',,
202 ({#'efun::set_this_player,'dest}), // set_this_player(dest)
203 ({#'call_other,'item,"init"})})})})));// item->init()
204 DEBUG("Master inaugurated");
205 return;
206}
207
208// epilog() gibt die Dateien zurueck, die vorgeladen werden muessen
209protected string *epilog(int eflag) {
210 string *files, *domains;
211 int i;
212
213 seteuid(ROOTID);
214 ReloadBanishFile();
215 ReloadDeputyFile();
216 ReloadInsecureFile();
217
218 if (eflag) {
219 write("-e angegeben -> Preloading unterdrueckt ...\n");
220 return 0;
221 }
222
223 printf("Preloading gestartet: %s\n\n",ctime(time()));
224
225 //Files fuers Preloading und Regionen holen
226 files=explode_files("/std/preload_file") + explode_files("/d/preload_file");
227 domains=get_domains() + ({"erzmagier"}); // EM haben auch ein Preload File
228
229 for (i=sizeof(domains);i--;)
230 files+=explode_files("/d/"+domains[i]+"/preload_file");
231
232 write("\n");
233
234 return files;
235}
236
237// preload() wird fuer jeder Datei im Preload einmal durchlaufen
238protected void preload(string file) {
239 string err;
240 string name;
241 int *res, zeit;
242
243 // Kein richtiger Dateiname: fertig
244 if(!file || !file[0] || file[0] == ';' || file_size(file+".c") < 0) return;
245
246 // Kein Besitzer -> Meldung ausgeben, fertig
247 if (!(name=creator_file(file)))
248 {
249 printf("Kein Besitzer gefunden fuer Datei %s.\n",file);
250 return;
251 }
252
253 // Datei und Besitzer ausgeben
254 printf("%-50s%-15s",file,name);
255
256 // Euid kann nicht geaendert werden -> Meldung, fertig
257 if (!seteuid(name))
258 {
259 printf("\nEuid konnte nicht auf %s gesetzt werden\n"+
260 "Sie ist nun %s.\n",name,geteuid(TO));
261 return;
262 }
263
264 // Dann mal laden .. dabei Zeit messen
265 zeit = apply(#'+,rusage()[0..1]);
266
267 // Waehrend des Preloads sind 1.5MTicks leider nicht soviel, insb. wenn
268 // sowas wie der channeld jede menge Objekte laden muss, die wiederum erst
269 // das ganze Geraffel aus /std/ laden. Daher hier einfach mal fuers Preload
270 // die Grenze hoch.
271 err = catch(limited(#'load_object,({5000000}),file));
272
273 if (err != 0)
274 printf("\nFehler beim Laden von %s:\n%s\n",file,err);
275 else
276 {
277 zeit=apply(#'+,rusage()[0..1])-zeit;
278 printf("(%2d.%:02d s)\n",zeit/1000,zeit%1000);
279 }
280
281 // Noch EUID zuruecksetzen
282 seteuid(ROOTID);
283
284 return;
285}
286
287//simul_efun.c laden oder die spare_simul_efun.c als Fallback
288//es ist moeglich, hier ein Array von strings zurueckzugeben. Die
289//nachfolgenden gelten als Backup-Objekte, falls eine sefun im Hauptobjekt
290//nicht gefunden wird.
291protected string *get_simul_efun() {
292 string err;
293
294 ++loading_simul_efuns;
295
296 if (!(err=catch(SIMUL_EFUN_FILE->start_simul_efun())) ) {
297 --loading_simul_efuns;
298 return ({SIMUL_EFUN_FILE});
299 }
300
301 write("Failed to load simul efun " + SIMUL_EFUN_FILE + "\n");
302 debug_message("Failed to load simul efun " + SIMUL_EFUN_FILE +
303 " " + err, DMSG_STDOUT | DMSG_LOGFILE);
304
305 if (!(err=catch(SPARE_SIMUL_EFUN_FILE->start_simul_efun())) ) {
306 --loading_simul_efuns;
307 return ({SPARE_SIMUL_EFUN_FILE});
308 }
309
310 write("Failed to load spare simul efun" + SPARE_SIMUL_EFUN_FILE + "\n");
311 debug_message("Failed to load spare simul efun " + SPARE_SIMUL_EFUN_FILE +
312 " " + err, DMSG_STDOUT | DMSG_LOGFILE);
313
314
315 efun::shutdown();
316
317 return 0;
318}
319
320protected mixed call_sefun(string sefun, varargs mixed args) {
321 if (!loading_simul_efuns)
322 return apply(symbol_function(sefun), args);
323 else {
324 switch(sefun) {
325 case "log_file":
326 case "secure_level":
327 case "secure_euid":
328 case "find_player":
329 case "find_netdead":
330 case "find_living":
331 case "process_call":
332 case "replace_personal":
333 case "file_time":
334 return 0;
335 case "dtime":
336 if (pointerp(args) && sizeof(args))
337 return strftime("%a %d. %b %Y, %H:%M:%S",args[0]);
338 else
339 return strftime("%a %d. %b %Y, %H:%M:%S");
340 case "uptime":
341 return to_string(time()-__BOOT_TIME__) + " Sekunden";
342 }
343 }
344 return 0;
345}
346
347
348// Preload manuell wiederholen; Keine GD-Funktion
349void redo_preload()
350{
351 string *to_preload;
352 int i,j;
353
354 to_preload=epilog(0);
355 j=sizeof(to_preload);
356 for (i=0;i<j;i++)
357 catch(preload(to_preload[i]));
358 return;
359}
360
361// ##################
362//########################## Standard-Lfuns #############################
363// ##################
364
365// Keine GD-Funktion, aber sinnvoll.
366public varargs int remove(int silent)
367{
368 write("Der Master will aber nicht zerstoert werden!\n");
369 return 0;
370}
371
372// Einige repetitiven Taetigkeiten kann der Reset erledigen
373protected void reset()
374{
375 int i, *date;
376 mixed *wl;
377
378 //Darf nicht von Hand aufgerufen werden!
379 if (TI||TP) return;
380
381 // Naechsten Reset setzen
382 set_next_reset(RESETINT);
383
384 // Userinfo aufraeumen
385 _cleanup_uinfo();
386
387 // Projekt-Cache loeschen
388 _cleanup_projects();
389
390 // Wenn Zeit abgelaufen, dann READ_FILE-Log rotieren
391 if (!logrotate_counter--)
392 {
393 i=time()/LOGFILEAGE;
394 date=get_dir(sprintf("%s.%d", READ_FILE,i%LOGNUM), GETDIR_DATES);
395 if (pointerp(date)&&sizeof(date)&&
396 (date[0]/LOGFILEAGE)==i) return;
397 if (file_size(READ_FILE)>0)
398 rename(READ_FILE, sprintf("%s.%d", READ_FILE,i%LOGNUM));
399 logrotate_counter=LOGROTATE;
400 }
401 // einmal am Tag die UIDAliase resetten. Hierzu wird der logrotate_counter
402 // missbraucht.
403 if (!(logrotate_counter%24)) {
404 ResetUIDAliase();
405#ifdef _PUREFTPD_
406 expire_ftp_user();
407#endif
408 }
409
410 // Wizlist altert
411 wl = wizlist_info();
412 for (i=sizeof(wl); i--; )
413 set_extra_wizinfo(wl[i][WL_NAME], wl[i][WL_EXTRA] * 99 / 100);
414
415 // Dann noch Mails bearbeiten
416 mails_last_hour=0;
417 mailread();
418
419 return;
420}
421
422
423// #################
424//########################## ID-Management ##############################
425// #################
426
427// Magier-ID fuer Datei str (als Objekt oder als String) ermitteln
428string creator_file(mixed str) {
429 string *strs,tmp;
430 int s;
431
432 // full_path_array nach strs
433 // TODO: was ist mit clones?
434 if(objectp(str))
435 strs=full_path_array(object_name(str), 0);
436 else if(stringp(str))
437 strs=full_path_array(str, 0);
438 else return NOBODY;
439
440 // absolute Pfade interessieren hier gerade nicht.
441 strs -= ({""});
442
443 s=sizeof(strs);
444 if(s<2) return NOBODY;
445
446 switch(strs[0]) {
447 case DOMAINDIR:
448 // Fuer Nicht-Magier bzw. "Pseudo-"Magier die Regionskennung
449 if( s==2 || WIZLVLS[strs[2]] || !IS_LEARNER(strs[2]) )
450 return strs[1];
451
452 // in /d/erzmagier gibt es Magier-IDs
453 if (strs[1]=="erzmagier") return strs[2];
454
455 // Ansonsten d.region.magiername
456 return sprintf("d.%s.%s", strs[1], strs[2]);
457
458 case PROJECTDIR:
459 // In p.service gibt es ids mit uid
460 if (s>2 && strs[1]=="service") return "p.service."+strs[2];
461
462 // Ansonsten nur p.projekt (p.service ist auch hier drin)
463 return "p."+strs[1];
464
465 case WIZARDDIR:
466 if (s>2)
467 return strs[1];
468 if (s==2 && file_size(strs[0]+"/"+strs[1])==FSIZE_DIR)
469 return strs[1];
470 return NOBODY;
471
472 case SECUREDIR:
473 return ROOTID;
474
475 case GUILDDIR:
476 case SPELLBOOKDIR:
477 tmp=strs[1];
478 if (tmp[<2..<2]==".") tmp=tmp[0..<3];
479 if ((s=member(tmp,'.'))>0) tmp=tmp[s+1..];
480 return "GUILD."+tmp;
481
482 case LIBROOMDIR:
483 return ROOMID;
484
485 case STDDIR:
486 case LIBOBJDIR:
487 return BACKBONEID;
488
489 case DOCDIR:
490 return DOCID;
491
492 case MAILDIR:
493 return MAILID;
494 case NEWSDIR:
495 return NEWSID;
496
497 case LIBITEMDIR:
498 return ITEMID;
499
500 /* Fall-Through */
501 default:
502 return NOBODY;
503
504 }
505 return NOBODY; //should never be reached.
506}
507
508// UID und EUID an Objekt geben (oder eben nicht)
509// Keine GD-Funktion, aber von Hooks aufgerufen
510protected mixed give_uid_to_object(string datei,object po)
511{
512 string creator,pouid;
513
514 // Parameter testen
515 if (!stringp(datei)||!objectp(po)) return 1;
516
517 // Keine Objekte in /log, /open oder /data
518 if (strstr(datei, "/"LIBDATADIR"/") == 0
519 || strstr(datei, "/"LIBLOGDIR"/") == 0
520 || strstr(datei, "/"FTPDIR"/") == 0
521 )
522 return 1;
523
524 // Datei muss Besitzer haben
525 if (!(creator=creator_file(datei))) return 1;
526
527 // Hack, damit simul_efun geladen werden kann
528 if (creator==ROOTID && po==TO) return ROOTID;
529
530 // Keine euid, kein Laden ...
531 if (!(pouid=geteuid(po))) return 1; // Disallow if no euid in po
532
533 // Root generiert keine Root-Objekte ;-)
534 // Nur UID setzen
535 if (pouid==ROOTID)
536 return ({creator,NOBODY}); // root does not create root objects!
537
538 // EUID mitsetzen, wenn PO==creator oder creator==BACKBONEID
539 if (creator==pouid || creator==BACKBONEID)
540 return pouid;
541
542 return ({creator,NOBODY});
543}
544
545// Die System-IDs muessen bekannt sein
546string get_master_uid() { return ROOTID;}
547string get_bb_uid() { return BACKBONEID; }
548// TODO: Bei get_wiz_name koennte man - so moeglich - auf 'wirkliche'
549// Magiernamen gehen (Idee von mandragon)
550string get_wiz_name(string file) { return creator_file(file);}
551
552// ##########################
553//###################### Sonstige GD-Funktionen #########################
554// ##########################
555
556// Spieler hat sich eingeloggt
557protected object connect()
558{
559 string err;
560 int errno;
561 object ob,bp;
562
563#if defined(SSLPORT) && __EFUN_DEFINED__(tls_available)
564 if (efun::interactive_info(this_player(), II_MUD_PORT) == SSLPORT) {
565 // reject connection of TLS is not available
566 if (!tls_available())
567 return 0;
568 // establish TLS
569 errno=tls_init_connection();
570 if (errno < 0) {
571 // Fehler im Vebindungsaufbau
572 printf("Can't establish a TLS/SSL encrypted connection: %s\n",
573 tls_error(errno));
574 return 0; // this will close the connection to the client.
575 }
576 }
577#endif
578
579 // Blueprint im Environment? Das geht nun wirklich nicht ...
580 if ((bp=find_object("/secure/login")) && environment(bp))
581 catch(destruct(bp);publish);
582
583 // Login-Shell clonen
584 err = catch(ob = clone_object("secure/login"); publish);
585
586 if (errno == 0 && err)
587 write("Fehler beim Laden von /secure/login.c\n"+err+"\n");
588
589 return ob;
590}
591
592// Was machen bei disconnect?
593protected void disconnect(object who, string remaining) {
594 who->NetDead(); return;
595}
596
597// Es gibt kein File 'filename'. VC aktivieren so vorhanden ...
598protected object compile_object(string filename)
599{
600 object ret;
601 string *str;
602 string compiler;
603
604 if (!sizeof(filename)) return 0;
605 str=efun::explode(filename,"/");
606
607 if(sizeof(str)<2) return 0;
608 compiler=implode(str[0..<2],"/")+"/virtual_compiler";
609
610 if (find_object(compiler)
611 || file_size(compiler+".c")>0)
612 {
613 if(catch(
614 ret=(object)call_other(compiler,"compile_object",str[<1]); publish))
615 return 0;
616 }
617 else
618 return(0);
619
620 if ( objectp(ret) && efun::explode(creator_file(filename), ".")[<1] !=
621 REAL_EUID(ret) ){
622 funcall( symbol_function('log_file/*'*/), "ARCH/VC_MISSBRAUCH",
623 sprintf( "%s: %s versucht per VC %s zu %s umzubenennen!\n",
624 funcall( symbol_function('dtime/*'*/), time() ),
625 (this_interactive() ? getuid(this_interactive()):
626 object_name(previous_object())), object_name(ret),
627 filename) );
628
629 return 0;
630 }
631 return ret;
632}
633
634// ############
635//############################ Shutdown #################################
636// ############
637
638// Spieler bei Shutdown entfernen
639protected void remove_player(object victim)
640{
641 catch(victim->quit());
642 if (victim) catch(victim->remove());
643 if (victim) destruct(victim);
644 return;
645}
646
647// Langsamer Shutdown
648protected void slow_shut_down(int minutes)
649{
650 //sollte nur vom GD gerufen werden. Oder allenfalls Master selbst
651 filter(users(),#'tell_object,
652 "Der Gamedriver ruft: Der Speicher wird knapp ! Bereitet euch auf das Ende vor !\n");
653 "/obj/shut"->shut(minutes);
654 return;
655}
656
657
658// In LD varargs void notify_shutdown(string crash_reason)
659protected varargs void notify_shutdown (string crash_reason) {
660
661 if (PO && PO != TO)
662 return;
663 if (crash_reason) {
664 //Uhoh... Verdammter Crash. :-( Zumindest mal mitloggen,
665 //was der Driver sagt...
666 write_file(CRASH_LOG,sprintf(
667 "\n%s: The driver crashed! Reason: %s\n",
668 ctime(time()),crash_reason));
669 }
670
671 filter(users(), #'tell_object,
672 "Game driver shouts: LDmud shutting down immediately.\n");
673 save_wiz_file();
674 return;
675}
676
677// ##################
678//########################## Berechtigungen #############################
679// ##################
680
681// Darf Verbindung durch name von obfrom nach ob gelegt werden?
682
683//int valid_exec(string name) {return 1;}
684
685int valid_exec(string name, object ob, object obfrom)
686{
687 // Ungueltige Parameter oder Aufruf durch process_string -> Abbruch
688 if (!objectp(ob) || !objectp(obfrom)
689 || !stringp(name) || !sizeof(name)
690 || funcall(symbol_function('process_call)) )
691 return 0;
692
693 // renew_player_object() darf ...
694 if (name=="/secure/master/misc.c"
695 || name=="secure/master/misc.c")
696 return 1;
697
698 // Ansonsten darf sich nur die Shell selber aendern ...
699 if (previous_object() != obfrom) return 0;
700
701 // Die Login-Shell zu jedem Objekt ...
702 if (name=="/secure/login.c"
703 || name=="secure/login.c")
704 return 1;
705
706 // Magier per exec nur, wenn sie damit keine Fremde uid/euid bekommen
707 if (this_interactive() == obfrom && getuid(obfrom) == getuid(ob)
708 && geteuid(obfrom) == geteuid(ob))
709 return 1;
710
711 // Sonst darf niemand was
712 return 0;
713}
714
715
716// Darf me you snoopen?
717int valid_snoop(object me, object you) {
718 return getuid(PO) == ROOTID;
719}
720
721// Darf wiz wissen, ob er gesnoopt wird?
722int valid_query_snoop(object wiz) {
723 return getuid(PO) == ROOTID;
724}
725
726// Darf ob seine EUID auf neweuid setzen?
727int valid_seteuid(object ob, string neweuid)
728{
729 return (ob==this_object() ||
730 getuid(ob) == ROOTID ||
731 getuid(ob) == neweuid ||
732 creator_file(object_name(ob)) == neweuid);
733}
734
735// Darf getraced werden?
736int valid_trace(string what, mixed arg) {
737 return IS_ARCH(TI);
738}
739
740
741// valid_write() und
742// valid_read() befinden sich in file_access.c
743
744
745// Darf PO ob shadowen?
746int query_allow_shadow(object ob)
747{
748 // ROOT darf nicht geshadowed werden
749 if(getuid(ob) == ROOTID)
750 return 0;
751
752 // Access-Rights auch nicht
753 if (efun::explode(object_name(ob),"#")[0][<14..]=="/access_rights")
754 return 0;
755
756 // Ansonsten query_prevent_shadow fragen ...
757 return !(int)ob->query_prevent_shadow(PO);
758}
759
760
761/* privilege_violation is called when objects try to do illegal things,
762 * or files being compiled request a privileged efun.
763 *
764 * return values:
765 * 1: The caller/file is allowed to use the privilege.
766 * 0: The caller was probably misleaded; try to fix the error.
767 * -1: A real privilege violation. Handle it as error.
768 */
769int privilege_violation(string op, mixed who, mixed arg1, mixed arg2)
770{
771
772 if (objectp(who) &&
773 (who==this_object() || geteuid(who)==ROOTID))
774 return 1;
775
776 switch(op)
777 {
778 case "call_out_info":
779 return -1;
780 case "send_udp":
781 return 1;
782
783 case "nomask simul_efun":
784 // <who> ist in diesem Fall ein string (Filename) und damit von dem
785 // Check da oben nicht abgedeckt. Daher explizite Behandlung hier.
786 // Ausserdem hat der Pfad (zur Zeit noch) keinen fuehrenden '/'.
787 // Falls das jemand einschraenken will: der Kram fuer die simul_efuns
788 // muss das duerfen!
789 if (stringp(who)
790 && strstr(who,"secure/") == 0)
791 return 1;
792 return 0; // alle andere nicht.
793
794 case "get_extra_wizinfo":
795 // benutzt von /secure/memory.c und /secure/simul_efun.c
796 case "set_extra_wizinfo":
797 // wird benutzt von simul_efun.c, welche aber als ROOT-Objekt implizit
798 // erlaubt ist (s.o.)
799 return -1; // fuer allen nicht erlaubt.
800
801 case "rename_object":
802 if (object_name(who)=="/secure/impfetch" ||
803 BLUE_NAME(who)=="/secure/login")
804 return 1;
805 return(-1);
806
807 case "configure_driver":
808 return call_sefun("secure_level") >= ARCH_LVL;
809
810 case "limited":
811 // Spielershells duerfen sich zusaetzliche Ticks fuer den Aufruf von
812 // ::die() beschaffen, damit der Tod nicht wegen wenig Ticks buggt.
813 if (strstr(load_name(who), "/std/shells/") == 0
814 && get_type_info(arg1, 2) == who
815 && get_type_info(arg1, 3) == "/std/living/life"
816// && get_type_info(arg1, 4) == "die"
817 && arg2[LIMIT_EVAL] <= 10000000 ) {
818 return 1;
819 }
820 //DEBUG(sprintf("%O, %O, %O", who, arg1, arg2));
821 int *limits=efun::driver_info(DI_CURRENT_RUNTIME_LIMITS);
822 // LIMIT_EVAL darf verringert werden. Alle anderen Limits duerfen nicht
823 // geaendert werden. Achja, LIMIT_EVAL darf nicht 0 (LIMIT_UNLIMITED)
824 // sein. *g*
825 // LIMIT_COST darf entweder 0 oder -100 sein.
826 if (arg2[LIMIT_EVAL]>1000 && (arg2[LIMIT_EVAL] < get_eval_cost())-500
827 && arg2[LIMIT_ARRAY] == limits[LIMIT_ARRAY]
828 && arg2[LIMIT_MAPPING_KEYS] == limits[LIMIT_MAPPING_KEYS]
829 && arg2[LIMIT_MAPPING_SIZE] == limits[LIMIT_MAPPING_SIZE]
830 && arg2[LIMIT_BYTE] == limits[LIMIT_BYTE]
831 && arg2[LIMIT_FILE] == limits[LIMIT_FILE]
832 && arg2[LIMIT_CALLOUTS] == limits[LIMIT_CALLOUTS]
833 && (arg2[LIMIT_COST] == 0 || arg2[LIMIT_COST] == -100) )
834 return(1);
835 //sonst verweigern.
836 return(-1);
837
838 case "sqlite_pragma":
839 return 1;
840 case "attach_erq_demon":
841 case "bind_lambda":
842 case "configure_interactive":
843 case "configure_object":
844 case "execute_command":
845 case "erq":
846 case "input_to":
847 case "mysql":
848 case "net_connect":
849 case "pgsql":
850 case "set_driver_hook":
851 case "set_this_object":
852 case "shadow_add_action":
853 case "symbol_variable":
854 case "variable_list":
855 case "wizlist_info":
856 default:
857 return(-1);
858 }
859 return -1;
860}
861
862// ####################
863//######################## Fehlerbehandlung #############################
864// ####################
865
866// Behandlung von Fehler im Heart_Beat
867protected int heart_beat_error( object culprit, string error, string program,
868 string current_object, int line, int caught)
869{
870 if (!objectp(culprit)) return 0;
871 if (interactive(culprit))
872 {
873 tell_object(culprit,"Der GameDriver teilt Dir mit: "
874 "Dein Herzschlag hat ausgesetzt!\n");
875 if (IS_LEARNER(culprit))
876 tell_object(culprit,
877 sprintf("Fehler: %sProgamm: %s, CurrObj: %s, Zeile: %d, "
878 "the error was %scaught at higher level.\n",
879 error,program,current_object,line,
880 caught ? "" : "not"));
881 }
882
883 if (efun::object_info(culprit, OI_ONCE_INTERACTIVE))
884 call_out("restart_heart_beat", 5, culprit);
885 else
886 catch(culprit->make_immortal(); publish);
887 return 0;
888}
889
890// Ausgabe einer Meldung an Spieler mit Level >= minlevel. Wird genutzt, um
891// Magier ueber Fehler zu informieren, die nicht normal behandelt werden
892// (z.B. rekursive Fehler, d.h. Fehler in der Fehlerbehandlung)
893private void tell_players(string msg, int minlevel) {
894 msg = efun::sprintf("%=-78s","Master: " + msg); // umbrechen
895 efun::filter(efun::users(), function int (object pl)
896 {
897 if (query_wiz_level(pl) >= minlevel)
898 efun::tell_object(pl, msg);
899 return 0;
900 } );
901}
902
903/**
904 * \brief Error handling fuer Fehler beim Compilieren.
905 *
906 * log_error() wird vom GameDriver aufgerufen, wenn zur Compile-Zeit ein
907 * Fehler auftrat. Die Fehlermeldung wird unter /log/error geloggt.
908 * Falls this_interactive() ein Magier ist, bekommt er die Fehlermeldung
909 * direkt angezeigt.
910 * Sollte das Logfile 50kB ueberschreiten, wird es rotiert. Auf [Entwicklung]
911 * wird dann eine Fehlermeldung abgesetzt.
912 *
913 * @param file Die Datei, in der der Fehler auftrat.
914 * @param message Die Fehlermeldung.
915 * @param warn Warnung (warn!=0) oder Fehler (warn==0)?
916 * */
917
918protected void log_error(string file, string message, int warn) {
919 string lfile;
920 string cr;
921 mixed *lfile_size;
922
923 if (handling_error == efun::time()) {
924 // Fehler im Verlauf einer Fehlerbehandlung: Fehlerbehandlung minimieren,
925 // nur Meldung an eingeloggte Erzmagier.
926 tell_players("log_error(): Rekursiver Fehler in Fehlerbehandlung. "
927 "Bitte Debuglog beachten. Aktueller Fehler in " + file + ": "
928 + message, ARCH_LVL);
929 return;
930 }
931 handling_error = efun::time();
932
933 //Fehlerdaten an den Errord zur Speicherung weitergeben, falls wir sowas
934 //haben.
935#ifdef ERRORD
936 // Only call the errord if we are _not_ compiling the sefuns. It uses sefuns
937 // and it will cause a recursing call to get_simul_efuns() which is bound to
938 // fail.
939 if (!loading_simul_efuns) {
940 catch(limited(#'call_other,({200000}),ERRORD,"LogCompileProblem",
941 file,message,warn);publish );
942 }
943#endif // ERRORD
944
945 // Logfile bestimmen
946 cr=creator_file(file);
947 if (!cr) lfile="NOBODY.err";
948 else if (cr==ROOTID) lfile="ROOT";
949 else if (efun::member(cr,' ')!=-1) lfile="STD";
950 else lfile=cr;
951 //je nach Warnung oder Fehler Verzeichnis und Suffix bestimmen
952 if (warn) {
953 lfile="/log/warning/" + lfile + ".warn";
954 }
955 else {
956 lfile="/log/error/" + lfile + ".err";
957 }
958
959 // Bei Bedarf Rotieren des Logfiles
960 if ( !loading_simul_efuns
961 && sizeof(lfile_size = get_dir(lfile,2))
962 && lfile_size[0] >= MAX_ERRLOG_SIZE )
963 {
964 catch(rename(lfile, lfile + ".old"); publish); /* No panic if failure */
965 if (!loading_simul_efuns)
966 {
967 catch(send_channel_msg("Entwicklung","<MasteR>",
968 "Logfile rotiert: "+lfile+"."));
969 }
970 }
971
972 efun::write_file(lfile,message);
973
974 // Magier bekommen die Fehlermeldung angezeigt
975 if (IS_LEARNER(TI)) efun::tell_object(TI, message);
976
977 handling_error = 0;
978}
979
980/* Gegenmassnahme gegen 'too long eval' im Handler vom runtime error:
981 Aufsplitten des Handlers und Nutzung von limited() */
982//keine GD-Funktion
983private void handle_runtime_error(string err, string prg, string curobj,
984 int line, mixed culprit, int caught, object po, int issueid)
985{
986 string code;
987 string debug_txt;
988 object ob, titp;
989
990 //DEBUG(sprintf("Callerstack: (handle_runtime_error()): %O\n",
991 // caller_stack(1)));
992 // Fehlermeldung bauen
993 if (!stringp(err)) err="<NULL>";
994 if (!stringp(prg)) prg="<NULL>";
995 if (!stringp(curobj)) curobj="<NULL>";
996 debug_txt=efun::sprintf("Fehler: %O, Objekt: %s, Programm: %O, Zeile %O (%s), "
997 "ID: %d",
998 err[0..<2], curobj, (prg[0]!='<'?"/":"")+prg, line,
999 (TI?efun::capitalize(efun::getuid(TI)):"<Unbekannt>"),
1000 issueid);
1001
1002 titp = TI || TP;
1003 // Fehlermeldung an Kanaele schicken, aber nur wenn der aktuelle Fehler
1004 // nicht waehrend des ladens der simulefuns auftrat, bei der Ausgabe der
1005 // Meldung ueber die Kaenaele wieder sefuns genutzt werden.
1006 if (!loading_simul_efuns) {
1007 if (titp && (IS_LEARNER(titp) || (titp->QueryProp(P_TESTPLAYER))))
1008 {
1009 catch(send_channel_msg("Entwicklung",
1010 capitalize(objectp(po) ? REAL_UID(po) : ""),
1011 debug_txt));
1012 }
1013 else
1014 {
1015 catch(send_channel_msg("Debug",
1016 capitalize(objectp(po) ? REAL_UID(po) : ""),
1017 debug_txt));
1018 }
1019 }
1020
1021 if (!titp) return;
1022
1023 // Fehlermeldung an Benutzer
1024 if (IS_LEARNER(titp))
1025 efun::tell_object(titp,
1026 efun::sprintf("%'-'78.78s\nfile: %s line: %d object: %s\n" +
1027 "%serror: %s%'-'78.78s\n","",prg,line,curobj,
1028 (prg&&(code=efun::read_file("/"+prg,line,1))?
1029 "\n"+code+"\n":""),err,""));
1030 else
1031 efun::tell_object(titp, "Du siehst einen Fehler im Raum-Zeit-Gefuege.\n");
1032}
1033
1034//Keine GD-Funktion, limitiert die Kosten fuer den handler
1035private void call_runtime_error(string err, string prg, string curobj,
1036 int line, mixed culprit, int caught, object po)
1037{
1038 if (handling_error == efun::time())
1039 {
1040 // Fehler im Verlauf einer Fehlerbehandlung: Fehlerbehandlung minimieren,
1041 // nur Meldung an eingeloggte Regionsmagier.
1042 tell_players("call_runtime_error(): Rekursiver Fehler in "
1043 "Fehlerbehandlung. Bitte Debuglog beachten. Aktueller Fehler in "
1044 + curobj + ": " + err, LORD_LVL);
1045 return;
1046 }
1047 handling_error = efun::time();
1048
1049 //Fehlerdaten an den Errord zur Speicherung weitergeben, falls wir sowas
1050 //haben.
1051#ifdef ERRORD
1052 int issueid;
1053 // Wenn die sefuns gerade geladen werden, erfolgt keine Weitergabe an den
1054 // ErrorD, da dabei wieder sefuns gerufen werden, was zu einer Rekursion
1055 // fuehrt.
1056 if (!loading_simul_efuns) {
1057 catch(issueid=efun::limited(#'call_other,({200000}),ERRORD,"LogError",
1058 err,prg,curobj,line,culprit,caught);publish);
1059 }
1060#endif // ERRORD
1061
1062 //eigenen Errorhandler laufzeitbegrenzt rufen
1063 efun::limited(#'handle_runtime_error, ({ 200000 }), err, prg, curobj,
1064 line,culprit,caught, po, issueid);
1065
1066 handling_error = 0;
1067}
1068
1069// Laufzeitfehlerbehandlung, hebt Evalcost-Beschraenkung auf und reicht weiter
1070// an call_runtime_error, die die Grenze wieder auf einen bestimmten Wert
1071// festlegt.
1072protected void runtime_error(string err ,string prg, string curobj, int line,
1073 mixed culprit, int caught) {
1074
1075 //DEBUG(sprintf("Callerstack: (runtime_error()): %O\nPO: %O\nPO(0): %O\n",
1076 // caller_stack(1),previous_object(),previous_object(0)));
1077
1078 limited(#'call_runtime_error, ({ LIMIT_UNLIMITED }),
1079 err,prg,curobj,line,culprit,caught,previous_object());
1080}
1081
1082//Warnungen mitloggen
1083protected void runtime_warning( string msg, string curobj, string prog, int line,
1084 int inside_catch)
1085{
1086 string code;
1087 string debug_txt;
1088 object titp;
1089
1090 //DEBUG(sprintf("Callerstack: in runtime_warning(): %O\nPO(0): %O\n",
1091 // caller_stack(1),previous_object(0)));
1092
1093 //Daten der Warnung an den Errord zur Speicherung weitergeben, falls wir
1094 //sowas haben.
1095 int issueid;
1096#ifdef ERRORD
1097 catch(issueid=limited(#'call_other,({200000}),ERRORD,"LogWarning",
1098 msg,prog,curobj,line,inside_catch); publish);
1099#endif // ERRORD
1100
1101 // Fehlermeldung bauen
1102 if (!stringp(msg)) msg="<NULL>";
1103 if (!stringp(prog)) prog="<NULL>";
1104 if (!stringp(curobj)) curobj="<NULL>";
1105 debug_txt=sprintf("Warnung: %O, Objekt: %s, Programm: %O, Zeile %O (%s) "
1106 "ID: %d",
1107 msg[0..<2], curobj, (prog[0]!='<'?"/":"")+prog, line,
1108 (TI?capitalize(getuid(TI)):"<Unbekannt>"),
1109 issueid);
1110
1111 //Fehlermeldungen an -warnungen schicken
1112 catch(send_channel_msg("Warnungen",
1113 capitalize(objectp(previous_object()) ?
1114 REAL_UID(previous_object()) : ""),
1115 debug_txt));
1116
1117 titp = TI || TP;
1118
1119 if (!titp) return;
1120
1121 // Fehlermeldung an Benutzer
1122 if (IS_LEARNER(titp))
1123 tell_object(titp,
1124 sprintf("%'-'78.78s\nfile: %s line: %d object: %s\n" +
1125 "%sWarnung: %s%'-'78.78s\n","",prog,line,curobj,
1126 (prog&&(code=read_file("/"+prog,line,1))?
1127 "\n"+code+"\n":""),msg,""));
1128 return;
1129}
1130
1131
1132// #####################
1133//######################## Einrichten des ED ############################
1134// #####################
1135
1136// Setup speichern
1137protected int save_ed_setup(object who, int code)
1138{
1139 string file;
1140
1141 if (!intp(code)) return 0;
1142 file = sprintf("/players/%s/.edrc",geteuid(who));
1143 rm(file);
1144 return write_file(file,(string)code);
1145}
1146
1147// Setup einladen
1148protected int retrieve_ed_setup(object who)
1149{
1150 string file;
1151
1152 file = sprintf("/players/%s/.edrc",getuid(who));
1153 if (file_size(file)<1) return 0;
1154 return (int)read_file(file);
1155}
1156
1157// Wo werden Dateien gespeichert?
1158string get_ed_buffer_save_file_name(string file)
1159{
1160 return sprintf("/players/%s/.dead_ed_files/%s",
1161 getuid(this_player()),efun::explode(file, "/")[<1]);
1162}
1163
1164// ################################
1165//################### Ungenutzte Pflichtfunktionen ######################
1166// ################################
1167
1168// Nichts zu tun beim Master-Neustart
1169protected void external_master_reload() { return; }
1170
1171// Keine externen Master-Flags
1172protected void flag(string str) { return; }
1173
1174// Wird benoetigt, falls ERQ angeschlossen ist
1175protected void stale_erq(closure callback) { return; }
1176
1177// Zerstoerten Master wiederbeleben ...
1178// nicht viel zu tun, wenn flag gesetzt ist. Wenn aber nicht, sind alle
1179// Variablen auf 0. Nach dieser Funktion wird wieder inaugurate_master()
1180// gerufen.
1181protected void reactivate_destructed_master(int flag) {
1182 if (flag) {
1183 //re-init
1184 //was machen? TODO
1185 }
1186 return;
1187}
1188
1189// Kein Quota-Demon (potentielles TODO)
1190//Handle quotas in times of memory shortage.
1191//is called during the final phase of a garbage collection, if the user
1192//reserve could not be re-allocated. Last (!) Chance to free (active) objects
1193//from the system and prevent call to slow_shut_down()!
1194protected void quota_demon() {
1195 //was kann man machen?
1196 //uebervolle Seherhaeuser leeren?
1197 return;
1198}
1199
1200// Keine Prepositionen in parse_command
1201//string *parse_command_prepos_list() { return ({}); }
1202
1203// Wie lautet das Wort fuer 'alle' ?
1204//string *parse_command_all_word() { return ({}); }
1205
1206
1207// Keine Besonderen Objektnamen
1208string printf_obj_name(object ob) { return 0; }
1209
1210// ###################
1211//######################### Sonstiges/Hooks #############################
1212// ###################
1213
1214//TODO: save_wiz_file in shutdown() integrieren?
1215// Wizliste speichern: Zeile generieren
1216static string _save_wiz_file_loop(mixed *a)
1217{
1218 return sprintf("%s %d %d\n",a[WL_NAME],a[WL_COMMANDS],a[WL_EXTRA]);
1219}
1220
1221// Wizliste speichern
1222protected void save_wiz_file()
1223{
1224 rm("/WIZLIST");
1225 write_file("/WIZLIST",implode(
1226 map(wizlist_info(),#'_save_wiz_file_loop),""));
1227}
1228
1229// TODO: macht der telnet_neg-hook ueberhaupt was?
1230void telnet_neg(mixed cmd,mixed opt,mixed args)
1231{
1232 if (opt==34 && cmd==251)
1233 binary_message(({255,250,34,1,1,255,240}));
1234}
1235
1236// EUID und UID werden von give_uid_to_object() vergeben, diese sind in
1237// inaugurate_master() als driver hooks angemeldet.
1238
1239/*load_uid_hook() sollte machen, was diese Lambda machte...
1240 unbound_lambda( ({'printf_obj_name}),
1241 ({#'give_uid_to_object,'printf_obj_name,
1242 ({#'previous_object}),0}))); */
1243protected mixed load_uid_hook(string datei) {
1244 return(give_uid_to_object(datei,previous_object()));
1245}
1246
1247/* clone_uid_hook sollte machen, was diese Lambda machte...
1248 unbound_lambda( ({'blueprint, 'new_name}),
1249 ({#'give_uid_to_object,'new_name,
1250 ({#'previous_object}),1}))); */
1251protected mixed clone_uid_hook(string blueprint,string new_name) {
1252 return(give_uid_to_object(new_name,previous_object()));
1253}
1254