/* OpenIDA - Outil d'analyse de fichiers binaires * gtkgraphview.c - affichage de morceaux de code sous forme graphique * * Copyright (C) 2009-2012 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 "gtkgraphview.h" #include "gtkblockview.h" #include "gtkbufferview.h" #include "gtkviewpanel-int.h" #include "graph/layout.h" #include "../gui/editem.h" /* Composant d'affichage sous forme graphique (instance) */ struct _GtkGraphView { GtkViewPanel parent; /* A laisser en premier */ GtkFixed *support; /* Support des vues en bloc */ vmpa_t start; /* Début de la portion vue */ vmpa_t end; /* Fin de la portion affichée */ GtkViewPanel **children; /* Liste des sous-blocs */ GtkAllocation *allocs; /* Emplacements prévisibles */ size_t children_count; /* Taille de cette liste */ GtkLinkRenderer **links; /* Liste des liens graphiques */ size_t links_count; /* Nombre de ces liens */ }; /* Composant d'affichage sous forme graphique (classe) */ struct _GtkGraphViewClass { GtkViewPanelClass parent; /* A laisser en premier */ }; /* Initialise la classe générique des graphiques de code. */ static void gtk_graph_view_class_init(GtkGraphViewClass *); /* Initialise une instance d'afficheur de code en graphique. */ static void gtk_graph_view_init(GtkGraphView *); /* Fournit la taille de composant requise pour un plein rendu. */ static void gtk_graph_view_size_request(GtkWidget *, GtkRequisition *); /* S'adapte à la surface concédée par le composant parent. */ static void gtk_graph_view_size_allocate(GtkWidget *, GtkAllocation *); /* Met à jour l'affichage de la vue sous forme graphique. */ static gboolean gtk_graph_view_expose(GtkWidget *, GdkEventExpose *, GtkGraphView *); /* Réagit à la sélection externe d'une adresse. */ static void gtk_graph_view_define_main_address(GtkGraphView *, vmpa_t); /* Actualise les besoins internes avant un redimensionnement. */ static void gtk_graph_view_prepare_resize(GtkGraphView *); /* Indique la position d'affichage d'une adresse donnée. */ static bool gtk_graph_view_get_address_coordinates(const GtkGraphView *, vmpa_t, gint *, gint *); /* Réagit à un défilement quelconque. */ static void gtk_graph_view_scroll(GtkGraphView *); /* Place en cache un rendu destiné à l'aperçu graphique rapide. */ static void gtk_graph_view_cache_glance(GtkGraphView *, cairo_t *); /* Supprime tout contenu de l'afficheur de code en graphique. */ static void gtk_graph_view_reset(GtkGraphView *); /* Liste d'éléments du graphique à placer. */ static GtkViewPanel **gtk_graph_view_load_nodes(GtkGraphView *, GLoadedBinary *, vmpa_t, vmpa_t); /* Détermine le type du composant d'affichage en graphique. */ G_DEFINE_TYPE(GtkGraphView, gtk_graph_view, GTK_TYPE_VIEW_PANEL) /****************************************************************************** * * * Paramètres : klass = classe GTK à initialiser. * * * * Description : Initialise la classe générique des graphiques de code. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void gtk_graph_view_class_init(GtkGraphViewClass *klass) { GtkWidgetClass *widget_class; /* Classe version Widget */ widget_class = (GtkWidgetClass *)klass; widget_class->size_request = gtk_graph_view_size_request; widget_class->size_allocate = gtk_graph_view_size_allocate; } /****************************************************************************** * * * Paramètres : view = instance GTK à initialiser. * * * * Description : Initialise une instance d'afficheur de code en graphique. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void gtk_graph_view_init(GtkGraphView *view) { GtkViewPanel *viewpanel; /* Instance parente #1 */ //GtkBinView *binview; /* Instance parente #2 */ GdkColor white; /* Couleur de fond normale */ viewpanel = GTK_VIEW_PANEL(view); viewpanel->define = (define_address_fc)gtk_graph_view_define_main_address; viewpanel->resize = (prepare_resize_fc)gtk_graph_view_prepare_resize; viewpanel->get_coordinates = (get_addr_coordinates_fc)gtk_graph_view_get_address_coordinates; viewpanel->scroll = (scroll_fc)gtk_graph_view_scroll; viewpanel->cache_glance = (cache_glance_fc)gtk_graph_view_cache_glance; //binview = GTK_BIN_VIEW(view); //binview->set_lines = (set_rendering_lines_fc)gtk_graph_view_set_rendering_lines; //binview->define_address = (define_main_address_fc)gtk_graph_view_define_main_address; //binview->get_coordinates = (get_addr_coordinates_fc)gtk_graph_view_get_address_coordinates; view->support = GTK_FIXED(gtk_fixed_new()); gtk_widget_set_has_window(GTK_WIDGET(view->support), TRUE); g_signal_connect(G_OBJECT(view->support), "expose-event", G_CALLBACK(gtk_graph_view_expose), view); gtk_widget_show(GTK_WIDGET(view->support)); gdk_color_white(gtk_widget_get_colormap(GTK_WIDGET(view->support)), &white); gtk_widget_modify_bg(GTK_WIDGET(view->support), GTK_STATE_NORMAL, &white); gtk_fixed_put(GTK_FIXED(view), GTK_WIDGET(view->support), 0, 0); //view->mutex = g_mutex_new(); //view->cond = g_cond_new(); } /****************************************************************************** * * * Paramètres : widget = composant GTK à consulter. * * requisition = dimensions souhaitées. [OUT] * * * * Description : Fournit la taille de composant requise pour un plein rendu. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void gtk_graph_view_size_request(GtkWidget *widget, GtkRequisition *requisition) { gpointer fixed_class; /* Classe parente */ GtkGraphView *view; /* Autre vision du composant */ gint left_corner; /* Abscisse minimale */ gint top_corner; /* Ordonnée minimale */ size_t i; /* Boucle de parcours */ fixed_class = g_type_class_peek_parent(GTK_GRAPH_VIEW_GET_CLASS(widget)); fixed_class = g_type_class_peek_parent(fixed_class); GTK_WIDGET_CLASS(fixed_class)->size_request(widget, requisition); view = GTK_GRAPH_VIEW(widget); left_corner = G_MAXINT; top_corner = G_MAXINT; for (i = 0; i < view->children_count; i++) { left_corner = MIN(left_corner, view->allocs[i].x); top_corner = MIN(top_corner, view->allocs[i].y); } if (left_corner != G_MAXINT) requisition->width += left_corner; if (top_corner != G_MAXINT) requisition->height += top_corner; requisition->width += GTK_VIEW_PANEL(widget)->hadjustment->value; requisition->height += GTK_VIEW_PANEL(widget)->vadjustment->value; } /****************************************************************************** * * * Paramètres : view = composant GTK à mettre à jour. * * allocation = étendue accordée à la vue. * * * * Description : S'adapte à la surface concédée par le composant parent. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void gtk_graph_view_size_allocate(GtkWidget *widget, GtkAllocation *allocation) { gpointer fixed_class; /* Classe parente */ GtkViewPanel *panel; /* Autre version du composant */ GtkAllocation valloc; /* Surface utilisable */ GtkRequisition req; /* Taille demandée */ gboolean changed; /* Changement de valeur ? */ /* Mise à jour GTK */ fixed_class = g_type_class_peek_parent(GTK_GRAPH_VIEW_GET_CLASS(widget)); fixed_class = g_type_class_peek_parent(fixed_class); GTK_WIDGET_CLASS(fixed_class)->size_allocate(widget, allocation); panel = GTK_VIEW_PANEL(widget); if (panel->hadjustment == NULL || panel->vadjustment == NULL) return; gtk_view_panel_compute_allocation(panel, &valloc); gtk_widget_size_request(widget, &req); /* Défilement horizontal */ panel->hadjustment->page_size = valloc.width; panel->hadjustment->step_increment = valloc.width * 0.1; panel->hadjustment->page_increment = valloc.width * 0.9; panel->hadjustment->upper = MAX(req.width, valloc.width); gtk_view_panel_reclamp_adjustment(panel->hadjustment, &changed); gtk_adjustment_changed(panel->hadjustment); if (changed) gtk_adjustment_value_changed(panel->hadjustment); /* Défilement vertical */ panel->vadjustment->page_size = valloc.height; panel->vadjustment->step_increment = valloc.width * 0.1; panel->vadjustment->page_increment = valloc.width * 0.9; panel->vadjustment->upper = MAX(req.height, valloc.height); gtk_view_panel_reclamp_adjustment(panel->vadjustment, &changed); gtk_adjustment_changed(panel->vadjustment); if (changed) gtk_adjustment_value_changed(panel->vadjustment); } /****************************************************************************** * * * Paramètres : widget = composant GTK à redessiner. * * event = informations liées à l'événement. * * view = support maître à consulter. * * * * Description : Met à jour l'affichage de la vue sous forme graphique. * * * * Retour : FALSE pour poursuivre la propagation de l'événement. * * * * Remarques : - * * * ******************************************************************************/ static gboolean gtk_graph_view_expose(GtkWidget *widget, GdkEventExpose *event, GtkGraphView *view) { size_t i; /* Boucle de parcours */ for (i = 0; i < view->links_count; i++) gtk_link_renderer_draw(view->links[i], GDK_DRAWABLE(widget->window), GTK_VIEW_PANEL(view)->gc); return FALSE; } /****************************************************************************** * * * Paramètres : view = composant GTK à mettre à jour. * * addr = adresse sélectionnée de manière externe. * * * * Description : Réagit à la sélection externe d'une adresse. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void gtk_graph_view_define_main_address(GtkGraphView *view, vmpa_t addr) { GExeFormat *format; /* Type de fichier chargé */ GBinRoutine **routines; /* Liste des routines trouvées */ size_t routines_count; /* Nombre de ces routines */ size_t i; /* Boucle de parcours */ vmpa_t start; /* Début d'une routine */ vmpa_t end; /* Fin d'une routine */ if (!(view->start <= addr && addr < view->end)) { gtk_graph_view_reset(view); format = g_loaded_binary_get_format(GTK_VIEW_PANEL(view)->binary); routines = g_binary_format_get_routines(G_BIN_FORMAT(format), &routines_count); for (i = 0; i < routines_count; i++) { start = g_binary_routine_get_address(routines[i]); end = start + g_binary_routine_get_size(routines[i]); if (start <= addr && addr < end) { view->start = start; view->end = end; view->children = gtk_graph_view_load_nodes(view, GTK_VIEW_PANEL(view)->binary, start, end); view->allocs = (GtkAllocation *)calloc(view->children_count, sizeof(GtkAllocation)); build_graph_view(view, view->children, view->children_count); break; } } change_editor_items_current_view_content(GTK_VIEW_PANEL(view)); } } /****************************************************************************** * * * Paramètres : view = composant GTK à mettre à jour. * * * * Description : Actualise les besoins internes avant un redimensionnement. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void gtk_graph_view_prepare_resize(GtkGraphView *view) { size_t i; /* Boucle de parcours */ if (view->children_count > 0) { for (i = 0; i < view->children_count; i++) gtk_widget_queue_resize(GTK_WIDGET(view->children[i])); build_graph_view(view, view->children, view->children_count); change_editor_items_current_view_content(GTK_VIEW_PANEL(view)); } } /****************************************************************************** * * * Paramètres : view = composant GTK à consulter. * * addr = adresse à présenter à l'écran. * * x = position horizontale au sein du composant. [OUT] * * y = position verticale au sein du composant. [OUT] * * * * Description : Indique la position d'affichage d'une adresse donnée. * * * * Retour : true si l'adresse fait partie du composant, false sinon. * * * * Remarques : - * * * ******************************************************************************/ static bool gtk_graph_view_get_address_coordinates(const GtkGraphView *view, vmpa_t addr, gint *x, gint *y) { return false; } /****************************************************************************** * * * Paramètres : view = composant GTK à mettre à jour. * * * * Description : Réagit à un défilement quelconque. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void gtk_graph_view_scroll(GtkGraphView *view) { gtk_fixed_move(GTK_FIXED(view), GTK_WIDGET(view->support), -GTK_VIEW_PANEL(view)->hadjustment->value, -GTK_VIEW_PANEL(view)->vadjustment->value); } /****************************************************************************** * * * Paramètres : view = composant GTK à manipuler. * * cairo = assistant pour la création de rendus. * * * * Description : Place en cache un rendu destiné à l'aperçu graphique rapide. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void gtk_graph_view_cache_glance(GtkGraphView *view, cairo_t *cairo) { size_t i; /* Boucle de parcours */ GtkAllocation *alloc; /* Emplacement d'un bloc */ cairo_set_line_width(cairo, 2); cairo_set_source_rgb(cairo, 0, 0, 0); for (i = 0; i < view->children_count; i++) { alloc = &view->allocs[i]; cairo_rectangle(cairo, alloc->x, alloc->y, alloc->width, alloc->height); cairo_stroke(cairo); } for (i = 0; i < view->links_count; i++) _gtk_link_renderer_draw(view->links[i], cairo, false); } /****************************************************************************** * * * Paramètres : - * * * * Description : Crée un nouveau composant pour l'affichage en graphique. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ GtkWidget *gtk_graph_view_new(void) { return g_object_new(GTK_TYPE_GRAPH_VIEW, NULL); } /****************************************************************************** * * * Paramètres : view = composant GTK à mettre à jour. * * widget = composant GTK à insérer. * * x = abscisse du point d'insertion. * * y = ordonnée du point d'insertion. * * * * Description : Place une vue sous forme de bloc dans le graphique. * * * * Retour : Plutôt que de redéfinir *toutes* les méthodes de * * GtkContainer, on étend ! * * * * Remarques : - * * * ******************************************************************************/ void gtk_graph_view_put(GtkGraphView *view, GtkWidget *widget, const GtkAllocation *alloc) { size_t i; /* Boucle de parcours */ GtkWidget *parent; /* Parent en cas de réajustemt.*/ for (i = 0; i < view->children_count; i++) if (GTK_WIDGET(view->children[i]) == widget) { view->allocs[i] = *alloc; break; } parent = gtk_widget_get_parent(widget); if (parent != NULL) { g_object_ref(G_OBJECT(widget)); gtk_container_remove(GTK_CONTAINER(parent), widget); } gtk_fixed_put(view->support, widget, alloc->x, alloc->y); if (parent != NULL) g_object_unref(G_OBJECT(widget)); } /****************************************************************************** * * * Paramètres : view = composant GTK à mettre à jour. * * links = liens graphiques entre les blocs à intégrer. * * count = quantité de ces liens graphiques. * * * * Description : Définit les liens graphiques à présenter avec la vue. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ void gtk_graph_view_attach_links(GtkGraphView *view, GtkLinkRenderer **links, size_t count) { view->links = links; view->links_count = count; } /****************************************************************************** * * * Paramètres : view = instance GTK à réinitialiser. * * * * Description : Supprime tout contenu de l'afficheur de code en graphique. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void gtk_graph_view_reset(GtkGraphView *view) { size_t i; /* Boucle de parcours */ view->start = VMPA_MAX; view->end = VMPA_MAX; for (i = 0; i < view->links_count; i++) gtk_object_destroy(GTK_OBJECT(view->links[i])); if (view->links_count > 0) { free(view->links); view->links = NULL; view->links_count = 0; } for (i = 0; i < view->children_count; i++) gtk_widget_destroy(GTK_WIDGET(view->children[i])); if (view->children_count > 0) { free(view->children); view->children = NULL; free(view->allocs); view->allocs = NULL; view->children_count = 0; } } /****************************************************************************** * * * Paramètres : view = composant d'affichage GTK à mettre à jour. * * binary = contenu binaire à l'origine des lignes. * * start = première adresse à traiter. * * end = première adresse hors cadre de l'opération. * * * * Description : Définit la liste complète des éléments du futur graphique. * * * * Retour : Liste d'éléments du graphique à placer. * * * * Remarques : - * * * ******************************************************************************/ static GtkViewPanel **gtk_graph_view_load_nodes(GtkGraphView *view, GLoadedBinary *binary, vmpa_t start, vmpa_t end) { GtkViewPanel **result; /* Liste à retourner */ size_t *count; /* Nombre d'éléments créés. */ GArchInstruction *list; /* Liste des instructions */ GCodeBuffer *buffer; /* Tampon brut à découper */ bool *addr; /* Affichage des adresses ? */ bool *code; /* Affichage du binaire ? */ vmpa_t first; /* Début d'un groupe de lignes */ GArchInstruction *iter; /* Boucle de parcours */ vmpa_t last; /* Fin d'un groupe de lignes */ GBufferView *subview; /* Partie affichée du tampon */ result = NULL; count = &view->children_count; *count = 0; list = g_loaded_binary_get_instructions(binary); buffer = g_loaded_binary_get_disassembled_buffer(binary); addr = GTK_VIEW_PANEL(view)->display_addr; code = GTK_VIEW_PANEL(view)->display_code; first = start; last = first; for (iter = g_arch_instruction_find_by_address(list, start, true); iter != NULL; iter = g_arch_instruction_get_next_iter(list, iter, end)) { if (first != VMPA_MAX && g_arch_instruction_has_sources(iter)) { result = (GtkViewPanel **)realloc(result, ++(*count) * sizeof(GtkViewPanel *)); result[*count - 1] = GTK_VIEW_PANEL(gtk_block_view_new()); gtk_widget_show(GTK_WIDGET(result[*count - 1])); gtk_view_panel_attach_binary(result[*count - 1], binary, addr, code); gtk_view_panel_show_border(result[*count - 1], true); subview = g_buffer_view_new(buffer); g_buffer_view_restrict(subview, first, last); gtk_buffer_view_attach_buffer(GTK_BUFFER_VIEW(result[*count - 1]), subview, addr, code); first = VMPA_MAX; } g_arch_instruction_get_location(iter, NULL, NULL, &last); if (first == VMPA_MAX) first = last; if (g_arch_instruction_has_destinations(iter) || g_arch_instruction_is_return(iter)) { result = (GtkViewPanel **)realloc(result, ++(*count) * sizeof(GtkViewPanel *)); result[*count - 1] = GTK_VIEW_PANEL(gtk_block_view_new()); gtk_widget_show(GTK_WIDGET(result[*count - 1])); gtk_view_panel_attach_binary(result[*count - 1], binary, addr, code); gtk_view_panel_show_border(result[*count - 1], true); subview = g_buffer_view_new(buffer); g_buffer_view_restrict(subview, first, last); gtk_buffer_view_attach_buffer(GTK_BUFFER_VIEW(result[*count - 1]), subview, addr, code); first = VMPA_MAX; } } if (first != VMPA_MAX) { result = (GtkViewPanel **)realloc(result, ++(*count) * sizeof(GtkViewPanel *)); result[*count - 1] = GTK_VIEW_PANEL(gtk_block_view_new()); gtk_widget_show(GTK_WIDGET(result[*count - 1])); gtk_view_panel_attach_binary(result[*count - 1], binary, addr, code); gtk_view_panel_show_border(result[*count - 1], true); subview = g_buffer_view_new(buffer); g_buffer_view_restrict(subview, first, last); gtk_buffer_view_attach_buffer(GTK_BUFFER_VIEW(result[*count - 1]), subview, addr, code); } return result; }