initial

14 files changed, 801 insertions, 0 deletions

diff --git a/other/Kermit/include/DevMemPatt.hpp b/other/Kermit/include/DevMemPatt.hpp
new file mode 100644
index 0000000..aa559e0
--- /dev/null
+++ b/other/Kermit/include/DevMemPatt.hpp
@@ -0,0 +1,69 @@
+/*
+ * DevMemPatt.hpp:
+ * search the kernel...
+ * written by palmers / teso
+ *
+ * ahh, btw. fuck. now you can grep for it :)
+ */
+#ifndef __DEVMEMPATT_C
+#define __DEVMEMPATT_C
+
+#define READ_BUFF_SIZE          4096
+
+#include <string>
+#include <rwKernel.hpp>
+#include <SymbolFingp.hpp>
+
+
+/**
+ * Searching the kernel. This class helps you by seaching for
+ * patterns in kernel memory. Each function has a, more or less, unique structure.
+ * There is nothing to wonder about this: each function is for solving a different
+ * task. If the function, or parts of it, are know it can be found without any further
+ * knowledge about it.
+ */
+class DevMemPatt
+{
+private:
+  rwKernel *rw;
+  int compare_data_snippet (unsigned char *, struct sfp *);
+
+public:
+/**
+ * This constructor will initialize the object with a reference to a rwKernel object.
+ * @see rwKernel
+ */
+  DevMemPatt (rwKernel *);
+
+/**
+ * Another constructor. This one will generate a new rwKernel object.
+ */
+  DevMemPatt ();
+
+/**
+ * Destruct DevMemPatt object. Local rwKernel object will not be deleted.
+ */
+  ~DevMemPatt ();
+
+/**
+ * Find a data string in kernel memory.
+ * @param start start address of the search.
+ * @param end the search will go upto this address in kernel memory.
+ * @param length the length of the data.
+ * @param data the data searched for.
+ * @return the address of the first byte of the searched data or
+ * zero if it was not found.
+ */
+  unsigned int find_patt (unsigned int start, unsigned int end, \
+                unsigned short len, unsigned char *data);
+
+/**
+ * Find a data pattern in kernel memory.
+ * @param a search a data pattern defined by a.
+ * @return the address of the first byte of the searched pattern or
+ * zero if it was not found.
+ * @see SymbolFingp
+ */
+  unsigned int find_patt (struct sfp *a);
+};
+#endif /* __DEVMEMPATT_C */
diff --git a/other/Kermit/include/Kermit b/other/Kermit/include/Kermit
new file mode 100644
index 0000000..bcdb720
--- /dev/null
+++ b/other/Kermit/include/Kermit
@@ -0,0 +1,16 @@
+/*
+ * common header for libKermit
+ * written palmers / teso
+ */
+#ifndef __Kermit__
+#define __Kermit__
+#include <DevMemPatt.hpp>
+#include <Patch.hpp>
+#include <SymbolFingp.hpp>
+#include <SymbolTable.hpp>
+#include <SystemMap.hpp>
+#include <name2add.h>
+#include <rwKernel.hpp>
+#include <stoi16.hpp>
+#include <itos16.hpp>
+#endif /* __Kermit__ */
diff --git a/other/Kermit/include/Makefile b/other/Kermit/include/Makefile
new file mode 100644
index 0000000..97cbe78
--- /dev/null
+++ b/other/Kermit/include/Makefile
@@ -0,0 +1,11 @@
+# written by palmers / teso
+include ../MakeOpt
+
+all:
+        $(UTIL_DIR)/gen_names_from_proto
+        $(UTIL_DIR)/gen_defines
+        $(UTIL_DIR)/gen_name2add
+
+clean:
+        rm -rf addresses.h
+
diff --git a/other/Kermit/include/Patch.hpp b/other/Kermit/include/Patch.hpp
new file mode 100644
index 0000000..a784f9c
--- /dev/null
+++ b/other/Kermit/include/Patch.hpp
@@ -0,0 +1,204 @@
+/*
+ * Patch.hpp:
+ * representation of a kernel patch.
+ * written by palmers / teso
+ */
+#ifndef __PATCH_C
+#define __PATCH_C
+
+#include <rwKernel.hpp>
+#include <SymbolTable.hpp>
+#include <SystemMap.hpp>
+#include <stoi16.hpp>
+#include <itos16.hpp>
+#include <utility>
+#include <functional>
+#include <algorithm>
+#include <list>
+#include <fstream>
+#include <string>
+#include <name2add.h>
+
+
+typedef pair<unsigned int, unsigned int>        Addr2Addr;
+typedef list<Addr2Addr *>                       Addr2AddrList;
+
+Addr2AddrList *genReplaceValMap (SymbolTable *st);
+void genDummyValMap ();
+extern SystemMap DummyValMap;
+
+
+#define CLEAN   1
+#define LINKED  2
+#define APPLIED 4
+#define LFAILED 8
+#define AFAILED 16
+
+
+/**
+ * Representation of a kernel patch. A Patch is a amount of data, which is to be written
+ * to a given address. Patching means modification of kernel memory. Therefore, the data,
+ * which will be overwritten, is saved (before writting).
+ * Additionally the status of the Patch is tracked. Thus, you are able to undo, reapply
+ * and debug patches. The states a Patch must be in are:
+ * CLEAN (the patch was never touched)
+ * LINKED (it was linked without an error)
+ * APPLIED (it was applied without an error)
+ * LFAILED (linking failed)
+ * AFAILED (applying failed)
+ */
+class Patch
+{
+private:
+  int state;
+  unsigned short len;
+  unsigned char *back_data, *data, *overwr;
+  unsigned int address;
+  rwKernel *local_rw;
+
+  bool initObjects (unsigned char *, unsigned short, unsigned int, rwKernel *);
+  string state2string ();
+  void string2state (string);
+  string data2string (unsigned char *);
+  void string2data (string, unsigned char *);
+  void parse (string);
+
+public:
+/**
+ * Create, but init nothing.
+ */
+  Patch ();
+
+/**
+ * Create a patch with supplied data.
+ * @param data patch data.
+ * @param len length of patch data.
+ * @param addr memory address to where the data shall be written.
+ */
+  Patch (unsigned char *data, unsigned short len, unsigned int addr);
+
+/**
+ * Create a patch with supplied data. This constructor, compared with the above,
+ * will set a local reference to a rwKernel object.
+ * @param x pointer to a rwKernel object.
+ */
+  Patch (unsigned char *data, unsigned short len, unsigned int addr, rwKernel *x);
+
+/**
+ * Initialize the object from a string as created by dump ().
+ * @see dump()
+ */
+  Patch (string);
+
+/**
+ * Initialize the object from a string as created by dump ().
+ * @see dump()
+ */
+  Patch (string, rwKernel *);
+
+/**
+ * Foo.
+ */
+  ~Patch ();
+
+
+/**
+ * init object from a string.
+ */
+  void initFromString (string);
+
+/**
+ * Foo.
+ */
+  string getPatchAsString ();
+
+/**
+ * tells you if the patch data was modified. (e.g. by linking).
+ * @return true if backup data and data differ.
+ */
+  bool wasChanged ();
+
+/**
+ * @return true if the linking returned no error messages. 
+ */
+  bool isLinked ();
+
+/**
+ * @return true if the applying was successful. 
+ */
+  bool isApplied ();
+
+/**
+ * @return true if linking or applying failed.
+ */
+  bool isFailed ();
+
+/**
+ * @return true if the patch was not touched.
+ */
+  bool isClean ();
+
+/**
+ * @return the status.
+ */
+  int getState ();
+
+/**
+ * Restore patch data. Might be helpful if linking failed.
+ */
+  void restore ();
+
+/**
+ * Remove applied Patch (Undo changes done to memory).
+ */
+  bool remove ();
+
+/**
+ * Remove applied Patch (Undo changes done to memory).
+ */
+  bool remove (rwKernel *);
+
+/**
+ * Get a pointer to patch data.
+ */
+  unsigned char *getData ();
+
+/**
+ * Apply the patch to the kernel. Effectivly write the patch data to the supplied address.
+ * The method allows you to supply a a reference to a rwKernel object. you can supply on
+ * construction of the patch. However, there might be none at that time.
+ */
+  void apply (rwKernel *);
+
+/**
+ * Apply the patch to the kernel. Use this apply method if you supplied a reference to a
+ * rwKernel object at creation time.
+ */
+  void apply ();
+
+/**
+ * link the patch with the kernel. Replace all placeholders with real addresses.
+ */
+  void link (Addr2AddrList *);
+
+/**
+ * Dump patch information into a file. This will produce human readable output. It
+ * can be used e.g. for restoring and debugging. Because the output is line based
+ * and can be used to initialize a Patch object you are effecitvely able to reproduce
+ * patching sessions.
+ * @see Patch(string)
+ * @param file filename.
+ */
+  void dump (string file);
+
+/**
+ * Foo.
+ */
+  friend istream& operator>> (istream&, Patch&);
+
+/**
+ * Foo.
+ */
+  friend ostream& operator<< (ostream&, Patch&);
+};
+#endif /* __PATCH_C */
diff --git a/other/Kermit/include/SymbolFingp.hpp b/other/Kermit/include/SymbolFingp.hpp
new file mode 100644
index 0000000..248ed13
--- /dev/null
+++ b/other/Kermit/include/SymbolFingp.hpp
@@ -0,0 +1,75 @@
+/*
+ * SymbolFingp.hpp:
+ * some fingerprint
+ * written by palmers / teso
+ */
+#ifndef __SymbolFingp_H
+#define __SymbolFingp_H
+#include <map>
+#include <fstream>
+#include <string>
+#include <iostream>
+
+/* default file to open */
+#define DEFAULT_FILE    "SymbolFind.conf"
+
+/* defines used for the type field in struct cell */
+#define WWCARD  1
+#define NOCARD  0
+
+
+struct cell
+{
+  unsigned char type;
+  unsigned char val;
+};
+
+
+struct sfp
+{
+  char *name;
+  unsigned long start_addr;
+  unsigned long stop_addr;
+  long offset;
+  unsigned short length;
+  struct cell *fp;
+};
+
+
+/** 
+ * class to hold fingerprints of a function (a [kernel-]symbol).
+ */
+class SymbolFingp
+{
+private:
+
+  typedef map<string, struct sfp> FingerThing;
+  FingerThing Fingers;
+
+  void readFingers (ifstream);
+  bool addFinger (struct sfp *);
+
+public:
+
+/**
+ * Reads configuration from default file.
+ */
+  SymbolFingp ();
+
+/**
+ * Reads configuration from specified file.
+ */
+  SymbolFingp (string);
+
+/**
+ * Foo.
+ */
+  ~SymbolFingp ();
+
+/**
+ * Return the Fingerprint matching the supplied name.
+ */
+  struct sfp *getFinger (string);
+};
+
+#endif /* __SymbolFingp_H */
diff --git a/other/Kermit/include/SymbolTable.hpp b/other/Kermit/include/SymbolTable.hpp
new file mode 100644
index 0000000..b0f8aa3
--- /dev/null
+++ b/other/Kermit/include/SymbolTable.hpp
@@ -0,0 +1,113 @@
+/*
+ * SymbolTable.hpp:
+ * a container for "on-demand" symbol address fetching
+ * written by palmers / teso
+ */
+#ifndef __SYMBOL_TABLE_C
+#define __SYMBOL_TABLE_C
+
+#include <SymbolFingp.hpp>
+#include <SystemMap.hpp>
+#include <DevMemPatt.hpp>
+#include <rwKernel.hpp>
+#include <list>
+#include <string>
+#include <iostream>
+#include <fstream>
+#include <algorithm>
+#include <iterator>
+
+#define DEFAULTDUMP             "SymbolTableDump"
+#define DEFAULTSYSTEMMAP        "System.map"
+
+typedef struct
+  {
+    string Name;
+    unsigned int Address;
+  } zzSym;
+typedef list<zzSym *> zzSymList;
+
+
+/**
+ * A container class for "on-demand" symbol address fetching.
+ */
+class SymbolTable
+{
+private:
+  SymbolFingp *fing;
+  DevMemPatt *patt;
+  SystemMap exported;
+  SystemMap mapp;
+  SystemMap rest;
+  string dump_file;
+
+  bool createObjects (rwKernel *);
+  bool loadFiles (string, string);
+
+public:
+/**
+ * List of name, address pairs.
+ */
+  zzSymList symList;
+
+/**
+ * Construct a SymbolTable object and load configuration from default files.
+ */
+  SymbolTable ();
+
+/**
+ * Construct a SymbolTable object and load configuration from defined files.
+ * @param res file name of restore file.
+ * @param sys System.map file to load.
+ */
+  SymbolTable (string res, string sys);
+
+/**
+ * Construct a SymbolTable object and use the referenced rwKernel object in all
+ * member attributes and methods.
+ */
+  SymbolTable (rwKernel *);
+
+/**
+ * Foo.
+ */
+  ~SymbolTable ();
+
+/**
+ * Define the file written to on saveCache ().
+ * @see saveCache()
+ */
+  void setSaveFile (string);
+
+/**
+ * get the address of a known symbol.
+ * @return If the symbol is unknow zero is returned.
+ * (hey, would you call 0x00000000?). Else, the address
+ * of the symbol.
+ */
+  unsigned int getSymbol (string);
+
+/**
+ * Find a symbol. This will try all available methods to
+ * find a symbol and cache the address, name pair (zero
+ * if search was not successfull).
+ * @return true on success.
+ */
+  bool findSymbol (string);
+
+/**
+ * add a symbol, address pair to the cache.
+ */
+  void addSymbolToCache (string, unsigned int);
+
+/**
+ * flush the address cache.
+ */
+  void clearCache ();
+
+/**
+ * save the cache to a file (human readable, System.map style).
+ */
+  bool saveCache ();
+};
+#endif /* __SYMBOL_TABLE_C */
diff --git a/other/Kermit/include/SystemMap.hpp b/other/Kermit/include/SystemMap.hpp
new file mode 100644
index 0000000..ff59094
--- /dev/null
+++ b/other/Kermit/include/SystemMap.hpp
@@ -0,0 +1,61 @@
+/*
+ * SystemMap.hpp:
+ * representation if a system map file (and alike).
+ * written by palmers / teso
+ */
+#ifndef SYSTEM_MAP_C
+#define SYSTEM_MAP_C
+
+#include <map>
+#include <string>
+#include <fstream>
+
+/**
+ * Representation of a System.map file. It maps names to addresses.
+ */
+class SystemMap
+{
+private:
+  typedef map<string, unsigned int> blamap;
+  typedef blamap::value_type bla_val;
+
+  blamap add_map;
+
+public:
+/**
+ * Create a SystemMap object and read symbol names and addresses from a file.
+ */
+  SystemMap (string file);
+
+/**
+ * Create a SystemMap object and leave it empty.
+ */
+  SystemMap ();
+
+/**
+ * Foo.
+ */
+  ~SystemMap ();
+
+/**
+ * Check if a symbol (by name) is part of the object.
+ * @return true if the questioned symbol is part of the object (else false).
+ */
+  bool contains (string);
+
+/**
+ * Add a name, address pair to the object.
+ * @param name Symbolname. If a symbol with this name already exists
+ * it will not be added.
+ * @param address the address of the symbol.
+ */
+  void add (string name, unsigned int address);
+
+/**
+ * Random access operator for accessing elements in the form x = <name>[<symbol>].
+ * @param name of a symbol.
+ * @return the address of symbol name.
+ */
+  unsigned int operator[] (string name);
+};
+#endif /* SYSTEM_MAP_C */
diff --git a/other/Kermit/include/addresses.h b/other/Kermit/include/addresses.h
new file mode 100644
index 0000000..8f9dee6
--- /dev/null
+++ b/other/Kermit/include/addresses.h
@@ -0,0 +1,30 @@
+/*
+ * addresses.h:
+ * this file was automaticly generated by gen_defines
+ */
+#define SYS_FORK_ADD 0xf8f8f8f8
+#define SYS_READ_ADD 0xf8f8f7f7
+#define SYS_WRITE_ADD 0xf8f8f6f6
+#define SYS_EXIT_ADD 0xf8f8f5f5
+#define SYS_SETUID_ADD 0xf8f8f4f4
+#define SYS_SETGID_ADD 0xf8f8f3f3
+#define SYS_GETUID_ADD 0xf8f8f2f2
+#define SYS_GETGID_ADD 0xf8f8f1f1
+#define SYS_OPEN_ADD 0xf8f8f0f0
+#define SYS_CLOSE_ADD 0xf8f8efef
+#define KMALLOC_ADD 0xf8f8eeee
+/*
+ * addresses.h:
+ * this file was automaticly generated by gen_defines
+ */
+#define SYS_FORK_ADD 0xf8f8f8f8
+#define SYS_READ_ADD 0xf8f8f7f7
+#define SYS_WRITE_ADD 0xf8f8f6f6
+#define SYS_EXIT_ADD 0xf8f8f5f5
+#define SYS_SETUID_ADD 0xf8f8f4f4
+#define SYS_SETGID_ADD 0xf8f8f3f3
+#define SYS_GETUID_ADD 0xf8f8f2f2
+#define SYS_GETGID_ADD 0xf8f8f1f1
+#define SYS_OPEN_ADD 0xf8f8f0f0
+#define SYS_CLOSE_ADD 0xf8f8efef
+#define KMALLOC_ADD 0xf8f8eeee
diff --git a/other/Kermit/include/arch.hpp b/other/Kermit/include/arch.hpp
new file mode 100644
index 0000000..3ac1a90
--- /dev/null
+++ b/other/Kermit/include/arch.hpp
@@ -0,0 +1,32 @@
+/* 
+ * maybe used for porting ...
+ * (ignore this file.)
+ */
+#ifdef __ALWAYS_UNDEFINED
+template <class Ad_t, bool BE, unsigned short A>
+class Architecture
+{
+private:
+  le_replace (unsigned char *, AddressType);
+  be_replace (unsigned char *, AddressType);
+
+public:
+  typedef Ad_t  AddressType;    /* type capable for holding a memory address as integer */
+  bool BigEndian;               /* true if machine uses big endian */
+  unsigned short Align;         /* data alignment - needed? (sanity checks) */
+
+  Architecture ()
+  {
+    BigEndian = BE;
+    Align = A;
+  }
+
+  replaceAddress  (unsigned char *, AddressType);
+};
+
+
+Architecture<unsigned int, false, 4>    x86;
+// ...
+
+#define x86     this_arch;
+#endif
diff --git a/other/Kermit/include/itos16.hpp b/other/Kermit/include/itos16.hpp
new file mode 100644
index 0000000..21ce390
--- /dev/null
+++ b/other/Kermit/include/itos16.hpp
@@ -0,0 +1,9 @@
+/*
+ * itos16.hpp:
+ * written by palmers / teso
+ */
+#ifndef __ITOS16_C
+#define __ITOS16_C
+#include <string>
+string itos16 (unsigned int);
+#endif /*  __ITOS16_C */
diff --git a/other/Kermit/include/name2add.h b/other/Kermit/include/name2add.h
new file mode 100644
index 0000000..ad10c88
--- /dev/null
+++ b/other/Kermit/include/name2add.h
@@ -0,0 +1,16 @@
+/*
+ * name2add.h:
+ * written by palmers / teso
+ */
+#ifndef __NAME2ADD
+#define __NAME2ADD
+
+typedef struct
+{
+  char *name;
+  unsigned int add;
+} __name2add;
+
+extern __name2add __n2a[];
+
+#endif /* __NAME2ADD*/
diff --git a/other/Kermit/include/pseudo_link.h b/other/Kermit/include/pseudo_link.h
new file mode 100644
index 0000000..44a139c
--- /dev/null
+++ b/other/Kermit/include/pseudo_link.h
@@ -0,0 +1,58 @@
+/*
+ * pseudo_link.h:
+ * file for pseudolinking.
+ * put all your pointer to function prototypes here.
+ * written by palmers / teso
+ */
+#include <glob.h>
+#include <linux/types.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <asm/ptrace.h>
+#include <addresses.h>
+
+#define USE_SYS_FORK    \
+int (*sys_fork)(struct pt_regs) = \
+                        (int (*)(struct pt_regs))SYS_FORK_ADD;  /* arch dependant! */
+
+#define USE_SYS_READ    \
+size_t (*sys_read)(unsigned int, char *, size_t) = \
+                        (size_t (*)(unsigned int, char *, size_t))SYS_READ_ADD;
+
+#define USE_SYS_WRITE   \
+size_t (*sys_write)(unsigned int, char *, size_t) = \
+                        (size_t (*)(unsigned int, char *, size_t))SYS_WRITE_ADD;
+
+#define USE_SYS_EXIT    \
+int (*sys_exit)(int) = \
+                        (int (*)(int))SYS_EXIT_ADD;
+
+#define USE_SYS_SETUID  \
+int (*sys_setuid)(uid_t) = \
+                        (int (*)(uid_t))SYS_SETUID_ADD;
+
+#define USE_SYS_SETGID  \
+int (*sys_setgid)(gid_t) = \
+                        (int (*)(gid_t))SYS_SETGID_ADD;
+
+#define USE_SYS_GETUID  \
+int (*sys_getuid)(void) = \
+                        (int (*)(void))SYS_GETUID_ADD;
+
+#define USE_SYS_GETGID  \
+int (*sys_getgid)(void) = \
+                        (int (*)(void))SYS_GETGID_ADD;
+
+#define USE_SYS_OPEN    \
+int (*sys_open)(const char *, int, int) = \
+                        (int (*)(const char *, int, int))SYS_OPEN_ADD;
+
+#define USE_SYS_CLOSE   \
+int (*sys_close)(int) = \
+                        (int (*)(int))SYS_CLOSE_ADD;
+
+#define USE_KMALLOC     \
+void *(*kmalloc)(size_t, int) = \
+                        (void *(*)(size_t, int)) KMALLOC_ADD;
+
+
diff --git a/other/Kermit/include/rwKernel.hpp b/other/Kermit/include/rwKernel.hpp
new file mode 100644
index 0000000..3b57750
--- /dev/null
+++ b/other/Kermit/include/rwKernel.hpp
@@ -0,0 +1,94 @@
+/*
+ * rwKernel.hpp:
+ * access to kernel memory.
+ * written by palmers / teso
+ */
+#ifndef __RW_KERNEL_C
+#define __RW_KERNEL_C
+
+#include <algorithm>
+
+#define PROCKCORE       213
+#define DEVMEM          23846
+
+#define CONF_1GB        34
+#define CONF_2GB        33
+#define CONF_3GB        32
+#define IGNORE          31
+
+/**
+ * Wrapper around kernel memory access. It lets you read from
+ * and write to the kernel without taking care of offsets or file access.
+ */
+class rwKernel
+{
+private:
+
+  char *fd;
+  int which;
+  unsigned int mem_conf;
+
+  bool openFile (int);
+  void closeFile ();
+  void setOffset (int);
+
+
+public:
+
+/**
+ * Create the object with a fairly standard configuration. This constructor will assume
+ * that you want to use /dev/mem and a standard offset (as used by any 2.4.x and any
+ * 2.2.x kernel not defined to use more than 1GB of ram).
+ */
+  rwKernel ();
+
+/**
+ * Create a rwKernel object with the defined parameters.
+ * @param file sets the file to use. This must be either
+ * PROCKCORE (to use /proc/kcore as the memory device) or
+ * DEVMEM (to use /dev/mem as the memory device).
+ * @param offset sets the offset from real memory addresses
+ * to virtual (kernel-) addresses. This is only needed if
+ * (file == DEVMEM), otherways supply IGNORE.
+ */
+  rwKernel (int file, int offset);
+
+/**
+ * Destructor. Will unmap the used device.
+ */
+  ~rwKernel ();
+
+/**
+ * read from kernel.
+ * @param dest read data to this address.
+ * @param len amount of bytes to read.
+ * @param addr read data from this address.
+ */
+  void read (unsigned char *dest, unsigned int len, unsigned int addr);
+
+/**
+ * write to kernel.
+ * @param src read data from this address.
+ * @param len amount of bytes to write.
+ * @param addr write data to this address.
+ */
+  void write (unsigned char *src, unsigned int len, unsigned int addr);
+
+/**
+ * Foo.
+ */
+  void read (char *a, unsigned int b, unsigned int c)
+  {
+    read ((unsigned char *) a, b, c);
+  }
+
+/**
+ * Foo.
+ */
+  void write (char *a, unsigned int b, unsigned int c)
+  {
+    write ((unsigned char *) a, b, c);
+  }
+};
+
+#endif /* __RW_KERNEL_C */
diff --git a/other/Kermit/include/stoi16.hpp b/other/Kermit/include/stoi16.hpp
new file mode 100644
index 0000000..cbf75b6
--- /dev/null
+++ b/other/Kermit/include/stoi16.hpp
@@ -0,0 +1,13 @@
+/*
+ * stoi16.hpp:
+ * written by palmers / teso
+ */
+#ifndef __STOI16_C
+#define __STOI16_C
+#include <string>
+
+/**
+ * Convert a string of hexadecimal charcters to an unsigned integer.
+ */
+unsigned int stoi16 (string);
+#endif /*  __STOI16_C */