diff --git a/p/daemon/channeld.c b/p/daemon/channeld.c
index a26f9ed..a0e0768 100644
--- a/p/daemon/channeld.c
+++ b/p/daemon/channeld.c
@@ -20,23 +20,58 @@
 #define NEED_PROTOTYPES
 #include "channel.h"
 
-#define CMNAME  "<MasteR>"
-#define CHANNEL_SAVE    "/p/daemon/save/channeld"
+#define CMNAME       "<MasteR>"
+#define CHANNEL_SAVE "/p/daemon/save/channeld"
+#define MEMORY       "/secure/memory"
+#define TIMEOUT      (time() - 60)
+#define CMDS         ({C_FIND, C_LIST, C_JOIN, C_LEAVE, C_SEND, C_NEW})
 
-#define MEMORY "/secure/memory"
-
-// channels - contains the simple channel information
-//            ([ channelname : ({ I_MEMBER, I_ACCESS, I_INFO, I_MASTER })...])
-private nosave mapping lowerch;
+/* list of channels and their corresponding data (members, etc.)
+   channels = ([string channelname : ({ ({object* members}),
+                                          closure access_rights,
+                                          string channel_info,
+                                          string|object master_object,
+                                          string channelname }) ]) */
 private nosave mapping channels;
+//private nosave mapping lowerch; // unused
+
+/* channel history
+   mapping channelH = ([ string channelname : ({ string channelname,
+                                                 string sender,
+                                                 string msg,
+                                                 int msg_type }) ]) */
 private nosave mapping channelH;
+
+/* list of global channelmaster stats
+   mapping stats:  ([ "time" : int object_time(),
+                      "boot" : string load_name(previous_object()),
+                      "new"  : int total_channels_created,
+                      "disposed" : int total_channels_removed ]) */
 private nosave mapping stats;
 
+/* channel cache
+   mapping channelC = ([ string channelname : ({ string I_NAME,
+                                                 string I_INFO,
+                                                 int time() }) ]) */
 private mapping channelC;
+
+/* list of players' banned commands, if any
+   mapping channelB = ([ string playername : ({ string* banned_commands })])*/
 private mapping channelB;
 
+/* timeout cache for player commands (timeout = 60 s, see above)
+   ensures that the same command is only executed once per minute, max
+   mapping Tcmd = ([ "lag": int timestamp,
+                     "uptime":  int timestamp,
+                     "statistik":  int timestamp]) */
+private mapping Tcmd = ([]);
+
+/* Flag to indicate that data changes have occurred and that we need saving
+   in the next save_object() run.
+   set to 0 or 1 */
 private int save_me_soon;
 
+
 // BEGIN OF THE CHANNEL MASTER ADMINISTRATIVE PART
 
 #define RECV    0
@@ -55,174 +90,221 @@
 int check(string ch, object pl, string cmd)
 {
   int level;
-  
-  if((admin[ch, FLAG] & F_NOGUEST) && pl->QueryGuest()) return 0;
 
-  if((admin[ch, FLAG] & F_WIZARD) && query_wiz_level(pl) < SEER_LVL) return 0;
+  if ((admin[ch, FLAG] & F_NOGUEST) && pl->QueryGuest())
+    return 0;
+
+  if ((admin[ch, FLAG] & F_WIZARD) && query_wiz_level(pl) < SEER_LVL)
+    return 0;
+
   level = (admin[ch, FLAG] & F_WIZARD
-           ? query_wiz_level(pl)
-           : pl->QueryProp(P_LEVEL));
+              ? query_wiz_level(pl)
+              : pl->QueryProp(P_LEVEL));
 
-  switch(cmd)
+  switch (cmd)
   {
-  case C_FIND:
-  case C_LIST:
-  case C_JOIN:
-    if(admin[ch, RECV] == -1) return 0;
-    if(admin[ch, RECV] <= level) return 1;
-    break;
-  case C_SEND:
-    if(admin[ch, SEND] == -1) return 0;
-    if(admin[ch, SEND] <= level) return 1;
-    break;
-  case C_LEAVE:
-    return 1;
-  default: break;
+    case C_FIND:
+    case C_LIST:
+    case C_JOIN:
+      if (admin[ch, RECV] == -1)
+        return 0;
+      if (admin[ch, RECV] <= level)
+        return 1;
+      break;
+
+    case C_SEND:
+      if (admin[ch, SEND] == -1)
+        return 0;
+      if (admin[ch, SEND] <= level)
+        return 1;
+      break;
+
+    case C_LEAVE:
+      return 1;
+
+    default:
+      break;
   }
-  return(0);
+  return (0);
 }
 
 private int CountUser(mapping l)
 {
   mapping n = ([]);
-  walk_mapping(l, function void (string chan_name, mixed* chan_data) {
-        n += mkmapping(chan_data[I_MEMBER]);
-      });
+  walk_mapping(l, function void (string chan_name, mixed * chan_data)
+    {
+      n += mkmapping(chan_data[I_MEMBER]);
+    });
   return sizeof(n);
 }
 
-private void banned(string n, mixed cmds, string res)
+private void banned(string n, string* cmds, string res)
 {
   res += sprintf("%s [%s], ", capitalize(n), implode(cmds, ","));
 }
 
-private mapping Tcmd = ([]);
-#define TIMEOUT (time() - 60)
-
 void ChannelMessage(mixed msg)
 {
   string ret, mesg;
   mixed lag;
   int max, rekord;
   string tmp;
-  if(msg[1] == this_object() || !stringp(msg[2]) ||
-     msg[0] != CMNAME || previous_object() != this_object()) return;
 
+  if (msg[1] == this_object() || !stringp(msg[2]) ||
+      msg[0] != CMNAME || previous_object() != this_object())
+    return;
 
   mesg = lower_case(msg[2]);
 
-  if(!strstr("hilfe", mesg) && sizeof(mesg) <= 5)
-    ret = "Folgende Kommandos gibt es: hilfe, lag, up[time], statistik, bann";
-  else
-  if(!strstr("lag", mesg) && sizeof(mesg) <= 3)
+  if (!strstr("hilfe", mesg) && sizeof(mesg) <= 5)
   {
-    if(Tcmd["lag"] > TIMEOUT) return;
+    ret = "Folgende Kommandos gibt es: hilfe, lag, up[time], statistik, bann";
+  }
+  else if (!strstr("lag", mesg) && sizeof(mesg) <= 3)
+  {
+    // TODO: invert logic to make this better understandable, e.g.
+    // if ( CMD_AVAILABLE("lag") ) and rearrange code block
+    if (Tcmd["lag"] > TIMEOUT)
+      return;
+
     Tcmd["lag"] = time();
     lag = "/p/daemon/lag-o-daemon"->read_ext_lag_data();
     ret = sprintf("Lag: %.1f%%/60, %.1f%%/15, %.1f%%/5, %.1f%%/1, "
-                       "%.1f%%/20s, %.1f%%/2s",
-                  lag[5], lag[4], lag[3], lag[2], lag[1], lag[0]);
-    call_out(#'send/*'*/, 2, CMNAME, this_object(), ret);
+              "%.1f%%/20s, %.1f%%/2s",
+              lag[5], lag[4], lag[3], lag[2], lag[1], lag[0]);
+    call_out(#'send, 2, CMNAME, this_object(), ret);
     ret = query_load_average();
-  } else
-  if(!strstr("uptime", mesg) && sizeof(mesg) <= 6)
+  }
+  // TODO: move this logic to a function with a self-explanatory name
+  else if (!strstr("uptime", mesg) && sizeof(mesg) <= 6)
   {
-    if(Tcmd["uptime"] > TIMEOUT) return;
+    if (Tcmd["uptime"] > TIMEOUT)
+      return;
+
     Tcmd["uptime"] = time();
-    if(file_size("/etc/maxusers") <= 0) {
+
+    if (file_size("/etc/maxusers") <= 0)
+    {
       ret = "Diese Information liegt nicht vor.";
-    } else {
+    }
+    else
+    {
       sscanf(read_file("/etc/maxusers"), "%d %s", max, tmp);
       sscanf(read_file("/etc/maxusers.ever"), "%d %s", rekord, tmp);
       ret = sprintf("Das MUD laeuft jetzt %s. Es sind momentan %d Spieler "
-                  "eingeloggt; das Maximum lag heute bei %d und der Rekord "
-                  "bisher ist %d.", uptime(), sizeof(users()), max, rekord);
+          "eingeloggt; das Maximum lag heute bei %d und der Rekord "
+          "bisher ist %d.", uptime(), sizeof(users()), max, rekord);
     }
-  } else
-  if(!strstr("statistik", mesg) && sizeof(mesg) <= 9)
+  }
+  else if (!strstr("statistik", mesg) && sizeof(mesg) <= 9)
   {
-    if(Tcmd["statistik"] > TIMEOUT) return;
+    if (Tcmd["statistik"] > TIMEOUT)
+      return;
+
     Tcmd["statistik"] = time();
     ret = sprintf(
-    "Im Moment sind insgesamt %d Ebenen mit %d Teilnehmern aktiv.\n"
-    "Der %s wurde das letzte mal am %s von %s neu gestartet.\n"
-    "Seitdem wurden %d Ebenen neu erzeugt und %d zerstoert.\n",
-    sizeof(channels), CountUser(channels), CMNAME,
-    dtime(stats["time"]), stats["boot"], stats["new"], stats["dispose"]);
-  } else
-  if(!strstr(mesg, "bann"))
+        "Im Moment sind insgesamt %d Ebenen mit %d Teilnehmern aktiv.\n"
+        "Der %s wurde das letzte mal am %s von %s neu gestartet.\n"
+        "Seitdem wurden %d Ebenen neu erzeugt und %d zerstoert.\n",
+        sizeof(channels), CountUser(channels), CMNAME,
+        dtime(stats["time"]), stats["boot"], stats["new"], stats["dispose"]);
+  }
+  else if (!strstr(mesg, "bann"))
   {
     string pl, cmd;
-    if(mesg == "bann")
-      if(sizeof(channelB))
+
+    if (mesg == "bann")
+    {
+      if (sizeof(channelB))
       {
         ret = "";
-        walk_mapping(channelB, #'banned/*'*/, &ret);
+        walk_mapping(channelB, #'banned, &ret);
         ret = "Fuer folgende Spieler besteht ein Bann: " + ret;
-      } else ret = "Zur Zeit ist kein Bann aktiv.";
-    else
-    {
-      if(sscanf(mesg, "bann %s %s", pl, cmd) == 2 &&
-         IS_DEPUTY(msg[1]))
-      {
-#     define CMDS ({C_FIND, C_LIST, C_JOIN, C_LEAVE, C_SEND, C_NEW})
-        pl = lower_case(pl); cmd = lower_case(cmd);
-        if(member(CMDS, cmd) != -1)
-        {
-          if(!pointerp(channelB[pl]))
-            channelB[pl] = ({});
-          if(member(channelB[pl], cmd) != -1)
-            channelB[pl] -= ({ cmd });
-          else
-            channelB[pl] += ({ cmd });
-          ret = "Fuer '"+capitalize(pl)+"' besteht "
-            + (sizeof(channelB[pl]) ?
-               "folgender Bann: "+implode(channelB[pl], ", ") :
-               "kein Bann mehr.");
-          if(!sizeof(channelB[pl]))
-            channelB = m_copy_delete(channelB, pl);
-          save_object(CHANNEL_SAVE);
-        }
-        else ret = "Das Kommando '"+cmd+"' ist unbekannt. Erlaubte Kommandos: "
-               + implode(CMDS, ", ");
       }
       else
       {
-        if(!IS_ARCH(msg[1])) return;
-        else ret = "Syntax: bann <name> <kommando>";
+        ret = "Zur Zeit ist kein Bann aktiv.";
+      }
+    }
+    else
+    {
+      if (sscanf(mesg, "bann %s %s", pl, cmd) == 2 && IS_DEPUTY(msg[1]))
+      {
+        pl = lower_case(pl);
+        cmd = lower_case(cmd);
+
+        if (member(CMDS, cmd) != -1)
+        {
+          if (!pointerp(channelB[pl]))
+            channelB[pl] = ({});
+
+          if (member(channelB[pl], cmd) != -1)
+            channelB[pl] -= ({ cmd });
+          else
+            channelB[pl] += ({ cmd });
+          ret = "Fuer '" + capitalize(pl) + "' besteht "
+            + (sizeof(channelB[pl]) ?
+              "folgender Bann: " + implode(channelB[pl], ", ") :
+              "kein Bann mehr.");
+
+          if (!sizeof(channelB[pl]))
+            channelB = m_copy_delete(channelB, pl);
+
+          save_object(CHANNEL_SAVE);
+        }
+        else
+        {
+          ret = "Das Kommando '" + cmd + "' ist unbekannt. "
+                "Erlaubte Kommandos: "+ implode(CMDS, ", ");
+        }
+      }
+      else
+      {
+        if (!IS_ARCH(msg[1]))
+          return;
+        else
+          ret = "Syntax: bann <name> <kommando>";
       }
     }
   }
-  else if(mesg == "lust")
+  else if (mesg == "lust")
   {
     mixed t, up;
-    if(Tcmd["lag"] > TIMEOUT ||
-       Tcmd["statistik"] > TIMEOUT ||
-       Tcmd["uptime"] > TIMEOUT) return;
+
+    if (Tcmd["lag"] > TIMEOUT ||
+        Tcmd["statistik"] > TIMEOUT ||
+        Tcmd["uptime"] > TIMEOUT)
+      return;
+
     Tcmd["lag"] = time();
     Tcmd["statistik"] = time();
     Tcmd["uptime"] = time();
     lag = "/p/daemon/lag-o-daemon"->read_lag_data();
-
     sscanf(read_file("/etc/maxusers"), "%d %s", max, tmp);
     sscanf(read_file("/etc/maxusers.ever"), "%d %s", rekord, tmp);
+    t = time() - last_reboot_time();
+    up = "";
 
-    t=time()-last_reboot_time();
-    up="";
-    if(t >= 86400)
-      up += sprintf("%dT", t/86400);
-    if(t >= 3600)
-      up += sprintf("%dh", (t=t%86400)/3600);
-    if(t > 60)
-      up += sprintf("%dm", (t=t%3600)/60);
-    up += sprintf("%ds", t%60);
+    if (t >= 86400)
+      up += sprintf("%dT", t / 86400);
 
+    if (t >= 3600)
+      up += sprintf("%dh", (t = t % 86400) / 3600);
+
+    if (t > 60)
+      up += sprintf("%dm", (t = t % 3600) / 60);
+
+    up += sprintf("%ds", t % 60);
     ret = sprintf("%.1f%%/15 %.1f%%/1 %s %d:%d:%d E:%d T:%d",
-                  lag[1], lag[2], up, sizeof(users()), max, rekord, 
-                  sizeof(channels), CountUser(channels));
-  } else return;
+            lag[1], lag[2], up, sizeof(users()), max, rekord,
+            sizeof(channels), CountUser(channels));
+  }
+  else
+  {
+    return;
+  }
 
-  call_out(#'send/*'*/, 2, CMNAME, this_object(), ret);
+  call_out(#'send, 2, CMNAME, this_object(), ret);
 }
 
 // setup() -- set up a channel and register it
@@ -240,33 +322,47 @@
   string d;
   d = "- Keine Beschreibung -";
   m = this_object();
-  if(sizeof(c) && sizeof(c[0]) > 1 && c[0][0] == '\\')
+
+  if (sizeof(c) && sizeof(c[0]) > 1 && c[0][0] == '\\')
     c[0] = c[0][1..];
 
-  switch(sizeof(c))
+  switch (sizeof(c))
   {
-  case 6:
-    if(!stringp(c[5]) || !sizeof(c[5]) 
-        || (catch(m=load_object(c[5]);publish) || !objectp(m) ))
-      m = this_object();
-  case 5: d = stringp(c[4]) || closurep(c[4]) ? c[4] : d;
-  case 4: admin[c[0], FLAG] = to_int(c[3]);
-  case 3: admin[c[0], SEND] = to_int(c[2]);
-  case 2: admin[c[0], RECV] = to_int(c[1]);
-    break;
-  case 0:
-  default:
-    return;
+    case 6:
+      if (!stringp(c[5]) || !sizeof(c[5]) ||
+          (catch(m = load_object(c[5]); publish) ||
+          !objectp(m)))
+        m = this_object();
+
+    case 5:
+      d = stringp(c[4]) || closurep(c[4]) ? c[4] : d;
+
+    case 4:
+      admin[c[0], FLAG] = to_int(c[3]);
+
+    case 3:
+      admin[c[0], SEND] = to_int(c[2]);
+
+    case 2:
+      admin[c[0], RECV] = to_int(c[1]);
+      break;
+
+    case 0:
+    default:
+      return;
   }
-  switch(new(c[0], m, d))
+
+  switch (new(c[0], m, d))
   {
-  case E_ACCESS_DENIED:
-    log_file("CHANNEL", sprintf("[%s] %s: %O: error, access denied\n",
-                           dtime(time()), c[0], m));
-    break;
-  default:
-    break;
+    case E_ACCESS_DENIED:
+      log_file("CHANNEL", sprintf("[%s] %s: %O: error, access denied\n",
+        dtime(time()), c[0], m));
+      break;
+
+    default:
+      break;
   }
+
   return;
 }
 
@@ -274,83 +370,103 @@
 {
   mixed tmp;
 #if !defined(__TESTMUD__) && MUDNAME=="MorgenGrauen"
-  tmp = read_file(object_name(this_object())+".init");
+  tmp = read_file(object_name(this_object()) + ".init");
 #else
-  tmp = read_file(object_name(this_object())+".init.testmud");
+  tmp = read_file(object_name(this_object()) + ".init.testmud");
 #endif
+
   if (!stringp(tmp))
     return;
+
   tmp = regexp(old_explode(tmp, "\n"), "^[^#]");
-  tmp = map(tmp, #'regexplode/*'*/, "[^:][^:]*$|[ \\t]*:[ \\t]*");
-  tmp = map(tmp, #'regexp/*'*/, "^[^: \\t]");
-  map(tmp, #'setup/*'*/);
+  tmp = map(tmp, #'regexplode, "[^:][^:]*$|[ \\t]*:[ \\t]*");
+  tmp = map(tmp, #'regexp, "^[^: \\t]");
+  map(tmp, #'setup);
 }
 
-// BEGIN OF THE CHANNEL MASTER IMPLEMENTATION
+        // BEGIN OF THE CHANNEL MASTER IMPLEMENTATION
 
 protected void create()
 {
   seteuid(getuid());
   restore_object(CHANNEL_SAVE);
-  if(!channelC) channelC = ([]);
-  if(!channelB) channelB = ([]);
+
+  if (!channelC)
+    channelC = ([]);
+
+  if (!channelB)
+    channelB = ([]);
+
   channels = ([]);
 
-  /* Die Channel-History wird nicht nur lokal sondern auch noch im Memory 
-     gespeichert, dadurch bleibt sie auch ueber ein Reload erhalten. 
+  /* Die Channel-History wird nicht nur lokal sondern auch noch im Memory
+     gespeichert, dadurch bleibt sie auch ueber ein Reload erhalten.
      Der folgende Code versucht, den Zeiger aus dem Memory zu holen. Falls
      das nicht moeglich ist, wird ein neuer erzeugt und gegebenenfalls im
      Memory abgelegt. */
 
   // Hab ich die noetigen Rechte im Memory?
-  if (call_other(MEMORY,"HaveRights")) {
+  if (call_other(MEMORY, "HaveRights"))
+  {
     // Objektpointer laden
-    channelH = call_other(MEMORY,"Load","History");
+    channelH = (mixed) call_other(MEMORY, "Load", "History");
 
     // Wenns nich geklappt hat, hat der Memory noch keinen Zeiger, dann
-    if (!mappingp(channelH)){
+    if (!mappingp(channelH)) {
       // Zeiger erzeugen
       channelH = ([]);
       // und in den Memory schreiben
-      call_other(MEMORY,"Save","History",channelH);
+      call_other(MEMORY, "Save", "History", channelH);
     }
-  } else {
+  }
+  else
+  {
     // Keine Rechte im Memory, dann wird mit einem lokalen Zeiger gearbeitet.
     channelH = ([]);
   }
 
   stats = (["time": time(),
-            "boot": capitalize(getuid(previous_object())||"<Unbekannt>")]);
-  new(CMNAME, this_object(), "Zentrale Informationen zu den Ebenen");
+                "boot": capitalize(getuid(previous_object()) || "<Unbekannt>")]);
+  new (CMNAME, this_object(), "Zentrale Informationen zu den Ebenen");
   initialize();
   map_objects(efun::users(), "RegisterChannels");
   this_object()->send(CMNAME, this_object(),
-                      sprintf("%d Ebenen mit %d Teilnehmern initialisiert.",
-                              sizeof(channels),
-                              CountUser(channels)));
+    sprintf("%d Ebenen mit %d Teilnehmern initialisiert.",
+      sizeof(channels),
+      CountUser(channels)));
 }
 
 // reset() and cache_to() - Cache Timeout, remove timed out cached channels
 // SEE: new, send
 private int cache_to(string key, mapping m, int t)
 {
-  if(!pointerp(m[key]) || m[key][2] + 43200 > t) return 1;
-  return(0);
+  if (!pointerp(m[key]) || m[key][2] + 43200 > t)
+    return 1;
+
+  return (0);
 }
 
 varargs void reset(int nonstd)
 {
-  channelC = filter_indices(channelC, #'cache_to/*'*/, channelC, time());
+  channelC = filter_indices(channelC, #'cache_to, channelC, time());
+
   if (save_me_soon)
   {
-    save_me_soon=0;
+    save_me_soon = 0;
     save_object(CHANNEL_SAVE);
   }
 }
 
 // name() - define the name of this object.
-string name() { return CMNAME; }
-string Name() { return CMNAME; }
+string name()
+{
+  return CMNAME;
+}
+
+string Name()
+{
+  return CMNAME;
+}
 
 // access() - check access by looking for the right argument types and
 //            calling access closures respectively
@@ -361,45 +477,53 @@
 {
   mixed co, m;
 
-  if(!stringp(ch) || !sizeof(ch = lower_case(ch)) || !channels[ch])
+  if (!stringp(ch) || !sizeof(ch = lower_case(ch)) || !channels[ch])
     return 0;
-  if(!channels[ch][I_ACCESS]||!previous_object(1)||!extern_call()||
-     previous_object(1)==this_object()||
-     (stringp(channels[ch][I_MASTER])&&
-      previous_object(1)==find_object(channels[ch][I_MASTER]))||
-     getuid(previous_object(1)) == ROOTID)
+
+  if (!channels[ch][I_ACCESS] || !previous_object(1) || !extern_call() ||
+      previous_object(1) == this_object() ||
+      (stringp(channels[ch][I_MASTER]) &&
+      previous_object(1) == find_object(channels[ch][I_MASTER])) ||
+      getuid(previous_object(1)) == ROOTID)
     return 2;
-  if(!objectp(pl) || 
-     ((previous_object(1)!=pl) &&(previous_object(1)!=this_object()))) 
-     return 0;
-   if(pointerp(channelB[getuid(pl)]) &&
-     member(channelB[getuid(pl)], cmd) != -1)
+
+  if (!objectp(pl) ||
+      ((previous_object(1) != pl) && (previous_object(1) != this_object())))
     return 0;
-   if(stringp(channels[ch][I_MASTER]) &&
-     (!(m = find_object(channels[ch][I_MASTER])) ||
-      (!to_object(channels[ch][I_ACCESS]) ||
-       get_type_info(channels[ch][I_ACCESS])[1])))
+
+  if (pointerp(channelB[getuid(pl)]) &&
+      member(channelB[getuid(pl)], cmd) != -1)
+    return 0;
+
+  if (stringp(channels[ch][I_MASTER]) &&
+      (!(m = find_object(channels[ch][I_MASTER])) ||
+        (!to_object(channels[ch][I_ACCESS]) ||
+        get_type_info(channels[ch][I_ACCESS])[1])))
   {
     string err;
-    if(!objectp(m)) err = catch(load_object(channels[ch][I_MASTER]);publish);
-    if(!err &&
-       ((!to_object(channels[ch][I_ACCESS]) ||
-         get_type_info(channels[ch][I_ACCESS])[1]) &&
-        !closurep(channels[ch][I_ACCESS] =
-                  symbol_function("check",
-                                  find_object(channels[ch][I_MASTER])))))
+
+    if (!objectp(m))
+      err = catch(load_object(channels[ch][I_MASTER]); publish);
+
+    if (!err &&
+        ((!to_object(channels[ch][I_ACCESS]) ||
+           get_type_info(channels[ch][I_ACCESS])[1]) &&
+          !closurep(channels[ch][I_ACCESS] =
+          symbol_function("check", find_object(channels[ch][I_MASTER])))))
     {
       log_file("CHANNEL", sprintf("[%s] %O -> %O\n",
-                                  dtime(time()), channels[ch][I_MASTER],
-                                  err));
+                dtime(time()), channels[ch][I_MASTER],
+                err));
       channels = m_copy_delete(channels, ch);
       return 0;
     }
+
     this_object()->join(ch, find_object(channels[ch][I_MASTER]));
   }
-  if(closurep(channels[ch][I_ACCESS]))
-      return funcall(channels[ch][I_ACCESS],
-                     channels[ch][I_NAME], pl, cmd, &txt);
+
+  if (closurep(channels[ch][I_ACCESS]))
+    return funcall(channels[ch][I_ACCESS],
+              channels[ch][I_NAME], pl, cmd, &txt);
 }
 
 // new() - create a new channel
@@ -408,57 +532,61 @@
 //         to display up-to-date information, check may contain a closure
 //         called when a join/leave/send/list/users message is received
 // SEE: access
-
 #define IGNORE  "^/xx"
 
 varargs int new(string ch, object pl, mixed info)
 {
   mixed pls;
 
-  if(!objectp(pl) || !stringp(ch) || !sizeof(ch) || channels[lower_case(ch)] ||
-     (pl == this_object() && extern_call()) ||
-     sizeof(channels) >= MAX_CHANNELS ||
-     sizeof(regexp(({ object_name(pl) }), IGNORE)) ||
-     (pointerp(channelB[getuid(pl)]) &&
+  if (!objectp(pl) || !stringp(ch) || !sizeof(ch) ||
+      channels[lower_case(ch)] || (pl == this_object() && extern_call()) ||
+      sizeof(channels) >= MAX_CHANNELS ||
+      sizeof(regexp(({ object_name(pl) }), IGNORE)) ||
+      (pointerp(channelB[getuid(pl)]) &&
       member(channelB[getuid(pl)], C_NEW) != -1))
     return E_ACCESS_DENIED;
 
-  if(!info) {
-    if(channelC[lower_case(ch)]) {
+  if (!info)
+  {
+    if (channelC[lower_case(ch)])
+    {
       ch = channelC[lower_case(ch)][0];
       info = channelC[lower_case(ch)][1];
     }
-    else return E_ACCESS_DENIED;
+    else
+    {
+      return E_ACCESS_DENIED;
+    }
   }
-  else channelC[lower_case(ch)] = ({ ch, info, time() });
+  else
+  {
+    channelC[lower_case(ch)] = ({ ch, info, time() });
+  }
 
   pls = ({ pl });
-
-  channels[lower_case(ch)] = ({ pls,
-                                symbol_function("check", pl) ||
-                                #'check/*'*/, info,
-                                (!living(pl) &&
-                                 !clonep(pl) &&
-                                 pl != this_object()
-                                 ? object_name(pl)
-                                 : pl),
-                                 ch,
-                             });
+  channels[lower_case(ch)] = ({
+                  pls,
+                  symbol_function("check", pl) || #'check, info,
+                  (!living(pl) && !clonep(pl) && pl != this_object()
+                      ? object_name(pl)
+                      : pl),
+                  ch});
 
   // ChannelH fuer einen Kanal nur dann initialisieren, wenn es sie noch nich gibt.
-  if ( !pointerp(channelH[lower_case(ch)]) )
-         channelH[lower_case(ch)] = ({});
+  if (!pointerp(channelH[lower_case(ch)]))
+    channelH[lower_case(ch)] = ({});
 
-  if(pl != this_object())
+  if (pl != this_object())
     log_file("CHANNEL.new", sprintf("[%s] %O: %O %O\n",
-                                    dtime(time()), ch, pl, info));
-  if(!pl->QueryProp(P_INVIS))
+        dtime(time()), ch, pl, info));
+
+  if (!pl->QueryProp(P_INVIS))
     this_object()->send(CMNAME, pl,
-                        "laesst die Ebene '"+ch+"' entstehen.", MSG_EMOTE);
+      "laesst die Ebene '" + ch + "' entstehen.", MSG_EMOTE);
+
   stats["new"]++;
- 
-  save_me_soon=1;
-  return(0);
+  save_me_soon = 1;
+  return (0);
 }
 
 // join() - join a channel
@@ -468,10 +596,14 @@
 // SEE: leave, access
 int join(string ch, object pl)
 {
-  if(!funcall(#'access,&ch, pl, C_JOIN)) return E_ACCESS_DENIED;
-  if(member(channels[ch][I_MEMBER], pl) != -1) return E_ALREADY_JOINED;
+  if (!funcall(#'access,&ch, pl, C_JOIN))
+    return E_ACCESS_DENIED;
+
+  if (member(channels[ch][I_MEMBER], pl) != -1)
+    return E_ALREADY_JOINED;
+
   channels[ch][I_MEMBER] += ({ pl });
-  return(0);
+  return (0);
 }
 
 // leave() - leave a channel
@@ -483,43 +615,46 @@
 int leave(string ch, object pl)
 {
   int pos;
-  if(!funcall(#'access,&ch, pl, C_LEAVE)) return E_ACCESS_DENIED;
+
+  if (!funcall(#'access,&ch, pl, C_LEAVE))
+    return E_ACCESS_DENIED;
+
   channels[ch][I_MEMBER] -= ({0}); // kaputte Objekte erstmal raus
-  if((pos = member(channels[ch][I_MEMBER], pl)) == -1) return E_NOT_MEMBER;
-  if(pl == channels[ch][I_MASTER] && sizeof(channels[ch][I_MEMBER]) > 1)
+
+  if ((pos = member(channels[ch][I_MEMBER], pl)) == -1)
+    return E_NOT_MEMBER;
+
+  if (pl == channels[ch][I_MASTER] && sizeof(channels[ch][I_MEMBER]) > 1)
   {
     channels[ch][I_MASTER] = channels[ch][I_MEMBER][1];
-    if(!pl->QueryProp(P_INVIS))
-      this_object()->send(ch, pl, "uebergibt die Ebene an "
-                          +channels[ch][I_MASTER]->name(WEN)+".", MSG_EMOTE);
+
+    if (!pl->QueryProp(P_INVIS))
+      this_object()->send(ch, pl, "uebergibt die Ebene an " +
+        channels[ch][I_MASTER]->name(WEN) + ".", MSG_EMOTE);
   }
   channels[ch][I_MEMBER][pos..pos] = ({ });
 
-
-  if(!sizeof(channels[ch][I_MEMBER]) &&
-     !stringp(channels[ch][I_MASTER]))
+  if (!sizeof(channels[ch][I_MEMBER]) && !stringp(channels[ch][I_MASTER]))
   {
     // delete the channel that has no members
-    if(!pl->QueryProp(P_INVIS))
-      this_object()->send(CMNAME, pl,
-                          "verlaesst als "
-                          +(pl->QueryProp(P_GENDER) == 1 ? "Letzter" :
-                            "Letzte")
-                          +" die Ebene '"
-                          +channels[ch][I_NAME]
-                          +"', worauf diese sich in einem Blitz oktarinen "
-                          +"Lichts aufloest.", MSG_EMOTE);
-    channelC[lower_case(ch)] = ({ channels[ch][I_NAME],
-                                  channels[ch][I_INFO], time() });
+    if (!pl->QueryProp(P_INVIS))
+        this_object()->send(CMNAME, pl,
+          "verlaesst als "+
+          (pl->QueryProp(P_GENDER) == 1 ? "Letzter" : "Letzte")+
+          " die Ebene '"+channels[ch][I_NAME]+"', worauf diese sich in "
+          "einem Blitz oktarinen Lichts aufloest.", MSG_EMOTE);
+
+    channelC[lower_case(ch)] =
+      ({ channels[ch][I_NAME], channels[ch][I_INFO], time() });
     m_delete(channels, lower_case(ch));
-
     // Wird ein Channel entfernt, wird auch seine History geloescht
+    // TODO: this foils the attempts at creating a persistent channel
+    // history via /secure/memory.c
     channelH = m_copy_delete(channelH, lower_case(ch));
-
     stats["dispose"]++;
-    save_me_soon=1;
+    save_me_soon = 1;
   }
-  return(0);
+  return (0);
 }
 
 // send() - send a message to all recipients of the specified channel 'ch'
@@ -532,35 +667,49 @@
 {
   int a;
 
-  if(!(a = funcall(#'access,&ch, pl, C_SEND, &msg))) return E_ACCESS_DENIED;
-  if(a < 2 && member(channels[ch][I_MEMBER], pl) == -1) return E_NOT_MEMBER;
-  if(!msg || !stringp(msg) || !sizeof(msg)) return E_EMPTY_MESSAGE;
-  map_objects(channels[ch][I_MEMBER],
-              "ChannelMessage", ({ channels[ch][I_NAME], pl, msg, type }));
-  if(sizeof(channelH[ch]) > MAX_HIST_SIZE)
+  if (!(a = funcall(#'access, &ch, pl, C_SEND, &msg)))
+    return E_ACCESS_DENIED;
+
+  if (a < 2 && member(channels[ch][I_MEMBER], pl) == -1)
+    return E_NOT_MEMBER;
+
+  if (!msg || !stringp(msg) || !sizeof(msg))
+    return E_EMPTY_MESSAGE;
+
+  map_objects(channels[ch][I_MEMBER], "ChannelMessage",
+                ({ channels[ch][I_NAME], pl, msg, type }));
+
+  if (sizeof(channelH[ch]) > MAX_HIST_SIZE)
     channelH[ch] = channelH[ch][1..];
-  channelH[ch] += ({ ({ channels[ch][I_NAME],
-                        (stringp(pl)
-                         ? pl
-                         : (pl->QueryProp(P_INVIS)
-                            ? "/("+capitalize(getuid(pl))+")$" : "")
-                         + (pl->Name(WER, 2) || "<Unbekannt>")),
-                         msg+" <"+strftime("%a, %H:%M:%S")+">\n",
-                         type }) });
-  return(0);
+
+  channelH[ch] +=
+    ({ ({ channels[ch][I_NAME],
+          (stringp(pl)
+              ? pl
+              : (pl->QueryProp(P_INVIS)
+                    ? "/(" + capitalize(getuid(pl)) + ")$"
+                    : "")
+                  + (pl->Name(WER, 2) || "<Unbekannt>")),
+          msg + " <" + strftime("%a, %H:%M:%S") + ">\n",
+          type }) });
+      return (0);
+    }
+
+private void clean(string n, mixed a)
+{
+  a[0] -= ({ 0 });
 }
 
 // list() - list all channels, that are at least receivable by 'pl'
 //          returns a mapping,
 // SEE: access, channels
-private void clean(string n, mixed a) { a[0] -= ({ 0 }); }
 mixed list(object pl)
 {
-  mapping chs;
-  
-  chs = filter_indices(channels, #'access/*'*/, pl, C_LIST);
-  walk_mapping(chs, #'clean/*'*/);
-  if(!sizeof(chs)) return E_ACCESS_DENIED;
+  mapping chs = filter_indices(channels, #'access, pl, C_LIST);
+  walk_mapping(chs, #'clean);
+
+  if (!sizeof(chs))
+    return E_ACCESS_DENIED;
   return deep_copy(chs);
 }
 
@@ -570,22 +719,34 @@
 mixed find(string ch, object pl)
 {
   mixed chs, s;
-  if(stringp(ch)) ch = lower_case(ch);
-  if( !sizeof(regexp(({ch}),"^[<>a-z0-9#-]*$")) ) return 0; // RUM
-  if(!sizeof(chs = regexp(m_indices(channels), "^"+ch+"$")))
-    chs = regexp(m_indices(channels), "^"+ch);
-  if((s = sizeof(chs)) > 1)
-    if(sizeof(chs = filter(chs, #'access/*'*/, pl, C_FIND)) == 1)
+
+  if (stringp(ch))
+    ch = lower_case(ch);
+
+  if (!sizeof(regexp(({ch}), "^[<>a-z0-9#-]*$")))
+    return 0; // RUM
+
+  if (!sizeof(chs = regexp(m_indices(channels), "^" + ch + "$")))
+    chs = regexp(m_indices(channels), "^" + ch);
+
+  if ((s = sizeof(chs)) > 1)
+  {
+    if (sizeof(chs = filter(chs, #'access, pl, C_FIND)) == 1)
       return channels[chs[0]][I_NAME];
-    else return chs;
-  return ((s && funcall(#'access,chs[0], pl, C_FIND)) ? channels[chs[0]][I_NAME] : 0);
+    else
+      return chs;
+  }
+
+  return ((s && funcall(#'access,chs[0], pl, C_FIND))
+            ? channels[chs[0]][I_NAME]
+            : 0);
 }
 
 // history() - get the history of a channel
 // SEE: access
 mixed history(string ch, object pl)
 {
-  if(!funcall(#'access,&ch, pl, C_JOIN))
+  if (!funcall(#'access, &ch, pl, C_JOIN))
     return E_ACCESS_DENIED;
   return deep_copy(channelH[ch]);
 }
@@ -596,53 +757,60 @@
 {
   mixed members;
 
-  if(previous_object() != this_object())
-    if(!stringp(ch) ||
-       pl != this_player() || this_player() != this_interactive() ||
-       this_interactive() != previous_object() ||
-       !IS_ARCH(this_interactive()))
+  if (previous_object() != this_object())
+  {
+    if (!stringp(ch) ||
+        pl != this_player() || this_player() != this_interactive() ||
+        this_interactive() != previous_object() ||
+        !IS_ARCH(this_interactive()))
       return E_ACCESS_DENIED;
+  }
 
-  if(channels[lower_case(ch)]) {
+  if (channels[lower_case(ch)])
+  {
     channels[lower_case(ch)][I_MEMBER] =
-        filter_objects(channels[lower_case(ch)][I_MEMBER],
-                       "QueryProp", P_CHANNELS);
+      filter_objects(channels[lower_case(ch)][I_MEMBER],
+      "QueryProp", P_CHANNELS);
     map(channels[lower_case(ch)][I_MEMBER],
-          function mixed (object listener) {
-            string* chans = listener->QueryProp(P_CHANNELS);
-            chans -= ({lower_case(ch)});
-            ({string*})listener->SetProp(P_CHANNELS, chans);
-          });
+    function mixed(object listener)
+      {
+        string* chans = listener->QueryProp(P_CHANNELS);
+        chans -= ({lower_case(ch)});
+        ({string*})listener->SetProp(P_CHANNELS, chans);
+      });
     channels = m_copy_delete(channels, lower_case(ch));
 
     // Wird ein Channel entfernt, wird auch seine History geloescht
-    if( pointerp(channelH[lower_case(ch)] ))
-     channelH = m_copy_delete(channelH, lower_case(ch));
+    if (pointerp(channelH[lower_case(ch)]))
+      channelH = m_copy_delete(channelH, lower_case(ch));
 
     stats["dispose"]++;
   }
-  if(!channelC[lower_case(ch)])
+
+  if (!channelC[lower_case(ch)])
     return E_ACCESS_DENIED;
+
   channelC = m_copy_delete(channelC, lower_case(ch));
-  save_me_soon=1;
-  return(0);
+  save_me_soon = 1;
+  return (0);
 }
 
-// Wird aus der Shell aufgerufen 
+// Wird aus der Shell aufgerufen
 mixed clear_history(string ch)
 {
-  mixed members;
   // Sicherheitsabfragen
-  if(previous_object() != this_object())
-    if(!stringp(ch) ||
-       this_player() != this_interactive() ||
-       this_interactive() != previous_object() ||
-       !IS_ARCH(this_interactive()))
+  if (previous_object() != this_object())
+  {
+    if (!stringp(ch) ||
+        this_player() != this_interactive() ||
+        this_interactive() != previous_object() ||
+        !IS_ARCH(this_interactive()))
       return E_ACCESS_DENIED;
+  }
 
   // History des Channels loeschen
-  if( pointerp(channelH[lower_case(ch)] ))
-    channelH[lower_case(ch)]=({});
+  if (pointerp(channelH[lower_case(ch)]))
+    channelH[lower_case(ch)] = ({});
 
   return 0;
 }