channeld.c-Dateireferenz

#include <sys_debug.h>
#include <lpctypes.h>
#include <wizlevels.h>
#include <properties.h>
#include <config.h>
#include "channel.h"
Include-Abhängigkeitsdiagramm für channeld.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen

#define NEED_PROTOTYPES
#define CMNAME   "<MasteR>"
#define CHANNEL_SAVE   "/p/daemon/save/channeld"
#define MEMORY   "/secure/memory"
#define RECV   0
#define SEND   1
#define FLAG   2
#define F_WIZARD   1
#define F_NOGUEST   2
#define TIMEOUT   (time() - 60)
#define CMDS   ({C_FIND, C_LIST, C_JOIN, C_LEAVE, C_SEND, C_NEW})
#define IGNORE   "^/xx"

Funktionen

int check (string ch, object pl, string cmd)
private int CountUser (mapping l)
static private void banned (string n, mixed cmds, string res)
void ChannelMessage (mixed msg)
private void setup (mixed c)
void initialize ()
void create ()
private int cache_to (string key, mapping m, int t)
varargs void reset (int nonstd)
string name ()
string Name ()
varargs private int access (mixed ch, mixed pl, string cmd, string txt)
varargs int new (string ch, object pl, mixed info)
int join (string ch, object pl)
int leave (string ch, object pl)
varargs int send (string ch, object pl, string msg, int type)
private void clean (string n, mixed a)
mixed list (object pl)
mixed find (string ch, object pl)
mixed history (string ch, object pl)
mixed remove (string ch, object pl)
mixed clear_history (string ch)

Variablen

static private mapping lowerch
static private mapping channels
static private mapping channelH
static private mapping stats
private mapping channelC
private mapping channelB
static private mapping admin = m_allocate(0, 3)
private mapping Tcmd = ([])

Makro-Dokumentation

#define CHANNEL_SAVE   "/p/daemon/save/channeld"

Definiert in Zeile 23 der Datei channeld.c.

Wird benutzt von ChannelMessage(), create(), new() und remove().

#define CMDS   ({C_FIND, C_LIST, C_JOIN, C_LEAVE, C_SEND, C_NEW})

Wird benutzt von ChannelMessage().

#define CMNAME   "<MasteR>"

Definiert in Zeile 22 der Datei channeld.c.

Wird benutzt von ChannelMessage(), create() und new().

#define F_NOGUEST   2

Definiert in Zeile 44 der Datei channeld.c.

Wird benutzt von check().

#define F_WIZARD   1

Definiert in Zeile 43 der Datei channeld.c.

Wird benutzt von check().

#define FLAG   2

Definiert in Zeile 41 der Datei channeld.c.

Wird benutzt von check(), eval_command(), inputPrompt(), More(), prompt() und setup().

#define IGNORE   "^/xx"

Definiert in Zeile 385 der Datei channeld.c.

Wird benutzt von new().

#define MEMORY   "/secure/memory"

Definiert in Zeile 25 der Datei channeld.c.

Wird benutzt von create().

#define NEED_PROTOTYPES

Definiert in Zeile 19 der Datei channeld.c.

#define RECV   0

Definiert in Zeile 39 der Datei channeld.c.

Wird benutzt von check() und setup().

#define SEND   1

Definiert in Zeile 40 der Datei channeld.c.

Wird benutzt von check() und setup().

#define TIMEOUT   (time() - 60)

Definiert in Zeile 96 der Datei channeld.c.

Wird benutzt von ChannelMessage() und Request().

Dokumentation der Funktionen

varargs private int access ( mixed  ch,
mixed  pl,
string  cmd,
string  txt 
)

Definiert in Zeile 333 der Datei channeld.c.

Benutzt channelB, channels, dtime(), err, I_ACCESS, I_MASTER, I_NAME, log_file, m_delete() und ROOTID.

00334 {
00335   mixed co, m;
00336 
00337   if(!stringp(ch) || !strlen(ch = lower_case(ch)) || !channels[ch])
00338     return 0;
00339   if(!channels[ch][I_ACCESS]||!previous_object(1)||!extern_call()||
00340      previous_object(1)==this_object()||
00341      (stringp(channels[ch][I_MASTER])&&
00342       previous_object(1)==find_object(channels[ch][I_MASTER]))||
00343      getuid(previous_object(1)) == ROOTID)
00344     return 2;
00345   if(!objectp(pl) || 
00346      ((previous_object(1)!=pl) &&(previous_object(1)!=this_object()))) 
00347      return 0;
00348    if(pointerp(channelB[getuid(pl)]) &&
00349      member(channelB[getuid(pl)], cmd) != -1)
00350     return 0;
00351    if(stringp(channels[ch][I_MASTER]) &&
00352      (!(m = find_object(channels[ch][I_MASTER])) ||
00353       (!to_object(channels[ch][I_ACCESS]) ||
00354        get_type_info(channels[ch][I_ACCESS])[1])))
00355   {
00356     string err;
00357     if(!objectp(m)) err = catch(load_object(channels[ch][I_MASTER]);publish);
00358     if(!err &&
00359        ((!to_object(channels[ch][I_ACCESS]) ||
00360          get_type_info(channels[ch][I_ACCESS])[1]) &&
00361         !closurep(channels[ch][I_ACCESS] =
00362                   symbol_function("check",
00363                                   find_object(channels[ch][I_MASTER])))))
00364     {
00365       log_file("CHANNEL", sprintf("[%s] %O -> %O\n",
00366                                   dtime(time()), channels[ch][I_MASTER],
00367                                   err));
00368       channels = m_delete(channels, ch);
00369       return 0;
00370     }
00371     this_object()->join(ch, find_object(channels[ch][I_MASTER]));
00372   }
00373   if(closurep(channels[ch][I_ACCESS]))
00374       return funcall(channels[ch][I_ACCESS],
00375                      channels[ch][I_NAME], pl, cmd, &txt);
00376 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

static private void banned ( string  n,
mixed  cmds,
string  res 
) [static]

Definiert in Zeile 90 der Datei channeld.c.

00091 {
00092   res += sprintf("%s [%s], ", capitalize(n), implode(cmds, ","));
00093 }

private int cache_to ( string  key,
mapping  m,
int  t 
)

Definiert in Zeile 313 der Datei channeld.c.

00314 {
00315   if(!pointerp(m[key]) || m[key][2] + 43200 > t) return 1;
00316   return(0);
00317 }

void ChannelMessage ( mixed  msg  ) 

Definiert in Zeile 98 der Datei channeld.c.

Benutzt call_out(), CHANNEL_SAVE, channelB, channels, CMDS, CMNAME, CountUser(), dtime(), IS_ARCH, IS_DEPUTY, last_reboot_time(), m_delete(), pl, save_object(), stats, TIMEOUT und uptime().

00099 {
00100   string ret, mesg;
00101   mixed lag;
00102   int max, rekord;
00103   string tmp;
00104   if(msg[1] == this_object() || !stringp(msg[2]) ||
00105      msg[0] != CMNAME || previous_object() != this_object()) return;
00106 
00107 
00108   mesg = lower_case(msg[2]);
00109 
00110   if(!strstr("hilfe", mesg) && strlen(mesg) <= 5)
00111     ret = "Folgende Kommandos gibt es: hilfe, lag, up[time], statistik, bann";
00112   else
00113   if(!strstr("lag", mesg) && strlen(mesg) <= 3)
00114   {
00115     if(Tcmd["lag"] > TIMEOUT) return;
00116     Tcmd["lag"] = time();
00117     lag = "/p/daemon/lag-o-daemon"->read_lag_data();
00118     ret = sprintf("Lag: %.1f%%/60, %.1f%%/15, %.1f%%/1",
00119                   lag[0], lag[1], lag[2]);
00120     call_out(#'send/*'*/, 2, CMNAME, this_object(), ret);
00121     ret = query_load_average();
00122   } else
00123   if(!strstr("uptime", mesg) && strlen(mesg) <= 6)
00124   {
00125     if(Tcmd["uptime"] > TIMEOUT) return;
00126     Tcmd["uptime"] = time();
00127     if(file_size("/etc/maxusers") <= 0) {
00128       ret = "Diese Information liegt nicht vor.";
00129     } else {
00130       sscanf(read_file("/etc/maxusers"), "%d %s", max, tmp);
00131       sscanf(read_file("/etc/maxusers.ever"), "%d %s", rekord, tmp);
00132       ret = sprintf("Das MUD laeuft jetzt %s. Es sind momentan %d Spieler "
00133                   "eingeloggt; das Maximum lag heute bei %d und der Rekord "
00134                   "bisher ist %d.", uptime(), sizeof(users()), max, rekord);
00135     }
00136   } else
00137   if(!strstr("statistik", mesg) && strlen(mesg) <= 9)
00138   {
00139     if(Tcmd["statistik"] > TIMEOUT) return;
00140     Tcmd["statistik"] = time();
00141     ret = sprintf(
00142     "Im Moment sind insgesamt %d Ebenen mit %d Teilnehmern aktiv.\n"
00143     "Der %s wurde das letzte mal am %s von %s neu gestartet.\n"
00144     "Seitdem wurden %d Ebenen neu erzeugt und %d zerstoert.\n",
00145     sizeof(channels), CountUser(channels), CMNAME,
00146     dtime(stats["time"]), stats["boot"], stats["new"], stats["dispose"]);
00147   } else
00148   if(!strstr(mesg, "bann"))
00149   {
00150     string pl, cmd;
00151     if(mesg == "bann")
00152       if(sizeof(channelB)) {
00153                 ret = "";
00154                 walk_mapping(channelB, #'banned/*'*/, &ret);
00155                 ret = "Fuer folgende Spieler besteht ein Bann: " + ret;
00156       } else ret = "Zur Zeit ist kein Bann aktiv.";
00157     else
00158       if(sscanf(mesg, "bann %s %s", pl, cmd) == 2 &&
00159                  IS_DEPUTY(msg[1])) {
00160 #     define CMDS ({C_FIND, C_LIST, C_JOIN, C_LEAVE, C_SEND, C_NEW})
00161                 pl = lower_case(pl); cmd = lower_case(cmd);
00162                 if(member(CMDS, cmd) != -1) {
00163                   if(!pointerp(channelB[pl])) channelB[pl] = ({});
00164                   if(member(channelB[pl], cmd) != -1)
00165                     channelB[pl] -= ({ cmd });
00166                   else
00167                     channelB[pl] += ({ cmd });
00168                   ret = "Fuer '"+capitalize(pl)+"' besteht "
00169                     + (sizeof(channelB[pl]) ?
00170                        "folgender Bann: "+implode(channelB[pl], ", ") :
00171                        "kein Bann mehr.");
00172                   if(!sizeof(channelB[pl])) channelB = m_delete(channelB, pl);
00173                   save_object(CHANNEL_SAVE);
00174                 }
00175                 else ret = "Das Kommando '"+cmd+"' ist unbekannt. Erlaubte Kommandos: "
00176                        + implode(CMDS, ", ");
00177       }
00178       else
00179                 if(!IS_ARCH(msg[1])) return;
00180                 else ret = "Syntax: bann <name> <kommando>";
00181   } else if(mesg == "lust") {
00182     mixed t, up;
00183     if(Tcmd["lag"] > TIMEOUT ||
00184        Tcmd["statistik"] > TIMEOUT ||
00185        Tcmd["uptime"] > TIMEOUT) return;
00186     Tcmd["lag"] = time();
00187     Tcmd["statistik"] = time();
00188     Tcmd["uptime"] = time();
00189     lag = "/p/daemon/lag-o-daemon"->read_lag_data();
00190 
00191     sscanf(read_file("/etc/maxusers"), "%d %s", max, tmp);
00192     sscanf(read_file("/etc/maxusers.ever"), "%d %s", rekord, tmp);
00193 
00194     t=time()-last_reboot_time();
00195     up="";
00196     if(t >= 86400)
00197       up += sprintf("%dT", t/86400);
00198     if(t >= 3600)
00199       up += sprintf("%dh", (t=t%86400)/3600);
00200     if(t > 60)
00201       up += sprintf("%dm", (t=t%3600)/60);
00202     up += sprintf("%ds", t%60);
00203 
00204     ret = sprintf("%.1f%%/15 %.1f%%/1 %s %d:%d:%d E:%d T:%d",
00205                                   lag[1], lag[2], up, sizeof(users()), max, rekord, 
00206                                   sizeof(channels), CountUser(channels));
00207   } else return;
00208 
00209   call_out(#'send/*'*/, 2, CMNAME, this_object(), ret);
00210 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

int check ( string  ch,
object  pl,
string  cmd 
)

Definiert in Zeile 48 der Datei channeld.c.

Benutzt admin, C_FIND, C_JOIN, C_LEAVE, C_LIST, C_SEND, F_NOGUEST, F_WIZARD, FLAG, level, P_LEVEL, query_wiz_level(), RECV, SEER_LVL und SEND.

00049 {
00050   int level;
00051   
00052   if((admin[ch, FLAG] & F_NOGUEST) && pl->QueryGuest()) return 0;
00053 
00054   if((admin[ch, FLAG] & F_WIZARD) && query_wiz_level(pl) < SEER_LVL) return 0;
00055   level = (admin[ch, FLAG] & F_WIZARD
00056            ? query_wiz_level(pl)
00057            : pl->QueryProp(P_LEVEL));
00058 
00059   switch(cmd)
00060   {
00061   case C_FIND:
00062   case C_LIST:
00063   case C_JOIN:
00064     if(admin[ch, RECV] == -1) return 0;
00065     if(admin[ch, RECV] <= level) return 1;
00066     break;
00067   case C_SEND:
00068     if(admin[ch, SEND] == -1) return 0;
00069     if(admin[ch, SEND] <= level) return 1;
00070     break;
00071   case C_LEAVE:
00072     return 1;
00073   default: break;
00074   }
00075   return(0);
00076 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

private void clean ( string  n,
mixed  a 
)

Definiert in Zeile 526 der Datei channeld.c.

00526 { a[0] -= ({ 0 }); }

mixed clear_history ( string  ch  ) 

Definiert in Zeile 604 der Datei channeld.c.

Benutzt channelH, E_ACCESS_DENIED und IS_ARCH.

00605 {
00606   mixed members;
00607   // Sicherheitsabfragen
00608   if(previous_object() != this_object())
00609     if(!stringp(ch) ||
00610        this_player() != this_interactive() ||
00611        this_interactive() != previous_object() ||
00612        !IS_ARCH(this_interactive()))
00613       return E_ACCESS_DENIED;
00614 
00615   // History des Channels loeschen
00616   if( pointerp(channelH[lower_case(ch)] ))
00617     channelH[lower_case(ch)]=({});
00618 
00619   return 0;
00620 }

private int CountUser ( mapping  l  ) 

Definiert in Zeile 78 der Datei channeld.c.

Wird benutzt von ChannelMessage() und create().

00079 {
00080   mapping n;
00081   n = ([]);
00082   walk_mapping(l, lambda(({'i/*'*/, 'a/*'*/, 'n/*'*/}),
00083                          ({#'+=/*'*/, 'n/*'*/,
00084                               ({#'mkmapping/*'*/,
00085                                    ({#'[/*'*/, 'a/*'*/, 0})})})),
00086                &n);
00087   return sizeof(n);
00088 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void create (  ) 

Definiert in Zeile 269 der Datei channeld.c.

Benutzt CHANNEL_SAVE, channelB, channelC, channelH, channels, CMNAME, CountUser(), initialize(), MEMORY, restore_object() und stats.

00270 {
00271   seteuid(getuid());
00272   restore_object(CHANNEL_SAVE);
00273   if(!channelC) channelC = ([]);
00274   if(!channelB) channelB = ([]);
00275   channels = ([]);
00276 
00277   /* Die Channel-History wird nicht nur lokal sondern auch noch im Memory 
00278      gespeichert, dadurch bleibt sie auch ueber ein Reload erhalten. 
00279      Der folgende Code versucht, den Zeiger aus dem Memory zu holen. Falls
00280      das nicht moeglich ist, wird ein neuer erzeugt und gegebenenfalls im
00281      Memory abgelegt. */
00282 
00283   // Hab ich die noetigen Rechte im Memory?
00284   if (call_other(MEMORY,"HaveRights")) {
00285     // Objektpointer laden
00286     channelH = (mixed) call_other(MEMORY,"Load","History");
00287 
00288     // Wenns nich geklappt hat, hat der Memory noch keinen Zeiger, dann
00289     if (!mappingp(channelH)){
00290       // Zeiger erzeugen
00291       channelH = ([]);
00292       // und in den Memory schreiben
00293       call_other(MEMORY,"Save","History",channelH);
00294     }
00295   } else {
00296     // Keine Rechte im Memory, dann wird mit einem lokalen Zeiger gearbeitet.
00297     channelH = ([]);
00298   }
00299 
00300   stats = (["time": time(),
00301             "boot": capitalize(getuid(previous_object())||"<Unbekannt>")]);
00302   new(CMNAME, this_object(), "Zentrale Informationen zu den Ebenen");
00303   initialize();
00304   map_objects(efun::users(), "RegisterChannels");
00305   this_object()->send(CMNAME, this_object(),
00306                       sprintf("%d Ebenen mit %d Teilnehmern initialisiert.",
00307                               sizeof(channels),
00308                               CountUser(channels)));
00309 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

mixed find ( string  ch,
object  pl 
)

Definiert in Zeile 540 der Datei channeld.c.

Benutzt C_FIND, channels und I_NAME.

00541 {
00542   mixed chs, s;
00543   if(stringp(ch)) ch = lower_case(ch);
00544   if( !sizeof(regexp(({ch}),"^[<>a-z0-9#-]*$")) ) return 0; // RUM
00545   if(!sizeof(chs = regexp(m_indices(channels), "^"+ch+"$")))
00546     chs = regexp(m_indices(channels), "^"+ch);
00547   if((s = sizeof(chs)) > 1)
00548     if(sizeof(chs = filter(chs, #'access/*'*/, pl, C_FIND)) == 1)
00549       return channels[chs[0]][I_NAME];
00550     else return chs;
00551   return ((s && funcall(#'access,chs[0], pl, C_FIND)) ? channels[chs[0]][I_NAME] : 0);
00552 }

mixed history ( string  ch,
object  pl 
)

Definiert in Zeile 556 der Datei channeld.c.

00557 {
00558   if(!funcall(#'access,&ch, pl, C_JOIN))
00559     return E_ACCESS_DENIED;
00560   return channelH[ch] + ({});
00561 }

void initialize (  ) 

Definiert in Zeile 257 der Datei channeld.c.

Benutzt old_explode().

Wird benutzt von create() und lisp().

00258 {
00259   mixed tmp;
00260   tmp = read_file(object_name(this_object())+".init");
00261   tmp = regexp(old_explode(tmp, "\n"), "^[^#]");
00262   tmp = map(tmp, #'regexplode/*'*/, "[^:][^:]*$|[ \\t]*:[ \\t]*");
00263   tmp = map(tmp, #'regexp/*'*/, "^[^: \\t]");
00264   map(tmp, #'setup/*'*/);
00265 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int join ( string  ch,
object  pl 
)

Definiert in Zeile 442 der Datei channeld.c.

00443 {
00444   if(!funcall(#'access,&ch, pl, C_JOIN)) return E_ACCESS_DENIED;
00445   if(member(channels[ch][I_MEMBER], pl) != -1) return E_ALREADY_JOINED;
00446   channels[ch][I_MEMBER] += ({ pl });
00447   return(0);
00448 }

int leave ( string  ch,
object  pl 
)

Definiert in Zeile 456 der Datei channeld.c.

00457 {
00458   int pos;
00459   if(!funcall(#'access,&ch, pl, C_LEAVE)) return E_ACCESS_DENIED;
00460   channels[ch][I_MEMBER] -= ({0}); // kaputte Objekte erstmal raus
00461   if((pos = member(channels[ch][I_MEMBER], pl)) == -1) return E_NOT_MEMBER;
00462   if(pl == channels[ch][I_MASTER] && sizeof(channels[ch][I_MEMBER]) > 1)
00463   {
00464     channels[ch][I_MASTER] = channels[ch][I_MEMBER][1];
00465     if(!pl->QueryProp(P_INVIS))
00466       this_object()->send(ch, pl, "uebergibt die Ebene an "
00467                                                   +channels[ch][I_MASTER]->name()+".", MSG_EMOTE);
00468   }
00469   channels[ch][I_MEMBER][pos..pos] = ({ });
00470 
00471 
00472   if(!sizeof(channels[ch][I_MEMBER]) &&
00473      !stringp(channels[ch][I_MASTER]))
00474   {
00475     // delete the channel that has no members
00476     if(!pl->QueryProp(P_INVIS))
00477       this_object()->send(CMNAME, pl,
00478                                                   "verlaesst als "
00479                                                   +(pl->QueryProp(P_GENDER) == 1 ? "Letzter" :
00480                                                     "Letzte")
00481                                                   +" die Ebene '"
00482                                                   +channels[ch][I_NAME]
00483                                                   +"', worauf diese sich in einem Blitz oktarinen "
00484                                                   +"Lichts aufloest.", MSG_EMOTE);
00485     channelC[lower_case(ch)] = ({ channels[ch][I_NAME],
00486                                   channels[ch][I_INFO], time() });
00487     efun::m_delete(channels, lower_case(ch));
00488 
00489     // Wird ein Channel entfernt, wird auch seine History geloescht
00490     channelH = m_delete(channelH, lower_case(ch));
00491 
00492     stats["dispose"]++;
00493     save_object(CHANNEL_SAVE);
00494   }
00495   return(0);
00496 }

mixed list ( object  pl  ) 

Definiert in Zeile 527 der Datei channeld.c.

00528 {
00529   mapping chs;
00530   
00531   chs = filter_indices(channels, #'access/*'*/, pl, C_LIST);
00532   walk_mapping(chs, #'clean/*'*/);
00533   if(!sizeof(chs)) return E_ACCESS_DENIED;
00534   return deep_copy(chs);
00535 }

string Name (  ) 

Definiert in Zeile 326 der Datei channeld.c.

Wird benutzt von _check_unwear_restrictions(), _check_wear_restrictions(), _clone(), _frieden(), add_player(), AddFP(), ask_sell(), Attack(), binde_seil(), buy(), CheckDailyPlaytime(), cm_smoke(), cm_stopf(), cmd_shoot(), create(), direct_move(), doUnwearMessage(), DoWear(), doWearMessage(), doWieldMessage(), drop(), evaluate(), FindRangedTarget(), give(), give_money(), GoblinCmdWaaagh(), init(), loese_seil(), make_to_money(), move(), pick(), put(), put_or_get(), really_buy(), RemoveFP(), sell(), show(), StopHuntText(), tie(), wurzel_an() und wurzel_aus().

00326 { return "<MasteR>"; }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

string name (  ) 

Definiert in Zeile 325 der Datei channeld.c.

00325 { return "<MasteR>"; }

varargs int new ( string  ch,
object  pl,
mixed  info 
)

Definiert in Zeile 387 der Datei channeld.c.

Benutzt C_NEW, CHANNEL_SAVE, channelB, channelC, channelH, channels, CMNAME, dtime(), E_ACCESS_DENIED, IGNORE, info, log_file, MSG_EMOTE, save_object() und stats.

00388 {
00389   mixed pls;
00390 
00391   if(!objectp(pl) || !stringp(ch) || !strlen(ch) || channels[lower_case(ch)] ||
00392      (pl == this_object() && extern_call()) ||
00393      sizeof(channels) >= MAX_CHANNELS ||
00394      sizeof(regexp(({ object_name(pl) }), IGNORE)) ||
00395      (pointerp(channelB[getuid(pl)]) &&
00396       member(channelB[getuid(pl)], C_NEW) != -1))
00397     return E_ACCESS_DENIED;
00398 
00399   if(!info) {
00400     if(channelC[lower_case(ch)]) {
00401       ch = channelC[lower_case(ch)][0];
00402       info = channelC[lower_case(ch)][1];
00403     }
00404     else return E_ACCESS_DENIED;
00405   }
00406   else channelC[lower_case(ch)] = ({ ch, info, time() });
00407 
00408   pls = ({ pl });
00409 
00410   channels[lower_case(ch)] = ({ pls,
00411                                 symbol_function("check", pl) ||
00412                                 #'check/*'*/, info,
00413                                 (!living(pl) &&
00414                                  !clonep(pl) &&
00415                                  pl != this_object()
00416                                  ? object_name(pl)
00417                                  : pl),
00418                                  ch,
00419                              });
00420 
00421   // ChannelH fuer einen Kanal nur dann initialisieren, wenn es sie noch nich gibt.
00422   if ( !pointerp(channelH[lower_case(ch)]) )
00423          channelH[lower_case(ch)] = ({});
00424 
00425   if(pl != this_object())
00426     log_file("CHANNEL.new", sprintf("[%s] %O: %O %O\n",
00427                                     dtime(time()), ch, pl, info));
00428   if(!pl->QueryProp(P_INVIS))
00429     this_object()->send(CMNAME, pl,
00430                                                 "laesst die Ebene '"+ch+"' entstehen.", MSG_EMOTE);
00431   stats["new"]++;
00432 
00433   save_object(CHANNEL_SAVE);
00434   return(0);
00435 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

mixed remove ( string  ch,
object  pl 
)

Definiert in Zeile 565 der Datei channeld.c.

Benutzt CHANNEL_SAVE, channelC, channelH, channels, E_ACCESS_DENIED, IS_ARCH, m_delete(), P_CHANNELS, save_object() und stats.

00566 {
00567   mixed members;
00568 
00569   if(previous_object() != this_object())
00570     if(!stringp(ch) ||
00571        pl != this_player() || this_player() != this_interactive() ||
00572        this_interactive() != previous_object() ||
00573        !IS_ARCH(this_interactive()))
00574       return E_ACCESS_DENIED;
00575 
00576   if(channels[lower_case(ch)]) {
00577     channels[lower_case(ch)][I_MEMBER] =
00578         filter_objects(channels[lower_case(ch)][I_MEMBER],
00579                        "QueryProp", P_CHANNELS);
00580     map(channels[lower_case(ch)][I_MEMBER],
00581         lambda(({'u/*'*/}), ({#'call_other/*'*/, 'u, /*'*/
00582                                    "SetProp", P_CHANNELS,
00583                                    ({#'-/*'*/,
00584                                           ({#'call_other/*'*/, 'u, /*'*/
00585                                                  "QueryProp", P_CHANNELS}),
00586                                           '({ lower_case(ch) })/*'*/,})
00587                                    })));
00588     channels = m_delete(channels, lower_case(ch));
00589 
00590     // Wird ein Channel entfernt, wird auch seine History geloescht
00591     if( pointerp(channelH[lower_case(ch)] ))
00592      channelH = m_delete(channelH, lower_case(ch));
00593 
00594     stats["dispose"]++;
00595   }
00596   if(!channelC[lower_case(ch)])
00597     return E_ACCESS_DENIED;
00598   channelC = m_delete(channelC, lower_case(ch));
00599   save_object(CHANNEL_SAVE);
00600   return(0);
00601 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

varargs void reset ( int  nonstd  ) 

Definiert in Zeile 319 der Datei channeld.c.

Benutzt channelC.

00320 {
00321   channelC = filter_indices(channelC, #'cache_to/*'*/, channelC, time());
00322 }

varargs int send ( string  ch,
object  pl,
string  msg,
int  type 
)

Definiert in Zeile 502 der Datei channeld.c.

Wird benutzt von reply_time_out().

00503 {
00504   int a;
00505   if(!(a = funcall(#'access,&ch, pl, C_SEND, &msg))) return E_ACCESS_DENIED;
00506   if(a < 2 && member(channels[ch][I_MEMBER], pl) == -1) return E_NOT_MEMBER;
00507   if(!msg || !stringp(msg) || !strlen(msg)) return E_EMPTY_MESSAGE;
00508   map_objects(channels[ch][I_MEMBER],
00509               "ChannelMessage", ({ channels[ch][I_NAME], pl, msg, type }));
00510   if(sizeof(channelH[ch]) > MAX_HIST_SIZE)
00511     channelH[ch] = channelH[ch][1..];
00512   channelH[ch] += ({ ({ channels[ch][I_NAME],
00513                         (stringp(pl)
00514                          ? pl
00515                          : (pl->QueryProp(P_INVIS)
00516                             ? "/("+capitalize(getuid(pl))+")$" : "")
00517                          + (pl->Name(WER, 2) || "<Unbekannt>")),
00518                          msg+" <"+dtime(time())[0..2]+dtime(time())[<10..]+">",
00519                          type }) });
00520   return(0);
00521 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

private void setup ( mixed  c  ) 

Definiert in Zeile 220 der Datei channeld.c.

Benutzt admin, cl, dtime(), E_ACCESS_DENIED, FLAG, log_file, RECV und SEND.

00221 {
00222   closure cl;
00223   object m;
00224   string d;
00225   d = "- Keine Beschreibung -";
00226   m = this_object();
00227   if(sizeof(c) && strlen(c[0]) > 1 && c[0][0] == '\\')
00228     c[0] = c[0][1..];
00229 
00230   switch(sizeof(c))
00231   {
00232   case 6:
00233     if(!stringp(c[5]) || !strlen(c[5]) 
00234                 || (catch(m=load_object(c[5]);publish) || !objectp(m) ))
00235       m = this_object();
00236   case 5: d = stringp(c[4]) || closurep(c[4]) ? c[4] : d;
00237   case 4: admin[c[0], FLAG] = to_int(c[3]);
00238   case 3: admin[c[0], SEND] = to_int(c[2]);
00239   case 2: admin[c[0], RECV] = to_int(c[1]);
00240     break;
00241   case 0:
00242   default:
00243     return;
00244   }
00245   switch(new(c[0], m, d))
00246   {
00247   case E_ACCESS_DENIED:
00248     log_file("CHANNEL", sprintf("[%s] %s: %O: error, access denied\n",
00249                            dtime(time()), c[0], m));
00250     break;
00251   default:
00252     break;
00253   }
00254   return;
00255 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Variablen-Dokumentation

private mapping admin = m_allocate(0, 3) [static]

Definiert in Zeile 46 der Datei channeld.c.

Wird benutzt von check() und setup().

private mapping channelB

Definiert in Zeile 35 der Datei channeld.c.

Wird benutzt von access(), ChannelMessage(), create() und new().

private mapping channelC

Definiert in Zeile 34 der Datei channeld.c.

Wird benutzt von create(), new(), remove() und reset().

private mapping channelH [static]

Definiert in Zeile 31 der Datei channeld.c.

Wird benutzt von clear_history(), create(), new() und remove().

private mapping channels [static]

Definiert in Zeile 30 der Datei channeld.c.

Wird benutzt von access(), ChannelMessage(), create(), find(), new() und remove().

private mapping lowerch [static]

Definiert in Zeile 29 der Datei channeld.c.

private mapping stats [static]

Definiert in Zeile 32 der Datei channeld.c.

Wird benutzt von ChannelMessage(), create(), new() und remove().

private mapping Tcmd = ([])

Definiert in Zeile 95 der Datei channeld.c.

Erzeugt am Thu Jun 3 14:40:32 2010 für MorgenGrauen Mudlib von  doxygen 1.6.3