From dbf4d1f93e54251568854bff0ebc9c84f60857f6 Mon Sep 17 00:00:00 2001
From: Cyrille Bagard <nocbos@gmail.com>
Date: Sat, 26 Jul 2008 23:46:10 +0000
Subject: Parsed x86 binary data and displayed the result.
git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@6 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a
---
ChangeLog | 46 +++++
src/Makefile.am | 9 +-
src/arch/Makefile.am | 22 +++
src/arch/instruction-int.h | 59 ++++++
src/arch/instruction.c | 64 +++++++
src/arch/instruction.h | 43 +++++
src/arch/operand-int.h | 51 ++++++
src/arch/operand.c | 55 ++++++
src/arch/operand.h | 44 +++++
src/arch/processor-int.h | 66 +++++++
src/arch/processor.c | 95 ++++++++++
src/arch/processor.h | 49 +++++
src/arch/x86/Makefile.am | 20 ++
src/arch/x86/instruction.h | 65 +++++++
src/arch/x86/op_int.c | 63 +++++++
src/arch/x86/opcodes.h | 40 ++++
src/arch/x86/processor.c | 228 +++++++++++++++++++++++
src/arch/x86/processor.h | 42 +++++
src/binary.c | 78 ++++++++
src/binary.h | 42 +++++
src/editor.c | 23 ++-
src/format/Makefile.am | 2 +
src/format/elf/Makefile.am | 14 ++
src/format/elf/format_elf.c | 24 +++
src/format/elf/format_elf.h | 34 ++++
src/gtksnippet.c | 435 ++++++++++++++++++++++++++++++++++++++++++++
src/gtksnippet.h | 128 +++++++++++++
27 files changed, 1834 insertions(+), 7 deletions(-)
create mode 100644 src/arch/Makefile.am
create mode 100644 src/arch/instruction-int.h
create mode 100644 src/arch/instruction.c
create mode 100644 src/arch/instruction.h
create mode 100644 src/arch/operand-int.h
create mode 100644 src/arch/operand.c
create mode 100644 src/arch/operand.h
create mode 100644 src/arch/processor-int.h
create mode 100644 src/arch/processor.c
create mode 100644 src/arch/processor.h
create mode 100644 src/arch/x86/Makefile.am
create mode 100644 src/arch/x86/instruction.h
create mode 100644 src/arch/x86/op_int.c
create mode 100644 src/arch/x86/opcodes.h
create mode 100644 src/arch/x86/processor.c
create mode 100644 src/arch/x86/processor.h
create mode 100644 src/binary.c
create mode 100644 src/binary.h
create mode 100644 src/format/Makefile.am
create mode 100644 src/format/elf/Makefile.am
create mode 100644 src/format/elf/format_elf.c
create mode 100644 src/format/elf/format_elf.h
create mode 100644 src/gtksnippet.c
create mode 100644 src/gtksnippet.h
diff --git a/ChangeLog b/ChangeLog
index 33af36e..4ea154e 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,49 @@
+2008-07-27 Cyrille Bagard <nocbos@gmail.com>
+
+ * configure.ac:
+ Remove AC_PROG_RANLIB in favor of AC_PROG_LIBTOOL. Add AM_PROG_CC_C_O
+ and schedule the creation of the new Makefiles.
+
+ * src/arch/instruction.c:
+ * src/arch/instruction.h:
+ * src/arch/instruction-int.h:
+ * src/arch/Makefile.am:
+ * src/arch/operand.c:
+ * src/arch/operand.h:
+ * src/arch/operand-int.h:
+ * src/arch/processor.c:
+ * src/arch/processor.h:
+ * src/arch/processor-int.h:
+ * src/arch/x86/instruction.h:
+ * src/arch/x86/Makefile.am:
+ * src/arch/x86/opcodes.h:
+ * src/arch/x86/op_int.c:
+ * src/arch/x86/processor.c:
+ * src/arch/x86/processor.h:
+ New entries: parse x86 binary data and display the result.
+
+ * src/binary.c:
+ * src/binary.h:
+ New entries: load a basic ASM content.
+
+ * src/editor.c:
+ Set some fixed fonts and use the new code snippet. Update the GPL header
+ (Firebox Tools -> OpenIDA, version 2 -> version 3).
+
+ * src/format/elf/format_elf.c:
+ * src/format/elf/format_elf.h:
+ * src/format/elf/Makefile.am:
+ * src/format/Makefile.am:
+ New entries: empty files.
+
+ * src/gtksnippet.c:
+ * src/gtksnippet.h:
+ New entries: from an example from GTK.org, display assembly content.
+
+ * src/Makefile.am:
+ Add binary.[ch] and gtksnippet.[cg] files to openida_SOURCES and internal
+ libraries to openida_LDADD.
+
2008-07-23 Cyrille Bagard <nocbos@gmail.com>
* AUTHORS:
diff --git a/src/Makefile.am b/src/Makefile.am
index 07af7b5..aaa1ff3 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -2,7 +2,9 @@
bin_PROGRAMS=openida
openida_SOURCES = \
- editor.c
+ binary.h binary.c \
+ editor.c \
+ gtksnippet.h gtksnippet.c
INCLUDES = -I$(top_srcdir) -I$(top_srcdir)/intl $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) `pkg-config --cflags gthread-2.0`
@@ -15,4 +17,7 @@ AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS)
openida_LDFLAGS = $(LIBGTK_LIBS) -L/usr/X11R6/lib -ldl $(LIBXML_LIBS) `pkg-config --libs gthread-2.0`
-openida_LDADD = $(LIBINTL)
+openida_LDADD = $(LIBINTL) arch/libarch.a arch/x86/libarchx86.a format/elf/libformatelf.a
+
+
+SUBDIRS = arch format
diff --git a/src/arch/Makefile.am b/src/arch/Makefile.am
new file mode 100644
index 0000000..7f231de
--- /dev/null
+++ b/src/arch/Makefile.am
@@ -0,0 +1,22 @@
+
+lib_LIBRARIES = libarch.a
+
+libarch_a_SOURCES = \
+ instruction-int.h \
+ instruction.h instruction.c \
+ operand-int.h \
+ operand.h operand.c \
+ processor-int.h \
+ processor.h processor.c
+
+libarch_a_CFLAGS = $(AM_CFLAGS)
+
+
+INCLUDES =
+
+AM_CPPFLAGS =
+
+AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS)
+
+
+SUBDIRS = x86
diff --git a/src/arch/instruction-int.h b/src/arch/instruction-int.h
new file mode 100644
index 0000000..11180dc
--- /dev/null
+++ b/src/arch/instruction-int.h
@@ -0,0 +1,59 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * instruction.h - prototypes pour la définition générique interne des instructions
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ARCH_INSTRUCTION_INT_H
+#define _ARCH_INSTRUCTION_INT_H
+
+
+#include "instruction.h"
+#include "operand.h"
+
+
+#include "operand-int.h" /* TODO: remove me */
+
+
+
+
+#define MAX_OPERANDS 4
+
+
+#define DB_OPCODE 0x00
+
+
+/* Définition générique d'une instruction */
+struct _asm_instr
+{
+ char opcode;
+
+ asm_operand operands[MAX_OPERANDS];
+ unsigned int operands_count; /* Nbre. d'opérandes utilisées */
+
+
+};
+
+#define ASM_INSTRUCTION(instr) ((asm_instr *)instr)
+
+
+
+
+#endif /* _ARCH_INSTRUCTION_INT_H */
diff --git a/src/arch/instruction.c b/src/arch/instruction.c
new file mode 100644
index 0000000..1af3b97
--- /dev/null
+++ b/src/arch/instruction.c
@@ -0,0 +1,64 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * instruction.c - gestion générique des instructions
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "instruction.h"
+
+
+#include <malloc.h>
+
+
+#include "instruction-int.h"
+
+
+
+/******************************************************************************
+* *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des données à analyser. *
+* *
+* Description : Crée une instruction de type 'db' à partir de données. *
+* *
+* Retour : Instruction mise en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+asm_instr *create_db_instruction(const char *data, off_t *pos, off_t len)
+{
+ asm_instr *result; /* Représentation à renvoyer */
+
+ result = (asm_instr *)calloc(1, sizeof(asm_instr));
+
+ result->opcode = DB_OPCODE;
+
+ /* TODO: check result */
+ fill_db_operand(&result->operands[0], data[(*pos)++]);
+
+ result->operands_count = 1;
+
+ return result;
+
+}
+
diff --git a/src/arch/instruction.h b/src/arch/instruction.h
new file mode 100644
index 0000000..3be2bf7
--- /dev/null
+++ b/src/arch/instruction.h
@@ -0,0 +1,43 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * instruction.h - prototypes pour la gestion générique des instructions
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ARCH_INSTRUCTION_H
+#define _ARCH_INSTRUCTION_H
+
+
+#include <sys/types.h>
+
+
+
+/* Définition générique d'une instruction */
+typedef struct _asm_instr asm_instr;
+
+
+
+/* Crée une instruction de type 'db' à partir de données. */
+asm_instr *create_db_instruction(const char *, off_t *, off_t);
+
+
+
+
+#endif /* _ARCH_INSTRUCTION_H */
diff --git a/src/arch/operand-int.h b/src/arch/operand-int.h
new file mode 100644
index 0000000..f09d9a9
--- /dev/null
+++ b/src/arch/operand-int.h
@@ -0,0 +1,51 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * operand-int.h - prototypes pour la définition générique interne des opérandes
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ARCH_OPERAND_INT_H
+#define _ARCH_OPERAND_INT_H
+
+
+#include <stdint.h>
+
+
+
+
+/* Définition générique d'une opérande */
+struct _asm_operand
+{
+
+
+ union
+ {
+ uint8_t val8; /* Valeur sur 8 bits */
+
+
+ } value;
+
+
+
+};
+
+
+
+#endif /* _ARCH_OPERAND_INT_H */
diff --git a/src/arch/operand.c b/src/arch/operand.c
new file mode 100644
index 0000000..98460c9
--- /dev/null
+++ b/src/arch/operand.c
@@ -0,0 +1,55 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * operand.c - gestion générique des opérandes
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "operand.h"
+
+
+#include "operand-int.h"
+
+
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : operand = structure dont le contenu est à définir. *
+* value = valeur immédiate à renseigner. *
+* *
+* Description : Crée une opérande pour l'instruction 'db'. *
+* *
+* Retour : true si l'opérande a été définie avec succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool fill_db_operand(asm_operand *operand, uint8_t value)
+{
+ operand->value.val8 = value;
+
+ return true;
+
+}
+
+
diff --git a/src/arch/operand.h b/src/arch/operand.h
new file mode 100644
index 0000000..81c9a53
--- /dev/null
+++ b/src/arch/operand.h
@@ -0,0 +1,44 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * operand.h - prototypes pour la gestion générique des opérandes
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ARCH_OPERAND_H
+#define _ARCH_OPERAND_H
+
+
+#include <stdbool.h>
+#include <stdint.h>
+
+
+
+/* Définition générique d'une opérande */
+typedef struct _asm_operand asm_operand;
+
+
+
+/* Crée une opérande pour l'instruction 'db'. */
+bool fill_db_operand(asm_operand *, uint8_t);
+
+
+
+
+#endif /* _ARCH_OPERAND_H */
diff --git a/src/arch/processor-int.h b/src/arch/processor-int.h
new file mode 100644
index 0000000..602bab6
--- /dev/null
+++ b/src/arch/processor-int.h
@@ -0,0 +1,66 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * processor.h - prototypes pour la définition générique interne des architectures
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ARCH_PROCESSOR_INT_H
+#define _ARCH_PROCESSOR_INT_H
+
+
+#include <sys/types.h>
+
+
+#include "instruction.h"
+#include "processor.h"
+
+
+
+
+typedef int AsmSyntax;
+
+
+/* Décode une instruction dans un flux de données. */
+typedef asm_instr * (* fetch_instruction) (const asm_processor *, const char *, off_t *, off_t);
+
+/* Traduit une instruction en version humainement lisible. */
+typedef void (* print_instruction) (const asm_processor *, const asm_instr *, char *, size_t, AsmSyntax);
+
+
+
+/* Définition générique d'une architecture */
+struct _asm_processor
+{
+
+ fetch_instruction fetch_instr; /* Lecture d'une instruction */
+
+ print_instruction print_instr; /* Version lisible d'une instr.*/
+
+
+};
+
+
+#define ASM_PROCESSOR(proc) ((asm_processor *)proc)
+
+
+
+
+
+#endif /* _ARCH_PROCESSOR_INT_H */
diff --git a/src/arch/processor.c b/src/arch/processor.c
new file mode 100644
index 0000000..fc59fdb
--- /dev/null
+++ b/src/arch/processor.c
@@ -0,0 +1,95 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * processor.c - gestion générique des architectures
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "processor.h"
+
+
+#include "processor-int.h"
+
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : proc = architecture visée par la procédure. *
+* data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des données à analyser. *
+* *
+* Description : Décode une instruction dans un flux de données. *
+* *
+* Retour : Instruction mise en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+asm_instr *decode_instruction(const asm_processor *proc, const char *data, off_t *pos, off_t len)
+{
+ asm_instr *result; /* Représentation à renvoyer */
+
+
+
+
+ result = proc->fetch_instr(proc, data, pos, len);
+
+
+#define NULL ((void *)0)
+
+
+ if (result == NULL)
+ result = create_db_instruction(data, pos, len);
+
+
+
+
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : proc = architecture visée par la procédure. *
+* instr = instruction à traiter. *
+* buffer = tampon de sortie mis à disposition. [OUT] *
+* len = taille de ce tampon. *
+* syntax = type de représentation demandée. *
+* *
+* Description : Traduit une instruction en version humainement lisible. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void print_hinstruction(const asm_processor *proc, const asm_instr *instr, char *buffer, size_t len/*, AsmSyntax syntax*/)
+{
+ proc->print_instr(proc, instr, buffer, len, 0);
+
+}
+
+
diff --git a/src/arch/processor.h b/src/arch/processor.h
new file mode 100644
index 0000000..1023d45
--- /dev/null
+++ b/src/arch/processor.h
@@ -0,0 +1,49 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * processor.h - prototypes pour la gestion générique des architectures
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ARCH_PROCESSOR_H
+#define _ARCH_PROCESSOR_H
+
+
+#include <sys/types.h>
+
+
+#include "instruction.h"
+
+
+
+/* Définition générique d'une architecture */
+typedef struct _asm_processor asm_processor;
+
+
+
+/* Décode une instruction dans un flux de données. */
+asm_instr *decode_instruction(const asm_processor *, const char *, off_t *, off_t);
+
+/* Traduit une instruction en version humainement lisible. */
+void print_hinstruction(const asm_processor *, const asm_instr *, char *, size_t);
+
+
+
+
+#endif /* _ARCH_PROCESSOR_H */
diff --git a/src/arch/x86/Makefile.am b/src/arch/x86/Makefile.am
new file mode 100644
index 0000000..6fe55c8
--- /dev/null
+++ b/src/arch/x86/Makefile.am
@@ -0,0 +1,20 @@
+
+lib_LIBRARIES = libarchx86.a
+
+libarchx86_a_SOURCES = \
+ instruction.h \
+ op_int.c \
+ opcodes.h \
+ processor.h processor.c
+
+libarchx86_a_CFLAGS = $(AM_CFLAGS)
+
+
+INCLUDES =
+
+AM_CPPFLAGS =
+
+AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS)
+
+
+SUBDIRS =
diff --git a/src/arch/x86/instruction.h b/src/arch/x86/instruction.h
new file mode 100644
index 0000000..47617ea
--- /dev/null
+++ b/src/arch/x86/instruction.h
@@ -0,0 +1,65 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * instruction.h - prototypes pour la gestion des instructions de l'architecture x86
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ARCH_X86_INSTRUCTION_H
+#define _ARCH_X86_INSTRUCTION_H
+
+
+#include "../instruction.h"
+#include "../instruction-int.h"
+
+
+
+/* Définition d'une instruction x86 */
+typedef struct _asm_x86_instr asm_x86_instr;
+
+
+
+/* Enumération de tous les opcodes */
+typedef enum _X86Opcodes
+{
+ X86_OP_INT, /* int (0xcd) */
+
+
+ X86_OP_COUNT
+
+} X86Opcodes;
+
+
+
+
+/* Définition d'une instruction x86 */
+struct _asm_x86_instr
+{
+ asm_instr base; /* A laisser en premier... */
+
+ X86Opcodes type;
+
+};
+
+
+
+
+
+
+#endif /* _ARCH_X86_INSTRUCTION_H */
diff --git a/src/arch/x86/op_int.c b/src/arch/x86/op_int.c
new file mode 100644
index 0000000..e7805e1
--- /dev/null
+++ b/src/arch/x86/op_int.c
@@ -0,0 +1,63 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * op_int.c - décodage des instructions d'interruption
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <malloc.h>
+
+
+#include "instruction.h"
+#include "../instruction-int.h"
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des données à analyser. *
+* *
+* Description : Décode une instruction de type 'int'. *
+* *
+* Retour : Instruction mise en place ou NULL. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+asm_x86_instr *read_instr_int(const char *data, off_t *pos, off_t len)
+{
+ asm_x86_instr *result;
+
+ result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+
+ ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+
+ /* TODO: check result */
+ fill_db_operand(&ASM_INSTRUCTION(result)->operands[0], data[(*pos)++]);
+
+ ASM_INSTRUCTION(result)->operands_count = 1;
+
+ return result;
+
+}
+
diff --git a/src/arch/x86/opcodes.h b/src/arch/x86/opcodes.h
new file mode 100644
index 0000000..17316e7
--- /dev/null
+++ b/src/arch/x86/opcodes.h
@@ -0,0 +1,40 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * opcodes.h - prototypes pour la liste de tous les opcodes de l'architecture x86
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ARCH_X86_OPCODES_H
+#define _ARCH_X86_OPCODES_H
+
+
+#include <sys/types.h>
+
+
+#include "../instruction.h"
+
+
+
+/* Décode une instruction de type 'int'. */
+asm_x86_instr *read_instr_int(const char *, off_t *, off_t);
+
+
+
+#endif /* _ARCH_X86_OPCODES_H */
diff --git a/src/arch/x86/processor.c b/src/arch/x86/processor.c
new file mode 100644
index 0000000..4ef1377
--- /dev/null
+++ b/src/arch/x86/processor.c
@@ -0,0 +1,228 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * processor.c - gestion de l'architecture x86
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "processor.h"
+
+
+#include "../processor-int.h"
+#include "instruction.h"
+#include "opcodes.h"
+
+
+#include <malloc.h>
+
+
+
+typedef asm_x86_instr * (* read_instr) (const char *, off_t *, off_t);
+
+
+/* Carte d'identité d'un opcode */
+typedef struct _x86_opcode
+{
+ char opcode; /* Opcode + préfixe eventuel */
+ const char *name; /* Désignation humaine */
+ read_instr read; /* Décodage de l'instruction */
+
+} x86_opcode;
+
+
+#define register_opcode(target, bin, n, func) \
+do {\
+target.opcode = bin; \
+target.name = n; \
+target.read = func; \
+} while (0)
+
+
+/* Définition générique d'une architecture */
+typedef struct _asm_x86_processor
+{
+ asm_processor base; /* A laisser en premier... */
+
+ x86_opcode opcodes[X86_OP_COUNT]; /* Liste des opcodes supportés */
+
+} asm_x86_processor;
+
+
+
+
+
+/* Enregistre toutes les instructions reconnues pour x86. */
+void x86_register_instructions(asm_x86_processor *);
+
+
+/* Décode une instruction dans un flux de données. */
+asm_instr *x86_fetch_instruction(const asm_x86_processor *, const char *, off_t *, off_t);
+
+/* Traduit une instruction en version humainement lisible. */
+void x86_print_instruction(const asm_x86_processor *, const asm_x86_instr *, char *, size_t, AsmSyntax);
+
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : - *
+* *
+* Description : Crée le support de l'architecture x86. *
+* *
+* Retour : Architecture mise en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+asm_processor *create_x86_processor(void)
+{
+ asm_x86_processor *result; /* Architecture à retourner */
+
+ result = (asm_x86_processor *)calloc(1, sizeof(asm_x86_processor));
+
+ x86_register_instructions(result);
+
+ ASM_PROCESSOR(result)->fetch_instr = x86_fetch_instruction;
+ ASM_PROCESSOR(result)->print_instr = x86_print_instruction;
+
+ return ASM_PROCESSOR(result);
+
+}
+
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : proc = architecture visée par la procédure. *
+* *
+* Description : Enregistre toutes les instructions reconnues pour x86. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void x86_register_instructions(asm_x86_processor *proc)
+{
+
+
+
+ register_opcode(proc->opcodes[X86_OP_INT], 0xcd, "int", read_instr_int);
+
+
+
+
+
+}
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : proc = architecture visée par la procédure. *
+* data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des données à analyser. *
+* *
+* Description : Décode une instruction dans un flux de données. *
+* *
+* Retour : Instruction mise en place ou NULL. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+asm_instr *x86_fetch_instruction(const asm_x86_processor *proc, const char *data, off_t *pos, off_t len)
+{
+ asm_x86_instr *result; /* Résultat à faire remonter */
+ X86Opcodes i; /* Boucle de parcours */
+
+ result = NULL;
+
+ //printf("--------\n");
+
+ for (i = 0; i < X86_OP_COUNT; i++)
+ {
+
+ /*
+ printf(" cmp :: 0x%02hhx vs 0x%02hhx ? %d\n",
+ data[*pos], proc->opcodes[i].opcode,
+ data[*pos] == proc->opcodes[i].opcode);
+ */
+
+ if (data[*pos] == proc->opcodes[i].opcode)
+ {
+ result = proc->opcodes[i].read(data, pos, len);
+ if (result != NULL) result->type = i;
+ break;
+ }
+
+ }
+
+
+ return ASM_INSTRUCTION(result);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : proc = architecture visée par la procédure. *
+* instr = instruction à traiter. *
+* buffer = tampon de sortie mis à disposition. [OUT] *
+* len = taille de ce tampon. *
+* syntax = type de représentation demandée. *
+* *
+* Description : Traduit une instruction en version humainement lisible. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void x86_print_instruction(const asm_x86_processor *proc, const asm_x86_instr *instr, char *buffer, size_t len, AsmSyntax syntax)
+{
+
+ if (ASM_INSTRUCTION(instr)->opcode == DB_OPCODE)
+
+
+ snprintf(buffer, len, "db\t0x%02hhx", ASM_INSTRUCTION(instr)->operands[0].value.val8);
+
+
+ else
+
+ snprintf(buffer, len, "%s\t0x%02hhx", proc->opcodes[instr->type].name, ASM_INSTRUCTION(instr)->operands[0].value.val8);
+
+
+}
+
+
+
+
+
+
+
diff --git a/src/arch/x86/processor.h b/src/arch/x86/processor.h
new file mode 100644
index 0000000..0bd587d
--- /dev/null
+++ b/src/arch/x86/processor.h
@@ -0,0 +1,42 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * processor.h - prototypes pour la gestion de l'architecture x86
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ARCH_X86_PROCESSOR_H
+#define _ARCH_X86_PROCESSOR_H
+
+
+#include "../instruction.h"
+#include "../processor.h"
+
+
+
+/* Crée le support de l'architecture x86. */
+asm_processor *create_x86_processor(void);
+
+
+
+
+
+
+
+#endif /* _ARCH_X86_PROCESSOR_H */
diff --git a/src/binary.c b/src/binary.c
new file mode 100644
index 0000000..79928d6
--- /dev/null
+++ b/src/binary.c
@@ -0,0 +1,78 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * binary.c - traitement des flots de code binaire
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "binary.h"
+
+
+#include "arch/processor.h"
+
+
+
+void fill_snippet(GtkSnippet *snippet)
+{
+ asm_processor *proc;
+ asm_instr *instr;
+
+ // char *data = "\x66\xba\x0c\x00\x00\x00\x66\xb9\x28\x00\x00\x00\x66\xbb\x01\x00\x00\x00\x66\xb8\x04\x00\x00\x00\xcd\x80\x66\xbb\x00\x00\x00\x00\x66\xb8\x01\x00\x00\x00\xcd\x80\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x0a";
+
+ char *data = "\x66\xbb\x00\x00\x00\x00\x66\xb8\x01\x00\x00\x00\xcd\x80\x90";
+
+ off_t pos;
+ off_t len;
+
+ char buffer[64];
+
+ uint64_t base = 0;
+ uint64_t offset = 0;
+
+ proc = create_x86_processor();
+
+ pos = 0;
+ len = 15;
+
+
+
+ gtk_snippet_set_processor(snippet, proc);
+
+
+ gtk_snippet_add_line(snippet, offset, NULL, "Simple HelloWorld !");
+
+
+ while (pos < len)
+ {
+ offset = base + pos;
+
+ instr = decode_instruction(proc, data, &pos, len);
+
+ gtk_snippet_add_line(snippet, offset, instr, NULL);
+
+
+ }
+
+ /*
+ gtk_snippet_build_content(snippet);
+ */
+
+
+}
+
diff --git a/src/binary.h b/src/binary.h
new file mode 100644
index 0000000..a6295c9
--- /dev/null
+++ b/src/binary.h
@@ -0,0 +1,42 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * binary.h - prototypes pour le traitement des flots de code binaire
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _BINARY_H
+#define _BINARY_H
+
+
+#include "gtksnippet.h"
+
+
+
+
+void fill_snippet(GtkSnippet *snippet);
+
+
+
+
+
+
+
+
+#endif /* _BINARY_H */
diff --git a/src/editor.c b/src/editor.c
index 3614379..1c33296 100644
--- a/src/editor.c
+++ b/src/editor.c
@@ -1,17 +1,17 @@
-/* Firebox Tools - Outils de configurations pour le WM Firebox
+/* OpenIDA - Outils de configurations pour le WM Firebox
* editor.c - fichier principal de l'éditeur de configuration
*
* Copyright (C) 2006-2007 Cyrille Bagard
*
- * This file is part of Firebox Tools.
+ * This file is part of OpenIDA.
*
- * Firebox Tools is free software; you can redistribute it and/or modify
+ * OpenIDA is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
- * Firebox Tools is distributed in the hope that it will be useful,
+ * OpenIDA is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
@@ -49,6 +49,10 @@
/** Partie ptrace() **/
+#include "binary.h"
+#include "gtksnippet.h"
+
+
#define _(str) str
@@ -426,7 +430,12 @@ GtkWidget *create_editor(void)
gtk_paned_pack1 (GTK_PANED (hpaned1), scrolledwindow2, FALSE, TRUE);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_SHADOW_IN);
+ textview2 = gtk_snippet_new();
+ gtk_snippet_set_sel(GTK_SNIPPET(textview2), 44);
+ fill_snippet(textview2);
+ /*
textview2 = gtk_text_view_new ();
+ */
gtk_widget_show (textview2);
gtk_container_add (GTK_CONTAINER (scrolledwindow2), textview2);
@@ -531,6 +540,7 @@ GtkWidget *create_editor(void)
gtk_misc_set_alignment (GTK_MISC (label12), 0, 0.5);
lbl_eax = label12;
+ gtk_widget_modify_font(lbl_eax, pango_font_description_from_string ("Monospace"));
label14 = gtk_label_new (_("0x00000000"));
gtk_widget_show (label14);
@@ -540,6 +550,7 @@ GtkWidget *create_editor(void)
gtk_misc_set_alignment (GTK_MISC (label14), 0, 0.5);
lbl_ebx = label14;
+ gtk_widget_modify_font(lbl_ebx, pango_font_description_from_string ("Monospace 10"));
label15 = gtk_label_new (_("0x00000000"));
gtk_widget_show (label15);
@@ -549,6 +560,7 @@ GtkWidget *create_editor(void)
gtk_misc_set_alignment (GTK_MISC (label15), 0, 0.5);
lbl_ecx = label15;
+ gtk_widget_modify_font(lbl_ecx, pango_font_description_from_string ("Monospace 10"));
label16 = gtk_label_new (_("0x00000000"));
gtk_widget_show (label16);
@@ -558,6 +570,7 @@ GtkWidget *create_editor(void)
gtk_misc_set_alignment (GTK_MISC (label16), 0, 0.5);
lbl_edx = label16;
+ gtk_widget_modify_font(lbl_edx, pango_font_description_from_string ("Monospace 10"));
label17 = gtk_label_new (_("0x00000000"));
gtk_widget_show (label17);
diff --git a/src/format/Makefile.am b/src/format/Makefile.am
new file mode 100644
index 0000000..99afa2e
--- /dev/null
+++ b/src/format/Makefile.am
@@ -0,0 +1,2 @@
+
+SUBDIRS = elf
diff --git a/src/format/elf/Makefile.am b/src/format/elf/Makefile.am
new file mode 100644
index 0000000..3cf5f1c
--- /dev/null
+++ b/src/format/elf/Makefile.am
@@ -0,0 +1,14 @@
+
+lib_LIBRARIES = libformatelf.a
+
+libformatelf_a_SOURCES = \
+ format_elf.h format_elf.c
+
+libformatelf_a_CFLAGS = $(AM_CFLAGS)
+
+
+INCLUDES =
+
+AM_CPPFLAGS =
+
+AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS)
diff --git a/src/format/elf/format_elf.c b/src/format/elf/format_elf.c
new file mode 100644
index 0000000..f043d0a
--- /dev/null
+++ b/src/format/elf/format_elf.c
@@ -0,0 +1,24 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * format_elf.c - support du format ELF
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "elf.h"
diff --git a/src/format/elf/format_elf.h b/src/format/elf/format_elf.h
new file mode 100644
index 0000000..894623a
--- /dev/null
+++ b/src/format/elf/format_elf.h
@@ -0,0 +1,34 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * format_elf.h - prototypes pour le support du format ELF
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _FORMAT_ELF_H
+#define _FORMAT_ELF_H
+
+
+
+
+
+
+
+
+#endif /* _FORMAT_ELF_H */
diff --git a/src/gtksnippet.c b/src/gtksnippet.c
new file mode 100644
index 0000000..a7eecb5
--- /dev/null
+++ b/src/gtksnippet.c
@@ -0,0 +1,435 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * gtksnippet.h - affichage d'un fragment de code d'assemblage
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "gtksnippet.h"
+
+
+#include <malloc.h>
+#include <string.h>
+
+
+#define CONTENT_BUFFER_LEN 64
+
+
+
+static void gtk_snippet_class_init(GtkSnippetClass *klass);
+static void gtk_snippet_init(GtkSnippet *cpu);
+static void gtk_snippet_size_request(GtkWidget *widget,
+ GtkRequisition *requisition);
+static void gtk_snippet_size_allocate(GtkWidget *widget,
+ GtkAllocation *allocation);
+static void gtk_snippet_realize(GtkWidget *widget);
+static gboolean gtk_snippet_expose(GtkWidget *widget,
+ GdkEventExpose *event);
+static void gtk_snippet_paint(GtkWidget *widget);
+static void gtk_snippet_destroy(GtkObject *object);
+
+
+GtkType
+gtk_snippet_get_type(void)
+{
+ static GtkType gtk_snippet_type = 0;
+
+
+ if (!gtk_snippet_type) {
+ static const GtkTypeInfo gtk_snippet_info = {
+ "GtkSnippet",
+ sizeof(GtkSnippet),
+ sizeof(GtkSnippetClass),
+ (GtkClassInitFunc) gtk_snippet_class_init,
+ (GtkObjectInitFunc) gtk_snippet_init,
+ NULL,
+ NULL,
+ (GtkClassInitFunc) NULL
+ };
+ gtk_snippet_type = gtk_type_unique(GTK_TYPE_WIDGET, >k_snippet_info);
+ }
+
+
+ return gtk_snippet_type;
+}
+
+void
+gtk_snippet_set_state(GtkSnippet *cpu, gint num)
+{
+ cpu->sel = num;
+ gtk_snippet_paint(GTK_WIDGET(cpu));
+}
+
+
+GtkWidget * gtk_snippet_new()
+{
+ GtkSnippet *result;
+
+ result = gtk_type_new(gtk_snippet_get_type());
+
+ return GTK_WIDGET(result);
+
+}
+
+
+static void
+gtk_snippet_class_init(GtkSnippetClass *klass)
+{
+ GtkWidgetClass *widget_class;
+ GtkObjectClass *object_class;
+
+
+ widget_class = (GtkWidgetClass *) klass;
+ object_class = (GtkObjectClass *) klass;
+
+ widget_class->realize = gtk_snippet_realize;
+ widget_class->size_request = gtk_snippet_size_request;
+ widget_class->size_allocate = gtk_snippet_size_allocate;
+ widget_class->expose_event = gtk_snippet_expose;
+
+ object_class->destroy = gtk_snippet_destroy;
+}
+
+
+static void
+gtk_snippet_init(GtkSnippet *snippet)
+{
+ snippet->sel = 0;
+}
+
+
+static void
+gtk_snippet_size_request(GtkWidget *widget,
+ GtkRequisition *requisition)
+{
+ g_return_if_fail(widget != NULL);
+ g_return_if_fail(GTK_IS_SNIPPET(widget));
+ g_return_if_fail(requisition != NULL);
+
+ requisition->width = 80;
+ requisition->height = 100;
+}
+
+
+static void
+gtk_snippet_size_allocate(GtkWidget *widget,
+ GtkAllocation *allocation)
+{
+ g_return_if_fail(widget != NULL);
+ g_return_if_fail(GTK_IS_SNIPPET(widget));
+ g_return_if_fail(allocation != NULL);
+
+ widget->allocation = *allocation;
+
+ if (GTK_WIDGET_REALIZED(widget)) {
+ gdk_window_move_resize(
+ widget->window,
+ allocation->x, allocation->y,
+ allocation->width, allocation->height
+ );
+ }
+}
+
+
+static void
+gtk_snippet_realize(GtkWidget *widget)
+{
+ GdkWindowAttr attributes;
+ guint attributes_mask;
+
+ g_return_if_fail(widget != NULL);
+ g_return_if_fail(GTK_IS_SNIPPET(widget));
+
+ GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
+
+ attributes.window_type = GDK_WINDOW_CHILD;
+ attributes.x = widget->allocation.x;
+ attributes.y = widget->allocation.y;
+ attributes.width = widget->allocation.width;
+ attributes.height = widget->allocation.height;
+
+ printf("(%d x %d)\n", widget->allocation.width, widget->allocation.height);
+
+ attributes.wclass = GDK_INPUT_OUTPUT;
+ attributes.event_mask = gtk_widget_get_events(widget) | GDK_EXPOSURE_MASK;
+
+ attributes_mask = GDK_WA_X | GDK_WA_Y;
+
+ widget->window = gdk_window_new(
+ gtk_widget_get_parent_window (widget),
+ & attributes, attributes_mask
+ );
+
+ gdk_window_set_user_data(widget->window, widget);
+
+ widget->style = gtk_style_attach(widget->style, widget->window);
+ gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL);
+
+
+ GTK_SNIPPET(widget)->layout = gtk_widget_create_pango_layout(widget, NULL);
+ GTK_SNIPPET(widget)->gc = gdk_gc_new(GDK_DRAWABLE(widget->window));
+
+ gtk_snippet_build_content(GTK_SNIPPET(widget));
+
+}
+
+
+static gboolean
+gtk_snippet_expose(GtkWidget *widget,
+ GdkEventExpose *event)
+{
+ g_return_val_if_fail(widget != NULL, FALSE);
+ g_return_val_if_fail(GTK_IS_SNIPPET(widget), FALSE);
+ g_return_val_if_fail(event != NULL, FALSE);
+
+ gtk_snippet_paint(widget);
+
+ return FALSE;
+}
+
+
+static void
+gtk_snippet_paint(GtkWidget *widget)
+{
+ cairo_t *cr;
+
+ cr = gdk_cairo_create(widget->window);
+
+ cairo_translate(cr, 0, 7);
+
+ cairo_set_source_rgb(cr, 1, 1, 1);
+ cairo_paint(cr);
+
+ gint pos = GTK_SNIPPET(widget)->sel;
+ gint rect = pos / 5;
+
+ cairo_set_source_rgb(cr, 0.2, 0.4, 0);
+
+ gint i;
+ for ( i = 1; i <= 20; i++) {
+ if (i > 20 - rect) {
+ cairo_set_source_rgb(cr, 0.6, 1.0, 0);
+ } else {
+ cairo_set_source_rgb(cr, 0.2, 0.4, 0);
+ }
+ cairo_rectangle(cr, 8, i*4, 30, 3);
+ cairo_rectangle(cr, 42, i*4, 30, 3);
+ cairo_fill(cr);
+ }
+
+ cairo_destroy(cr);
+
+ printf("rendering...\n");
+
+ gdk_draw_layout(GDK_DRAWABLE(widget->window), GTK_SNIPPET(widget)->gc,
+ 10, 100, GTK_SNIPPET(widget)->layout);
+
+}
+
+
+static void
+gtk_snippet_destroy(GtkObject *object)
+{
+ GtkSnippet *cpu;
+ GtkSnippetClass *klass;
+
+ g_return_if_fail(object != NULL);
+ g_return_if_fail(GTK_IS_SNIPPET(object));
+
+ cpu = GTK_SNIPPET(object);
+
+ klass = gtk_type_class(gtk_widget_get_type());
+
+ if (GTK_OBJECT_CLASS(klass)->destroy) {
+ (* GTK_OBJECT_CLASS(klass)->destroy) (object);
+ }
+}
+
+
+
+
+void gtk_snippet_set_sel(GtkSnippet *cpu, gint sel)
+{
+ cpu->sel = sel;
+
+}
+
+
+
+void gtk_snippet_test(GtkSnippet *snippet)
+{
+
+
+
+ pango_layout_set_markup(snippet->layout, "<tt>int\t<span foreground='#ff0000'>80</span></tt>", -1);
+
+
+
+
+}
+
+
+
+
+
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : snippet = composant GTK à mettre à jour. *
+* proc = architecture à associer au contenu. *
+* *
+* Description : Définit l'architecture à laquelle le contenu est lié. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void gtk_snippet_set_processor(GtkSnippet *snippet, const asm_processor *proc)
+{
+ snippet->proc = proc;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : snippet = composant GTK à mettre à jour. *
+* offset = position de l'instruction à ajouter. *
+* instr = instruction à représenter ou NULL. *
+* comment = commentaire à imprimer ou NULL. *
+* *
+* Description : Ajoute une ligne dans le bloc de représentation. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void gtk_snippet_add_line(GtkSnippet *snippet, uint64_t offset, asm_instr *instr, const char *comment)
+{
+ snippet->info = (code_line_info *)realloc(snippet->info, ++snippet->info_count * sizeof(code_line_info));
+
+ snippet->info[snippet->info_count - 1].offset = offset;
+ snippet->info[snippet->info_count - 1].instr = instr;
+ snippet->info[snippet->info_count - 1].comment = (comment != NULL ? strdup(comment) : NULL);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : snippet = composant GTK à mettre à jour. *
+* *
+* Description : Définit le contenu visuel à partir des infos enregistrées. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void gtk_snippet_build_content(GtkSnippet *snippet)
+{
+ char *content; /* Contenu à définir */
+ size_t content_len; /* Taille du contenu */
+ AdressMode mode; /* Affichage des adresses */
+ unsigned int i; /* Boucle de traitement */
+ char buffer[CONTENT_BUFFER_LEN]; /* Zone tampon à utiliser */
+
+ content_len = strlen("<tt>") + 1;
+ content = (char *)calloc(content_len, sizeof(char));
+ strcpy(content, "<tt>");
+
+ mode = ADM_32BITS; /* FIXME */
+
+ for (i = 0; i < snippet->info_count; i++)
+ {
+ if (i > 0)
+ {
+ content = (char *)realloc(content, ++content_len * sizeof(char));
+ strcat(content, "\n");
+ }
+
+ /* Adresse */
+
+ switch (mode)
+ {
+ case ADM_32BITS:
+ snprintf(buffer, CONTENT_BUFFER_LEN,
+ "<span foreground='#333333'>0x%08llx</span>",
+ snippet->info[i].offset);
+ break;
+
+ case ADM_64BITS:
+ snprintf(buffer, CONTENT_BUFFER_LEN,
+ "<span foreground='#333333'>0x%16llx</span>",
+ snippet->info[i].offset);
+ break;
+
+ }
+
+ content_len += strlen(buffer);
+ content = (char *)realloc(content, content_len * sizeof(char));
+ strcat(content, buffer);
+
+ /* Eventuelle instruction */
+
+ if (snippet->info[i].instr != NULL)
+ {
+ print_hinstruction(snippet->proc, snippet->info[i].instr, buffer, CONTENT_BUFFER_LEN);
+
+ content_len += strlen("\t") + strlen(buffer);
+
+ content = (char *)realloc(content, content_len * sizeof(char));
+ strcat(content, "\t");
+ strcat(content, buffer);
+
+ }
+
+ /* Eventuel commantaire */
+
+ if (snippet->info[i].comment != NULL)
+ {
+ content_len += strlen("\t<b><span foreground='#003300'>; ") + strlen(snippet->info[i].comment) + strlen("</span></b>");
+
+ content = (char *)realloc(content, content_len * sizeof(char));
+ strcat(content, "\t<b><span foreground='#003300'>; ");
+ strcat(content, snippet->info[i].comment);
+ strcat(content, "</span></b>");
+
+ }
+
+ }
+
+ content_len += strlen("</tt>");
+ content = (char *)realloc(content, content_len * sizeof(char));
+ strcat(content, "</tt>");
+
+ pango_layout_set_markup(snippet->layout, content, content_len - 1);
+
+}
+
+
+
diff --git a/src/gtksnippet.h b/src/gtksnippet.h
new file mode 100644
index 0000000..e66eedc
--- /dev/null
+++ b/src/gtksnippet.h
@@ -0,0 +1,128 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * format_elf.h - prototypes pour l'affichage d'un fragment de code d'assemblage
+ *
+ * Copyright (C) 2008 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _GTK_SNIPPET_H
+#define _GTK_SNIPPET_H
+
+
+#include <stdint.h>
+#include <gtk/gtk.h>
+#include <cairo.h>
+
+
+
+
+#include "arch/instruction.h"
+#include "arch/processor.h"
+
+
+
+
+
+
+
+G_BEGIN_DECLS
+
+
+#define GTK_SNIPPET(obj) GTK_CHECK_CAST(obj, gtk_snippet_get_type (), GtkSnippet)
+#define GTK_SNIPPET_CLASS(klass) GTK_CHECK_CLASS_CAST(klass, gtk_snippet_get_type(), GtkSnippetClass)
+#define GTK_IS_SNIPPET(obj) GTK_CHECK_TYPE(obj, gtk_snippet_get_type())
+
+
+typedef struct _GtkSnippet GtkSnippet;
+typedef struct _GtkSnippetClass GtkSnippetClass;
+
+
+/* Mode d'adressage à utiliser */
+typedef enum _AdressMode
+{
+ ADM_32BITS, /* Adresses sur 32 bits */
+ ADM_64BITS /* Adresses sur 64 bits */
+
+} AdressMode;
+
+
+
+typedef struct _code_line_info
+{
+ uint64_t offset; /* Position de l'instruction */
+ asm_instr *instr; /* Eventuelle instruction */
+ char *comment; /* Eventuel commentaire */
+
+} code_line_info;
+
+
+struct _GtkSnippet {
+
+ GtkWidget widget; /* Présence obligatoire en 1er */
+
+ AdressMode mode; /* Mode d'affichage */
+
+ PangoLayout *layout; /* Moteur de rendu du code ASM */
+ GdkGC *gc; /* Contexte graphique du rendu */
+
+ const asm_processor *proc; /* Architecture utilisée */
+ code_line_info *info; /* Contenu à représenter */
+ unsigned int info_count; /* Quantité d'informations */
+
+
+ gint sel;
+};
+
+struct _GtkSnippetClass {
+ GtkWidgetClass parent_class;
+};
+
+
+GtkType gtk_snippet_get_type(void);
+void gtk_snippet_set_sel(GtkSnippet *cpu, gint sel);
+
+GtkWidget * gtk_snippet_new();
+
+
+
+
+void gtk_snippet_test(GtkSnippet *cpu);
+
+
+
+/* Définit l'architecture à laquelle le contenu est lié. */
+void gtk_snippet_set_processor(GtkSnippet *, const asm_processor *);
+
+/* Ajoute une ligne dans le bloc de représentation. */
+void gtk_snippet_add_line(GtkSnippet *, uint64_t, asm_instr *, const char *);
+
+/* Définit le contenu visuel à partir des infos enregistrées. */
+void gtk_snippet_build_content(GtkSnippet *);
+
+
+
+
+G_END_DECLS
+
+
+
+
+
+
+#endif /* _GTK_SNIPPET_H */
--
cgit v0.11.2-87-g4458