diff --git a/p/daemon/channel-sv.c b/p/daemon/channel-sv.c
new file mode 100644
index 0000000..b089e8f
--- /dev/null
+++ b/p/daemon/channel-sv.c
@@ -0,0 +1,21 @@
+// channel-sv.c
+//
+// Standard-SV der Mudlib
+
+#pragma strong_types,rtt_checks
+#pragma no_shadow,no_clone, no_inherit
+
+#include "channel.h"
+
+inherit "/std/channel_supervisor";
+
+protected void create()
+{
+  ::create();
+  // Namen setzen, der auf den Ebenen genannt werden soll.
+  ch_set_sv_name(DEFAULTSVNAME);
+  // Das systemweite Init-File einlesen und die Zugriffsrechte fuer die Ebenen
+  // merken, in denen dieses Objekt SV ist.
+  ch_read_init_file();
+}
+
diff --git a/p/daemon/channel.h b/p/daemon/channel.h
index 9580326..668d7ec 100644
--- a/p/daemon/channel.h
+++ b/p/daemon/channel.h
@@ -11,6 +11,8 @@
 
 #define CHMASTER          "/p/daemon/channeld"
 #define CMNAME            "<MasteR>"
+#define DEFAULTSV         "/p/daemon/channel-sv"
+#define DEFAULTSVNAME     "Merlin"
 
 // Message types
 #define MSG_SAY           0
@@ -33,9 +35,15 @@
 #define C_LIST            "list"
 #define C_FIND            "find"
 
-// Flags
+// Ebenen-Flags, die Verhalten von Ebenen steuern (vom CHANNELD verwendet)
 #define CHF_FIXED_SUPERVISOR 1   // Kein Wechsel des SV erlaubt
 
+// Flags fuer Zugriffsverwaltung, nur benutzt von den Ebenen-Supervisoren
+// F_WIZARD kennzeichnet reine Magierebenen
+#define CH_ACCESS_WIZARD 1
+// Ebenen, auf denen keine Gaeste erlaubt sind, sind mit F_NOGUEST markiert.
+#define CH_ACCESS_NOGUEST 2
+
 #endif //__DAEMON_CHANNEL_H__
 
 // prototypes
diff --git a/p/daemon/channeld.c b/p/daemon/channeld.c
index 630093d..50d05cf 100644
--- a/p/daemon/channeld.c
+++ b/p/daemon/channeld.c
@@ -36,9 +36,6 @@
 #define MAX_INACTIVE_CHANNELS 500
 #define CMDS          ({C_FIND, C_LIST, C_JOIN, C_LEAVE, C_SEND, C_NEW})
 
-// Standard-Ebenen-Supervisor erben, Variablen nosave, die sollen hier nicht
-// gespeichert werden.
-nosave variables inherit "/std/channel_supervisor";
 
 // Datenstrukturen fuer die Ebenen.
 // Basisdaten, welche auch inaktive Ebenen in channelC haben
@@ -385,63 +382,40 @@
 private void setup(string* chinfo)
 {
   string desc = "- Keine Beschreibung -";
-  object supervisor = this_object();
-  int sv_recv, sv_send, sv_flags; // an den Supervisor weiterreichen
+  object supervisor;
   int chflags;
 
   if (sizeof(chinfo) && sizeof(chinfo[0]) > 1 && chinfo[0][0] == '\\')
     chinfo[0] = chinfo[0][1..];
 
-  switch (sizeof(chinfo))
-  {
-    // Alle Fallthroughs in dem switch() sind Absicht.
-    default:
-      if (stringp(chinfo[6]) && sizeof(chinfo[6]))
-        catch(supervisor = load_object(chinfo[6]); publish);
-      if (!objectp(supervisor))
-        supervisor = this_object();
-    case 6:
-      if (stringp(chinfo[5]))
-        desc = chinfo[5];
-    case 5:
-        chflags = to_int(chinfo[4]);
-    case 4:
-      sv_flags = to_int(chinfo[3]);
-    case 3:
-      sv_send = to_int(chinfo[2]);
-    case 2:
-      sv_recv = to_int(chinfo[1]);
-      break;
-
-    case 0:
-    case 1:
-      return;
-  }
-  // Zugriffsrechte im channel_supervisor konfigurieren. (Kann auch dieses
-  // Objekt selber sein...)
-  supervisor->ch_supervisor_setup(lower_case(chinfo[0]), sv_recv,
-                                  sv_send, sv_flags);
   // Wenn der channeld nur neugeladen wurde, aber das Mud nicht neugestartet,
-  // sind alle Ebenen noch da, weil sie im MEMORY liegen. Dann muessen wir das
-  // new() natuerlich ueberspringen.
-  if (!member(channels, lower_case(chinfo[0])))
+  // sind alle Ebenen noch da, weil sie im MEMORY liegen. D.h. ist die Ebene
+  // noch bekannt, muss nichts gemacht werden.
+  if (member(channels, lower_case(chinfo[0])))
+    return;
+
+  // Nur die Angabe des SV (Index 6) im initfile ist optional, alle Elemente
+  // davor muessen da sein.
+  if (sizeof(chinfo) < 6)
+    return;
+  // Bei genug Elementen schauen, ob der SV ladbar ist.
+  if (sizeof(chinfo) >= 7)
   {
-    if (new(chinfo[0], supervisor, desc, chflags) == E_ACCESS_DENIED)
-    {
-      log_file("CHANNEL", sprintf("[%s] %s: %O: error, access denied\n",
-        dtime(time()), chinfo[0], supervisor));
-    }
+    if (stringp(chinfo[6]) && sizeof(chinfo[6]))
+      catch(supervisor = load_object(chinfo[6]); publish);
   }
-  else
+  // Aber falls kein SV angegeben wird oder das Objekt nicht ladbar war, wird
+  // ein Default-SV genutzt.
+  if (!supervisor)
+    supervisor = load_object(DEFAULTSV);
+
+  desc = chinfo[5];
+  chflags = to_int(chinfo[4]);
+
+  if (new(chinfo[0], supervisor, desc, chflags) == E_ACCESS_DENIED)
   {
-    // aber auch falls die Ebene (noch) existiert: wenn der channeld
-    // Supervisor sein soll, muss er die Ebene in jedem Fall
-    // (neu) betreten. Dabei wird er dann wieder Supervisor.
-    // Das Recht hat er immer und access() erlaubt das sogar vor dem Pruefen,
-    // ob es einen Supervisor gibt (den es jetzt gerade nicht gibt fuer
-    // Ebenen, in denen der CHANNELD supervisor war).
-    if (supervisor == this_object())
-      join(chinfo[0], this_object());
+    log_file("CHANNEL", sprintf("[%s] %s: %O: error, access denied\n",
+      dtime(time()), chinfo[0], supervisor));
   }
   return;
 }
@@ -540,26 +514,19 @@
             "boot": capitalize(getuid(previous_object()) || "<Unbekannt>")]);
 
   // Das muss auch laufen, wenn wir die alten Ebenen aus dem MEMORY bekommen
-  // haben, weil es dafuer sorgt, dass das Mapping <admin> aus
-  // channel_supervisor wieder mit den Informationen aus .init befuellt wird,
-  // weil das nicht in MEMORY liegt (weil das vermutlich ein Grund ist, den
-  // channeld neuzuladen: zum neuen Einlesen der Ebenenrechte).
-  // Ausserdem ist der channeld selber ja ein neues Objekt und trotz MEMORY
-  // nirgendwo mehr als Listener/Supervisor eingetragen, wo er eingetragen
-  // sein sollte...
-  // initialize() und setup() koennen aber mit Ebenen umgehen, die es schon
-  // gibt 
+  // haben, weil es ja neue Ebenen geben koennte, die dann erstellt werden
+  // muessen (verschwundete werden aber nicht aufgeraeumt!)
   initialize();
+  // <MasteR>-Ebene betreten, damit der channeld auf seine Kommandos auf
+  // dieser Ebene reagieren kann.
+  this_object()->join(CMNAME, this_object());
 
   // Wenn wir die alten Ebenen nicht aus MEMORY hatten, gibts noch Dinge zu
   // erledigen.
   if (do_complete_init)
   {
-    // <MasteR>-Ebene erstellen. Channeld wird Ebenenbesitzer und somit auch
-    // Zuhoerer, damit er auf Kommandos auf dieser Ebene reagieren kann.
-    new(CMNAME, this_object(), "Zentrale Informationen zu den Ebenen");
     // Spieler muessen die Ebenen abonnieren. NPC und andere Objekte haben
-    // leider Pech gehabt.
+    // leider Pech gehabt, falls das nicht das erste Laden nach Reboot war.
     users()->RegisterChannels();
     // Die Zugriffskontrolle auf die Ebenen wird von der Funktion access()
     // erledigt. Weil sowohl externe Aufrufe aus dem Spielerobjekt, als auch
@@ -636,14 +603,14 @@
 }
 
 // name() - define the name of this object.
-string name()
+public varargs string name(int casus,int demon)
 {
   return CMNAME;
 }
 
-string Name()
+public varargs string Name(int casus, int demon)
 {
-  return CMNAME;
+  return capitalize(CMNAME);
 }
 
 // Low-level function for adding members without access checks
@@ -791,7 +758,7 @@
   object old_sv = ch.supervisor;
 
   ch.supervisor = new_sv;
-  ch.access_cl = symbol_function("check_ch_access", new_sv);
+  ch.access_cl = symbol_function("ch_check_access", new_sv);
 
   if (old_sv && new_sv
       && !old_sv->QueryProp(P_INVIS)
@@ -896,7 +863,7 @@
 varargs private int access(struct channel_s ch, object user, string cmd,
                            string txt)
 {
-  if (!ch)
+  if (!ch || !user)
     return 0;
 
   // Dieses Objekt und Root-Objekte duerfen auf der Ebene senden, ohne
@@ -905,16 +872,17 @@
   // Supervisoren. (z.B. kann dieses Objekt sogar Meldungen im Namen anderer
   // Objekte faken)
   // Die Pruefung erfolgt absichtlich vor assert_supervisor(), damit der
-  // CHANNELD z.b. Ebenen re-joinen kann und dort wieder supervisor werden
-  // kann.
+  // CHANNELD auch in temporaeren SV-losen Zustaenden was machen kann.
   if ( !previous_object(1) || !extern_call() ||
        previous_object(1) == this_object() ||
        getuid(previous_object(1)) == ROOTID)
     return 2;
 
   // Objekte duerfen keine Meldungen im Namen anderer Objekte faken, d.h. der
-  // vermeintliche <user> muss auch der Aufrufer sein.
-  if (!objectp(user) || previous_object(1) != user)
+  // vermeintliche <user> muss auch der Aufrufer sein. Ausser darf auch sonst
+  // kein Objekt was fuer ein anderes Objekt duerfen, sonst kann jemand z.B.
+  // eine History abfragen indem einfach ein anderes Objekt uebergeben wird.
+  if (previous_object(1) != user)
     return 0;
 
   if (IsBanned(user, cmd))
@@ -929,10 +897,11 @@
     return 1;
 
   // Das SV-Objekt wird gefragt, ob der Zugriff erlaubt ist. Dieses erfolgt
-  // fuer EM+ aber nur, wenn der CHANNELD selber das SV-Objekt ist, damit
+  // fuer EM+ aber nur, wenn es das Default-SV-Objekt ist, damit
   // nicht beliebige SV-Objekt EMs den Zugriff verweigern koennen. Ebenen mit
-  // CHANNELD als SV koennen aber natuerlich auch EM+ Zugriff verweigern.
-  if (IS_ARCH(previous_object(1)) && ch.supervisor != this_object())
+  // Default-SV koennen aber auch EM+ Zugriff verweigern.
+  if (IS_ARCH(previous_object(1))
+      && ch.supervisor != find_object(DEFAULTSV))
     return 1;
 
   return funcall(ch.access_cl, lower_case(ch.name), user, cmd, &txt);
@@ -941,7 +910,7 @@
 // Neue Ebene <ch> erstellen mit <owner> als Ebenenbesitzer.
 // <desc> kann die statische Beschreibung der Ebene sein oder eine Closure,
 // die dynamisch aktualisierte Infos ausgibt.
-// Das Objekt <owner> kann eine Funktion check_ch_access() definieren, die
+// Das Objekt <owner> sollte eine Funktion ch_check_access() definieren, die
 // gerufen wird, wenn eine Ebenenaktion vom Typ join/leave/send/list/users
 // eingeht.
 #define IGNORE  "^/xx"
@@ -1007,9 +976,9 @@
 
   ch.members = ({ owner });
   ch.supervisor = owner;
-  // check_ch_access() dient der Zugriffskontrolle und entscheidet, ob die
+  // ch_check_access() dient der Zugriffskontrolle und entscheidet, ob die
   // Nachricht gesendet werden darf oder nicht.
-  ch.access_cl = symbol_function("check_ch_access", owner);
+  ch.access_cl = symbol_function("ch_check_access", owner);
 
   m_add(channels, ch_name, ch);
 
@@ -1057,7 +1026,8 @@
      richtige ist. */
   if (!funcall(#'access, ch, joining, C_JOIN))
     return E_ACCESS_DENIED;
-
+  //TODO: Sollte der creator das Recht auf join haben, auch wenn der aktuelle
+  //SV es verweigert? (s.u.)
   int res = add_member(ch, joining);
   if (res != 1)
     return res;
@@ -1074,10 +1044,9 @@
 // Objekt <pl> verlaesst Ebene <ch>.
 // Zugriffsrechte werden nur der Vollstaendigkeit halber geprueft; es duerfte
 // normalerweise keinen Grund geben, das Verlassen einer Ebene zu verbieten.
-// Dies ist in check_ch_access() so geregelt, allerdings koennte dem Objekt
+// Dies ist in ch_check_access() so geregelt, allerdings koennte dem Objekt
 // <pl> das Verlassen auf Grund eines Banns verboten sein.
-// Wenn kein Spieler mehr auf der Ebene ist, loest sie sich auf, sofern nicht
-// noch ein Ebenenbesitzer eingetragen ist.
+// Wenn kein Zuhoerer mehr auf der Ebene ist, loest sie sich auf.
 public int leave(string chname, object leaving)
 {
   struct channel_s ch = channels[lower_case(chname)];
@@ -1155,8 +1124,8 @@
     return E_ACCESS_DENIED;
 
   // a<2 bedeutet effektiv a==1 (weil a==0 oben rausfaellt), was dem
-  // Rueckgabewert von check_ch_access() entspricht, wenn die Aktion zugelassen
-  // wird. access() allerdings 2 fuer "privilegierte" Objekte (z.B.
+  // Rueckgabewert von ch_check_access() entspricht, wenn die Aktion zugelassen
+  // wird. access() liefert allerdings 2 fuer "privilegierte" Objekte (z.B.
   // ROOT-Objekte oder den channeld selber). Der Effekt ist, dass diese
   // Objekte auf Ebenen senden duerfen, auf denen sie nicht zuhoeren.
   if (a < 2 && !IsChannelMember(ch, sender))
diff --git a/p/daemon/channeld.init b/p/daemon/channeld.init
index e8695b3..babf6d5 100644
--- a/p/daemon/channeld.init
+++ b/p/daemon/channeld.init
@@ -1,6 +1,7 @@
 # CHANNEL MASTER INIT FILE
 # To create a new channel:
 # <name>:<recv>:<send>:<accessflags>:<channelflags>:<desc>:<supervisor>
+<MasteR>:    0: 0: 0: 1:Zentrale Informationen zu den Ebenen
 Allgemein:   0: 0: 0: 0:Allgemeine Unterhaltungsebene
 Abenteuer:   0: 0: 0: 0:Fragen die Abenteuer betreffen:/secure/questmaster
 Grats:       0: 0: 0: 0:Gratulationen zu geloesten Abenteuern etc
diff --git a/p/daemon/channeld.init.testmud b/p/daemon/channeld.init.testmud
index ea9696d..508dc2b 100644
--- a/p/daemon/channeld.init.testmud
+++ b/p/daemon/channeld.init.testmud
@@ -3,6 +3,7 @@
 # <name>:<recv>:<send>:<accessflags>:<channelflags>:<desc>:<supervisor>
 #
 # Debug-Ebenen initialisieren.
+<MasteR>:    0: 0: 0: 1:Zentrale Informationen zu den Ebenen
 Debug:       20:60:1:1:Debug und Fehlermeldungen:/p/daemon/debug
 Entwicklung: 20:60:1:1:Fehler rund um Eigenentwicklungen:/p/daemon/debug
 Warnungen:   20:60:1:1:Laufzeit-Warnungen:/p/daemon/debug
diff --git a/std/channel_supervisor.c b/std/channel_supervisor.c
index bb57717..80ed899 100644
--- a/std/channel_supervisor.c
+++ b/std/channel_supervisor.c
@@ -1,43 +1,66 @@
-// /std/channel_supervisor.c
+/* /std/channel_supervisor.c
 //
-// Der Standard-Supervisor fuer Ebenen. Wird genutzt vom channeld fuer die
-// Ebenen, die der verwaltet.
+// Der Standard-Supervisor fuer Ebenen. Sollte von allen Objekten geerbt
+// werden, die Zugriffsrechte fuer Ebenen verwalten ("das Sagen" auf der Ebene
+// haben).
+// Das Objekt braucht ggf. eine eUID zum Dateizugriff. Zum Setzen dieser ist
+// der Erbende verantwortlich.
+// Standardmaessig wird /p/daemon/channeld.init[.testmud] eingelesen.
+// Erbende koennen ihre Daten auch voellig anderweitig einlesen/ermitteln und
+// Rechte voellig anders pruefen statt gegen ein Level zu pruefen.
+// Das einzig wichtige fuer die Rechtepruefung ist die Funktion
+// ch_check_access(), die vom CHANNELD gerufen wird. Sie muss 1 zurueckgeben,
+// falls die Aktion erlaubt wird und 0 anderenfalls.
+//
+// Benutzung fuer Standardebenen:
+//    Dieses Objekt erben, ggf. eine eUID setzen und ch_read_init_file()
+//    rufen.
+//    Zusaetzlich sollte dieses Objekt aber auch ein Namen haben, weil es
+//    damit auf den Ebenen angezeigt wird. (D.h. minimal name() und Name()
+//    sollten implementiert/geerbt sein.)
+*/
 
-#pragma strict_types,save_types, rtt_checks
+#pragma strict_types, rtt_checks
 #pragma no_shadow, no_clone
 
 #include <wizlevels.h>
+#include <regexp.h>
 #include "/p/daemon/channel.h"
 #include <living/description.h>
 
-// Indizes fuer Zugriffe auf das Mapping <admin>.
-#define RECV    0
-#define SEND    1
-#define FLAG    2
-
-// Ebenenflags, gespeichert in admin[ch, FLAG]
-// F_WIZARD kennzeichnet reine Magierebenen
-#define F_WIZARD 1
-// Ebenen, auf denen keine Gaeste erlaubt sind, sind mit F_NOGUEST markiert.
-#define F_NOGUEST 2
-
 /* Speichert Sende- und Empfangslevel sowie Flags zu den einzelnen Channeln.
- * Diese werden aber nur ausgewertet, wenn der Channeld die Rechtepruefung
- * fuer die jeweilige Ebene macht, d.h. in der Praxis bei Ebenen, bei denen
- * der CHANNELD der Supervisor ist.
- * Deswegen sind diese Daten auch nicht in der struct (<channel_s>) drin.
- * Wird beim Laden des Masters via create() -> initalize() -> setup() mit den
- * Daten aus dem Init-File ./channeld.init befuellt.
-   mapping admin = ([ string channel_name : int RECV_LVL,
-                                            int SEND_LVL,
-                                            int FLAG ]) */
-private mapping admin = m_allocate(0, 3);
+   mapping ch_access_data = ([ string channel_name : (<ch_access>) ]) */
+struct ch_access {
+    int recv;
+    int send;
+    int flags;
+};
+// nicht nosave hier, damit man es zwar nosave erben kann, aber ggf. auch
+// speichern kann
+protected mapping ch_access_data = m_allocate(0, 1);
 
-// check_ch_access() prueft die Zugriffsberechtigungen auf Ebenen.
+// oeffentlicher Name des Supervisors
+protected string ch_sv_name = "Generischer SV";
+
+protected void ch_set_sv_name(string newname)
+{
+  ch_sv_name = newname;
+}
+
+public varargs string name(int casus,int demon)
+{
+  return ch_sv_name;
+}
+
+public varargs string Name(int casus, int demon)
+{
+  return capitalize(name( casus, demon )||"");
+}
+
+// ch_check_access() prueft die Zugriffsberechtigungen auf Ebenen.
 //
+// Wird vom CHANNELD gerufen.
 // Gibt 1 zurueck, wenn Aktion erlaubt, 0 sonst.
-// Wird von access() gerufen; access() gibt das Ergebnis von
-// check_ch_access() zurueck.
 //
 // Verlassen (C_LEAVE) ist immer erlaubt. Die anderen Aktionen sind in zwei
 // Gruppen eingeteilt:
@@ -47,79 +70,144 @@
 //
 // Aktionen werden zugelassen, wenn Spieler/MagierLevel groesser ist als die
 // fuer die jeweilige Aktionsgruppe RECV oder SEND festgelegte Stufe.
-// Handelt es sich um eine Magierebene (F_WIZARD), muss die Magierstufe
-// des Spielers groesser sein als die Mindeststufe der Ebene. Ansonsten
-// wird gegen den Spielerlevel geprueft.
+// Handelt es sich um eine Magierebene (<accessflags> enthaelt das Flag
+// CH_ACCESS_WIZARD), muss die Magierstufe des Spielers groesser sein als die
+// Mindeststufe der Ebene. Ansonsten wird gegen den Spielerlevel geprueft.
+// Enthaelt <accessflags> das Flag CH_ACCESS_NOGUEST, darf die Ebene nicht von
+// Gaesten benutzt werden.
 //
 // Wenn RECV_LVL oder SEND_LVL auf -1 gesetzt ist, sind die Aktionen der
 // jeweiligen Gruppen komplett geblockt.
 
-public int check_ch_access(string ch, object pl, string cmd)
+public int ch_check_access(string ch, object user, string cmd)
 {
-  // <pl> ist Gast, es sind aber keine Gaeste zugelassen? Koennen wir
+  struct ch_access access = ch_access_data[ch];
+  // <user> ist Gast, es sind aber keine Gaeste zugelassen? Koennen wir
   // direkt ablehnen.
-  if ((admin[ch, FLAG] & F_NOGUEST) && ({int})pl->QueryGuest())
+  if ((access.flags & CH_ACCESS_NOGUEST) && ({int})user->QueryGuest())
     return 0;
 
   // Ebenso auf Magier- oder Seherebenen, wenn ein Spieler anfragt, der
   // noch kein Seher ist.
-  if ((admin[ch, FLAG] & F_WIZARD) && query_wiz_level(pl) < SEER_LVL)
+  if ((access.flags & CH_ACCESS_WIZARD) && query_wiz_level(user) < SEER_LVL)
     return 0;
 
   // Ebene ist Magierebene? Dann werden alle Stufenlimits gegen Magierlevel
   // geprueft, ansonsten gegen Spielerlevel.
-  int level = (admin[ch, FLAG] & F_WIZARD
-                  ? query_wiz_level(pl)
-                  : ({int})pl->QueryProp(P_LEVEL));
+  int level = (access.flags & CH_ACCESS_WIZARD
+                  ? query_wiz_level(user)
+                  : ({int})user->QueryProp(P_LEVEL));
 
   switch (cmd)
   {
     case C_FIND:
     case C_LIST:
     case C_JOIN:
-      if (admin[ch, RECV] == -1)
+      if (access.recv == -1)
         return 0;
-      if (admin[ch, RECV] <= level)
+      if (access.recv <= level)
         return 1;
       break;
 
     case C_SEND:
-      if (admin[ch, SEND] == -1)
+      if (access.send == -1)
         return 0;
-      if (admin[ch, SEND] <= level)
+      if (access.send <= level)
         return 1;
       break;
 
     // Verlassen ist immer erlaubt
     case C_LEAVE:
       return 1;
-
-    default:
-      break;
   }
   return 0;
 }
 
-// ggf. zum ueberschreiben
-protected int ch_caller_allowed(object caller)
+// ch_store_access() - Angaben zu Zugriffsrechten fuer eine Ebene merken
+//            Angaben kommen in folgender Reihenfolge:
+//            string* chinfo = ({ channel_name, receive_level, send_level,
+//                                adminflags, channelflags, description,
+//                                supervisor })
+//            mapping &data ist im Regelfall das <ch_access_data>, was per
+//              Referenz uebergeben wird (auch wenn das nicht noetig ist,
+//              macht es klar, was beabsichtigt ist).
+protected void ch_store_access(string* chinfo, mapping data)
 {
-  if (caller == find_object(CHMASTER))
-    return 1;
-  return 0;
-}
+  object supervisor;
 
-// stores the read and write levels and flags for a channel for
-// usage in check_ch_access(). By default it is called by channeld::setup()
-// during setup of a default channel in the supervisor configured for the
-// channel.
-// recv and send are minimum levels, flag is a combination of the F_* above.
-visible void ch_supervisor_setup(string chname, int recv, int send, int flag)
-{
-  if (!extern_call() || ch_caller_allowed(previous_object()))
+  // Nur die Angabe des SV (Index 6) im initfile ist optional, alle Elemente
+  // davor muessen da sein. Wenn kein Supervisor angegeben ist, wird der
+  // Default-SV angenommen.
+
+  if (sizeof(chinfo) >= 7)
   {
-    admin[chname, FLAG] = flag;
-    admin[chname, SEND] = send;
-    admin[chname, RECV] = recv;
+    if (stringp(chinfo[6]) && sizeof(chinfo[6]))
+      supervisor = find_object(chinfo[6]);
   }
+  else if (sizeof(chinfo) == 6)
+    supervisor = find_object(DEFAULTSV);
+  else
+    return;
+
+  // Nur Daten merken, wenn wir auch der Supervisor fuer die Ebene sein
+  // sollen.
+  if (supervisor != this_object())
+    return;
+
+  struct ch_access access = (<ch_access>
+                               recv: to_int(chinfo[1]),
+                               send: to_int(chinfo[2]),
+                               flags: to_int(chinfo[3])
+                             );
+
+  data[lower_case(chinfo[0])] = access;
+  // Rest der Ebenendaten interessiert uns nicht.
+}
+
+// Liest ein channeld.init file ein. Wenn keines angegeben wird, wird der
+// das Standardfile fuers Mud eingelesen. Die Angaben werden in das Mapping
+// <ch_access_data> uebernommen, dieses vorher aber nicht geloescht.
+// Der Rueckgabewert ist < 0 fuer Fehler, ansonsten die Groesse von
+// <ch_access_data> nach Einlesen des Files.
+protected varargs int ch_read_init_file(string fname)
+{
+  string ch_list;
+  if (!fname)
+  {
+#if !defined(__TESTMUD__) && MUDNAME=="MorgenGrauen"
+    fname = CHMASTER ".init";
+#else
+    fname = CHMASTER ".init.testmud";
+#endif
+  }
+
+  ch_list = read_file(fname);
+  if (!stringp(ch_list))
+    return -1;
+
+  // Channeldatensaetze erzeugen, dazu zuerst Datenfile in Zeilen zerlegen
+  // "Allgemein:   0: 0: 0: 0: Allgemeine Unterhaltungsebene"
+  // Danach drueberlaufen und in Einzelfelder splitten, dabei gleich die
+  // Trennzeichen (Doppelpunkt, Tab und Space) rausfiltern.
+  foreach(string ch : old_explode(ch_list, "\n"))
+  {
+    if (ch[0]=='#')
+      continue;
+    ch_store_access(regexplode(ch, ":[ \t]*", RE_OMIT_DELIM),
+                    &ch_access_data);
+  }
+  return sizeof(ch_access_data);
+}
+
+// Nur falls es mal gebraucht wird und  damit es schon jetzt alle rufen
+// koennen.
+protected void create()
+{
+}
+
+public varargs int remove(int silent)
+{
+  destruct(this_object());
+  return 1;
 }