initial

13 files changed, 1238 insertions, 0 deletions

diff --git a/other/Kermit/lib/DevMemPatt.cpp b/other/Kermit/lib/DevMemPatt.cpp
new file mode 100644
index 0000000..81fd6e9
--- /dev/null
+++ b/other/Kermit/lib/DevMemPatt.cpp
@@ -0,0 +1,122 @@
+/*
+ * DevMemPatt.cpp:
+ * written by palmers / teso
+ */
+#include <DevMemPatt.hpp>
+
+
+  DevMemPatt::DevMemPatt ()
+  {
+    rw = new rwKernel ();
+  }
+
+
+  DevMemPatt::DevMemPatt (rwKernel *a)
+  {
+    rw = a;
+  }
+
+
+  DevMemPatt::~DevMemPatt ()
+  {
+  }
+
+
+  int DevMemPatt::compare_data_snippet (unsigned char *x, struct sfp *y)
+  {
+    bool                i = false;
+    int                 ret = -1;
+    short               a = 0,
+                        b = 0;
+
+  while ((b < y->length) && (a < READ_BUFF_SIZE))
+    {
+      if ((x[a] == y->fp[b].val) || (y->fp[b].type == WWCARD))
+        {
+          if (i == false)
+            {
+              i = true;
+              ret = a;
+            }
+          b++;
+        }
+      else if (i == true)
+        {
+          i = false;
+          ret = -1;
+          b = 0;
+        }
+      a++;
+    }
+  return ret;
+  }
+
+
+  unsigned int DevMemPatt::find_patt (unsigned int s, \
+                unsigned int e, unsigned short l, unsigned char *snipp)
+  {
+    bool                i = false;
+    int                 ret = -1;
+    unsigned short      a = 0,
+                        b = 0;
+    unsigned char       *readBuff = NULL;
+
+    readBuff = new unsigned char[READ_BUFF_SIZE];
+
+    while (s < e)
+      {
+        rw->read (readBuff, READ_BUFF_SIZE, s);
+        while ((b < l) && (a < READ_BUFF_SIZE))
+          {
+            if (readBuff[a] == snipp[b])
+              {
+                if (i == false)
+                  {
+                    i = true;
+                    ret = a;
+                  }
+                b++;
+              }
+            else if (i == true)
+              {
+                i = false;
+                ret = -1;
+                b = 0;
+              }
+            a++;
+          }
+        if (ret != -1)
+          {
+            if (ret == 0)
+              return s;
+            s = s + ret - READ_BUFF_SIZE;
+          }
+        s += READ_BUFF_SIZE;
+      }
+    return 0;
+  }
+
+
+  unsigned int DevMemPatt::find_patt (struct sfp *a)
+  {
+    int                 x = -1;
+    unsigned int        s = a->start_addr,
+                        e = a->stop_addr;
+    unsigned char       *readBuff = NULL;
+
+    readBuff = new unsigned char[READ_BUFF_SIZE];
+
+    while (s < e)
+      {
+        rw->read (readBuff, READ_BUFF_SIZE, s);
+        if ((x = compare_data_snippet (readBuff, a)) != -1)
+          {
+            if (x == 0)
+              return s;
+            s = s + x - READ_BUFF_SIZE;
+          }
+        s += READ_BUFF_SIZE;
+      }
+    return 0;
+  }
+
diff --git a/other/Kermit/lib/DevMemPatt.o b/other/Kermit/lib/DevMemPatt.o
new file mode 100644
index 0000000..196bdfd
--- /dev/null
+++ b/other/Kermit/lib/DevMemPatt.o
diff --git a/other/Kermit/lib/Makefile b/other/Kermit/lib/Makefile
new file mode 100644
index 0000000..6d1a1a8
--- /dev/null
+++ b/other/Kermit/lib/Makefile
@@ -0,0 +1,16 @@
+# written by palmers / teso
+include ../MakeOpt
+
+OBJECTS = name2add.o Patch.o DevMemPatt.o SymbolTable.o SystemMap.o \
+        stoi16.o itos16.o rwKernel.o SymbolFingp.o
+
+
+all: $(OBJECTS) libs
+
+libs:
+        $(AR) $(ARFLAGS) $(AR_OUT) $(OBJECTS)
+        $(CXX) $(CXXFLAGS) -shared -o $(SHARE_OUT) $(OBJECTS)
+
+clean:
+        rm -rf *.o name2add.c $(SHARE_OUT) $(AR_OUT)
+
diff --git a/other/Kermit/lib/Patch.cpp b/other/Kermit/lib/Patch.cpp
new file mode 100644
index 0000000..b72f860
--- /dev/null
+++ b/other/Kermit/lib/Patch.cpp
@@ -0,0 +1,502 @@
+/*
+ * Patch.cpp:
+ * written by palmers / teso
+ */
+#include <Patch.hpp>
+
+SystemMap DummyValMap;
+
+/*
+ * helper class
+ */
+class replaceAddr
+{
+private:
+  unsigned char         *data;
+  unsigned short        len;
+
+public:
+  replaceAddr (unsigned char *a, unsigned short x)
+  {
+    data = a;
+    len = x;
+  }
+ 
+  void operator() (Addr2Addr *a)
+  {
+    unsigned short      x = 0;
+    unsigned char       *b = NULL,
+                        *c = NULL;
+
+    b = (unsigned char *) &a->first;
+    c = (unsigned char *) &a->second;
+
+    for (x = 0; x <= (len - 3); x++)
+      {
+        if (b[0] == data[x])
+          {
+            if ((b[1] == data[x + 1]) && \
+                (b[2] == data[x + 2]) && \
+                (b[3] == data[x + 3]))
+              {
+                data[x] = c[0];
+                data[x + 1] = c[1];
+                data[x + 2] = c[2];
+                data[x + 3] = c[3];
+              }
+          }
+      }
+  }
+};
+
+
+/*
+ * member functions
+ */
+  string Patch::state2string ()
+  {
+    string              ret;
+
+    switch (state)
+      {
+        case CLEAN:
+          ret = "Clean";
+          break;
+        case LINKED:
+          ret = "Linked";
+          break;
+        case APPLIED:
+          ret = "Applied";
+          break;
+        case AFAILED:
+          ret = "ApplyFailed";
+          break;
+        case LFAILED:
+          ret = "LinkFailed";
+          break;
+        default:
+          ret = "Unknown";
+          break;
+      }
+    return ret;
+  }
+
+
+  void Patch::string2state (string a)
+  {
+    if (a == "Clean")
+      state = CLEAN;
+    else if (a == "Linked")
+      state = LINKED;
+    else if (a == "Applied")
+      state = APPLIED;
+    else if (a == "ApplyFailed")
+      state = AFAILED;
+    else if (a == "LinkFailed")
+      state = LFAILED;
+    else if (a == "Unknown")
+      abort ();
+  }
+
+
+  string Patch::data2string (unsigned char *a)
+  {
+    string              ret;
+    int                 x;
+
+    ret = itos16 ((unsigned int) a[0]);
+    for (x = 1; x < len; x++)
+      {
+        ret += ' ';
+        ret += itos16 ((unsigned int) a[x]);
+      }
+
+    return ret;
+  }
+
+
+  void Patch::string2data (string s, unsigned char *d)
+  {
+    string              tmp;
+    unsigned short      x,
+                        y;
+
+    for (x = 0; x < (len - 1); x++)
+      {
+        y = s.find_first_of (" ");
+        tmp.resize (y);
+        s.copy (tmp.begin (), y);
+        s.erase (0, y + 1);
+        d[x] = (unsigned char) stoi16 (tmp) & 0xff;
+        tmp.erase ();
+      }
+    tmp.resize (s.length ());
+    s.copy (tmp.begin (), s.length ());
+    d[x] = (unsigned char) stoi16 (tmp) & 0xff;
+  }
+
+
+  bool Patch::initObjects (unsigned char *d, unsigned short l, unsigned int add, rwKernel *x)
+  {
+    len = l;
+    address = add;
+    local_rw = x;
+
+    data = new unsigned char[len];
+    back_data = new unsigned char[len];
+    overwr = new unsigned char[len];
+
+    copy (d, d + len, data);
+    copy (d, d + len, back_data);
+    state = CLEAN;
+    return true;
+  }
+
+
+  void Patch::parse (string s)
+  {
+    unsigned char       *a = NULL;
+    string              tmp;
+    int                 x = 0;
+
+    x = s.find_first_of (",");
+    tmp.resize (x);
+    s.copy (tmp.begin (), x);
+    s.erase (0, x + 1);
+
+    address = stoi16 (tmp);
+    tmp.erase ();
+
+    x = s.find_first_of (":");
+    tmp.resize (x);
+    s.copy (tmp.begin (), x);
+    s.erase (0, x + 1);
+
+    string2state (tmp);
+    tmp.erase ();
+
+    x = s.find_first_of ("(");
+    s.erase (0, x + 1);
+
+    x = s.find_first_of (")");
+    tmp.resize (x);
+    s.copy (tmp.begin (), x);
+    len = count (tmp.begin (), tmp.end (), ' ') + 1;
+
+    data = new unsigned char[len];
+    back_data = new unsigned char[len];
+    overwr = new unsigned char[len];
+
+    string2data (tmp, data);
+    tmp.erase ();
+
+    if (state == CLEAN)
+      return;
+
+    switch (state)
+      {
+        case LINKED:
+        case LFAILED:
+          a = back_data;
+          break;
+        case APPLIED:
+        case AFAILED:
+          a = overwr;
+          break;
+      }
+
+    x = s.find_first_of ("(");
+    s.erase (0, x + 1);
+
+    x = s.find_first_of (")");
+    tmp.resize (x);
+    s.copy (tmp.begin (), x);
+
+    string2data (tmp, a);
+  }
+
+
+  Patch::Patch ()
+  {
+  }
+
+
+  Patch::Patch (unsigned char *d, unsigned short l, unsigned int add)
+  {
+    initObjects (d, l, add, NULL);
+  }
+
+
+  Patch::Patch (unsigned char *d, unsigned short l, unsigned int add, rwKernel *x)
+  {
+    initObjects (d, l, add, x);
+  }
+
+
+  Patch::Patch (string s)
+  {
+    parse (s);
+  }
+
+
+  Patch::Patch (string s, rwKernel *rw)
+  {
+    parse (s);
+    local_rw = rw;
+  }
+
+
+  Patch::~Patch ()
+  {
+    delete data;
+    delete back_data;
+    delete overwr;
+  }
+
+
+  void Patch::initFromString (string a)
+  {
+    parse (a);
+  }
+
+
+  string Patch::getPatchAsString ()
+  {
+    unsigned char       *a = NULL;
+    string              b;
+
+    switch (state)
+      {
+        case LINKED:
+        case LFAILED:
+          a = back_data;
+          break;
+        case APPLIED:
+        case AFAILED:
+          a = overwr;
+          break;
+      }
+
+    b = itos16 (address) + ',' + state2string () + ": (" + data2string (data) + ')';
+    if (a != NULL)
+      b += ", (" + data2string (a) + ')';
+    b += '\n';
+    return b;
+  }
+
+
+  bool Patch::isLinked ()
+  {
+    return (state & LINKED);
+  }
+
+
+  bool Patch::wasChanged ()
+  {
+    int                 x;
+
+    for (x = 0; x < len; x++)
+      if (data[x] != back_data[x])
+        return true;
+    return false;
+  }
+
+
+  bool Patch::isApplied ()
+  {
+    return (state & APPLIED);
+  }
+
+
+  bool Patch::isClean ()
+  {
+    return (state & CLEAN);
+  }
+
+
+  bool Patch::isFailed ()
+  {
+    return (state & AFAILED) || (state & LFAILED);
+  }
+
+
+  int Patch::getState ()
+  {
+    return state;
+  }
+
+
+  void Patch::restore ()
+  {
+    copy (back_data, back_data + len, data);
+    state = CLEAN;
+  }
+
+
+  bool Patch::remove (rwKernel *rw)
+  {
+    if (state != APPLIED)
+      return false;
+
+    rw->write (overwr, len, address);
+    return true;
+  }
+
+
+  bool Patch::remove ()
+  {
+    if (local_rw == NULL)
+      return false;
+    if (state != APPLIED)
+      return false;
+
+    local_rw->write (overwr, len, address);
+    return true;
+  }
+
+
+  unsigned char *Patch::getData ()
+  {
+    return data;
+  }
+
+
+  void Patch::apply (rwKernel *rw)
+  {
+/* pretty simple :) */
+    rw->read (overwr, len, address);
+    rw->write (data, len, address);
+    state = APPLIED;
+  }
+
+
+  void Patch::apply ()
+  {
+    if (local_rw == NULL)
+      {
+        state = AFAILED;
+        return;
+      }
+    local_rw->read (overwr, len, address);
+    local_rw->write (data, len, address);
+    state = APPLIED;
+  }
+
+
+  void Patch::link (Addr2AddrList *a2a)
+  {
+    replaceAddr                 x (data, len);
+    int                         y = a2a->size ();
+    Addr2AddrList::iterator     z = a2a->begin ();
+    Addr2Addr                   *t = NULL;
+
+/* XXX: why doesnt for_each work with pointer to list???
+ * its the same problem with for "(x = a2a->begin (); x != a2a->end (); ..."
+ * the x != end (); just f#$§ true!
+ */
+    while (y--)
+      {
+        t = *z;
+        x (t);
+        z++;
+      }
+    state = LINKED;
+  }
+
+
+  void Patch::dump (string file)
+  {
+    unsigned char       *a = NULL;
+/*
+ * dump file format:
+ * <Address>,<State>: (<data, hex, byte wise>){, (<other data, hex, byte wise>)}\n
+ * where the data in the curled brackets in depending on the state:
+ * state:       data in the curled bbrackets:
+ * clean        none
+ * applied      overwr
+ * afailed      overwr
+ * linked       back_date
+ * lfailed      back_data
+ */
+    ofstream f;
+
+    switch (state)
+      {
+        case LINKED:
+        case LFAILED:
+          a = back_data;
+          break;
+        case APPLIED:
+        case AFAILED:
+          a = overwr;
+          break;
+      }
+
+    f.open (file.c_str (), ios::ate | ios::app);
+
+    f.setf (ios::hex, ios::basefield);
+    f << address << ',' << state2string () << ':' << ' ';
+    f << '(' << data2string (data) << ')';
+    if (a != NULL)
+      f << ',' <<  ' ' << '(' << data2string (a) << ')';
+    f << endl;
+    f.setf (ios::dec, ios::basefield);
+  }
+
+
+  istream& operator>> (istream& is, Patch& p)
+  {
+    string              tmp;
+
+    getline (is, tmp, '\n');
+    p.initFromString (tmp);
+    return is;
+  }
+
+
+  ostream& operator<< (ostream& os, Patch& p)
+  {
+    os << p.getPatchAsString ();
+    return os;
+  }
+
+
+/*
+ * unrelated functions ....
+ */
+  Addr2AddrList *genReplaceValMap (SymbolTable *st)
+  {
+    zzSymList::iterator x;
+    Addr2Addr           *y = NULL;
+    zzSym               *z = NULL;
+    Addr2AddrList       *a2a = NULL;
+
+    a2a = new Addr2AddrList ();
+
+    /* get all symbol addressess together with dummy values */
+    for (x = st->symList.begin (); x != st->symList.end (); x++)
+      {
+        z = *x;
+        if (DummyValMap[z->Name] != 0)
+          {
+            y = new Addr2Addr ();
+            y->first = DummyValMap[z->Name];
+            y->second = z->Address;
+            a2a->push_back (y);
+          } 
+      }
+    return a2a;
+  }
+
+
+  void genDummyValMap ()
+  {
+    int                 x = 0;
+
+    while (__n2a[x].name != NULL)
+     {
+       DummyValMap.add (string (__n2a[x].name), __n2a[x].add);
+       x++;
+     }
+  }
+
diff --git a/other/Kermit/lib/Patch.o b/other/Kermit/lib/Patch.o
new file mode 100644
index 0000000..630c201
--- /dev/null
+++ b/other/Kermit/lib/Patch.o
diff --git a/other/Kermit/lib/SymbolFingp.cpp b/other/Kermit/lib/SymbolFingp.cpp
new file mode 100644
index 0000000..4b29bef
--- /dev/null
+++ b/other/Kermit/lib/SymbolFingp.cpp
@@ -0,0 +1,108 @@
+/*
+ * SymbolFingp.cpp:
+ * written by palmers / teso
+ */
+#include <SymbolFingp.hpp>
+#include <stoi16.hpp>
+
+
+bool SymbolFingp::addFinger (struct sfp *a)
+{
+  Fingers.insert (FingerThing::value_type (string (a->name), *a));
+  return true; /* ah, well - think positiv ... */
+}
+
+
+void SymbolFingp::readFingers (ifstream a)
+{
+  int                   x = 0;
+  struct sfp            *tmp_sfp = NULL;
+  string                tmp_string;
+
+  if (!a.is_open ())
+    {
+      cerr << "failed to open file" << endl;
+      abort ();
+    }
+#ifdef DEBUG
+  else
+    {
+      cout << "Reading fingerprints ..." << endl;
+    }
+#endif
+
+  a.setf (ios::skipws);
+  while (!a.eof ())
+    {
+      tmp_sfp = new struct sfp;
+
+/* get the name */
+      a >> tmp_string;
+      tmp_sfp->name = new char[tmp_string.length () + 1];
+      copy (tmp_string.begin (), tmp_string.end (), tmp_sfp->name);
+
+/* the addresses */
+      a.setf (ios::hex, ios::basefield);
+      a >> tmp_sfp->start_addr;
+      a >> tmp_sfp->stop_addr;
+
+/* offset from fp to real address */
+      a >> tmp_sfp->offset;
+
+/* length of fp */
+      a >> tmp_sfp->length;
+
+/* the cells */
+      tmp_sfp->fp = new struct cell[tmp_sfp->length];
+
+      for (x = 0; x < tmp_sfp->length; x++)
+      {
+        a >> tmp_string;
+
+        if ((tmp_string.length () == 1) && (tmp_string[0] == '?'))
+          {
+            tmp_sfp->fp[x].type = WWCARD;
+            tmp_sfp->fp[x].val = 0;
+          }
+        else
+          {
+            tmp_sfp->fp[x].type = NOCARD;
+            tmp_sfp->fp[x].val = stoi16 (tmp_string);
+          }
+      }
+      if (addFinger (tmp_sfp) != true)
+        {
+          cerr << "Could not add fingerprint" << endl;
+          abort ();
+        }
+    }
+      a.setf (ios::dec, ios::basefield);
+#ifdef DEBUG
+ cout << "done." << endl;
+#endif
+}
+
+
+SymbolFingp::SymbolFingp ()
+{
+  readFingers (ifstream (DEFAULT_FILE));
+}
+
+
+SymbolFingp::SymbolFingp (string a)
+{
+  readFingers (ifstream (a.c_str ()));
+}
+
+
+SymbolFingp::~SymbolFingp ()
+{
+  Fingers.clear ();
+}
+
+
+struct sfp *SymbolFingp::getFinger (string a)
+{
+  return &Fingers[a];
+}
+
diff --git a/other/Kermit/lib/SymbolTable.cpp b/other/Kermit/lib/SymbolTable.cpp
new file mode 100644
index 0000000..1d412e0
--- /dev/null
+++ b/other/Kermit/lib/SymbolTable.cpp
@@ -0,0 +1,205 @@
+/*
+ * SymbolTable.cpp:
+ * written by palmers / teso
+ */
+#include <SymbolTable.hpp>
+
+
+/*
+ * helper classes
+ */
+class DumpTable
+  {
+private:
+    string              file;
+
+public:
+    DumpTable (string a)
+    {
+      file = string (a);
+    }
+
+    ~DumpTable ()
+    {
+    }
+
+    void operator() (zzSym *foo)
+    {
+      ofstream dump (file.c_str ());
+      if (!dump.is_open ())
+        {
+          cerr << "Pfff..." << endl;
+          abort ();
+        }
+      dump << foo->Name << "\tE\t" << foo->Address << endl;
+      dump.close ();
+    }
+  };
+
+
+class FindFind
+  {
+  private:
+    string              search;
+
+  public:
+    FindFind (string a)
+    {
+      search = string (a);
+    }
+
+    bool operator() (struct zzSym *foo)
+    {
+      if (search.compare (foo->Name, search.length ()))
+        {
+          return true;
+        }
+     return false;
+    }
+  };
+
+
+/*
+ * member functions
+ */
+  bool SymbolTable::loadFiles (string a, string b)
+  {
+/* check for System.map */
+    mapp = SystemMap (a);
+
+/* load a dumped cache */
+    rest = SystemMap (b);
+    return true;
+  }
+
+
+  bool SymbolTable::createObjects (rwKernel *a)
+  {
+    if (a == NULL)
+      patt = new DevMemPatt ();
+    else
+      patt = new DevMemPatt (a);
+    fing = new SymbolFingp ();
+    return true;
+  }
+
+
+  SymbolTable::SymbolTable ()
+  {
+    loadFiles (DEFAULTSYSTEMMAP, DEFAULTDUMP);
+    createObjects (NULL);
+
+/* XXX, init set of exported symbols */
+    if (false)
+      {
+        exported = SystemMap ();
+      }
+  }
+
+
+  SymbolTable::SymbolTable (string res, string sys)
+  {
+    loadFiles (sys, res);
+    createObjects (NULL);
+
+/* XXX, init set of exported symbols */
+    if (false)
+      {
+        exported = SystemMap ();
+      }
+  }
+
+
+  SymbolTable::SymbolTable (rwKernel *f)
+  {
+    loadFiles (DEFAULTSYSTEMMAP, DEFAULTDUMP);
+    createObjects (f);
+  }
+
+
+  SymbolTable::~SymbolTable ()
+  {
+    delete fing;
+    delete patt;
+    clearCache ();
+  }
+
+
+  void SymbolTable::setSaveFile (string file)
+  {
+    dump_file = string (file);
+  }
+
+
+  unsigned int SymbolTable::getSymbol (string name)
+  {
+    zzSymList::iterator x;
+    zzSym               *y = NULL;
+
+    x = find_if (symList.begin (), symList.end (), FindFind (name));
+    if (x == symList.end ())
+      return 0;
+    y = *x;
+    return y->Address;
+  }
+
+
+  bool SymbolTable::findSymbol (string name)
+  {
+    unsigned int        x = 0;
+/*
+ * first  check if the symbol can be found in restore date
+ * second check if the symbol can be found using SymbolFingp
+ * third  is list of exported symbols
+ * fourth System.map (if supplied)
+ */
+    if (rest.contains (name))
+      {
+        addSymbolToCache (name, rest[name]);
+        return true;
+      }
+
+    if ((x = patt->find_patt (fing->getFinger (name))) != 0)
+      {
+        addSymbolToCache (name, x);
+        return true;
+      }
+
+    if (exported.contains (name))
+      {
+        addSymbolToCache (name, exported[name]);
+        return true;
+      }
+
+    if (mapp.contains (name))
+      {
+        addSymbolToCache (name, mapp[name]);
+        return true;
+      }
+
+    return false;
+  }
+
+
+  void SymbolTable::addSymbolToCache (string name, unsigned int add)
+  {
+    zzSym               *x = new zzSym;
+
+    x->Name = string (name);
+    x->Address = add;
+    symList.push_back (x);
+  }
+
+
+  void SymbolTable::clearCache ()
+  {
+    symList.clear ();
+  }
+
+
+  bool SymbolTable::saveCache ()
+  {
+    for_each (symList.begin (), symList.end (), DumpTable (dump_file));
+    return true;
+  }
+
diff --git a/other/Kermit/lib/SystemMap.cpp b/other/Kermit/lib/SystemMap.cpp
new file mode 100644
index 0000000..03e2fb4
--- /dev/null
+++ b/other/Kermit/lib/SystemMap.cpp
@@ -0,0 +1,67 @@
+/*
+ * SystemMap.cpp:
+ * written by palmers / teso
+ */
+#include <SystemMap.hpp>
+
+
+  SystemMap::SystemMap (string a)
+  {
+    string              tmp;
+    unsigned int        num = 0;
+    ifstream            f;
+
+    f.open (a.c_str ());
+    if (!f.is_open ())
+      {
+        cerr << "Error opening file \"" << a << "\"!" << endl;
+        abort ();
+      }
+
+    f.setf (ios::skipws);
+    f.setf (ios::hex, ios::basefield);
+
+    while (!f.eof ())
+      {
+        f >> num;
+        f >> tmp;
+        f >> tmp;
+
+        add_map.insert (add_map.end (), bla_val (tmp, num));       
+      }
+    f.close ();
+  }
+
+
+  SystemMap::SystemMap ()
+  {
+  }
+
+
+  SystemMap::~SystemMap ()
+  {
+    add_map.clear ();
+  }
+
+
+  bool SystemMap::contains (string a)
+  {
+    if (add_map.find (a) == add_map.end ())
+      return false;
+    return true;
+  }
+
+
+  void SystemMap::add (string a, unsigned int x)
+  {
+    add_map.insert (add_map.end (), bla_val (a, x));       
+  }
+
+
+  unsigned int SystemMap::operator[] (string a)
+  {
+    if (add_map.find (a) == add_map.end ())
+      return 0;
+    return add_map[a];
+  }
+
diff --git a/other/Kermit/lib/itos16.cpp b/other/Kermit/lib/itos16.cpp
new file mode 100644
index 0000000..b7a8a20
--- /dev/null
+++ b/other/Kermit/lib/itos16.cpp
@@ -0,0 +1,36 @@
+/*
+ * itos16.cpp:
+ * written by palmers / teso
+ */
+#include <itos16.hpp>
+#include <iostream>
+
+  string itos16 (unsigned int x)
+  {
+    char                t[] = "0123456789abcdef";
+    string              y;
+    unsigned int        a,
+                        base = 1,
+                        z = 0;
+
+    while (base < x && z++ < 7)
+      base *= 16;
+
+    if (z != 8 && z != 0)
+      base /= 16;
+
+    while (base != 1)
+      {
+        a = 0;
+        while (x >= base)
+          {
+            a++;
+            x -= base;
+          }
+        y += t[a];
+        base /= 16;
+      }
+    y += t[x];
+    return y;
+  }
+
diff --git a/other/Kermit/lib/name2add.c b/other/Kermit/lib/name2add.c
new file mode 100644
index 0000000..a141075
--- /dev/null
+++ b/other/Kermit/lib/name2add.c
@@ -0,0 +1,46 @@
+/*
+ * name2add.c:
+ * this file was automaticly generated by gen_name2add
+ */
+#include <stdio.h>
+#include <name2add.h>
+
+__name2add __n2a[] =
+{
+  {"sys_fork", 0xf8f8f8f8},
+  {"sys_read", 0xf8f8f7f7},
+  {"sys_write", 0xf8f8f6f6},
+  {"sys_exit", 0xf8f8f5f5},
+  {"sys_setuid", 0xf8f8f4f4},
+  {"sys_setgid", 0xf8f8f3f3},
+  {"sys_getuid", 0xf8f8f2f2},
+  {"sys_getgid", 0xf8f8f1f1},
+  {"sys_open", 0xf8f8f0f0},
+  {"sys_close", 0xf8f8efef},
+  {"kmalloc", 0xf8f8eeee},
+  {NULL, 0}
+};
+
+/*
+ * name2add.c:
+ * this file was automaticly generated by gen_name2add
+ */
+#include <stdio.h>
+#include <name2add.h>
+
+__name2add __n2a[] =
+{
+  {"sys_fork", 0xf8f8f8f8},
+  {"sys_read", 0xf8f8f7f7},
+  {"sys_write", 0xf8f8f6f6},
+  {"sys_exit", 0xf8f8f5f5},
+  {"sys_setuid", 0xf8f8f4f4},
+  {"sys_setgid", 0xf8f8f3f3},
+  {"sys_getuid", 0xf8f8f2f2},
+  {"sys_getgid", 0xf8f8f1f1},
+  {"sys_open", 0xf8f8f0f0},
+  {"sys_close", 0xf8f8efef},
+  {"kmalloc", 0xf8f8eeee},
+  {NULL, 0}
+};
+
diff --git a/other/Kermit/lib/name2add.o b/other/Kermit/lib/name2add.o
new file mode 100644
index 0000000..260866e
--- /dev/null
+++ b/other/Kermit/lib/name2add.o
diff --git a/other/Kermit/lib/rwKernel.cpp b/other/Kermit/lib/rwKernel.cpp
new file mode 100644
index 0000000..4077ff5
--- /dev/null
+++ b/other/Kermit/lib/rwKernel.cpp
@@ -0,0 +1,107 @@
+/*
+ * rwKernel.cpp:
+ * written by palmers / teso
+ */
+#include <rwKernel.hpp>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <iostream>
+
+
+  bool rwKernel::openFile (int w)
+  {
+    int                 a = 0;
+    void                *tmp = NULL;
+    char                *file = NULL;
+
+    if (w == DEVMEM)
+      file = "/dev/mem";
+    else if (w == PROCKCORE)
+      file = "/proc/kcore";
+
+    if ((a = open (file, O_RDWR)) <= 0)
+      {
+        cerr << "open error" << endl;
+        abort ();
+      }
+
+    if ((tmp = mmap (NULL, 0x40000000, PROT_READ | \
+        PROT_WRITE, MAP_SHARED, a, 0xc0000000 - mem_conf)) == (void *) -1)
+      {
+        cerr << "mmap failed" << endl;
+        abort ();
+      }
+    fd = (char *) tmp;
+    return true;
+  }
+
+
+  void rwKernel::setOffset (int x)
+  {
+    switch (x)
+      {
+        case CONF_1GB:
+          mem_conf = 0xC0000000;
+          break;
+        case CONF_2GB:
+          mem_conf = 0x80000000;
+          break;
+        case CONF_3GB:
+          mem_conf = 0x40000000;
+          break;
+        case IGNORE:
+          mem_conf = 0xC0000000;
+          break;
+        default:
+          mem_conf = 0xC0000000;
+          break;
+      }
+  }
+
+
+  void rwKernel::closeFile ()
+  {
+    munmap (fd, 0x40000000);
+  }
+
+
+  rwKernel::rwKernel ()
+  {
+    setOffset (CONF_1GB);
+    openFile (DEVMEM);
+  }
+
+
+  rwKernel::rwKernel (int file, int off)
+  {
+    if (file == PROCKCORE)
+      off = IGNORE;
+    setOffset (off);
+    openFile (file);
+  }
+
+
+  rwKernel::~rwKernel ()
+  {
+    closeFile ();
+  }
+
+
+  void rwKernel::read (unsigned char *dest, unsigned int len, \
+                unsigned int offset)
+  {
+    offset -= mem_conf;
+    copy (fd + offset, fd + offset + len, dest);
+  }
+
+
+  void rwKernel::write (unsigned char *src, unsigned int len, \
+                unsigned int offset)
+  {
+    offset -= mem_conf;
+    copy (src, src + len, fd + offset); 
+  }
+
diff --git a/other/Kermit/lib/stoi16.cpp b/other/Kermit/lib/stoi16.cpp
new file mode 100644
index 0000000..83aad59
--- /dev/null
+++ b/other/Kermit/lib/stoi16.cpp
@@ -0,0 +1,29 @@
+/*
+ * stoi16.cpp:
+ * written by palmers / teso
+ */
+#include <stoi16.hpp>
+
+  unsigned int stoi16 (string x)
+  {
+    int                 num = 0,
+                        base = 1,
+                        z = x.length () - 1;
+    unsigned int        y = 0;
+
+    while (z >= 0)
+      {
+        if (x[z] <= '9' && x[z] >= '0')
+          num = x[z] - '0';
+        if (x[z] <= 'f' && x[z] >= 'a')
+          num = x[z] - 'a' + 10;
+        if (x[z] <= 'F' && x[z] >= 'A')
+          num = x[z] - 'A' + 10;
+
+        y += num * base;
+        base *= 16;
+        z--;
+      }
+    return y;
+  }
+