/* OpenIDA - Outil d'analyse de fichiers binaires
* gtksnippet.c - 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 .
*/
#include "gtksnippet.h"
#include
#include
#include "../common/dllist.h"
#define CONTENT_BUFFER_LEN 64
#define MARGIN_SPACE 4
/* Redessine l'affichage suite une mise à jour dans la marge. */
void gtk_snippet_update_margin(GRenderingLine *, GtkSnippet *);
/******************************************************************************
* *
* Paramètres : offset = position de l'instruction à ajouter. *
* instr = instruction à représenter ou NULL. *
* comment = commentaire à imprimer ou NULL. *
* *
* Description : Crée une ligne de représentation insérable. *
* *
* Retour : Struture rassemblant les informations mise en place. *
* *
* Remarques : - *
* *
******************************************************************************/
code_line_info *create_code_line_info(uint64_t offset, asm_instr *instr, const char *comment)
{
code_line_info *result; /* Structure à renvoyer */
result = (code_line_info *)calloc(1, sizeof(code_line_info));
result->offset = offset;
result->instr = instr;
result->comment = (comment != NULL ? strdup(comment) : NULL);
result->bp_set = FALSE;
return result;
}
/******************************************************************************
* *
* Paramètres : line = informations à effacer de la mémoire. *
* *
* Description : Supprime une ligne de représentation. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void delete_code_line_info(code_line_info *line)
{
free(line->instr);
free(line->comment);
free(line);
}
/******************************************************************************
* *
* Paramètres : a = premières informations à consulter. *
* b = secondes informations à consulter. *
* *
* Description : Etablit la comparaison entre deux lignes de représentation. *
* *
* Retour : Bilan : -1 (a < b), 0 (a == b) ou 1 (a > b). *
* *
* Remarques : - *
* *
******************************************************************************/
int compare_code_line_info(const code_line_info **a, const code_line_info **b)
{
int result; /* Bilan à renvoyer */
if ((*a)->offset < (*b)->offset) result = -1;
else if((*a)->offset > (*b)->offset) result = 1;
else result = 0;
return result;
}
/* Réclame une nouvelle taille adaptée au contenu présent. */
void gtk_snippet_recompute_size_request(GtkSnippet *);
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_button_press(GtkWidget *, GdkEventButton *event);
static gboolean gtk_snippet_expose(GtkWidget *widget,
GdkEventExpose *event);
static void gtk_snippet_paint(GtkSnippet *snippet);
static void gtk_snippet_destroy(GtkObject *object);
G_DEFINE_TYPE(GtkSnippet, gtk_snippet, GTK_TYPE_WIDGET)
GtkWidget * gtk_snippet_new(void)
{
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->button_press_event = gtk_snippet_button_press;
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;
GdkColor white; /* Couleur de fond normale */
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;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.event_mask = gtk_widget_get_events(widget) | GDK_BUTTON_PRESS_MASK | 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);
gdk_color_white(gtk_widget_get_colormap(widget), &white);
gtk_widget_modify_bg(widget, GTK_STATE_NORMAL, &white);
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_button_press(GtkWidget *widget, GdkEventButton *event)
{
gboolean result; /* Décision à retourner */
GtkSnippet *snippet; /* Composant GTK réel */
gdouble y; /* Position à manipuler */
GRenderingLine *line; /* Ligne de rendu visée */
result = FALSE;
snippet = GTK_SNIPPET(widget);
y = event->y;
line = g_rendering_line_find_by_y(snippet->lines, &y);
if (line != NULL)
{
/* Clic dans la marge */
if (event->type == GDK_BUTTON_PRESS && event->x < (2 * MARGIN_SPACE + snippet->line_height))
{
result = TRUE;
g_rendering_line_toggle_flag(line, RLF_BREAK_POINT);
}
}
if (result)
{
/* TODO: regions */
gtk_snippet_paint(snippet);
}
return result;
}
/******************************************************************************
* *
* Paramètres : line = ligne dont un drapeau a évolué. *
* snippet = composant GTK à mettre à jour. *
* *
* Description : Redessine l'affichage suite une mise à jour dans la marge. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void gtk_snippet_update_margin(GRenderingLine *line, GtkSnippet *snippet)
{
gtk_snippet_paint(snippet);
}
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(GTK_SNIPPET(widget));
/*
gdk_gc_set_clip_region (GdkGC *gc,
const GdkRegion *region);
gdk_window_invalidate_region (GdkWindow *window,
const GdkRegion *region,
gboolean invalidate_children);
gdk_window_begin_paint_region (GdkWindow *window,
const GdkRegion *region);
void gdk_window_end_paint (GdkWindow *window);
*/
return TRUE;
}
static void
gtk_snippet_paint(GtkSnippet *snippet)
{
GtkWidget *widget; /* Version GTK du composant */
GdkGCValues values; /* Propriétés du contexte */
GdkColor white; /* Couleur du fond */
int width; /* Largeur de l'élément */
int height; /* Hauteur de l'élément */
GdkColor red; /* Couleur des arrêts */
PangoLayoutIter *iter; /* Boucle de parcours */
unsigned int index; /* Indice de la ligne visée */
int y0; /* Ordonnée du haut d'une ligne*/
int y1; /* Ordonnée du bas d'une ligne */
GRenderingLine *liter;
widget = GTK_WIDGET(snippet);
gdk_gc_get_values(snippet->gc, &values);
gdk_color_white(gtk_widget_get_colormap(widget), &white);
gdk_gc_set_foreground(snippet->gc, &white);
gtk_widget_get_size_request(widget, &width, &height);
gdk_draw_rectangle(GDK_DRAWABLE(widget->window), GTK_SNIPPET(widget)->gc,
TRUE, 0, 0, width, height);
gdk_color_parse("#ff0000", &red);
gdk_color_alloc(gtk_widget_get_colormap(widget), &red);
gdk_gc_set_foreground(snippet->gc, &red);
index = 0;
iter = pango_layout_get_iter(snippet->layout);
for (; index < snippet->info_count; index++, pango_layout_iter_next_line(iter))
{
if (!snippet->info[index].bp_set) continue;
pango_layout_iter_get_line_yrange(iter, &y0, &y1);
gdk_draw_arc(GDK_DRAWABLE(widget->window), GTK_SNIPPET(widget)->gc,
FALSE, MARGIN_SPACE, y0 / PANGO_SCALE,
snippet->line_height - 2, snippet->line_height - 2,
0, 360 * 64);
}
pango_layout_iter_free(iter);
gdk_gc_set_foreground(snippet->gc, &values.foreground);
gdk_draw_layout(GDK_DRAWABLE(widget->window), snippet->gc,
2 * MARGIN_SPACE + snippet->line_height, 0,
snippet->layout);
y0 = 0;
for (/* l! */liter = snippet->lines; liter != NULL; liter = g_rendering_line_get_next_iter(snippet->lines, liter))
{
g_rendering_line_draw(liter, GDK_DRAWABLE(widget->window), snippet->gc,
MARGIN_SPACE, 2 * MARGIN_SPACE + snippet->line_height,
y0, snippet->line_height);
y0 += snippet->line_height;
}
}
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);
}
}
/******************************************************************************
* *
* Paramètres : snippet = composant GTK à mettre à jour. *
* show = état de l'affichage auquel parvenir. *
* *
* Description : Choisit d'afficher les adresses virtuelles ou non. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void gtk_snippet_show_vaddress(GtkSnippet *snippet, gboolean show)
{
snippet->show_vaddress = show;
gtk_snippet_build_content(snippet);
}
/******************************************************************************
* *
* Paramètres : snippet = composant GTK à mettre à jour. *
* show = état de l'affichage auquel parvenir. *
* *
* Description : Choisit d'afficher le code brut ou non. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void gtk_snippet_show_code(GtkSnippet *snippet, gboolean show)
{
snippet->show_code = show;
gtk_snippet_build_content(snippet);
}
/******************************************************************************
* *
* Paramètres : snippet = composant GTK à mettre à jour. *
* format = format du binaire affiché. *
* *
* Description : Définit le format auquel le contenu est lié. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void gtk_snippet_set_format(GtkSnippet *snippet, const exe_format *format)
{
snippet->format = format;
}
/******************************************************************************
* *
* 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. *
* lines = informations à intégrer. *
* *
* Description : Définit les lignes du bloc de représentation. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void gtk_snippet_set_rendering_lines(GtkSnippet *snippet, GRenderingLine *lines)
{
GRenderingLine *iter; /* Boucle de parcours */
snippet->lines = lines;
for (iter = lines; iter != NULL; iter = g_rendering_line_get_next_iter(lines, iter))
g_signal_connect(iter, "rendering-line-flags-changed",
G_CALLBACK(gtk_snippet_update_margin), snippet);
g_rendering_line_update_bin_len(lines);
gtk_snippet_recompute_size_request(snippet);
}
/******************************************************************************
* *
* Paramètres : snippet = composant GTK à mettre à jour. *
* *
* Description : Réclame une nouvelle taille adaptée au contenu présent. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void gtk_snippet_recompute_size_request(GtkSnippet *snippet)
{
int width; /* Largeur de l'objet actuelle */
int height; /* Hauteur de l'objet actuelle */
g_rendering_line_get_size(snippet->lines, &width, &height, &snippet->line_height);
gtk_widget_set_size_request(GTK_WIDGET(snippet),
width + 2 * MARGIN_SPACE + snippet->line_height,
height);
}
/******************************************************************************
* *
* Paramètres : snippet = composant GTK à mettre à jour. *
* line = informations à intégrer. *
* *
* Description : Ajoute une ligne dans le bloc de représentation. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void gtk_snippet_add_line(GtkSnippet *snippet, const code_line_info *line)
{
snippet->info = (code_line_info *)realloc(snippet->info, ++snippet->info_count * sizeof(code_line_info));
snippet->info[snippet->info_count - 1] = *line;
}
/******************************************************************************
* *
* 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)
{
#if 0
const uint8_t *exe_content; /* Contenu binaire global */
off_t max_bin_len; /* Taille max du code brut */
unsigned int i; /* Boucle de traitement */
off_t bin_len; /* Taille d'instruction */
char *bin_code; /* Tampon du code binaire */
char *content; /* Contenu à définir */
size_t content_len; /* Taille du contenu */
AdressMode mode; /* Affichage des adresses */
char buffer[CONTENT_BUFFER_LEN]; /* Zone tampon à utiliser */
off_t bin_offset; /* Début de l'instruction */
off_t k; /* Boucle de parcours #2 */
off_t j; /* Boucle de parcours #1 */
int width; /* Largeur de l'objet actuelle */
int height; /* Hauteur de l'objet actuelle */
PangoLayoutIter *iter; /* Boucle de parcours */
int y0; /* Ordonnée du haut d'une ligne*/
int y1; /* Ordonnée du bas d'une ligne */
/* Calcul de la largeur maximale brute si besoin est */
if (snippet->show_code)
{
exe_content = get_exe_content(snippet->format, NULL);
max_bin_len = 1;
for (i = 0; i < snippet->info_count; i++)
{
/* Commentaire uniquement */
if (snippet->info[i].instr == NULL) continue;
get_asm_instr_offset_and_length(snippet->info[i].instr, NULL, &bin_len);
if (bin_len > max_bin_len) max_bin_len = bin_len;
}
max_bin_len = max_bin_len * 2 + (max_bin_len - 1);
bin_code = (char *)calloc(max_bin_len + 1, sizeof(char));
}
content_len = strlen("") + 1;
content = (char *)calloc(content_len, sizeof(char));
strcpy(content, "");
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");
}
/* Eventuelle adresse virtuelle */
if (snippet->show_vaddress)
{
switch (mode)
{
case ADM_32BITS:
snprintf(buffer, CONTENT_BUFFER_LEN,
"0x%08llx",
snippet->info[i].offset);
break;
case ADM_64BITS:
snprintf(buffer, CONTENT_BUFFER_LEN,
"0x%16llx",
snippet->info[i].offset);
break;
}
content_len += strlen(buffer);
content = (char *)realloc(content, content_len * sizeof(char));
strcat(content, buffer);
}
/* Eventuel code brut */
if (snippet->show_code)
{
k = 0;
if (snippet->info[i].instr != NULL)
{
get_asm_instr_offset_and_length(snippet->info[i].instr, &bin_offset, &bin_len);
for (j = 0; j < bin_len; j++)
{
if ((j + 1) < bin_len)
k += snprintf(&bin_code[j * (2 + 1)], 4, "%02hhx ", exe_content[bin_offset + j]);
else
k += snprintf(&bin_code[j * (2 + 1)], 3, "%02hhx", exe_content[bin_offset + j]);
}
}
for (; k < max_bin_len; k++)
snprintf(&bin_code[k], 2, " ");
if (snippet->show_vaddress) content_len += strlen("\t");
content_len += strlen(bin_code);
content = (char *)realloc(content, content_len * sizeof(char));
if (snippet->show_vaddress) strcat(content, "\t");
strcat(content, bin_code);
}
/* Eventuelle instruction */
if (snippet->info[i].instr != NULL)
{
print_hinstruction(snippet->proc, snippet->format, snippet->info[i].instr, buffer, CONTENT_BUFFER_LEN, ASX_INTEL);
if (snippet->show_vaddress || snippet->show_code) content_len += strlen("\t");
content_len += strlen(buffer);
content = (char *)realloc(content, content_len * sizeof(char));
if (snippet->show_vaddress || snippet->show_code) strcat(content, "\t");
strcat(content, buffer);
}
/* Eventuel commantaire */
if (snippet->info[i].comment != NULL)
{
if (snippet->show_vaddress || snippet->show_code) content_len += strlen("\t");
content_len += strlen("; ") + strlen(snippet->info[i].comment) + strlen("");
content = (char *)realloc(content, content_len * sizeof(char));
if (snippet->show_vaddress || snippet->show_code) strcat(content, "\t");
strcat(content, "; ");
strcat(content, snippet->info[i].comment);
strcat(content, "");
}
}
content_len += strlen("");
content = (char *)realloc(content, content_len * sizeof(char));
strcat(content, "");
if (snippet->show_code) free(bin_code);
pango_layout_set_markup(snippet->layout, content, content_len - 1);
pango_layout_get_pixel_size(snippet->layout, &width, &height);
snippet->line_height = 0;
iter = pango_layout_get_iter(snippet->layout);
do
{
pango_layout_iter_get_line_yrange(iter, &y0, &y1);
snippet->line_height = MAX(snippet->line_height, (y1 - y0) / PANGO_SCALE);
}
while (pango_layout_iter_next_line(iter));
pango_layout_iter_free(iter);
//gtk_widget_set_size_request(GTK_WIDGET(snippet), width + 2 * MARGIN_SPACE + snippet->line_height, height);
#endif
}
/******************************************************************************
* *
* Paramètres : snippet = composant GTK à consulter. *
* address = adresse à présenter à l'écran. *
* position = position verticale au sein du composant. [OUT] *
* *
* Description : Indique la position verticale d'une adresse donnée. *
* *
* Retour : TRUE si l'adresse fait partie du composant, FALSE sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
gboolean gtk_snippet_get_address_vposition(GtkSnippet *snippet, uint64_t address, gint *position)
{
unsigned int i; /* Boucle de parcours */
*position = 0;
for (i = 0; i < snippet->info_count; i++)
{
if (snippet->info[i].offset == address) break;
else *position += snippet->line_height;
}
return (i < snippet->info_count);
}