/* Chrysalide - Outil d'analyse de fichiers binaires * gtkgraphview.c - affichage de morceaux de code sous forme graphique * * Copyright (C) 2009-2014 Cyrille Bagard * * This file is part of Chrysalide. * * 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 "../analysis/blocks/flow.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 */ GBinRoutine *routine; /* Routine en cours d'affichage*/ vmpa_t start; /* Début de la portion vue */ /* FIXME : à garder ? */ vmpa_t end; /* Fin de la portion affichée */ /* FIXME : à garder ? */ GtkViewPanel **children; /* Liste des sous-blocs */ GtkAllocation *allocs; /* Emplacements prévisibles */ size_t children_count; /* Taille de cette liste */ GGraphLayout *layout; /* Disposition en graphique */ 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 hauteur de composant requise pour un plein rendu. */ static void gtk_graph_view_get_preferred_height(GtkWidget *, gint *, gint *); /* Fournit la largeur de composant requise pour un plein rendu. */ static void gtk_graph_view_get_preferred_width(GtkWidget *, gint *, gint *); /* 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_draw(GtkWidget *, cairo_t *, 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 *, const GtkAllocation *, double); /* Supprime tout contenu de l'afficheur de code en graphique. */ static void gtk_graph_view_reset(GtkGraphView *); /* Définit la liste complète des éléments du futur graphique. * * * * Retour : Liste d'éléments du graphique à placer. */ static GtkViewPanel **gtk_graph_view_load_nodes(GtkGraphView *, GLoadedBinary *, const GBinRoutine *); /* 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->get_preferred_height = gtk_graph_view_get_preferred_height; widget_class->get_preferred_width = gtk_graph_view_get_preferred_width; 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), "draw", G_CALLBACK(gtk_graph_view_draw), 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. * * minimal = taille minimale. [OUT] * * natural = taille idéale. [OUT] * * * * Description : Fournit la hauteur de composant requise pour un plein rendu. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void gtk_graph_view_get_preferred_height(GtkWidget *widget, gint *minimal, gint *natural) { GtkGraphView *view; /* Autre vision du composant */ GtkRequisition requisition; /* Taille requise */ gpointer fixed_class; /* Classe parente */ view = GTK_GRAPH_VIEW(widget); if (view->layout != NULL) { g_graph_layout_size_request(view->layout, &requisition); *minimal = requisition.height; *natural = *minimal; } else { 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)->get_preferred_height(widget, minimal, natural); } } /****************************************************************************** * * * Paramètres : widget = composant GTK à consulter. * * minimal = taille minimale. [OUT] * * natural = taille idéale. [OUT] * * * * Description : Fournit la largeur de composant requise pour un plein rendu. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void gtk_graph_view_get_preferred_width(GtkWidget *widget, gint *minimal, gint *natural) { GtkGraphView *view; /* Autre vision du composant */ GtkRequisition requisition; /* Taille requise */ gpointer fixed_class; /* Classe parente */ view = GTK_GRAPH_VIEW(widget); if (view->layout != NULL) { g_graph_layout_size_request(view->layout, &requisition); *minimal = requisition.width; *natural = *minimal; } else { 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)->get_preferred_width(widget, minimal, natural); } } /****************************************************************************** * * * 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 */ GtkGraphView *view; /* Autre vision du composant */ GdkWindow *window; /* Fenêtre associée au support */ 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_get_preferred_size(widget, NULL, &req); /* Correction de la taille du support */ view = GTK_GRAPH_VIEW(widget); window = gtk_widget_get_window(GTK_WIDGET(view->support)); if (gdk_window_get_width(window) != req.width || gdk_window_get_height(window) != req.height) gdk_window_resize(window, req.width, req.height); /* Défilement horizontal */ gtk_adjustment_set_page_size(panel->hadjustment, valloc.width); gtk_adjustment_set_step_increment(panel->hadjustment, valloc.width * 0.1); gtk_adjustment_set_page_increment(panel->hadjustment, valloc.width * 0.9); gtk_adjustment_set_upper(panel->hadjustment, 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 */ gtk_adjustment_set_page_size(panel->vadjustment, valloc.width); gtk_adjustment_set_step_increment(panel->vadjustment, valloc.width * 0.1); gtk_adjustment_set_page_increment(panel->vadjustment, valloc.width * 0.9); gtk_adjustment_set_upper(panel->vadjustment, 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. * * cr = contexte graphique associé à 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_draw(GtkWidget *widget, cairo_t *cr, GtkGraphView *view) { if (view->layout != NULL) g_graph_layout_draw(view->layout, cr, true); 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->routine = routines[i]; g_object_ref(G_OBJECT(view->routine)); view->start = start; view->end = end; view->children = gtk_graph_view_load_nodes(view, GTK_VIEW_PANEL(view)->binary, routines[i]); view->allocs = (GtkAllocation *)calloc(view->children_count, sizeof(GtkAllocation)); /* build_graph_view(view, g_binary_routine_get_basic_blocks(view->routine), view->children, view->children_count); */ view->layout = g_graph_layout_new(g_binary_routine_get_basic_blocks(view->routine), view->children, view->children_count); g_graph_layout_place(view->layout, view); 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, g_binary_routine_get_basic_blocks(view->routine), view->children, view->children_count); */ g_graph_layout_refresh(view->layout); g_graph_layout_place(view->layout, view); 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_adjustment_get_value(GTK_VIEW_PANEL(view)->hadjustment), -gtk_adjustment_get_value(GTK_VIEW_PANEL(view)->vadjustment)); } /****************************************************************************** * * * Paramètres : view = composant GTK à manipuler. * * cairo = assistant pour la création de rendus. * * area = taille de la surface réduite à disposition. * * scale = échelle vis à vis de la taille réelle. * * * * 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, const GtkAllocation *area, double scale) { size_t i; /* Boucle de parcours */ GtkAllocation sub_area; /* Emplacement réservé */ for (i = 0; i < view->children_count; i++) { sub_area.x = view->allocs[i].x * scale; sub_area.y = view->allocs[i].y * scale; sub_area.width = view->allocs[i].width * scale + 1; sub_area.height = view->allocs[i].height * scale + 1; gtk_view_panel_cache_glance(view->children[i], cairo, &sub_area, scale); } cairo_scale(cairo, scale, scale); if (view->layout != NULL) g_graph_layout_draw(view->layout, 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. * * routine = routine à présenter via ledit composant. * * * * 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, const GBinRoutine *routine) { GtkViewPanel **result; /* Liste à retourner */ GCodeBuffer *buffer; /* Tampon brut à découper */ bool *addr; /* Affichage des adresses ? */ bool *code; /* Affichage du binaire ? */ size_t *count; /* Nombre d'éléments créés. */ GInstrBlock *main_block; /* Premier bloc rattaché */ GInstrBlock **blocks; /* Liste des blocs basiques */ size_t i; /* Boucle de parcours */ vmpa_t first; /* Début d'un groupe de lignes */ vmpa_t last; /* Fin d'un groupe de lignes */ GBufferView *subview; /* Partie affichée du tampon */ buffer = g_loaded_binary_get_disassembled_buffer(binary); addr = GTK_VIEW_PANEL(view)->display_addr; code = GTK_VIEW_PANEL(view)->display_code; count = &view->children_count; main_block = g_binary_routine_get_basic_blocks(routine); blocks = NULL; *count = 0; g_instr_block_list_all_blocks(main_block, &blocks, count); result = (GtkViewPanel **)calloc(*count, sizeof(GtkViewPanel *)); for (i = 0; i < *count; i++) { result[i] = GTK_VIEW_PANEL(gtk_block_view_new()); gtk_widget_show(GTK_WIDGET(result[i])); gtk_view_panel_attach_binary(result[i], binary, addr, code); gtk_view_panel_show_border(result[i], true); g_flow_block_get_boundary_addresses(G_FLOW_BLOCK(blocks[i]), &first, &last); subview = g_buffer_view_new(buffer); g_buffer_view_restrict(subview, first, last); gtk_buffer_view_attach_buffer(GTK_BUFFER_VIEW(result[i]), subview, addr, code); } return result; }