X-Git-Url: https://git.siccegge.de//index.cgi?p=frida%2Ffrida.git;a=blobdiff_plain;f=src%2Fgui%2FMainwindow.cxx;h=654dc16aafd6f7ad386b7840a15f155ba0b84531;hp=7d6b8d28b5b244ca965f3b435858f5596ef88a43;hb=788d2cf483ac868d2ce1e2007b578fc798853760;hpb=8e4fd3f1e861dcebaa853e73b32a8a0603aef793

diff --git a/src/gui/Mainwindow.cxx b/src/gui/Mainwindow.cxx
index 7d6b8d2..654dc16 100644
--- a/src/gui/Mainwindow.cxx
+++ b/src/gui/Mainwindow.cxx
@@ -1,116 +1,328 @@
- #include "Mainwindow.hxx"
-#include "widgets/BasicBlockWidget.hxx"
+#include "Mainwindow.hxx"
 #include "qt.hxx"
 #include "disassembler/llvm/LLVMDisassembler.hxx"
+#include "core/Function.hxx"
+#include "core/BasicBlock.hxx"
+#include "core/InformationManager.hxx"
+#include "widgets/ScriptingDock.hxx"
+#include "widgets/CFGScene.hxx"
+#include "widgets/FunctionWidget.hxx"
+#include "dialogs/NewFunctionDialog.hxx"
+#include "dialogs/SimpleStringDialog.hxx"
 
-#include <iostream>
 #include <sstream>
 
-#include <QtGui>
+namespace {
+	BasicBlockWidget *
+	local__add_basic_block(BasicBlock * block, 
+	                       Mainwindow * mainwindow, InformationManager * manager,
+	                       std::map<uint64_t, BasicBlockWidget*>& known_blocks,
+	                       CFGScene * scene, uint64_t starty, uint64_t startx);
+}
 
-Mainwindow::Mainwindow(const std::string& filename)
-{
-    openAction = new QAction(tr("&Open"), this);
-    // saveAction = new QAction(tr("&Save"), this);
-    exitAction = new QAction(tr("E&xit"), this);
+Mainwindow::Mainwindow(InformationManager* mgr)
+	: manager(mgr)
+	, logger(log4cxx::Logger::getLogger("Mainwindow")) {
+	openAction = new QAction(tr("&Open"), this);
+	loadAction = new QAction(tr("&Load"), this);
+	saveAction = new QAction(tr("&Save"), this);
+	exitAction = new QAction(tr("E&xit"), this);
+
+	connect(openAction, &QAction::triggered,
+	        this, &Mainwindow::open);
+	connect(loadAction, &QAction::triggered,
+	        this, &Mainwindow::load);
+	connect(saveAction, &QAction::triggered,
+	        this, &Mainwindow::save);
+	connect(exitAction, &QAction::triggered,
+	        qApp, &QApplication::quit);
 
-    connect(openAction, SIGNAL(triggered()), this, SLOT(open()));
-    // connect(saveAction, SIGNAL(triggered()), this, SLOT(save()));
-    connect(exitAction, SIGNAL(triggered()), qApp, SLOT(quit()));
+	fileMenu = menuBar()->addMenu(tr("&File"));
+	fileMenu->addAction(openAction);
+	fileMenu->addAction(loadAction);
+	fileMenu->addAction(saveAction);
+	fileMenu->addSeparator();
+	fileMenu->addAction(exitAction);
 
-    fileMenu = menuBar()->addMenu(tr("&File"));
-    fileMenu->addAction(openAction);
-    // fileMenu->addAction(saveAction);
-    fileMenu->addSeparator();
-    fileMenu->addAction(exitAction);
+	scripting = new ScriptingDock(tr("Scripting"), this);
+	scripting->setAllowedAreas(Qt::BottomDockWidgetArea);
+	addDockWidget(Qt::BottomDockWidgetArea, scripting);
 
-    listWidget = new QListWidget();
-    stackedWidget = new QStackedWidget();
-    dockWidget = new QDockWidget(tr("Functions"), this);
-    dockWidget->setAllowedAreas(Qt::LeftDockWidgetArea |
-                                Qt::RightDockWidgetArea);
-    dockWidget->setWidget(listWidget);
-    addDockWidget(Qt::LeftDockWidgetArea, dockWidget);
-    setCentralWidget(stackedWidget);
+	listWidget = new QTreeWidget();
+	listWidget->setColumnCount(1);
+	listWidget->setDragDropMode(QAbstractItemView::InternalMove);
+	listWidget->setContextMenuPolicy(Qt::CustomContextMenu);
+	connect(listWidget, SIGNAL(customContextMenuRequested(const QPoint&)),
+	        this, SLOT(showListContextMenu(const QPoint&)));
 
-    connect(listWidget, SIGNAL(currentRowChanged(int)),
-            stackedWidget, SLOT(setCurrentIndex(int)));
+	stackedWidget = new QStackedWidget();
+	dockWidget = new QDockWidget(tr("Functions"), this);
+	dockWidget->setAllowedAreas(Qt::LeftDockWidgetArea |
+	                            Qt::RightDockWidgetArea);
+	dockWidget->setWidget(listWidget);
+	addDockWidget(Qt::LeftDockWidgetArea, dockWidget);
+	setCentralWidget(stackedWidget);
+
+	connect(listWidget, &QTreeWidget::currentItemChanged,
+	        [=] (QTreeWidgetItem* current, QTreeWidgetItem*) {
+		        switchMainPlane(current);
+	        });
+
+	setWindowTitle(tr("FRIDA"));
+
+	QTreeWidgetItem * external = new QTreeWidgetItem(listWidget, QStringList("External Functions"));
+	external->setChildIndicatorPolicy(QTreeWidgetItem::ShowIndicator);
+	external->setBackground(0, QBrush(QColor(0xff, 0xdd, 0xdd)));
+	mgr->connect_new_function_signal([&] (Function* fun) {addFunction(fun);});
+	mgr->connect_new_dyn_symbol_signal([=] (const std::string& name) {
+			auto item = new QTreeWidgetItem(external, QStringList(name.c_str()));
+			item->setBackground(0, QBrush(QColor(0xff, 0xdd, 0xdd)));
+		});
+	setGlobalHotkeys();
+}
 
-    setWindowTitle(tr("FRIDA"));
+void Mainwindow::setGlobalHotkeys() {
+	QShortcut *shortcut = new QShortcut(QKeySequence("f"), this);
+	connect(shortcut, &QShortcut::activated, this, &Mainwindow::requestNewFunction);
 
-	openBinary(filename);
+	shortcut = new QShortcut(QKeySequence("r"), listWidget);
+	connect(shortcut, &QShortcut::activated, [=]() {
+			QTreeWidgetItem * item = listWidget->currentItem();
+			if (item) renameFunction(objects_list[item]->getFunction());
+		});
 }
 
 void Mainwindow::quit()
 {
-    QMessageBox messageBox;
-    messageBox.setWindowTitle(tr("Notepad"));
-    messageBox.setText(tr("Do you really want to quit?"));
-    messageBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
-    messageBox.setDefaultButton(QMessageBox::No);
-    if (messageBox.exec() == QMessageBox::Yes)
-        qApp->quit();
+	QMessageBox messageBox;
+	messageBox.setWindowTitle(tr("Frida"));
+	messageBox.setText(tr("Do you really want to quit?"));
+	messageBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
+	messageBox.setDefaultButton(QMessageBox::No);
+	if (messageBox.exec() == QMessageBox::Yes)
+		qApp->quit();
 }
 
 void Mainwindow::open() {
-    QString fileName = QFileDialog::getOpenFileName(this, tr("Open File"), "",
-                                                    tr("Binaries (*)"));
+	QString fileName = QFileDialog::getOpenFileName(this, tr("Open File"), "",
+	                                                tr("Binaries (*)"));
+	manager->reset(fileName.toStdString());
+}
 
-	openBinary(fileName.toStdString());
+void Mainwindow::load() {
+	QString fileName = QFileDialog::getOpenFileName(this, tr("Open File"), "",
+	                                                tr("Frida Archives (*.frida)"));
+	manager->load(fileName.toStdString());
 }
 
-void Mainwindow::openBinary(const std::string& filename) {
-    if (filename != "") {
-        disassembler.reset(new LLVMDisassembler(filename));
-		disassembler->forEachFunction([&](uint64_t address, Function* fun) {
-				populateSymbolInformation(fun);
-			});
-    }
+void Mainwindow::save() {
+	QString filename = QFileDialog::getSaveFileName(this, tr("Save File"), "", tr("Frida Archives (*.frida)"));
+	manager->save(filename.toStdString());
 }
 
-namespace {
-	void local__add_basic_block(BasicBlock * block, Disassembler * dis, QGraphicsScene * scene,
-								uint64_t starty, uint64_t startx) {
-		std::stringstream s;
-		s << "BLOCK_" << std::hex << block->getStartAddress()
-		  << "_" << block->getEndAddress();
-		BasicBlockWidget * widget = new BasicBlockWidget(s.str().c_str());
-		scene->addItem(widget);
-		widget->setFlag(QGraphicsItem::ItemIsMovable, true);
-		widget->moveBy(100*startx, 10*(block->getStartAddress() - starty));
+void Mainwindow::switchMainPlaneToAddress(uint64_t address) {
+	if (objects_list_by_address.find(address) != objects_list_by_address.end()) {
+		LOG4CXX_DEBUG(logger, "Switching to function " << std::hex << address);
+		QTreeWidgetItem * item = objects_list_by_address[address];
+		listWidget->setCurrentItem(item);
+		stackedWidget->setCurrentWidget(objects_list[item]);
+	} else {
+		LOG4CXX_DEBUG(logger, "No function at " << std::hex << address
+		              << " -- it's probably an imported Symbol");
+	}
+}
+
+void Mainwindow::switchMainPlane(QTreeWidgetItem* to) {
+	if (objects_list.end() != objects_list.find(to))
+		stackedWidget->setCurrentWidget(objects_list[to]);
+}
+
+void Mainwindow::showListContextMenu(const QPoint& point) {
+	QAction * act;
+	QTreeWidgetItem * item = listWidget->itemAt(point);
+	QMenu menu(this);
+
+	act = menu.addAction("Add Function");
+	connect(act, &QAction::triggered, this, &Mainwindow::requestNewFunction);
+
+	act = menu.addAction("Add Group");
+	connect(act, &QAction::triggered, this, &Mainwindow::requestNewGroup);
+
+	if (item) {
+		if (objects_list.find(item) != objects_list.end()) {
+			act = menu.addAction("Rename Function");
+			connect(act, &QAction::triggered, [=]() {this->renameFunction(objects_list[item]->getFunction());});
+		} else {
+			act = menu.addAction("Rename Group");
+			connect(act, &QAction::triggered, [=]() {renameGroup(item);});
+		}
+
+
+		QMenu* submenu = menu.addMenu("Move to group");
+
+		for (QTreeWidgetItem* groupitem : group_list) {
+			act = submenu->addAction(groupitem->text(0));
+			connect(act, &QAction::triggered,
+			        [=] () {
+				        listWidget->invisibleRootItem()->removeChild(item);
+				        groupitem->addChild(item);
+			        });
+		}
+	}
+
+	menu.exec(listWidget->mapToGlobal(point));
+}
 
-		dis->printEachInstruction(block->getStartAddress(), block->getEndAddress(),
-								  [&](uint8_t* bytes, size_t byte_count, const std::string& line) {
-									  widget->addItem(bytes, byte_count, line.c_str() + 1);
-								  });
+void Mainwindow::requestNewFunction() {
+	NewFunctionDialog dialog;
+	int result = dialog.exec();
+	if (QDialog::Accepted == result) {
+		requestNewFunctionByAddress(dialog.result());
+	} else {
+		LOG4CXX_DEBUG(logger, "requestNewFunction aborted");
+	}
+}
 
-		if (block->getNextBlock(0) != 0)
-			local__add_basic_block(dis->getBasicBlock(block->getNextBlock(0)), dis, scene, starty, startx+1);
-		if (block->getNextBlock(1) != 0)
-			local__add_basic_block(dis->getBasicBlock(block->getNextBlock(1)), dis, scene, starty, startx-1);
+void Mainwindow::requestNewGroup() {
+	SimpleStringDialog dialog("New Group");
+	int result = dialog.exec();
+	if (QDialog::Accepted == result) {
+		QTreeWidgetItem * external = new QTreeWidgetItem(listWidget, QStringList(dialog.result()));
+		external->setChildIndicatorPolicy(QTreeWidgetItem::ShowIndicator);
+		group_list.push_back(external);
+	} else {
+		LOG4CXX_DEBUG(logger, "requestNewGroup aborted");
 	}
 }
 
-void Mainwindow::populateSymbolInformation(Function* fun) {
-    QTabWidget * w = new QTabWidget();
+void Mainwindow::requestNewFunctionByAddress(uint64_t address) {
+	LOG4CXX_DEBUG(logger, "requesting Function at " << std::hex << address);
+	manager->getDisassembler()->disassembleFunctionAt(address);
+	switchMainPlaneToAddress(address);
+}
+
+void Mainwindow::renameFunction(Function* function) {
+	SimpleStringDialog dialog("New name");
+	int result = dialog.exec();
+	if (QDialog::Accepted == result) {
+		LOG4CXX_DEBUG(logger, "renaming Function " << function->getName()
+		              << " to " << dialog.result().toStdString());
+		function->setName(dialog.result().toStdString());
+		objects_list_by_address[function->getStartAddress()]->setText(0, dialog.result());
+	} else {
+		LOG4CXX_DEBUG(logger, "renameFunction aborted");
+	}
+}
 
-    // CFG
-    QGraphicsScene * scene = new QGraphicsScene;
+void Mainwindow::renameGroup(QTreeWidgetItem* item) {
+	SimpleStringDialog dialog("New name");
+	int result = dialog.exec();
+	if (QDialog::Accepted == result) {
+		LOG4CXX_DEBUG(logger, "renaming group " << item->text(0).toStdString()
+		              << " to " << dialog.result().toStdString());
+		item->setText(0, dialog.result());
+	} else {
+		LOG4CXX_DEBUG(logger, "renameFunction aborted");
+	}
+}
 
-	BasicBlock * block = disassembler->getBasicBlock(fun->getStartAddress());
+void Mainwindow::addFunction(Function* fun) {
+	if (functions.find(fun->getStartAddress()) != functions.end())
+		return;
 
-	local__add_basic_block(block, disassembler.get(), scene, block->getStartAddress(), 100);
+	functions.insert(std::make_pair(fun->getStartAddress(), fun));
 
-    QGraphicsView * view = new QGraphicsView(scene);
-    w->addTab(view, "CFG");
+	FunctionWidget * w = new FunctionWidget(fun);
 
-    // Listing
-    QTableWidget * t = new QTableWidget();
-    t->setColumnCount(3);
-    t->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
+	// CFG
+	CFGScene * scene = new CFGScene;
 
-    w->addTab(t, "Listing");
+	BasicBlock * block = manager->getBasicBlock(fun->getStartAddress());
 
-    listWidget->addItem(fun->getName().c_str());
-    stackedWidget->addWidget(w);
+	uint64_t start_address(std::numeric_limits<uint64_t>::max());
+	for (auto b : fun->blocks()) {
+		if (b.first < start_address)
+			start_address = b.first;
+	}
+
+	local__add_basic_block(block, this,
+	                       manager, blocks, scene, start_address, 100);
+
+	QGraphicsView * view = new QGraphicsView(scene);
+	w->addTab(view, "CFG");
+
+	// Listing
+	QTableWidget * t = new QTableWidget();
+	t->setColumnCount(3);
+	t->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
+
+	w->addTab(t, "Listing");
+
+	QTreeWidgetItem * item = new QTreeWidgetItem(listWidget, QStringList(fun->getName().c_str()));
+	stackedWidget->addWidget(w);
+	objects_list.insert(std::make_pair(item, w));
+	LOG4CXX_DEBUG(logger, "Adding function widget at " << std::hex
+	              << fun->getStartAddress());
+	objects_list_by_address.insert(std::make_pair(fun->getStartAddress(), item));
+}
+
+namespace {
+	BasicBlockWidget *
+	local__add_basic_block(BasicBlock * block,
+	                       Mainwindow * mainwindow, InformationManager * manager,
+	                       std::map<uint64_t, BasicBlockWidget*>& known_blocks,
+	                       CFGScene * scene, uint64_t starty, uint64_t startx) {
+
+		decltype(known_blocks.begin()) old;
+		if ((old = known_blocks.find(block->getStartAddress())) != known_blocks.end())
+			return old->second;
+
+		std::stringstream s;
+		s << "BLOCK_" << std::hex << block->getStartAddress()
+		  << "_" << block->getEndAddress();
+		BasicBlockWidget * widget = new BasicBlockWidget(s.str().c_str(),
+		                                                 block, mainwindow);
+
+		known_blocks.insert(std::make_pair(block->getStartAddress(), widget));
+
+		scene->addItem(widget);
+		widget->setFlag(QGraphicsItem::ItemIsMovable, true);
+		widget->moveBy(100*startx, block->getStartAddress() - starty);
+
+		manager->getDisassembler()
+			->printEachInstruction(block->getStartAddress(),
+			                       block->getEndAddress(),
+			                       [&](uint8_t* bytes,
+			                           size_t byte_count,
+			                           const std::string& line,
+			                           const std::string& ref) {
+				                       widget->addItem(bytes, byte_count,
+				                                       line.c_str() + 1, // remove \t
+				                                       ref.c_str());
+			                       });
+
+		BasicBlockWidget *tmp, *nextl(NULL), *nextr(NULL);
+		BasicBlock * tmpblock;
+		if (block->getNextBlock(0) != 0) {
+			int xshift = 0;
+			if (block->getNextBlock(1) != 0)
+				xshift = 1;
+			tmpblock = manager->getBasicBlock(block->getNextBlock(0));
+			tmp = local__add_basic_block(tmpblock, mainwindow, manager,
+			                             known_blocks,
+			                             scene, starty, startx+xshift);
+			nextl = tmp;
+			tmp->addPrevious(widget);
+		}
+		if (block->getNextBlock(1) != 0) {
+			tmpblock = manager->getBasicBlock(block->getNextBlock(1));
+			tmp = local__add_basic_block(tmpblock, mainwindow, manager,
+			                             known_blocks,
+			                             scene, starty, startx-1);
+			nextr = tmp;
+			tmp->addPrevious(widget);
+		}
+		widget->addNext(nextl, nextr);
+		return widget;
+	}
 }