Changeset 3453

Show
Ignore:
Timestamp:
08/15/08 17:01:04 (5 years ago)
Author:
nopper
Message:

Creating a Pages directory

Location:
branch/PacketManipulator/PMGui
Files:
3 added
1 modified
1 moved

Legend:

Unmodified
Added
Removed

  • branch/PacketManipulator/PMGui/Tabs/MainTab.py

    r3448 r3453  
    2323 
    2424from umitCore.I18N import _ 
    25 from Manager.PreferenceManager import Prefs 
    2625 
    2726from PMGui.Core.App import PMApp 
    2827from PMGui.Core.Views import UmitView 
    29 from PMGui.Core.Icons import get_pixbuf 
    30  
    31 from PMGui.Widgets.HexView import HexView 
     28 
    3229from PMGui.Widgets.Expander import AnimatedExpander 
    33 from PMGui.Widgets.Sniff import SniffPage 
    3430from PMGui.Widgets.ClosableLabel import ClosableLabel 
    3531 
    36 from PMGui.Tabs.OperationsTab import SendOperation, SendReceiveOperation 
    37  
    38 class ProtocolHierarchy(gtk.ScrolledWindow): 
    39     def __init__(self, parent): 
    40         gtk.ScrolledWindow.__init__(self) 
    41  
    42         self.__create_widgets() 
    43         self.__pack_widgets() 
    44         self.__connect_signals() 
    45  
    46         self.session = parent 
    47         self.proto_icon = get_pixbuf('protocol_small') 
    48  
    49         self.reload() 
    50  
    51     def reload(self): 
    52         self.store.clear() 
    53  
    54         if not self.session.packet: 
    55             return 
    56  
    57         root = None 
    58  
    59         # We pray to be ordered :( 
    60         for proto in Backend.get_packet_protos(self.session.packet): 
    61             root = self.store.append(root, [self.proto_icon, Backend.get_proto_name(proto), proto]) 
    62  
    63         self.tree.expand_all() 
    64         self.tree.get_selection().select_path((0, )) 
    65  
    66     def __create_widgets(self): 
    67         # Icon / string (like TCP packet with some info?) / hidden 
    68         self.store = gtk.TreeStore(gtk.gdk.Pixbuf, str, object) 
    69         self.tree = gtk.TreeView(self.store) 
    70  
    71         pix = gtk.CellRendererPixbuf() 
    72         txt = gtk.CellRendererText() 
    73  
    74         col = gtk.TreeViewColumn(_('Protocol')) 
    75  
    76         col.pack_start(pix, False) 
    77         col.pack_start(txt, True) 
    78  
    79         col.set_attributes(pix, pixbuf=0) 
    80         col.set_attributes(txt, text=1) 
    81  
    82         self.tree.append_column(col) 
    83  
    84         self.tree.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH) 
    85         self.tree.set_rules_hint(True) 
    86  
    87     def __pack_widgets(self): 
    88         self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) 
    89         self.set_shadow_type(gtk.SHADOW_ETCHED_IN) 
    90  
    91         self.add(self.tree) 
    92  
    93     def __connect_signals(self): 
    94         self.tree.enable_model_drag_dest([('text/plain', 0, 0)], gtk.gdk.ACTION_COPY) 
    95         self.tree.connect('drag-data-received', self.__on_drag_data) 
    96  
    97     def __on_drag_data(self, widget, ctx, x, y, data, info, time): 
    98         if not self.session.packet: 
    99             ctx.finish(False, False, time) 
    100  
    101         if data and data.format == 8: 
    102             ret = self.tree.get_dest_row_at_pos(x, y) 
    103  
    104             try: 
    105                 # Try to construct an empty packet 
    106                 packet = Backend.get_proto(data.data)() 
    107                 packet = Backend.MetaPacket(packet) 
    108             except Exception: 
    109                 ctx.finish(False, False, time) 
    110  
    111             # We append as default 
    112             where = -1 
    113  
    114             if ret: 
    115                 path, pos = ret 
    116                 where = len(path) # because it's a treeview with only one child for row 
    117  
    118                 if pos == gtk.TREE_VIEW_DROP_AFTER or \ 
    119                    pos == gtk.TREE_VIEW_DROP_INTO_OR_AFTER: 
    120                     where += 1 
    121              
    122             # Now try to insert this stuff into the packet 
    123  
    124             if self.session.packet.insert(packet, where): 
    125                 ctx.finish(True, False, time) 
    126                 self.session.reload() 
    127             else: 
    128                 ctx.finish(False, False, time) 
    129  
    130         else: 
    131             ctx.finish(False, False, time) 
    132  
    133     def get_active_protocol(self): 
    134         """ 
    135         Return the selected protocol or the most 
    136         important protocol if no selection. 
    137  
    138         @return a tuple Packet, Protocol or None, None 
    139         """ 
    140  
    141         model, iter = self.tree.get_selection().get_selected() 
    142  
    143         if not iter: 
    144             return None, None 
    145  
    146         obj = model.get_value(iter, 2) 
    147          
    148         assert (Backend.is_proto(obj), "Should be a Protocol instance.") 
    149  
    150         return self.session.packet, obj 
    151  
    152  
    153 class PacketPage(gtk.VBox): 
    154     def __init__(self, parent): 
    155         super(PacketPage, self).__init__(False, 4) 
    156  
    157         self.session = parent 
    158  
    159         # Create the toolbar for sending selected packet 
    160         self.toolbar = gtk.Toolbar() 
    161         self.toolbar.set_style(gtk.TOOLBAR_ICONS) 
    162  
    163         stocks = ( 
    164             gtk.STOCK_GO_UP, 
    165             gtk.STOCK_GO_DOWN 
    166         ) 
    167  
    168         tooltips = ( 
    169             _('Send packet'), 
    170             _('Send/receive packet') 
    171         ) 
    172  
    173         callbacks = ( 
    174             self.__on_send, 
    175             self.__on_send_receive 
    176         ) 
    177  
    178         for tooltip, stock, callback in zip(tooltips, stocks, callbacks): 
    179             action = gtk.Action(None, None, tooltip, stock) 
    180             action.connect('activate', callback) 
    181             self.toolbar.insert(action.create_tool_item(), -1) 
    182  
    183         self.toolbar.insert(gtk.SeparatorToolItem(), -1) 
    184  
    185         from sys import maxint 
    186  
    187         self.packet_count = gtk.SpinButton(gtk.Adjustment(1, 0, maxint, 1, 10)) 
    188         self.packet_interval = gtk.SpinButton(gtk.Adjustment(0, 0, maxint, 1, 10)) 
    189  
    190         for lbl, widget in zip((_('No:'), _('Interval:')), 
    191                                (self.packet_count, self.packet_interval)): 
    192  
    193             hbox = gtk.HBox(False, 4) 
    194             hbox.set_border_width(2) 
    195  
    196             label = gtk.Label(lbl) 
    197             label.set_use_markup(True) 
    198             label.set_alignment(0, 0.5) 
    199  
    200             hbox.pack_start(label) 
    201             hbox.pack_start(widget) 
    202  
    203             item = gtk.ToolItem() 
    204             item.add(hbox) 
    205  
    206             self.toolbar.insert(item, -1) 
    207  
    208         self.pack_start(self.toolbar, False, False) 
    209  
    210         self.proto_hierarchy = ProtocolHierarchy(self.session) 
    211         self.hexview = HexView() 
    212  
    213         vpaned = gtk.VPaned() 
    214         vpaned.pack1(self.proto_hierarchy, True, False) 
    215         vpaned.pack2(self.hexview, True, False) 
    216          
    217         self.pack_start(vpaned) 
    218  
    219         Prefs()['gui.maintab.hexview.font'].connect(self.hexview.modify_font) 
    220         Prefs()['gui.maintab.hexview.bpl'].connect(self.hexview.set_bpl) 
    221  
    222     def redraw_hexview(self): 
    223         """ 
    224         Redraws the hexview 
    225         """ 
    226         if self.session.packet: 
    227             self.hexview.payload = Backend.get_packet_raw(self.session.packet) 
    228         else: 
    229             self.hexview.payload = "" 
    230  
    231     def reload(self): 
    232         self.redraw_hexview() 
    233         self.proto_hierarchy.reload() 
    234  
    235     def __on_send(self, action): 
    236         packet, protocol = self.proto_hierarchy.get_active_protocol() 
    237  
    238         if not packet: 
    239             return 
    240  
    241         # We start a background process in Operations tab 
    242  
    243         count = self.packet_count.get_value_as_int() 
    244         inter = self.packet_interval.get_value_as_int() 
    245  
    246         tab = PMApp().main_window.get_tab("OperationsTab") 
    247         tab.tree.append_operation(SendOperation(packet, count, inter)) 
    248  
    249     def __on_send_receive(self, action): 
    250         packet, protocol = self.proto_hierarchy.get_active_protocol() 
    251  
    252         if not packet: 
    253             return 
    254  
    255         # We start a background process in Operations tab 
    256  
    257         count = self.packet_count.get_value_as_int() 
    258         inter = self.packet_interval.get_value_as_int() 
    259  
    260         tab = PMApp().main_window.get_tab("OperationsTab") 
    261         tab.tree.append_operation(SendReceiveOperation(packet, count, inter)) 
     32from PMGui.Pages.SniffPage import SniffPage 
     33from PMGui.Pages.PacketPage import PacketPage 
    26234 
    26335class SessionPage(gtk.VBox): 

  • branch/PacketManipulator/PMGui/Widgets/FilterEntry.py

    r3448 r3453  
     1#!/usr/bin/env python 
     2# -*- coding: utf-8 -*- 
     3# Copyright (C) 2008 Adriano Monteiro Marques 
     4# 
     5# Author: Francesco Piccinno <stack.box@gmail.com> 
     6# 
     7# This program is free software; you can redistribute it and/or modify 
     8# it under the terms of the GNU General Public License as published by 
     9# the Free Software Foundation; either version 2 of the License, or 
     10# (at your option) any later version. 
     11# 
     12# This program is distributed in the hope that it will be useful, 
     13# but WITHOUT ANY WARRANTY; without even the implied warranty of 
     14# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
     15# GNU General Public License for more details. 
     16# 
     17# You should have received a copy of the GNU General Public License 
     18# along with this program; if not, write to the Free Software 
     19# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
     20 
    121import gtk 
    2 import pango 
    322import gobject 
    4 import Backend 
    523 
    6 from umitCore.I18N import _ 
    7  
    8 from PMGui.Core.App import PMApp 
    9 from Manager.PreferenceManager import Prefs 
    10 from higwidgets.higanimates import HIGAnimatedBar 
    11  
    12 class SniffRenderer(gtk.CellRendererText): 
    13     __gtype_name__ = "SniffRenderer" 
    14  
    15     def do_render(self, window, widget, back, cell, expose, flags): 
    16         cr = window.cairo_create() 
    17         cr.save() 
    18  
    19         cr.set_line_width(0.5) 
    20         cr.set_dash([1, 1], 1) 
    21         cr.move_to(back.x, back.y + back.height) 
    22         cr.line_to(back.x + back.width, back.y + back.height) 
    23         cr.stroke() 
    24  
    25         cr.restore() 
    26  
    27         return gtk.CellRendererText.do_render(self, window, widget, back, cell, expose, flags) 
    28  
    29 gobject.type_register(SniffRenderer) 
    30  
    31 class SniffPage(gtk.VBox): 
    32     COL_NO     = 0 
    33     COL_TIME   = 1 
    34     COL_SRC    = 2 
    35     COL_DST    = 3 
    36     COL_PROTO  = 4 
    37     COL_INFO   = 5 
    38     COL_COLOR  = 6 
    39     COL_OBJECT = 7 
    40  
    41     def __init__(self, session): 
    42         super(SniffPage, self).__init__(False, 4) 
    43  
    44         self.session = session 
    45  
    46         self.set_border_width(2) 
    47  
    48         self.__create_toolbar() 
    49         self.__create_view() 
    50  
    51         self.statusbar = HIGAnimatedBar('', gtk.STOCK_INFO) 
    52         self.pack_start(self.statusbar, False, False) 
    53  
    54         self.show_all() 
    55  
    56         self.use_colors = True 
    57  
    58         # TODO: get from preference 
    59         self.colors = ( 
    60             gtk.gdk.color_parse('#FFFA99'), 
    61             gtk.gdk.color_parse('#8DFF7F'), 
    62             gtk.gdk.color_parse('#FFE3E5'), 
    63             gtk.gdk.color_parse('#C797FF'), 
    64             gtk.gdk.color_parse('#A0A0A0'), 
    65             gtk.gdk.color_parse('#D6E8FF'), 
    66             gtk.gdk.color_parse('#C2C2FF'), 
    67         ) 
    68  
    69         Prefs()['gui.maintab.sniffview.font'].connect(self.__modify_font) 
    70         Prefs()['gui.maintab.sniffview.usecolors'].connect(self.__modify_colors) 
    71  
    72         self.tree.get_selection().connect('changed', self.__on_selection_changed) 
    73         self.filter.get_entry().connect('activate', self.__on_apply_filter) 
    74  
    75         self.timeout_id = None 
    76         self.reload() 
    77  
    78     def __create_toolbar(self): 
    79         self.toolbar = gtk.Toolbar() 
    80         self.toolbar.set_style(gtk.TOOLBAR_ICONS) 
    81  
    82         stocks = ( 
    83             gtk.STOCK_REFRESH, 
    84             gtk.STOCK_MEDIA_STOP, 
    85             gtk.STOCK_SAVE, 
    86             gtk.STOCK_SAVE_AS 
    87         ) 
    88  
    89         callbacks = ( 
    90             self.__on_restart, 
    91             self.__on_stop, 
    92             self.__on_save, 
    93             self.__on_save_as 
    94         ) 
    95  
    96         tooltips = ( 
    97             _('Restart capturing'), 
    98             _('Stop capturing'), 
    99             _('Save packets'), 
    100             _('Save packets as') 
    101         ) 
    102  
    103         for tooltip, stock, callback in zip(tooltips, stocks, callbacks): 
    104             action = gtk.Action(None, None, tooltip, stock) 
    105             action.connect('activate', callback) 
    106  
    107             self.toolbar.insert(action.create_tool_item(), -1) 
    108  
    109         self.filter = SniffFilter() 
    110  
    111         item = gtk.ToolItem() 
    112         item.add(self.filter) 
    113         item.set_expand(True) 
    114  
    115         self.toolbar.insert(item, -1) 
    116  
    117         self.pack_start(self.toolbar, False, False) 
    118  
    119     def __create_view(self): 
    120         sw = gtk.ScrolledWindow() 
    121         sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) 
    122         sw.set_shadow_type(gtk.SHADOW_ETCHED_IN) 
    123  
    124         self.store = gtk.ListStore(object) 
    125         self.tree = gtk.TreeView(self.store) 
    126  
    127         # Create a filter function 
    128         self.model_filter = self.store.filter_new() 
    129         self.model_filter.set_visible_func(self.__filter_func) 
    130  
    131         self.tree.set_model(self.model_filter) 
    132  
    133         idx = 0 
    134         rend = SniffRenderer() 
    135  
    136         for txt in (_('No.'), _('Time'), _('Source'), \ 
    137                     _('Destination'), _('Protocol'), _('Info')): 
    138  
    139             col = gtk.TreeViewColumn(txt, rend) 
    140             col.set_cell_data_func(rend, self.__cell_data_func, idx) 
    141             self.tree.append_column(col) 
    142  
    143             idx += 1 
    144  
    145         sw.add(self.tree) 
    146         self.pack_start(sw) 
    147  
    148     def __cell_data_func(self, col, cell, model, iter, idx): 
    149         packet = model.get_value(iter, 0) 
    150  
    151         if idx == self.COL_NO: 
    152             cell.set_property('text', str(model.get_path(iter)[0] + 1)) 
    153         elif idx == self.COL_TIME: 
    154             cell.set_property('text', packet.get_time()) 
    155         elif idx == self.COL_SRC: 
    156             cell.set_property('text', packet.get_source()) 
    157         elif idx == self.COL_DST: 
    158             cell.set_property('text', packet.get_dest()) 
    159         elif idx == self.COL_PROTO: 
    160             cell.set_property('text', packet.get_protocol_str()) 
    161         elif idx == self.COL_INFO: 
    162             cell.set_property('text', packet.summary()) 
    163  
    164         cell.set_property('cell-background-gdk', self.__get_color(packet)) 
    165         
    166     def __modify_font(self, font): 
    167         try: 
    168             desc = pango.FontDescription(font) 
    169  
    170             for col in self.tree.get_columns(): 
    171                 for rend in col.get_cell_renderers(): 
    172                     rend.set_property('font-desc', desc) 
    173  
    174             self.__redraw_rows() 
    175         except: 
    176             # Block change 
    177  
    178             return True 
    179      
    180     def __modify_colors(self, value): 
    181         self.use_colors = value 
    182         self.tree.set_rules_hint(not self.use_colors) 
    183  
    184         self.__redraw_rows() 
    185  
    186     def __redraw_rows(self): 
    187         def emit_row_changed(model, path, iter): 
    188             model.row_changed(path, iter) 
    189  
    190         self.store.foreach(emit_row_changed) 
    191  
    192     def __get_color(self, packet): 
    193         if self.use_colors: 
    194             proto = packet.get_protocol_str() 
    195             return self.colors[hash(proto) % len(self.colors)] 
    196         else: 
    197             return None 
    198  
    199     def __update_tree(self): 
    200         for packet in self.session.context.get_data(): 
    201             self.store.append([packet]) 
    202  
    203             # Scroll to end 
    204             if getattr(self.session.context, 'auto_scroll', True): 
    205                 self.tree.scroll_to_cell(len(self.model_filter) - 1) 
    206  
    207         alive = self.session.context.is_alive() 
    208  
    209         if not alive: 
    210             self.statusbar.label = "<b>%s</b>" % self.session.context.summary 
    211             self.statusbar.image = gtk.STOCK_INFO 
    212             self.statusbar.show() 
    213  
    214         return alive 
    215  
    216     # Public functions 
    217  
    218     def populate(self, pktlist): 
    219         for packet in pktlist: 
    220             self.store.append([packet]) 
    221  
    222     def clear(self): 
    223         self.store.clear() 
    224  
    225     def reload(self): 
    226         for packet in self.session.context.get_data(): 
    227             self.store.append([packet]) 
    228  
    229         self.statusbar.label = "<b>%s</b>" % self.session.context.summary 
    230  
    231         if self.timeout_id: 
    232             gobject.source_remove(self.timeout_id) 
    233  
    234         if isinstance(self.session.context, Backend.TimedContext): 
    235             self.timeout_id = gobject.timeout_add(200, self.__update_tree) 
    236  
    237     def save(self): 
    238         return self.__on_save(None) 
    239  
    240     def save_as(self): 
    241         return self.__on_save_as(None) 
    242  
    243     # Signals callbacks 
    244  
    245     def __on_selection_changed(self, selection): 
    246         model, iter = selection.get_selected() 
    247  
    248         if not iter: 
    249             return 
    250  
    251         packet = model.get_value(iter, 0) 
    252  
    253         if not packet: 
    254             return 
    255  
    256         nb = PMApp().main_window.get_tab("MainTab").session_notebook 
    257         session = nb.get_current_session() 
    258  
    259         if session: 
    260             session.set_active_packet(packet) 
    261  
    262     def __on_apply_filter(self, entry): 
    263         self.model_filter.refilter() 
    264  
    265     def __filter_func(self, model, iter): 
    266         txt = self.filter.get_text() 
    267  
    268         if not txt: 
    269             return True 
    270  
    271         packet = model.get_value(iter, 0) 
    272  
    273         strs = ( 
    274             str(model.get_path(iter)[0] + 1), 
    275             packet.get_time(), 
    276             packet.get_source(), 
    277             packet.get_dest(), 
    278             packet.get_protocol_str(), 
    279             packet.summary() 
    280         ) 
    281  
    282         # TODO: implement a search engine like num: summary: ? 
    283  
    284         for pattern in strs: 
    285             if txt in pattern: 
    286                 return True 
    287  
    288         return False 
    289  
    290     def __on_stop(self, action): 
    291         self.session.context.stop() 
    292     def __on_restart(self, action): 
    293         self.session.context.restart() 
    294  
    295     def __on_save(self, action): 
    296         if self.session.context.cap_file: 
    297             return self.__save_packets(self.session.context.cap_file) 
    298         else: 
    299             return self.__on_save_as(None) 
    300  
    301     def __on_save_as(self, action): 
    302         dialog = gtk.FileChooserDialog(_('Save Pcap file to'), 
    303                 self.get_toplevel(), gtk.FILE_CHOOSER_ACTION_SAVE, 
    304                 buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, 
    305                          gtk.STOCK_SAVE, gtk.RESPONSE_ACCEPT)) 
    306  
    307         for name, pattern in ((_('Pcap files'), '*.pcap'), 
    308                               (_('Pcap gz files'), '*.pcap.gz'), 
    309                               (_('All files'), '*')): 
    310  
    311             filter = gtk.FileFilter() 
    312             filter.set_name(name) 
    313             filter.add_pattern(pattern) 
    314             dialog.add_filter(filter) 
    315  
    316         ret = False 
    317         if dialog.run() == gtk.RESPONSE_ACCEPT: 
    318             ret = self.__save_packets(dialog.get_filename()) 
    319  
    320         dialog.hide() 
    321         dialog.destroy() 
    322  
    323         return ret 
    324  
    325     def __save_packets(self, fname): 
    326         self.session.context.cap_file = fname 
    327         ret = self.session.context.save() 
    328  
    329         if ret: 
    330             self.statusbar.image = gtk.STOCK_HARDDISK 
    331         else: 
    332             self.statusbar.image = gtk.STOCK_DIALOG_ERROR 
    333  
    334         self.statusbar.label = "<b>%s</b>" % self.session.context.summary 
    335         self.statusbar.start_animation(True) 
    336  
    337         return ret 
    338  
    339 class SniffFilter(gtk.HBox): 
    340     __gtype_name__ = "SniffFilter" 
     24class FilterEntry(gtk.HBox): 
     25    __gtype_name__ = "FilterEntry" 
    34126 
    34227    def __init__(self): 
    343         super(SniffFilter, self).__init__(False, 2) 
     28        super(FilterEntry, self).__init__(False, 2) 
    34429 
    34530        self.set_border_width(4) 
    … …  
    418103        return self._entry 
    419104 
    420 gobject.type_register(SniffFilter) 
     105gobject.type_register(FilterEntry)