inetd.c-Dateireferenz

#include <udp.h>

Include-Abhängigkeitsdiagramm für inetd.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	ZDEBUG(x)
#define	COMMANDS   ({ "channel", "finger", "tell", "who", "mail", "www", "htmlwho", "locate" })
#define	UDP_MASTER   __MASTER_OBJECT__
#define	SET_EUID   seteuid(getuid())
#define	MAX_PACKET_LEN   1024
#define	USE_OLD_DELIMITER
#define	USE_OLD_DATA_FORMAT
#define	UNKNOWN   0
#define	UP   time()
#define	DOWN   (-time())
#define	NEW_DELIMITER   "\n"
#define	DELIMITER   "|"
#define	OLD_DELIMITER   "|"
#define	HOSTFILE_DEL   ":"
#define	HOSTFILE_DEL2   ","
#define	RETRY   "_RETRY"
#define	DEBUG(msg)
Funktionen
	ctime (time())
void	create ()
status	check_system_field (mapping data, string field)
mapping	add_system_field (mapping data, string field)
private mapping	read_host_list (string file)
void	set_host_list ()
int	dump_hosts_list ()
void	startup (string *muds)
void	remove_incoming (string id)
mixed	decode (string arg)
mixed	decode_packet (string packet, string delimiter)
string	valid_request (mapping data)
void	_receive_udp (string sender, string packet)
int	do_match (string mudname, string match_str)
string *	expand_mud_name (string name)
string	encode (mixed arg)
string	encode_packet (mapping data)
string *	explode_packet (string packet, int len)
varargs string	_send_udp (string mudname, mapping data, int expect_reply)
void	reply_time_out (string id)
void	remove_received_id (string id)
varargs mixed	query (string what, mixed extra1, mixed extra2)

---

Makro-Dokumentation

#define COMMANDS   ({ "channel", "finger", "tell", "who", "mail", "www", "htmlwho", "locate" })

Definiert in Zeile 30 der Datei inetd.c.

Wird benutzt von query() und read_host_list().

#define DEBUG

(

msg

)

#define DELIMITER   "|"

Wird benutzt von _send_udp() und encode_packet().

#define DOWN   (-time())

Wird benutzt von reply_time_out().

#define HOSTFILE_DEL   ":"

Wird benutzt von read_host_list().

#define HOSTFILE_DEL2   ","

Wird benutzt von read_host_list().

#define MAX_PACKET_LEN   1024

Definiert in Zeile 55 der Datei inetd.c.

Wird benutzt von _send_udp().

#define NEW_DELIMITER   "\n"

#define OLD_DELIMITER   "|"

#define RETRY   "_RETRY"

Wird benutzt von reply_time_out().

#define SET_EUID   seteuid(getuid())

Definiert in Zeile 42 der Datei inetd.c.

#define UDP_MASTER   __MASTER_OBJECT__

Definiert in Zeile 38 der Datei inetd.c.

#define UNKNOWN   0

Wird benutzt von read_host_list().

#define UP   time()

#define USE_OLD_DATA_FORMAT

Definiert in Zeile 61 der Datei inetd.c.

#define USE_OLD_DELIMITER

Definiert in Zeile 59 der Datei inetd.c.

#define ZDEBUG

(

x

)

Wert:

if (find_player("zesstra"))\
            tell_object(find_player("zesstra"),"Inetd: "+x+"\n")

Definiert in Zeile 17 der Datei inetd.c.

Wird benutzt von _call_DoDecay(), InternalModifySkillAttribute() und UpdateSACache().

---

Dokumentation der Funktionen

void _receive_udp	(	string	sender,
		string	packet
	)

Definiert in Zeile 434 der Datei inetd.c.

Wird benutzt von _receive_udp().

                                                {
    mapping data;
    string req, err, id;

#ifdef UDP_MASTER
    if (!previous_object() ||
    object_name(previous_object()) != UDP_MASTER) {
        log_file(INETD_LOG_FILE, DATE + ": Illegal call of _receive_udp() by " +
        object_name(previous_object()) + "\n\n");
        return;
    }
#endif

    //ZDEBUG(sprintf("%O -> %.500O\n",sender, packet));
    if (
#ifdef DELIMITER_COMPAT
#ifdef USE_EXTRACT
        (!(data = decode_packet(packet, NEW_DELIMITER))
#else
        (!(data = decode_packet(packet, NEW_DELIMITER))
#endif
        || (data[HOST] = sender) && (err = valid_request(data))) &&
        (!(data = decode_packet(packet, OLD_DELIMITER)) ||
        (data[HOST] = sender) && (err = valid_request(data)))
#else
#ifdef USE_EXTRACT
        !(data = decode_packet(packet, DELIMITER))
#else
        !(data = decode_packet(packet, DELIMITER))
#endif
#endif
    ) {
        if (!data)
#ifdef RECEIVE_UDP_COMPAT
            RECEIVE_UDP_COMPAT(sender, packet);
#else
            log_file(INETD_LOG_FILE, DATE + ": Received invalid packet.\nSender: " +
            sender + "\nPacket:\n" + packet + "\n\n");
#endif
        return;
    }
#ifdef DELIMITER_COMPAT
    if (!mappingp(data))
        return;
    if (err)
#else
          if (!mappingp(data))
                  return;
    data[HOST] = sender;
    if (err = valid_request(data))
#endif
    {
        log_file(INETD_LOG_FILE, err + "Sender: " + sender + "\nPacket:\n" +
        packet + "\n\n");
        return;
    }
    hosts[lower_case(data[NAME])][HOST_STATUS] = UP;
    if ((req = data[REQUEST]) == REPLY) {
            mapping pending;

        /* If we can't find the reply in the pending list then bin it. */
        if (!(pending = pending_data[lower_case(data[NAME]) + ":" + data[ID]]))
            return;
        /* Set data[REQUEST] correctly, but still send to (req = REPLY) */
        data[REQUEST] = pending[REQUEST];
#ifdef INETD_DIAGNOSTICS
        data[PACKET_LOSS] = pending[PACKET_LOSS];
        data[RESPONSE_TIME] = time() - pending[RESPONSE_TIME] + 1;
#endif
#if 0
/* channel replies may not include a recipient, and shouldn't have one set */
        /* Restore the RECIPIENT in replies if none given and it is known. */
        if (!data[RECIPIENT] && pending[SENDER])
            data[RECIPIENT] = pending[SENDER];
#endif
        pending_data =
        m_delete(pending_data, lower_case(data[NAME]) + ":" + data[ID]);
    }
    else if (data[ID]) {
      id = lower_case(data[NAME]) + ":" + data[ID];
      if (member(received_ids, id) == -1)
      {
        received_ids += ({ id });
        call_out("remove_received_id",
              REPLY_TIME_OUT + REPLY_TIME_OUT * (RETRIES + 1), id);
      }
      else
            add_system_field(data, REPEAT);
    }
    if (err = catch(
        call_other(UDP_CMD_DIR + req, "udp_" + req, deep_copy(data));publish))
    {
        _send_udp(data[NAME], ([
            REQUEST: REPLY,
            RECIPIENT: data[SENDER],
            ID: data[ID],
            DATA: capitalize(req)+ " request failed @" + LOCAL_NAME + ".\n"
        ]) );
        log_file(INETD_LOG_FILE, DATE + ": " + data[REQUEST] + " from " +
        data[NAME] + " failed.\n" + err + packet + "\n\n");
    }
}

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

varargs string _send_udp	(	string	mudname,
		mapping	data,
		int	expect_reply
	)

Definiert in Zeile 648 der Datei inetd.c.

Benutzt break_string(), call_out(), DATE, DELIMITER, encode_packet(), expand_mud_name(), explode_packet(), HOST_IP, HOST_NAME, HOST_UDP_PORT, i, INETD_DIAGNOSTICS, INETD_LOG_FILE, LOCAL_NAME, log_file, m_delete(), MAX_PACKET_LEN, PACKET, REPLY, REPLY_TIME_OUT, REQUEST und RESPONSE_TIME.

Wird benutzt von reply_time_out() und startup().

                                                                         {
    mixed host_data;
    string *packet_arr;
    string packet;
    int i;

    mudname = lower_case(mudname);
    if (!(host_data = hosts[mudname])) {
        string *names;

        if (sizeof(names = expand_mud_name(mudname)) == 1)
            host_data = hosts[mudname = names[0]];
        else
#ifdef SEND_UDP_COMPAT
            return (string)SEND_UDP_COMPAT(mudname, data, expect_reply);
#else
        if (!sizeof(names))
            return "Unbekannter Mudname: " + capitalize(mudname) + "\n";
        else
            return break_string("Mudname ("+capitalize(mudname)+
            ") nicht eindeutig, es passen: "+implode(map(names,#'capitalize),", ")+
            ".\n",78);
#endif
    }
    
    if (data[REQUEST] != PING &&
        data[REQUEST] != QUERY &&
        data[REQUEST] != REPLY &&
        member(host_data[HOST_COMMANDS], "*") == -1 &&
        member(host_data[HOST_COMMANDS], data[REQUEST]) == -1)
        return capitalize(data[REQUEST]) + ": Command unavailable @" +
                   host_data[HOST_NAME] + "\n";
    
    data[NAME] = LOCAL_NAME;
    data[UDP_PORT] = LOCAL_UDP_PORT;
    
    if (expect_reply) {
        /* Don't use zero. */
        data[ID] = ++packet_id;
        /* Don't need deep_copy() as we are changing the mapping size. */
        pending_data[mudname + ":" + packet_id] =
#ifdef INETD_DIAGNOSTICS
        data + ([ NAME: host_data[HOST_NAME], RESPONSE_TIME: time() ]);
#else
        data + ([ NAME: host_data[HOST_NAME] ]);
#endif
    }
    if (!(packet = encode_packet(data))) {
        if (expect_reply)
            pending_data = m_delete(pending_data, mudname + ":" + packet_id);
        log_file(INETD_LOG_FILE, DATE + ": Illegal packet sent by " +
        object_name(previous_object()) + "\n\n");
        return "inetd: Illegal packet.\n";
    }
    if (expect_reply)
        call_out("reply_time_out", REPLY_TIME_OUT, mudname + ":" + packet_id);

    if (strlen(packet) <= MAX_PACKET_LEN)
        packet_arr = ({ packet });
    else {
        string header;
        int max;

        /* Be careful with the ID.  data[ID] could have been set up by RETRY */
        header =
            PACKET + ":" + lower_case(LOCAL_NAME) + ":" +
            ((expect_reply || data[REQUEST] != REPLY)&& data[ID] ?
            data[ID] : ++packet_id) + ":";
        
        /* Allow 8 extra chars: 3 digits + "/" + 3 digits + DELIMITER */
        packet_arr = explode_packet(packet,
            MAX_PACKET_LEN - (strlen(header) + 8));

        for(i = max = sizeof(packet_arr); i--; )
            packet_arr[i] =
            header + (i+1) + "/" + max + DELIMITER + packet_arr[i];
    }
    
    for(i = sizeof(packet_arr); i--; ) {
            
      if (!send_udp(
        host_data[HOST_IP], host_data[HOST_UDP_PORT], packet_arr[i]))
            return "inetd: Error in sending packet.\n";
    }
    return 0;
}

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

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

mapping add_system_field	(	mapping	data,
		string	field
	)

Definiert in Zeile 128 der Datei inetd.c.

Benutzt check_system_field() und SYSTEM.

Wird benutzt von reply_time_out().

                                                     {
    if (data[SYSTEM]) {
        if (!check_system_field(data, field))
            data[SYSTEM] += ({ field });
    }
    else
        data[SYSTEM] = ({ field });
    return data;
}

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

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

status check_system_field	(	mapping	data,
		string	field
	)

Definiert in Zeile 124 der Datei inetd.c.

Benutzt SYSTEM.

Wird benutzt von add_system_field().

                                                      {
    return data[SYSTEM] && member(data[SYSTEM], field) != -1;
}

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

void create

(

)

Definiert in Zeile 115 der Datei inetd.c.

Benutzt reset().

              {
#else
void reset(arg) {
    if (arg)
        return;
#endif
    my_create();
}

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

ctime

(

time()

)

Definiert in Zeile 68 der Datei inetd.c.

Wird benutzt von __query_variable(), _query_short(), _set_currentdir(), _set_disable_attack(), add_gluehwein(), AddFP(), alles(), check_illegal(), check_password(), check_too_many_from_same_ip(), check_too_many_logons(), CheckSecond(), DeepTransferMoney(), deliver_mail(), DeliverMail(), efun_ctime(), epilog(), FtpAccess(), gtell(), InterpretTime(), liste(), load_player_ob_2(), load_player_object(), RemoveFP(), reset(), rubriken(), scan_objects(), send_mail(), ShowEPObjects(), shutdown(), SiteBanish(), udp_www(), valid_read(), wear_best_armours(), Xcall() und Xeval().

                             :"
#define HOSTFILE_DEL2        ","
#define RETRY                "_RETRY"

private nosave mapping hosts, pending_data, incoming_packets;
private nosave mapping static_host_list;
private nosave string *received_ids;
private nosave int packet_id;

void set_host_list();
varargs string _send_udp(string mudname, mapping data, int expect_reply);

#define DEBUG(msg)

void my_create() {
#ifndef COMPAT_FLAG
    SET_EUID;
#endif
    packet_id = 0;
    pending_data = ([ ]);
    incoming_packets = ([ ]);
    hosts = ([ ]);
    received_ids = ({ });
    set_host_list();
    if (!this_player())
        call_out("startup", 1, 0);
}

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

mixed decode

(

string

arg

)

Definiert in Zeile 260 der Datei inetd.c.

Wird benutzt von udp_www().

                         {

    if (strlen(arg) && arg[0] == '$')
        return arg[1..];
#ifdef RESTRICTED_CASTS
    if (to_string(to_int(arg)) == arg)
        return to_int(arg);
#else
    if ((string)((int)arg) == arg)
        return (int)arg;
#endif
    return arg;
}

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

mixed decode_packet	(	string	packet,
		string	delimiter
	)

Definiert in Zeile 280 der Datei inetd.c.

                                                     {
    string *data;
    mapping ret;
    string info, tmp;
    mixed class;
    int i, id, n;

    /* If this packet has been split, handle buffering. */
    if (packet[0..strlen(PACKET)] == PACKET + ":") {
        if (sscanf(packet, PACKET + ":%s:%d:%d/%d" + delimiter + "%s",
        class, id, i, n, tmp) != 5)
            return 0;
        class = lower_case(class) + ":" + id;
        if (pointerp(incoming_packets[class])) {
            incoming_packets[class][i-1] = tmp;
            if (member(incoming_packets[class], 0) == -1) {
                ret =
                decode_packet(implode(incoming_packets[class], ""), delimiter);
                remove_incoming(class);
                return ret;
            }
        } else {
            incoming_packets[class] = allocate(n);
            incoming_packets[class][i-1] = tmp;
/* Is it possible to already have a timeout running here ?!? */
            /* If no timeout is running then start one. */
            if (!pending_data[class]) {
                call_out("remove_incoming",
                REPLY_TIME_OUT + REPLY_TIME_OUT * RETRIES, class);
            } else {
                DEBUG("\nINETD: *** Buffered packet Timeout already running! ***\n");
            }
        }
        return 1;
    }
    ret = ([ ]);
    for(i = 0, n = sizeof(data = old_explode(packet, delimiter)); i < n; i++) {
        /* DATA fields can be denoted by a preceeding blank field. */
        if (data[i] == "") {
            tmp = DATA;
            /* Test for illegal packet length (no DATA) */
            if (++i >= n)
                return 0;
            info = data[i];
        }
        else if (sscanf(data[i], "%s:%s", tmp, info) != 2)
            return 0;
        switch((string)(class = decode(tmp))) {
            case DATA:
#ifdef USE_EXTRACT
                return ret + ([ DATA: decode(implode(
                    ({ info }) + extract(data, i+1), delimiter)) ]);
#else
                return ret + ([ DATA: decode(implode(
                    ({ info }) + data[i+1..], delimiter)) ]);
#endif
            case SYSTEM:
                ret[class] = old_explode(info, ":");
                continue;
            default:
                ret[class] = decode(info);
                continue;
        }
    }
    return ret;
}

int do_match	(	string	mudname,
		string	match_str
	)

Definiert in Zeile 537 der Datei inetd.c.

                                               {
    return mudname[0..strlen(match_str)-1] == match_str;
}

int dump_hosts_list

(

)

Definiert in Zeile 209 der Datei inetd.c.

Benutzt HOST_FILE, HOST_STATUS, MUDNAME und strftime().

                       {
  
  write_file(HOST_FILE+".dump", sprintf(
    "#Hostlist dump from "MUDNAME", created %s\n", strftime()), 1);

  foreach(string mudname, mixed tmp : hosts) {
    // skip muds we did not hear from for 2 days.
    if (tmp[HOST_STATUS] + 172800 < time())
      continue;
    write_file(HOST_FILE+".dump",
        sprintf("%s:%s:%d:%s:%s\n",tmp[0],tmp[1],tmp[2],implode(tmp[3],","),
          implode(tmp[4],",")));
  }
  return 1;
}

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

string encode

(

mixed

arg

)

Definiert in Zeile 566 der Datei inetd.c.

Wird benutzt von encode_packet() und udp_www().

                         {
    if (objectp(arg))
        return object_name(arg);
    if (stringp(arg) && (arg[0] == '$' ||
#ifdef RESTRICTED_CASTS
    to_string(to_int(arg)) == (string)arg))
#else
    (string)to_int(arg) == (string)arg))
#endif
        return "$" + arg;
    return to_string(arg);
}

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

string encode_packet

(

mapping

data

)

Definiert in Zeile 579 der Datei inetd.c.

Benutzt DATA, DELIMITER, encode() und i.

Wird benutzt von _send_udp().

                                   {
    int i;
    mixed indices;
    string header, body, t1, t2;
    string *ret;
    status data_flag;

    for(ret = ({ }), i = sizeof(indices = m_indices(data)); i--; ) {
        if (indices[i] == DATA) {
            data_flag = 1;
            continue;
        }
        header = encode(indices[i]);
        body = encode(data[indices[i]]);
        if (sscanf(header, "%s:%s", t1, t2) ||
            sscanf(header + body, "%s" + DELIMITER + "%s", t1, t2)
        )
            return 0;
        
        ret += ({ header + ":" + body });
    }
    if (data_flag)
#ifdef USE_OLD_DATA_FORMAT
        ret += ({ DATA + ":" + encode(data[DATA]) });
#else
        ret += ({ "", encode(data[DATA]) });
#endif
    return implode(ret, DELIMITER);
}

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

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

string* expand_mud_name

(

string

name

)

Definiert in Zeile 557 der Datei inetd.c.

Wird benutzt von _send_udp().

                                     {
    return sort_array(
        filter(m_indices(hosts), #'do_match, name),
        #'>
    );
}

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

string* explode_packet	(	string	packet,
		int	len
	)

Definiert in Zeile 613 der Datei inetd.c.

Benutzt extract() und result().

Wird benutzt von _send_udp().

                                               {

  int ptr, m_ptr,size;
  string *result;

  // Variablen initialisieren
  m_ptr=ptr=0;
  size=strlen(packet);
  result=({});

  // Um Arrayadditionen zu vermeiden wird vorher allokiert. Die Division 
  // durch 0 ist nicht abgefangen, da bei len=0 was im Aufruf falch ist.
  result=allocate((size/len+1));

  while (ptr<size) {
    result[m_ptr] = // Aktuellen Teilstring speichern
#ifdef USE_EXTRACT
            extract(packet,ptr,ptr+len-1);
#else
            packet[ptr..ptr+len-1]; 
#endif
    ptr+=len;// Neuen Pointer im String berechnen
    m_ptr++; // Neuen Pointer im Mapping berechnen. Hier nutze ich eine
             // Variable mehr als noetig, weil das billiger ist, als jedes
             // mal ptr=m_ptr*len auszurechnen. Lieber zwei Additionen als 
             // eine Multiplikation und eine Addtion.
  }

  // Wenn size/len aufgeht, ist das Result-Feld zu gross. Dann bleibt 
  // ein Element leer, das wird hier gestrippt. Das ist billiger als
  // jedesmal auszurechnen, ob size/len aufgeht.
  return result-({0});
 
}

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

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

varargs mixed query	(	string	what,
		mixed	extra1,
		mixed	extra2
	)

Definiert in Zeile 778 der Datei inetd.c.

Benutzt COMMANDS, data und HOST_COMMANDS.

Wird benutzt von Request().

                                                             {
    mixed data;

    switch(what) {
        case "commands":
            return COMMANDS;
        case "hosts":
            return deep_copy(hosts);
        case "pending":
            return deep_copy(pending_data);
        case "incoming":
            return deep_copy(incoming_packets);
        case "received":
            return ({ }) + received_ids;
        /* args: "valid_request", request, mudname */
        case "valid_request":
            if (data = hosts[extra2])
                return member(data[HOST_COMMANDS], "*") != -1 ||
                        member(data[HOST_COMMANDS], extra1) != -1;
            return 0;
    }
    return(0);
}

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

private mapping read_host_list

(

string

file

)

Definiert in Zeile 138 der Datei inetd.c.

Benutzt COMMANDS, data, HOST_COMMANDS, HOST_IP, HOST_NAME, HOST_STATUS, HOST_UDP_PORT, HOSTFILE_DEL, HOSTFILE_DEL2, INETD_LOG_FILE, LOCAL_COMMANDS, log_file, name, old_explode() und UNKNOWN.

Wird benutzt von set_host_list().

                                            {

  mixed data = (read_file(file));
  if (!data) {
    log_file(INETD_LOG_FILE, "*Error in reading host file: "
        + file +"\n\n");
    return 0;
  }

  data = old_explode(data, "\n");
  mapping new_hosts = m_allocate(sizeof(data),1);

  foreach(string line: data) {
    if (line == "" || line[0] == '#')
      continue;
    mixed fields = old_explode(line, HOSTFILE_DEL);
    if (sizeof(fields) < 5) {
      log_file(INETD_LOG_FILE, sprintf(
            "*Parse error in hosts file: %s, Line: %s\n", file, line));
      continue;
    }

    string name = lower_case(fields[HOST_NAME]);
    if (member(new_hosts, name))
      continue; // mud already in list

    string *local_cmds = old_explode(fields[LOCAL_COMMANDS],HOSTFILE_DEL2);
    if (member(local_cmds,"*") != -1)
        local_cmds = local_cmds - ({ "*" }) + COMMANDS;
    
    new_hosts[name] = ({ capitalize(fields[HOST_NAME]),
                     fields[HOST_IP],
                     to_int(fields[HOST_UDP_PORT]),
                     local_cmds,
                     old_explode(fields[HOST_COMMANDS], HOSTFILE_DEL2),
                     UNKNOWN
                   });
    /*
     * Get existing host status from current active host lost as long as the
     * IP and UDP ports are the same.
     */
    if (hosts[name] &&
        hosts[name][HOST_IP] == new_hosts[name][HOST_IP] &&
        hosts[name][HOST_UDP_PORT] == new_hosts[name][HOST_UDP_PORT])
        new_hosts[name][HOST_STATUS] = hosts[name][HOST_STATUS];
  }
  return new_hosts;
}

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

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

void remove_incoming

(

string

id

)

Definiert in Zeile 252 der Datei inetd.c.

Wird benutzt von reply_time_out().

                                {
    incoming_packets = m_delete(incoming_packets, id);
}

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

void remove_received_id

(

string

id

)

Definiert in Zeile 774 der Datei inetd.c.

                                   {
    received_ids -= ({ id });
}

void reply_time_out

(

string

id

)

Definiert in Zeile 735 der Datei inetd.c.

Benutzt _send_udp(), add_system_field(), call_out(), data, DOWN, HOST_STATUS, m_delete(), ob(), PACKET_LOSS, remove_incoming(), REPLY, REPLY_TIME_OUT, RESPONSE_TIME, RETRIES, RETRY, send(), TIME_OUT und UDP_CMD_DIR.

                               {
    mapping data;

    if (data = pending_data[id]) {
        object ob;

#ifdef INETD_DIAGNOSTICS
        data[PACKET_LOSS]++;
#endif
        if (data[RETRY] < RETRIES) {
            mapping send;

            data[RETRY]++;
            /* We must use a copy so the NAME field in pending_data[id]
             * isn't corrupted by _send_udp(). */
            send = deep_copy(data);
            send = m_delete(send, RETRY);
#ifdef INETD_DIAGNOSTICS
            send = m_delete(send, PACKET_LOSS);
            send = m_delete(send, RESPONSE_TIME);
#endif
            call_out("reply_time_out", REPLY_TIME_OUT, id);
            _send_udp(data[NAME], send);
            return;
        }
        data = m_delete(data, RETRY);
#ifdef INETD_DIAGNOSTICS
        data = m_delete(data, RESPONSE_TIME);
#endif
        catch(call_other(UDP_CMD_DIR + REPLY, "udp_" + REPLY,
        add_system_field(data, TIME_OUT));publish);
        /* It's just possible this was removed from the host list. */
        if (hosts[lower_case(data[NAME])])
            hosts[lower_case(data[NAME])][HOST_STATUS] = DOWN;
        remove_incoming(lower_case(data[NAME]) + ":" + id);
    }
    pending_data = m_delete(pending_data, id);
}

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

void set_host_list

(

)

Definiert in Zeile 193 der Datei inetd.c.

Benutzt HOST_FILE und read_host_list().

                     {

  // read the static host file and the last host file dump.
  mapping static_hosts = read_host_list(HOST_FILE);
  if (!static_hosts)
      return; // retain the old list(s)

  // remember the static hosts
  static_host_list = m_reallocate(static_hosts,0);
  
  // read the last host file dump and add the static hosts. Then the static
  // hosts have precedence over the ones from the dump.
  hosts = (read_host_list(HOST_FILE".dump") || ([])) + static_hosts;

}

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

void startup

(

string *

muds

)

Definiert in Zeile 231 der Datei inetd.c.

Benutzt _send_udp(), call_out(), PING und REQUEST.

                           {

    if (!pointerp(muds))
      muds=m_indices(hosts);
    if (!sizeof(muds))
      return;
    string *part;
    if (sizeof(muds) > 9)
      part=muds[0..9];
    else
      part=muds;
    foreach(string mud: part) 
      _send_udp(mud, ([ REQUEST: PING ]), 1);
    muds -= part;
    if (sizeof(muds))
      call_out(#'startup, 4, muds);
}

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

string valid_request

(

mapping

data

)

Definiert in Zeile 352 der Datei inetd.c.

                                   {
    mixed host_data;
    string *muds;
    string req;
    int i;
    
    if (!data[NAME] || !data[UDP_PORT])
        return DATE + ": Illegal packet.\n";
    if (host_data = hosts[lower_case(data[NAME])]) {
        if (data[HOST] != host_data[HOST_IP]) {
            if (data[NAME] == LOCAL_NAME)
                return DATE + ": *** FAKE MUD ***\n";
            log_file(INETD_LOG_FILE, DATE + ": Host change:\n" +
            host_data[HOST_NAME] + ": " + host_data[HOST_IP] + " -> " +
            data[HOST] + "\n\n");
            host_data[HOST_IP] = data[HOST];
        }
        if (data[UDP_PORT] != host_data[HOST_UDP_PORT]) {
            if (data[NAME] == LOCAL_NAME)
                return DATE + ": *** FAKE MUD ***\n";
            log_file(INETD_LOG_FILE, DATE + ": Port change:\n" +
                host_data[HOST_NAME] + " (" + host_data[HOST_IP] + "): " +
                host_data[HOST_UDP_PORT] + " -> " + data[UDP_PORT] + "\n\n");
            host_data[HOST_UDP_PORT] = data[UDP_PORT];
        }
    } else {
        if (lower_case(data[NAME]) == lower_case(LOCAL_NAME))
            return DATE + ": *** FAKE MUD ***\n";
        for(i = sizeof(muds = m_indices(hosts)); i--; ) {
            host_data = hosts[muds[i]];
            if (data[HOST] == host_data[HOST_IP] &&
            data[UDP_PORT] == host_data[HOST_UDP_PORT]) {
                log_file(INETD_LOG_FILE, DATE + ": Name change:\n" +
                    host_data[HOST_NAME] + " (" + host_data[HOST_IP] +
                    ") -> " + data[NAME] + "\n\n");
                host_data[HOST_NAME] = data[NAME];
                hosts[lower_case(data[NAME])] = host_data;
                hosts = m_delete(hosts, muds[i]);
                i = -2;
                break;
            }
        }
        if (i != -2) {
            host_data = hosts[lower_case(data[NAME])] = ({
                data[NAME],
                data[HOST],
                data[UDP_PORT],
                COMMANDS,
                ({ "*" }),
                UP
            });
            log_file(INETD_LOG_FILE, DATE + ": New mud.\n" + data[NAME] + ":" +
            data[HOST] + ":" + data[UDP_PORT] + "\n\n");
        }
    }
    if (!(req = data[REQUEST]))
        return DATE + ": System message.\n";
    if (req != PING &&
        req != QUERY &&
        req != REPLY &&
        member(host_data[LOCAL_COMMANDS], req) == -1)
    {
        /* This should probably send a system message too. */
        _send_udp(host_data[HOST_NAME], ([
            REQUEST: REPLY,
            RECIPIENT: data[SENDER],
            ID: data[ID],
            DATA: "Invalid request @" + LOCAL_NAME + ": " +
                capitalize(data[REQUEST]) + "\n"
        ]) );
        return DATE + ": Invalid request.\n";
    }
    return 0;
}