secure/memory.c

/*!
// MorgenGrauen Mudlib
//
// secure/memory.c  -- zum Speichern von Daten ueber die gesamte Mud-Uptime
//
// Memory speichert seine Daten als Pointer in der extra-wizinfo. Andere 
// Programme koennen Ihre Daten im Memory ablegen. Die Daten bleiben dadurch 
// auch ueber ein Update/Reload der Blueprint erhalten.
//
// Die Daten werden auf Klassenebene behandelt. Jeder Clone eines Programms
// (Blueprint) darf auf die gespeicherten Daten des Programms schreibend und
// lesend zugreifen. Andere Programme haben keinen Zugriff auf diese Daten.
//
// Nur Objekte in /secure/memory_lib bzw. /secure/memory_nolib eingetragen 
// sind, haben Rechte den Memory zu nutzen.
//
// Die Idee, sensible Daten in der extra_wizinfo abzuspeichern entstammt 
// /secure/memory.c aus der Wunderland Mudlib von Holger@Wunderland
*/
#include <config.h>
#include <wizlevels.h>
#include <files.h>

#pragma strict_types
#pragma no_clone
#pragma no_shadow
#pragma no_inherit
#pragma verbose_errors
#pragma combine_strings
#pragma pedantic
//#pragma range_check
#pragma warn_deprecated


/* Global variable declaration */
/*! \brief Liste mit Programmen, die den Memory nutzen duerfen 
 Die Variable wird entweder im create() oder durch manuellen Aufruf 
 von RereadProgramLists() aus /secure/memory_lib und /secure/memory_nolib
 befuellt.
 */
string *known_programs;

/* Function declaration - public interface */
void create();

// Payload Interface
int   Save  (string key, mixed data);
mixed Load  (string key);
int   Remove(string key);
int   HaveRights();

// Administrative Interface
varargs int RereadProgramLists(int silent);

// Debugging Interface
varargs void ShowData(string user, string key);

/* Function definition */ 
/*! Objekt initialisieren */
void create() {
  seteuid(getuid(this_object()));

  // Wizinfo-Pointer holen
  mixed *info = get_extra_wizinfo(0);
  if(!pointerp(info))
    raise_error("WIZINFO nicht lesbar. secure/simul_efun muss neu "
                "geladen werden.\n");

  mapping memory = info[MEMORY_BUFF];
  // Mein Feld der Wizinfo bei Bedarf initialisieren
  if(!mappingp(memory))
    info[MEMORY_BUFF]=([]);

  RereadProgramLists(1);
}

/*!
 Wenn das aufrufende Programm fuer die Speichernutzung zugelassen ist,
 wird hier der Hash zurueckgegeben unter dem seine Daten abgespeichert
 sind. Der Hash ist derzeit der Filename des Blueprint.
*/
private string get_caller_hash() {
  if (member(known_programs, program_name(previous_object())[..<3]) != -1) 
    return program_name(previous_object())[..<3];
  else 
    return 0;
}

/*! 
 Die Hilfsfunktion liest eine Liste mit Dateinamen und gibt die Programme 
 als Array of Strings zurueck. Alle Zeilen die nicht mit einem Slash 
 anfangen, werden dabei ignoriert.
 \param file Die auszulesende Datei.
*/
private mixed read_list(string file)
{
  mixed data;
  if (!stringp(file) || file_size(file) == FSIZE_NOFILE )
    return ({});

  // Daten laden
  data = explode(read_file(file)||"", "\n");

  // Alle Zeilen die nicht mit / beginnen entfernen ...
  data=regexp(data,"^/.+");

  // ".c" und eventuelle Leerzeichen in jeder Zeile werden entfernt
  data= map(data, 
     function string (string x) {return regreplace(x,"(.c)* *$","",1);});
  return data;
}

/*! 
 Wenn die Liste mit Programmen geaendert wurde, kann sie hier per Hand
 neu eingelesen werden.
 \param silent Varargs Flag, um Bildschirmausgabe zu unterdruecken
*/
varargs int RereadProgramLists(int silent)
{
  // Objekte laden, die zur Mudlib gehoeren
  known_programs = read_list("/secure/memory_lib");

  // Objekte laden, die nicht zur Mudlib gehoeren
  known_programs+=read_list("/secure/memory_nolib");

  if(!silent) printf ("%O\n", known_programs);

  return sizeof(known_programs);
}

/*! Zeiger auf den Speicher holen */
private mapping get_memory_pointer(){
  mixed *info = get_extra_wizinfo(0);

  // Die Fehlermeldungen sind etwas ausfuehrlicher, um dem Debugger
  // einen Hinweis auf Reparaturmoeglichkeiten zu geben
  if(!pointerp(info))
    raise_error("Wizinfo nicht ladbar. Entweder ich hab keine Rechte "
                "oder das Mud hat ein echtes Problem!\n");

  if(!mappingp(info[MEMORY_BUFF]))
    raise_error("Ich finde meine Daten in der Wizinfo nicht. Ein EM kann "
                "versuchen, mich neu zu laden, aber was die alten Daten "
                "betrifft, frei nach Catty: Keine Arme, keine Kekse!\n");
  // Da info[MEMORY_BUFF] immer ein Mapping ist (siehe Create), wird hier ein 
  // Pointer uebergeben. Dadurch werden Details zum Aufbau der extra_wizinfo
  // nur in dieser Funktion benoetigt.
  return info[MEMORY_BUFF];
}

/*!
  Pruefen, ob previous_object() Nutzungsrechte fuer den Memory hat.
  \return Gibt 1 zurueck, wenn der Aufrufende berechtigt ist, das 
          Objekt zu nutzen, sonst 0
*/
int HaveRights(){
  return stringp(get_caller_hash());
}

/*!
 Daten im Memory ablegen
 \param key ID unter der die Daten gespeichert werden
 \param var Zu speicherndes Datum
*/
int Save(string key, mixed var) {
  string who;
  mapping memory;

  // Hash des Aufrufers holen. Hat der keinen, ist er nicht befugt,
  // den Memory zu nutzen.
  if(!stringp(who=get_caller_hash())) return 0;

  // Wenn kein Key uebergeben wird, kann auch nichts gespeichert werden.
  if(!stringp(key)) return 0;

  // (hoffentlich) globalen memory_pointer holen
  memory = get_memory_pointer();

  // Wenn keine Daten da sind, muss man auch nichts anlegen. Rueckgabewert
  // ist dennoch 1, weil Load bei unbekannten Keys auch 0 liefert, die 
  // Null wird also korrekt gespeichert, irgendwie. Das muss aber nach dem
  // get_memory_pointer() passieren, da sonst das Korrekte Funktionieren von
  // Load nicht sichergestellt ist.
  if(var==0) return 1;

  // Erster Aufruf durch PO? Dann muss sein Speicherbereich initialisiert 
  // werden
  if(!member(memory,who))
    memory[who]=([]);

  // Endlich! Daten koennen gespeichert werden.
  memory[who][key]=var;

  return 1;
}

/*!
 Daten ausgeben/referenzieren
 \param key Id unter der die Daten gespeichert sind.
*/
mixed Load(string key) {
  string who;
  mapping memory;

  // Hash des Aufrufers holen. Hat der keinen, ist er nicht befugt,
  // den Memory zu nutzen.
  if(!stringp(who=get_caller_hash())) return 0;

  // Wenn kein Key uebergeben wird, kann auch nichts gespeichert werden.
  if(!stringp(key)) return 0;

  // (hoffentlich) globalen memory_pointer holen
  memory = get_memory_pointer();

  // Das Objekt hat noch nie Save() aufgerufen.
  if(!member(memory,who))
    return 0;

  // Unter diesem Key ist noch nichts gespeichert.
  if(!member(memory[who],key))
    return 0;

  // Gespeicherten Wert zurueckgeben
  return memory[who][key];
}

/*! 
 Ein Eintrag oder alle Eintraege werden geloescht
 \param key Id unter der die Daten gespeichert sind. 
            Wird kein Key uebergeben, werden alle Daten des Objekts 
            geloescht.
*/
varargs int Remove(string key) {
  string who;
  mapping memory;

  // Hash des Aufrufers holen. Hat der keinen, ist er nicht befugt,
  // den Memory zu nutzen.
  if(!stringp(who=get_caller_hash())) return 0;

  // (hoffentlich) globalen memory_pointer holen
  memory = get_memory_pointer();

  // Das Objekt hat noch nie Save() aufgerufen.
  if(!member(memory,who)) return 0;

  // Wenn kein Key uebergeben wird, wird alles zum Objekt gehoerende geloescht.
  if(stringp(key)){
    // Unter diesem Key ist nichts gespeichert.
    if(!member(memory[who],key)) return 0;

    // Wert unter Key fuer das File loeschen
    m_delete(memory[who], key);

  } else {
    // Alles fuer das File loeschen
    m_delete(memory, who);
  }

  return 1; 
}

varargs void ShowData(string user, string key)
{
  // Bekannte Objekte
  if (!ELDER_SECURITY )
    printf("I'm fine. Thanks for asking.\n");
  else {
    printf("known_programs:\n%O\n\n", known_programs);
    // EM duerfen sich auch noch zuscrollen lassen, wenn sie wollen
    if (ARCH_SECURITY && user)
    {
      mapping data = get_memory_pointer();
      if (!member(data,user))
        printf("memory: Keine Daten fuer %s vorhanden.\n",user);
      else if (user && key)
        printf("memory: Daten fuer User %s, Key %s:\n%O\n",user, key,
                  data[user][key]);
      else
        printf("memory: Daten fuer User %s:\n%O\n",user,data[user]);
    }
    else
    {
      mapping memory;
      memory = get_memory_pointer();
      // Andere bekommen eine anonymisierte Version
      printf("memory: (Nur Feldnamen, keine Daten)\n");
      foreach (string program, mapping data: memory ) {
        if ( mappingp(data) && sizeof(data) ){
          printf(break_string(
                   implode(m_indices(data),";\n"), 78,  
                   sprintf("  %-50s: ",program)),1);
        }
        else
        printf("  %-50s: - leer -\n", program);
      }
    }
  }
  return;
}