initial

1 files changed, 204 insertions, 0 deletions

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 */