Complete accessors for InformationManager managed objects

[frida/frida.git] / src / core / InformationManager.cxx

diff --git a/src/core/InformationManager.cxx b/src/core/InformationManager.cxx
index 294dc2f53583b7e3a9c5ce6b8f33fd49427bf058..61daa3d269d094dc130ae80e82d51f3ac9871a89 100644 (file)
--- a/src/core/InformationManager.cxx
+++ b/src/core/InformationManager.cxx
@@ -8,6 +8,16 @@
 #include <quazip/quazip.h>
 #include <quazip/quazipfile.h>
 
+#include <QTemporaryFile>
+
+InformationManager* current_information_manager;
+
+InformationManager::InformationManager()
+       : logger(log4cxx::Logger::getLogger("core.InformationManager"))
+{
+       current_information_manager = this;
+}
+
 InformationManager::~InformationManager() {
        for (auto b : blocks)
                delete b.second;
@@ -17,17 +27,69 @@ InformationManager::~InformationManager() {
 }
 
 void InformationManager::reset(const std::string& filename) {
+       this->filename = filename;
        disassembler.reset(createLLVMDisassembler(filename, this));
        if (disassembler.get() != NULL)
                disassembler.get()->start();
 }
 
-void InformationManager::save(const QString& filename) {
-       QuaZip zip(filename);
+void InformationManager::load(const std::string& filename) {
+       QuaZip zip(filename.c_str());
+       QuaZipFile file(&zip);
+       QuaZipFileInfo info;
+
+       zip.open(QuaZip::mdUnzip);
+       tmpfile.reset(new QTemporaryFile());
+
+       {
+               LOG4CXX_INFO(logger, "Loading binary from archive");
+               zip.setCurrentFile("binary");
+               tmpfile->open();
+               file.open(QIODevice::ReadOnly);
+               QByteArray buffer;
+               while (!file.atEnd()) {
+                       buffer = file.read(4096);
+                       tmpfile->write(buffer);
+               }
+               tmpfile->flush();
+               file.close();
+               disassembler.reset(createLLVMDisassembler(tmpfile->fileName().toStdString(), this));
+       }
+
+       for (bool more = zip.goToFirstFile(); more; more = zip.goToNextFile()) {
+               zip.getCurrentFileInfo(&info);
+               file.open(QIODevice::ReadOnly);
+
+               if(info.name != "binary") {
+                       QXmlStreamReader reader(&file);
+                       assert(QXmlStreamReader::StartDocument == reader.readNext());
+                       assert(QXmlStreamReader::StartElement == reader.readNext());
+                       Function * fun = Function::deserialize(reader, this);
+               }
+               file.close();
+       }
+}
+
+void InformationManager::save(const std::string& filename) {
+       QuaZip zip(filename.c_str());
        zip.open(QuaZip::mdCreate);
        zip.setComment("FRIDA 0.0");
        QuaZipFile outZipFile(&zip);
 
+       {
+               QFile binary(this->filename.c_str());
+               binary.open(QIODevice::ReadOnly);
+               QuaZipNewInfo zipinfo("binary");
+               zipinfo.setPermissions(static_cast<QFile::Permissions>(0x6444));
+               outZipFile.open(QIODevice::WriteOnly, zipinfo);
+               QByteArray buffer;
+               while (!binary.atEnd()) {
+                       buffer = binary.read(4096);
+                       outZipFile.write(buffer);
+               }
+               outZipFile.close();
+       }
+
        for (auto funpair : functions) {
                Function* fun = funpair.second;
                QuaZipNewInfo zipinfo(fun->getName().c_str());
@@ -37,23 +99,9 @@ void InformationManager::save(const QString& filename) {
                stream.setAutoFormatting(true);
                stream.setAutoFormattingIndent(-1);
                stream.writeStartDocument();
-               stream.writeStartElement("function");
-               stream.writeAttribute("name", fun->getName().c_str());
-               stream.writeAttribute("entry", QString::number(fun->getStartAddress(), 16));
-
-               for (auto& blockentry : fun->blocks()) {
-                       stream.writeStartElement("block");
-                       stream.writeAttribute("id", blockentry.second->getName().c_str());
-                       stream.writeTextElement("start", QString::number(blockentry.second->getStartAddress(), 16));
-                       stream.writeTextElement("end", QString::number(blockentry.second->getEndAddress(), 16));
-                       if (0 != blockentry.second->getNextBlock(0))
-                               stream.writeTextElement("next", QString::number(blockentry.second->getNextBlock(0), 16));
-                       if (0 != blockentry.second->getNextBlock(1))
-                               stream.writeTextElement("next", QString::number(blockentry.second->getNextBlock(1), 16));
-                       stream.writeEndElement(); // "block"
-               }
 
-               stream.writeEndElement(); // "function"
+               fun->serialize(stream);
+
                stream.writeEndDocument();
                outZipFile.close();
        }
@@ -64,6 +112,12 @@ void InformationManager::save(const QString& filename) {
 void InformationManager::signal_new_function(Function* fun) {
 }
 
+
+
+/* *******************************
+ * Accessors for the Functions map
+ */
+
 Function* InformationManager::getFunction(uint64_t address) {
        auto it = functions.find(address);
        if (it != functions.end())
@@ -72,6 +126,18 @@ Function* InformationManager::getFunction(uint64_t address) {
                return NULL;
 }
 
+std::map<uint64_t, Function*>::const_iterator InformationManager::beginFunctions() {
+       return functions.begin();
+}
+std::map<uint64_t, Function*>::const_iterator InformationManager::endFunctions() {
+       return functions.end();
+}
+
+
+/* *********************************
+ * Accessors for the BasicBlocks map
+ */
+
 BasicBlock* InformationManager::getBasicBlock(uint64_t address) {
        auto it = blocks.find(address);
        if (it != blocks.end())
@@ -80,6 +146,19 @@ BasicBlock* InformationManager::getBasicBlock(uint64_t address) {
                return NULL;
 }
 
+std::map<uint64_t, BasicBlock*>::const_iterator InformationManager::beginBasicBlocks() {
+       return blocks.begin();
+}
+std::map<uint64_t, BasicBlock*>::const_iterator InformationManager::endBasicBlocks() {
+       return blocks.end();
+}
+
+
+
+/* ********************************
+ * Factory methods for data classes
+ */
+
 Function* InformationManager::newFunction(uint64_t address) {
        Function* fun = new Function(address, this);
        functions.insert(std::make_pair(address, fun));
@@ -101,6 +180,7 @@ Comment* InformationManager::newLocalComment(uint64_t address, Function* f) {
 }
 
 void InformationManager::finishFunction(Function* fun) {
+       LOG4CXX_DEBUG(logger, "Finishing function " << fun->getName());
        for (auto b : fun->blocks()) {
                BasicBlock* bl = b.second;
                blocks.insert(std::make_pair(bl->getStartAddress(), bl));