def __init__(self, option=None):
OptionDisplay.__init__(self)
#Profile and Wizard core
self._profilecore = None
self._wizardcore = None
self._notebook= None
self._profile = None
self._wizard = None
self._changed = False
hbox = HIGHBox()
hbox.set_border_width(12)
self.delete_button = HIGButton(stock='gtk-delete')
self.delete_button.connect('clicked', self.delete_option)
self.new_button = HIGButton(stock='gtk-new')
self.new_button.connect('clicked', self.new_option)
self.update_button = HIGButton(stock='gtk-refresh')
self.update_button.connect('clicked', self.update_option)
self.add_button = HIGButton(stock='gtk-add')
self.add_button.connect('clicked', self.add_option)
hbox.pack_end(self.delete_button,False,False)
hbox.pack_end(self.update_button, False, False)
hbox.pack_end(self.add_button, False, False)
hbox.pack_end(self.new_button, False,False)
self.attach(hbox, 1,2,6,7)
self.optionlist = option
class PathEntry(HIGHBox, object):
def __init__(self):
HIGHBox.__init__(self)
self.entry = gtk.Entry()
self.button = HIGButton(stock=gtk.STOCK_OPEN)
self.entry.set_width_chars(20)
self.button.connect("clicked", self.open_dialog)
self._pack_expand_fill(self.entry)
self._pack_noexpand_nofill(self.button)
def connect_entry_change(self, method):
self.entry.connect("focus-out-event", method)
def open_dialog(self, widget):
dialog = DirectoryChooserDialog(title=_("Choose the path to search in"))
dialog.run()
self.path = dialog.get_filename()
self.entry.grab_focus()
dialog.destroy()
def get_path(self):
return self.entry.get_text()
def set_path(self, path):
self.entry.set_text(path)
path = property(get_path, set_path)
class OptionFile(HIGHBox, OptionWidget, object):
def __init__(self, param=""):
HIGHBox.__init__(self)
self.entry = OptionEntry()
self.button = HIGButton(stock=gtk.STOCK_OPEN)
self._pack_expand_fill(self.entry)
self._pack_noexpand_nofill(self.button)
self.entry.set_text(param)
self.button.connect('clicked', self.open_dialog_cb)
def open_dialog_cb(self, widget):
dialog = AllFilesFileChooserDialog(_("Choose file"))
if dialog.run() == gtk.RESPONSE_OK:
self.entry.set_text(dialog.get_filename())
dialog.destroy()
def get_filename(self):
return "\ ".join(self.entry.get_text().split(" "))
def set_filename(self, filename):
self.entry.set_text(" ".join(filename.split("\ ")))
filename = property(get_filename, set_filename)
def _create_widgets(self):
self._optionlist = OptionList()
label = gtk.Label('Items at the %s ' % self._name)
self._box = gtk.HPaned()
ol = self._optionlist
ol.reload()
self.vbox.pack_start(label, False, False, 0)
self._box.add(ol)
self.vbox.pack_start(self._box)
self._box.show_all()
self._move_box = HIGVBox()
self._add_bt = HIGButton(stock='gtk-add')
self._add_bt.connect('clicked', self._on_add_press)
self._remove_bt = HIGButton(stock='gtk-remove')
self._remove_bt.connect('clicked', self._on_remove_press)
#XXX - moves don't work yet: lack the connect
self._move_up_bt = HIGButton(stock='gtk-go-up')
self._move_down_bt = HIGButton(stock='gtk-go-down')
self._move_box.pack_start(self._add_bt, False, False)
self._move_box.pack_start(self._remove_bt, False, False)
self._move_box.pack_start(self._move_up_bt, False, False)
self._move_box.pack_start(self._move_down_bt, False, False)
self._create_option_tv()
self._box.set_position(200)
self._box_other = gtk.HPaned()
self._box.add(self._box_other)
self._box_other.add(self._move_box)
self._box_other.add(self._sw)
self._move_box.show_all()
self.vbox.show_all()
label.show()
def __create_widgets(self):
self.vbox = HIGVBox()
self.hbox = HIGHBox()
self.img_logo = gtk.Image()
self.event_img_logo = gtk.EventBox()
self.img = 1
self.d = {}
for c in (65, 97):
for i in range(26):
self.d[chr(i+c)] = chr((i+13) % 26 + c)
self.lbl_program_version = gtk.Label("""\
<span size='30000' weight='heavy'>Umit %s</span>""" % VERSION)
self.lbl_program_description = gtk.Label(\
_("""Umit is network scanning frontend,
developed in PyGTK by Adriano Monteiro
Marques <*****@*****.**>
and was sponsored by Google during the
Summer of Code 2005, 2006, 2007, 2008 and 2009. Thanks Google!"""))
self.lbl_copyright=gtk.Label("<small>Copyright (C) 2005-2006 \
Insecure.Com LLC. and (C) 2007-2009 Adriano Monteiro Marques</small>")
self.lbl_program_website = gtk.Label(\
"<span underline='single' \
foreground='blue'>http://www.umitproject.org</span>")
self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE)
self.btn_credits = HIGButton(_("Credits"))
def __create_widgets(self):
self.label = HIGAnimatedLabel(self.label_text)
self.close_image = gtk.Image()
self.close_image.set_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_BUTTON)
self.close_button = HIGButton()
self.close_button.set_size_request(22, 22)
self.close_button.set_relief(gtk.RELIEF_NONE)
self.close_button.set_focus_on_click(False)
self.close_button.add(self.close_image)
self.ok_image = gtk.Image()
self.ok_image.set_from_stock(gtk.STOCK_APPLY, gtk.ICON_SIZE_BUTTON)
self.ok_button = HIGButton()
self.ok_button.set_size_request(22, 22)
self.ok_button.set_relief(gtk.RELIEF_NONE)
self.ok_button.set_focus_on_click(False)
self.ok_button.add(self.ok_image)
self.close_button.connect('clicked', self.__close_button_clicked)
self.ok_button.connect('clicked', self.__ok_button_clicked)
self.label.connect('button-press-event', self.on_button_press_event)
self.label.entry.connect('focus-out-event', self.on_entry_focus_out)
for w in (self.label, self.close_button, self.ok_button):
self.pack_start(w, False, False, 0)
self.show_all()
self.switch_button_mode(False) # Change to label mode
def _create_action_area(self):
self._button_ok = HIGButton(stock='gtk-ok')
self._button_cancel = HIGButton(stock='gtk-cancel')
self._button_cancel.connect('clicked', self._on_cancel_press)
self._button_ok.connect('clicked', self._on_ok_press)
self.action_area.pack_start(self._button_cancel)
self.action_area.pack_start(self._button_ok)
self.action_area.show_all()
def __create_buttons(self):
# bottom buttons
self.apply = HIGButton(stock=gtk.STOCK_APPLY)
self.cancel = HIGButton(stock=gtk.STOCK_CANCEL)
self.ok = HIGButton(stock=gtk.STOCK_OK)
self.apply.connect("clicked", self._apply_settings)
self.ok.connect("clicked", self._apply_settings_exit)
self.cancel.connect("clicked", self._exit)
def __init__(self):
HIGWindow.__init__(self)
self.wtitle = _("SMTP Account Editor")
# header
self.title_markup = "<span size='16500' weight='heavy'>%s</span>"
self.ttitle = HIGEntryLabel("")
self.ttitle.set_line_wrap(False)
self.ttitle.set_markup(self.title_markup % self.wtitle)
self.umit_logo = gtk.Image()
self.umit_logo.set_from_file(logo)
# schemas name
self.schema_name_lbl = HIGEntryLabel(_("Schema name"))
self.schema_name = gtk.combo_box_entry_new_text()
self.schema_name.connect('changed', self._check_schema)
# smtp server
self.smtp_server_lbl = HIGEntryLabel(_("Server"))
self.smtp_server = gtk.Entry()
self.smtp_port_lbl = HIGEntryLabel(_("Port"))
self.smtp_port = gtk.Entry()
# sending mail..
self.smtp_mailfrom_lbl = HIGEntryLabel(_("Mail from"))
self.smtp_mailfrom = gtk.Entry()
# smtp auth
self.smtp_need_auth = gtk.CheckButton(_("Servers requires authentication"))
self.smtp_need_auth.connect('toggled', self._auth_need)
self.smtp_login_lbl = HIGEntryLabel(_("Username"))
self.smtp_login = gtk.Entry()
self.smtp_passwd_lbl = HIGEntryLabel(_("Password"))
self.smtp_passwd = gtk.Entry()
self.smtp_passwd.set_visibility(False)
self._auth_need(None)
# smtp encryption
self.smtp_encrypt_tls = gtk.CheckButton(_("Use TLS Encryption"))
"""
Missing: SSL encryption,
Other authentication methods.
"""
# bottom buttons
self.help = HIGButton(stock=gtk.STOCK_HELP)
self.help.connect('clicked', self._show_help)
self.apply = HIGButton(stock=gtk.STOCK_APPLY)
self.apply.connect('clicked', self._save_schema)
self.cancel = HIGButton(stock=gtk.STOCK_CANCEL)
self.cancel.connect('clicked', self._exit)
self.ok = HIGButton(stock=gtk.STOCK_OK)
self.ok.connect('clicked', self._save_schema_and_leave)
self.load_schemas()
self.__set_props()
self.__do_layout()
self.connect('destroy', self._exit)
def __create_widgets(self):
self.property_name_label = HIGEntryLabel("")
self.example_label = HIGEntryLabel("")
self.bold_tg_button = HIGToggleButton(" ", gtk.STOCK_BOLD)
self.italic_tg_button = HIGToggleButton(" ", gtk.STOCK_ITALIC)
self.underline_tg_button = HIGToggleButton(" ", gtk.STOCK_UNDERLINE)
self.text_color_button = HIGButton(_("Text"),
stock=gtk.STOCK_SELECT_COLOR)
self.highlight_color_button = HIGButton(_("Highlight"),
stock=gtk.STOCK_SELECT_COLOR)
class About(HIGWindow):
def __init__(self):
HIGWindow.__init__(self)
self.lbl_program_version = gtk.Label(
("<span size='30000' weight='heavy'>UMIT %s</span>" % VERSION) +
("\n<span size='10000' weight='heavy'>Network Inventory ") +
_("Build") + (" %s</span>" % __version__))
self.lbl_program_description = gtk.Label(
_("UMIT Network Inventory and UMIT Scheduler are UMIT\n") +
_("extensions developed by") + (" %s\n" % __author__) +
_("and was sponsored by Google during the Summer of Code "
"2007.\nThanks Google!"))
self.logo_img = gtk.Image()
self.logo_img.set_from_file(logo)
self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE)
self.btn_close.connect('clicked', lambda x, y=None:self.destroy())
self.__set_props()
self.__do_layout()
def __set_props(self):
"""
Set widget properties.
"""
self.set_title(_("About UMIT Network Inventory"))
self.set_position(gtk.WIN_POS_CENTER)
self.lbl_program_version.set_use_markup(True)
self.lbl_program_description.set_justify(gtk.JUSTIFY_CENTER)
self.lbl_program_description.set_selectable(True)
self.lbl_program_version.set_selectable(True)
def __do_layout(self):
"""
Layout window widgets.
"""
main_vbox = HIGVBox()
btns_box = HIGHBox()
main_vbox.pack_start(self.logo_img)
main_vbox.pack_start(self.lbl_program_version)
main_vbox.pack_start(self.lbl_program_description)
btns_box.pack_end(self.btn_close)
main_vbox._pack_noexpand_nofill(btns_box)
self.btn_close.grab_focus()
self.add(main_vbox)
class ScriptManagerProgressWindow(HIGWindow):
def __init__(self, parent):
HIGWindow.__init__(self)
self.set_title(_("Script Manager Progress"))
self.set_position(gtk.WIN_POS_CENTER)
self.set_size_request(300, 200)
self.vbox = HIGVBox()
self.label = gtk.Label()
self.vbox.pack_start(self.label)
self.progress_all = HIGLabeledProgressBar(_("Overall progress"))
self.vbox.pack_start(self.progress_all)
self.progress_current = HIGLabeledProgressBar(_("Current source"))
self.vbox.pack_start(self.progress_current)
self.btn_cancel = HIGButton(stock=gtk.STOCK_CANCEL)
self.btn_cancel.connect("clicked", self._cancel_cb)
self.vbox.pack_start(self.btn_cancel)
self.add(self.vbox)
self.show_all()
self.timeout_id = gobject.timeout_add(100, self.callback)
self.status = (None, None, None)
import thread
self.lock = thread.allocate_lock()
reload_thread(parent.base, self, self.lock)
#thread.start_new_thread(reload_thread, (parent.base, self, self.lock))
#self.thread = ScriptManagerReloadThread(parent.base)
#self.thread.start()
def _cancel_cb(self, widget):
if self.timeout_id:
gobject.source_remove(self.timeout_id)
self.lock.acquire()
self.destroy()
def callback(self):
src, all, current = self.status
print "cb:", self.status
if src:
self.label.set_text(src.path)
if all:
if all[0] == all[1]:
gobject.source_remove(self.timeout_id)
self.timeout_id = None
self.progress_all.progress_bar.set_fraction(float(all[0])/all[1])
self.progress_all.label.set_text("%d/%d" % all)
else:
self.progress_all.progress_bar.set_fraction(0)
self.progress_all.label.set_text("")
if current:
self.progress_current.progress_bar.set_fraction(float(current[0])/current[1])
self.progress_current.label.set_text("%d/%d" % current)
else:
self.progress_current.progress_bar.set_fraction(0)
self.progress_current.label.set_text("")
def __create_widgets(self):
""""""
self.peerinfo_hbox = HIGHBox()
self.cloudagg_hbox = HIGHBox()
self.superpeers_hbox = HIGHBox()
self.pref_location_hbox = HIGHBox()
self.peerinfo_section = HIGSectionLabel(_("Peer Info"))
self.peerinfo_table = HIGTable()
self.pref_location_section = HIGSectionLabel(_("Preferred Locations"))
self.pref_location_table = HIGTable()
self.cloudagg_section = HIGSectionLabel(_("Cloud Aggregator"))
self.cloudagg_table = HIGTable()
self.cloudagg_subhbox = HIGHBox()
self.superpeers_section = HIGSectionLabel(_("Super Peers"))
self.superpeers_table = HIGTable()
self.peerid_label = HIGEntryLabel(_("Peer ID:"))
self.email_label = HIGEntryLabel(_("Email Address:"))
self.test_version_label = HIGEntryLabel(_("Test Sets Version:"))
self.peerid_label2 = HIGEntryLabel()
self.email_entry = gtk.Entry()
self.test_version_label2 = HIGEntryLabel()
self.longitude_label = HIGLabel(_("longitude:"))
self.longitude_entry = gtk.Entry()
self.latitude_label = HIGLabel(_("latitude:"))
self.latitude_entry = gtk.Entry()
self.cloudagg_entry = gtk.Entry()
self.cloudagg_button = HIGButton(_("Reset"))
self.cloudagg_button.connect('clicked', lambda w: self.reset_aggregator_url())
self.cloudagg_button.set_size_request(80, 28)
self.superpeers_ip_label = HIGLabel(_("IP:"))
self.superpeers_ip_entry = gtk.Entry()
self.superpeers_ip_entry.set_size_request(160, 26)
self.superpeers_port_label = HIGLabel(_("Port:"))
self.superpeers_port_entry = gtk.Entry()
self.superpeers_port_entry.set_size_request(80, 26)
self.superpeers_subhbox = HIGHBox()
self.btn_box = gtk.HButtonBox()
self.superpeers_button1 = HIGButton(_("Add"))
self.superpeers_button1.connect('clicked',lambda w:self.add_superpeer())
self.superpeers_button2 = HIGButton(_("Show all"))
self.superpeers_button2.connect('clicked', lambda w:
self.show_super_peer_list_window())
class TimeBox(gtk.HBox):
"""
GUI Controls for handling Timeline date visualization.
"""
def __init__(self, connector, tlbase):
gtk.HBox.__init__(self)
self.connector = connector
self.tlbase = tlbase
self.connector.connect('date-changed', self._update_current_date)
# viewing by
cur_mode = view_mode_descr[self.tlbase.graph_mode]
self.dateselect_lbl = HIGEntryLabel(cur_mode)
values = self.tlbase.bounds_by_graphmode()
self.dateselect = gtk.SpinButton(gtk.Adjustment(value=values[2],
lower=values[0], upper=values[1], step_incr=1), 1)
self.dateselect_apply = HIGButton(stock=gtk.STOCK_APPLY)
self.dateselect_apply.connect("clicked", self._date_change)
self.__layout()
def _date_change(self, event):
"""
Sends new date.
"""
self.connector.emit('date-update', self.dateselect.get_value_as_int())
def _update_current_date(self, event):
"""
Update spinbutton and values based on new date.
"""
cur_mode = view_mode_descr[self.tlbase.graph_mode]
self.dateselect_lbl.set_label(cur_mode)
values = self.tlbase.bounds_by_graphmode()
self.dateselect.set_range(values[0], values[1])
self.dateselect.set_value(values[2])
def __layout(self):
"""
Layout widgets.
"""
self.pack_start(self.dateselect_lbl, False, False, 0)
self.pack_start(self.dateselect, False, False, 0)
self.pack_start(self.dateselect_apply, False, False, 0)
def __create_widgets(self):
self.set_spacing(4)
self.richlist = HIGRichList()
self.hbbox = gtk.HButtonBox()
self.hbbox.set_layout(gtk.BUTTONBOX_END)
self.find_updates_btn = \
HIGButton(_('Find updates'), gtk.STOCK_REFRESH)
self.install_updates_btn = \
HIGButton(_('Install updates'), gtk.STOCK_APPLY)
self.skip_install_btn = \
HIGButton(_('Skip'), gtk.STOCK_CANCEL)
self.restart_btn = \
HIGButton(_('Restart UMIT'), gtk.STOCK_REFRESH)
def __init__(self, type_ = None, path = None):
if type_ and path:
title = _("Edit Source")
else:
type_ = "FILE"
path = ""
title = _("Add Source")
HIGDialog.__init__(self, title, None,
gtk.DIALOG_MODAL,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OK, gtk.RESPONSE_OK))
hbox = HIGHBox()
self.combo = gtk.combo_box_new_text()
types = sorted(self.types.keys())
for t in types:
self.combo.append_text(t)
self.combo.set_active(types.index(type_))
self.combo.connect("changed", self._changed_cb)
hbox.pack_start(self.combo, False, False)
self.entry = HIGTextEntry()
self.entry.set_text(path)
hbox.pack_start(self.entry)
self.btn = HIGButton(_("Browse..."), stock=gtk.STOCK_OPEN)
self.btn.connect("clicked", self._clicked_cb)
hbox.pack_start(self.btn, False, False)
self.vbox.add(hbox)
self.show_all()
self.update()
def __create_widgets(self):
self.vbox = HIGVBox()
self.hbox = HIGHBox()
self.notebook = HIGNotebook()
self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE)
self.written_by_scroll = HIGScrolledWindow()
self.written_by_text = HIGTextView()
self.design_scroll = HIGScrolledWindow()
self.design_text = HIGTextView()
self.soc2007_scroll = HIGScrolledWindow()
self.soc2007_text = HIGTextView()
self.soc2008_scroll = HIGScrolledWindow()
self.soc2008_text = HIGTextView()
self.soc2009_scroll = HIGScrolledWindow()
self.soc2009_text = HIGTextView()
self.contributors_scroll = HIGScrolledWindow()
self.contributors_text = HIGTextView()
self.translation_scroll = HIGScrolledWindow()
self.translation_text = HIGTextView()
self.nokia_scroll = HIGScrolledWindow()
self.nokia_text = HIGTextView()
def create_and_attach_widgets(self):
self.option_label = HIGSectionLabel('New Option')
self.attach(self.option_label, 0, 3, 0, 1)
self.name_label = HIGEntryLabel(_('Name:'))
self.name_entry = HIGTextEntry()
self.attach(self.name_label, 0,1,1,2)
self.attach(self.name_entry, 1,3,1,2)
self.hint_label = HIGEntryLabel(_('Hint:'))
self.hint_entry = HIGTextEntry()
self.attach(self.hint_label, 0,1,2,3)
self.attach(self.hint_entry,1,3,2,3)
self.need_root = gtk.CheckButton(_('Need root'))
self.attach(self.need_root, 0,1,3,4)
self.options_label = HIGEntryLabel(_('Options:'))
hbox = HIGHBox()
self.options_entry = HIGTextEntry()
self.insert_arg_button = HIGButton(title='Args', stock='gtk-add')
self.insert_arg_button.connect('clicked', self.update_args)
self.attach(self.options_label,0,1,4,5)
self.attach(self.options_entry, 1,2,4,5)
self.attach(self.insert_arg_button, 2,3, 4, 5)
self.aguments_label = HIGEntryLabel(_('Arguments:'))
self.arguments_entry = HIGTextEntry()
self.arguments_entry.set_editable(False)
self.attach(self.aguments_label, 0,1, 5,6)
self.attach(self.arguments_entry, 1,3,5,6)
def __create_widgets(self):
self.image = gtk.image_new_from_pixbuf(self._reader.get_logo())
self.label = gtk.Label('')
self.label.set_ellipsize(pango.ELLIPSIZE_END)
self.versions_model = gtk.ListStore(str, str)
self.versions_button = gtk.ComboBox(self.versions_model)
rend = gtk.CellRendererPixbuf()
self.versions_button.pack_start(rend, False)
self.versions_button.add_attribute(rend, 'stock-id', 0)
rend = gtk.CellRendererText()
self.versions_button.pack_end(rend)
self.versions_button.add_attribute(rend, 'text', 1)
self.img_play = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PLAY, \
gtk.ICON_SIZE_BUTTON)
self.img_stop = gtk.image_new_from_stock(gtk.STOCK_MEDIA_STOP, \
gtk.ICON_SIZE_BUTTON)
self.action_btn = HIGButton('')
self.uninstall_btn = HIGButton(_("Uninstall"), gtk.STOCK_CLEAR)
self.preference_btn = HIGButton(stock=gtk.STOCK_PREFERENCES)
self.progressbar = gtk.ProgressBar()
def __init__(self, daddy, profile=None):
HIGWindow.__init__(self)
self.daddy = daddy
self.wtitle = _("Scheduling Profiles Editor")
self.start_profile = profile
# header
self.title_markup = "<span size='16500' weight='heavy'>%s</span>"
self.ttitle = HIGEntryLabel("")
self.ttitle.set_line_wrap(False)
self.ttitle.set_markup(self.title_markup % self.wtitle)
self.umit_logo = gtk.Image()
self.umit_logo.set_from_file(logo)
# profiles name
self.schedp_name_lbl = HIGEntryLabel(_("Scheduling Profile"))
self.schedp_name = gtk.combo_box_entry_new_text()
self.schedp_name.connect("changed", self._check_profile)
# cron format
self.cron_frame = HIGFrame(_("Schedule"))
self.cron_minute_lbl = HIGEntryLabel(_("Minute"))
self.cron_minute = gtk.Entry()
self.cron_hour_lbl = HIGEntryLabel(_("Hour"))
self.cron_hour = gtk.Entry()
self.cron_day_lbl = HIGEntryLabel(_("Day of month"))
self.cron_day = gtk.Entry()
self.cron_month_lbl = HIGEntryLabel(_("Month"))
self.cron_month = gtk.Entry()
self.cron_weekday_lbl = HIGEntryLabel(_("Weekday"))
self.cron_weekday = gtk.Entry()
# bottom buttons
self.help = HIGButton(stock=gtk.STOCK_HELP)
self.help.connect("clicked", self._show_help)
self.apply = HIGButton(stock=gtk.STOCK_APPLY)
self.apply.connect("clicked", self._save_profile)
self.cancel = HIGButton(stock=gtk.STOCK_CANCEL)
self.cancel.connect("clicked", self._exit)
self.ok = HIGButton(stock=gtk.STOCK_OK)
self.ok.connect("clicked", self._save_profile_and_leave)
self.load_profiles()
self.__set_props()
self.__do_layout()
self.connect("destroy", self._exit)
def __create_widgets (self):
# Creating widgets
self.scrolled = gtk.ScrolledWindow ()
self.text_view = gtk.TextView ()
self.btn_refresh = gtk.Button (stock=gtk.STOCK_REFRESH)
self.check_enable_color = gtk.CheckButton(\
_("Enable Nmap output highlight"))
self.btn_output_properties = HIGButton(stock=gtk.STOCK_PREFERENCES)
self.hbox_buttons = gtk.HBox (spacing=5)
def __init__(self):
HIGHBox.__init__(self)
self.entry = gtk.Entry()
self.button = HIGButton(stock=gtk.STOCK_OPEN)
self.entry.set_width_chars(20)
self.button.connect("clicked", self.open_dialog)
self._pack_expand_fill(self.entry)
self._pack_noexpand_nofill(self.button)
def __init__(self, param=""):
HIGHBox.__init__(self)
self.entry = OptionEntry()
self.button = HIGButton(stock=gtk.STOCK_OPEN)
self._pack_expand_fill(self.entry)
self._pack_noexpand_nofill(self.button)
self.entry.set_text(param)
self.button.connect('clicked', self.open_dialog_cb)
def __init__(self):
HIGWindow.__init__(self)
self.tooltips = gtk.Tooltips()
self.data_lbl = HIGSectionLabel(_("Delete data older than"))
self.days_lbl = HIGSectionLabel(_("days"))
self.days = gtk.SpinButton(gtk.Adjustment(value=get_decays()[1],
lower=0, upper=5000, step_incr=1), 1)
self.tooltips.set_tip(self.days,
_("Set value as 0 to disable data removal"))
self.cancel = HIGButton(stock=gtk.STOCK_CANCEL)
self.apply = HIGButton(stock=gtk.STOCK_APPLY)
self.cancel.connect("clicked", self._exit)
self.apply.connect("clicked", self._set_new_decay)
self.__set_props()
self.__do_layout()
def __create_widgets(self):
self.main_vbox = HIGVBox()
self.command_expander = HIGExpander('<b>'+_('Command')+'</b>')
self.command_expander.set_expanded(True)
self.command_entry = gtk.Entry()
self.notebook = gtk.Notebook()
# Profile info page
self.profile_info_vbox = HIGVBox()
self.profile_info_label = HIGSectionLabel(_('Profile Information'))
self.profile_name_label = HIGEntryLabel(_('Profile name'))
self.profile_name_entry = gtk.Entry()
self.profile_hint_label = HIGEntryLabel(_('Hint'))
self.profile_hint_entry = gtk.Entry()
self.profile_description_label = HIGEntryLabel(_('Description'))
#self.profile_description_label = HIGHBox()
self.profile_description_scroll = HIGScrolledWindow()
self.profile_description_text = HIGTextView()
self.profile_annotation_label = HIGEntryLabel(_('Annotation'))
#self.profile_annotation_label = HIGHBox()
self.profile_annotation_scroll = HIGScrolledWindow()
self.profile_annotation_text = HIGTextView()
# Buttons
self.buttons_hbox = HIGHBox()
self.help_button = HIGButton(stock=gtk.STOCK_HELP)
self.help_button.connect('clicked', self.help)
#self.delete_button = HIGButton(stock=gtk.STOCK_DELETE)
#self.delete_button.connect('clicked', self.delete_profile)
self.cancel_button = HIGButton(stock=gtk.STOCK_CANCEL)
self.cancel_button.connect('clicked', self.quit_without_saving)
self.ok_button = HIGButton(stock=gtk.STOCK_OK)
self.ok_button.connect('clicked', self.save_profile)
def _create_widgets(self):
self.main_vbox = HIGVBox()
self.hbox_mode = HIGHBox()
self.hbox_settings = HIGHBox()
self.hbox_buttons = HIGHBox()
self.hbox_result = HIGHBox()
self.btn_open_browser = HIGButton(_("Open in Browser"),
stock=gtk.STOCK_EXECUTE)
self.btn_help = HIGButton(stock=gtk.STOCK_HELP)
self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE)
self.check_color = gtk.CheckButton(_("Enable colored diffies"))
self.btn_legend = HIGButton(_("Color Descriptions"),
stock=gtk.STOCK_SELECT_COLOR)
self.text_mode = gtk.ToggleButton(_("Text Mode"))
self.compare_mode = gtk.ToggleButton(_("Compare Mode"))
self.vpaned = gtk.VPaned()
self.hpaned = gtk.HPaned()
self.scan_chooser1 = ScanChooser(self.scans, "1")
self.scan_chooser2 = ScanChooser(self.scans, "2")
self.scan_buffer1 = self.scan_chooser1.get_buffer()
self.scan_buffer2 = self.scan_chooser2.get_buffer()
def create_widgets(self):
vboxmain = gtk.VBox()
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.store = gtk.ListStore(str)
self.update_model()
self.treeView = gtk.TreeView(self.store)
#treeView.connect("row-activated", self.on_activated)
#treeView.set_rules_hint(True)
self.create_columns(self.treeView)
sw.add(self.treeView)
# buttons
vbox = HIGVBox()
btn = HIGButton(_("Edit..."), gtk.STOCK_EDIT)
vbox.pack_start(btn, False, False)
btn.connect("clicked", self._edit_template)
btn = HIGButton(_("Remove"), gtk.STOCK_REMOVE)
vbox.pack_start(btn, False, False)
btn.connect("clicked", self._remove_template)
hbox = HIGHBox()
hbox.pack_start(sw, True, True)
hbox.pack_start(vbox, False, False)
vboxmain.pack_start(hbox, True, True, 0)
self.add(vboxmain)
self.show_all()
def _create_widgets(self):
t = localtime()
self.date_button = HIGButton()
self.date_sep = gtk.Label(", ")
self.hour = gtk.SpinButton(gtk.Adjustment(value=t[3],
lower=0,
upper=23,
step_incr=1), 1)
self.hour_sep = gtk.Label(":")
self.minute = gtk.SpinButton(gtk.Adjustment(value=t[4],
lower=0,
upper=59,
step_incr=1), 1)
def _draw_buttons(self):
self.button_list = HIGButton('Option List')
img = gtk.Image()
img_dir = os.path.join(pixmaps_dir, 'uie', 'combo.png')
img.set_from_file(img_dir)
self.button_list.set_image(img)
self.button_list.drag_source_set(gtk.gdk.BUTTON1_MASK ,
target, gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE)
self.button_list.connect('drag_data_get', self._drag_option_list)
self.button_label = HIGButton('Label')
img = gtk.Image()
img_dir = os.path.join(pixmaps_dir,'uie', 'label.png')
img.set_from_file(img_dir)
self.button_label.set_image(img)
self.button_label.drag_source_set(gtk.gdk.BUTTON1_MASK ,
target, gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE)
self.button_label.connect('drag_data_get', self.source_drag_data_get)
self.button_check = HIGButton('Option Check')
img = gtk.Image()
img_dir = os.path.join(pixmaps_dir, 'uie', 'checkbutton.png')
img.set_from_file(img_dir)
self.button_check.set_image(img)
self.button_path = HIGButton('Choose Path')
self.button_text_entry = HIGButton('String')
img = gtk.Image()
img_dir = os.path.join(pixmaps_dir,'uie', 'entry.png')
img.set_from_file(img_dir)
self.button_text_entry.set_image(img)
self.button_float = HIGButton('Float Spin')
img = gtk.Image()
img_dir = os.path.join(pixmaps_dir, 'uie', 'spinbutton.png')
img.set_from_file(img_dir)
self.button_float.set_image(img)
self.button_level = HIGButton('Level Spin')
img = gtk.Image()
img_dir = os.path.join(pixmaps_dir, 'uie', 'spinbutton.png')
img.set_from_file(img_dir)
self.button_level.set_image(img)
self.button_interface = HIGButton('Interface')
self.button_integer = HIGButton('Integer Spin ')
img = gtk.Image()
img_dir = os.path.join(pixmaps_dir, 'uie', 'spinbutton.png')
img.set_from_file(img_dir)
self.button_integer.set_image(img)
def _create_widgets(self):
'''
Create the main entrys of the option
'''
self._box = HIGVBox()
self._table = HIGTable()
#Name
self._label_name = HIGEntryLabel(_('Name'))
self._entry_name = HIGTextEntry()
self._entry_name.connect('activate', self._update_label)
#Type
self._label_type = HIGEntryLabel(_('Type'))
self._combo_type = gtk.combo_box_new_text()
self._combo_type.append_text('')
self._combo_type.append_text('Option List')
self._combo_type.append_text('Option Check')
self._combo_type.set_active(0)
self._combo_type.connect('changed', self.change_combo)
self._label_opt = HIGEntryLabel(_('Option'))
self._entry_opt = HIGTextEntry()
self._entry_opt.set_sensitive(False)
#For option list open a dialog to add/remove options
self._button_list = HIGButton('Edit Option List')
img = gtk.Image()
img_dir = os.path.join(pixmaps_dir, 'uie', 'combo.png')
img.set_from_file(img_dir)
self._button_list.set_image(img)
self._button_list.connect('button-press-event', self._button_list_clicked)
self._table.attach(self._label_name, 0,1,0, 1)
self._table.attach(self._entry_name, 1,2,0,1)
self._table.attach(self._label_type, 0,1,1,2)
self._table.attach(self._combo_type, 1,2,1, 2)
self._table.attach(self._button_list, 0,2, 3,4)
self._table.attach(self._label_opt, 0,1, 4,5)
self._table.attach(self._entry_opt, 1,2,4,5)
self._box.pack_start(self._table, False, False)
class PeerInfoPage(HIGVBox):
""""""
#----------------------------------------------------------------------
def __init__(self):
"""Constructor"""
HIGVBox.__init__(self)
self.__create_widgets()
self.__pack_widgets()
def __create_widgets(self):
""""""
self.peerinfo_hbox = HIGHBox()
self.cloudagg_hbox = HIGHBox()
self.superpeers_hbox = HIGHBox()
self.pref_location_hbox = HIGHBox()
self.peerinfo_section = HIGSectionLabel(_("Peer Info"))
self.peerinfo_table = HIGTable()
self.pref_location_section = HIGSectionLabel(_("Preferred Locations"))
self.pref_location_table = HIGTable()
self.cloudagg_section = HIGSectionLabel(_("Cloud Aggregator"))
self.cloudagg_table = HIGTable()
self.cloudagg_subhbox = HIGHBox()
self.superpeers_section = HIGSectionLabel(_("Super Peers"))
self.superpeers_table = HIGTable()
self.peerid_label = HIGEntryLabel(_("Peer ID:"))
self.email_label = HIGEntryLabel(_("Email Address:"))
self.test_version_label = HIGEntryLabel(_("Test Sets Version:"))
self.peerid_label2 = HIGEntryLabel()
self.email_entry = gtk.Entry()
self.test_version_label2 = HIGEntryLabel()
self.longitude_label = HIGLabel(_("longitude:"))
self.longitude_entry = gtk.Entry()
self.latitude_label = HIGLabel(_("latitude:"))
self.latitude_entry = gtk.Entry()
self.cloudagg_entry = gtk.Entry()
self.cloudagg_button = HIGButton(_("Reset"))
self.cloudagg_button.connect('clicked',
lambda w: self.reset_aggregator_url())
self.cloudagg_button.set_size_request(80, 28)
self.superpeers_ip_label = HIGLabel(_("IP:"))
self.superpeers_ip_entry = gtk.Entry()
self.superpeers_ip_entry.set_size_request(160, 26)
self.superpeers_port_label = HIGLabel(_("Port:"))
self.superpeers_port_entry = gtk.Entry()
self.superpeers_port_entry.set_size_request(80, 26)
self.superpeers_subhbox = HIGHBox()
self.btn_box = gtk.HButtonBox()
self.superpeers_button1 = HIGButton(_("Add"))
self.superpeers_button1.connect('clicked',
lambda w: self.add_superpeer())
self.superpeers_button2 = HIGButton(_("Show all"))
self.superpeers_button2.connect(
'clicked', lambda w: self.show_super_peer_list_window())
def __pack_widgets(self):
self.set_border_width(12)
self._pack_noexpand_nofill(self.peerinfo_section)
self._pack_noexpand_nofill(self.peerinfo_hbox)
self._pack_noexpand_nofill(self.pref_location_section)
self._pack_noexpand_nofill(self.pref_location_hbox)
self._pack_noexpand_nofill(self.cloudagg_section)
self._pack_noexpand_nofill(self.cloudagg_hbox)
self._pack_noexpand_nofill(self.superpeers_section)
self._pack_noexpand_nofill(self.superpeers_hbox)
self.peerinfo_hbox._pack_noexpand_nofill(hig_box_space_holder())
self.peerinfo_hbox._pack_expand_fill(self.peerinfo_table)
self.pref_location_hbox._pack_noexpand_nofill(hig_box_space_holder())
self.pref_location_hbox._pack_expand_fill(self.pref_location_table)
self.cloudagg_hbox._pack_noexpand_nofill(hig_box_space_holder())
self.cloudagg_hbox._pack_expand_fill(self.cloudagg_table)
self.superpeers_hbox._pack_noexpand_nofill(hig_box_space_holder())
self.superpeers_hbox._pack_expand_fill(self.superpeers_table)
self.peerinfo_table.attach_label(self.peerid_label, 0, 1, 0, 1)
self.peerinfo_table.attach_label(self.email_label, 0, 1, 2, 3)
self.peerinfo_table.attach_label(self.test_version_label, 0, 1, 1, 2)
self.peerinfo_table.attach_label(self.test_version_label2, 1, 2, 1, 2)
self.peerinfo_table.attach_label(self.peerid_label2, 1, 2, 0, 1)
self.peerinfo_table.attach_entry(self.email_entry, 1, 2, 2, 3)
self.pref_location_table.attach(self.longitude_label, 0, 1, 0, 1)
self.pref_location_table.attach(self.longitude_entry, 1, 2, 0, 1)
self.pref_location_table.attach(self.latitude_label, 2, 3, 0, 1)
self.pref_location_table.attach(self.latitude_entry, 3, 4, 0, 1)
self.cloudagg_subhbox._pack_expand_fill(self.cloudagg_entry)
self.cloudagg_subhbox._pack_noexpand_nofill(self.cloudagg_button)
self.cloudagg_table.attach_entry(self.cloudagg_subhbox, 0, 1, 0, 1)
self.btn_box.set_layout(gtk.BUTTONBOX_END)
self.btn_box.set_spacing(8)
self.btn_box.pack_start(self.superpeers_button1)
self.btn_box.pack_start(self.superpeers_button2)
self.superpeers_subhbox._pack_expand_fill(self.superpeers_ip_label)
self.superpeers_subhbox._pack_expand_fill(self.superpeers_ip_entry)
self.superpeers_subhbox._pack_expand_fill(self.superpeers_port_label)
self.superpeers_subhbox._pack_expand_fill(self.superpeers_port_entry)
self.superpeers_subhbox._pack_noexpand_nofill(self.btn_box)
self.superpeers_table.attach_label(self.superpeers_subhbox, 0, 1, 0, 1)
def add_superpeer(self):
"""
Add Super Peer by manual into database
"""
ip = self.superpeers_ip_entry.get_text()
port = self.superpeers_port_entry.get_text()
g_db_helper.set_super_peer_manual(ip, port)
def reset_aggregator_url(self):
"""
"""
aggregator_url = 'http://east1.openmonitor.org'
self.cloudagg_entry.set_text(aggregator_url)
theApp.aggregator.base_url = aggregator_url
g_config.set('network', 'aggregator_url', aggregator_url)
g_db_helper.set_value('config', 'aggregator_url', aggregator_url)
def show_super_peer_list_window(self):
from umit.icm.agent.gui.Preference.SuperPeerSetting import SuperPeerListWindow, SuperPeersBox
wnd = SuperPeerListWindow()
wnd.show_all()
class GeneralSettings(TabBox, object):
"""
General Settings
- Splash enable/disable
- Warnings
- Erros, log, configure bugreport
- Autosave: clean up, define folder etc
- Define Nmap Command
"""
def __init__(self, name):
TabBox.__init__(self, name)
def _create_widgets(self):
"""
Design all
"""
# Create general widgets
self._create_widgets_common()
self._create_widgets_autosave()
self._create_widgets_error()
# Packing main section
self.pack_start(self._box_common, False, False)
self.pack_start(self._box_error_frame, False, False)
self.pack_start(self._box_save_frame, False, False)
self._box_error_frame.set_shadow_type(gtk.SHADOW_NONE)
self._box_error_frame.set_shadow_type(gtk.SHADOW_NONE)
# Settings Values
self.splash = general_settings.splash
self.warnings_extensions = general_settings.warnings_extensions
self.silent_root = general_settings.silent_root
self.crash_report = general_settings.crash_report
self.log = general_settings.log
self.log_file = general_settings.log_file
self.warnings_save = general_settings.warnings_save
self._connect_events()
def _create_widgets_common(self):
""" generally tab """
self._box_common = HIGVBox() # pack main section
self.__check_splash = gtk.CheckButton(_('Enable Splash on start'))
self.__check_silent_root = gtk.CheckButton(\
_('Silent Warning Non-Root'))
self.__check_warning_extensions = gtk.CheckButton(\
_('Set/Check extensions - Windows only'))
self._box_common.pack_start(self.__check_splash, False, False)
#self._box_common.pack_start(self.__check_warning_extensions, False, \
# False)
self._box_common.pack_start(self.__check_silent_root, False, False)
self.__label_nmap = HIGEntryLabel(_('Nmap Command'))
self.__entry_nmap = HIGTextEntry()
# Files usr saved on predefined directory:
self.__label_path = HIGEntryLabel(_('Nmap Command'))
self.__entry_path = HIGTextEntry()
self.__button_path = HIGButton(_('Choose'))
self.__box_path = HIGHBox()
self.__box_path.pack_start(self.__label_path, False, False)
self.__box_path.pack_end(self.__button_path, False, False)
self._box_common.set_border_width(0)
def _create_widgets_error(self):
# Create Widgets
self._box_error_frame = HIGFrame('Error')
self._box_error = HIGTable(5, 2)
self._box_error.set_border_width(10)
self._box_error_frame.add(self._box_error)
self.__crash_report = gtk.CheckButton(_('Enable Crash Report'))
# Radio Button List
self.__log_no = gtk.RadioButton(None, _('No log'))
self.__log_terminal = gtk.RadioButton(self.__log_no, _('Enable log in terminal'))
self.__log_file = gtk.RadioButton(self.__log_terminal,\
_('Enable log file'))
self.__log_file_label = HIGEntryLabel(_('Log file'))
self.__log_file_entry = HIGTextEntry()
self.__log_file_entry.set_editable(False)
# FIXME: Do default file ~/.umit/umit.log
self.__log_file_browser = HIGButton(_('Browse file'), \
gtk.STOCK_DIRECTORY)
tmpbox = HIGHBox()
tmpbox.pack_start(self.__log_file_entry, False, False)
tmpbox.pack_start(self.__log_file_browser, False, False)
# attach table
self._box_error.attach(self.__crash_report, 0,1,0,1,\
gtk.FILL|gtk.EXPAND| gtk.SHRINK, gtk.FILL)
self._box_error.attach(self.__log_no, 0,1,1,2,\
gtk.FILL|gtk.EXPAND| gtk.SHRINK, gtk.FILL)
self._box_error.attach(self.__log_terminal, 0,1,2,3,\
gtk.FILL|gtk.EXPAND| gtk.SHRINK, gtk.FILL)
self._box_error.attach(self.__log_file, 0,1,3,4,\
gtk.FILL|gtk.EXPAND| gtk.SHRINK, gtk.FILL)
self._box_error.attach(self.__log_file_label, 0,1,4,5,\
gtk.FILL|gtk.EXPAND| gtk.SHRINK, gtk.FILL)
self._box_error.attach(tmpbox, 1,2,4,5,\
gtk.FILL|gtk.EXPAND| gtk.SHRINK, gtk.FILL)
def _create_widgets_autosave(self):
# Create Widgets
self._box_save_frame = HIGFrame('Auto-save')
self._box_save = HIGVBox()
self._box_save_frame.add(self._box_save)
self._box_save.set_border_width(10)
self._warnings_save = gtk.CheckButton(
_('Enable warnings without saving'))
self._clean_b = HIGButton(_('Delete saved files'), gtk.STOCK_CLEAR)
self._clean_b_box = HIGHBox()
self._clean_b_box.pack_start(self._clean_b, False, True)
# pack
self._box_save.pack_start(self._warnings_save, False, False)
self._box_save.pack_start(self._clean_b_box, False, False)
def _connect_events(self):
"""
connect call backs
"""
self.__check_splash.connect('toggled', self.update_splash)
self.__check_silent_root.connect('toggled', self.update_silent_root)
self.__crash_report.connect('toggled', self.update_crash_report)
self.__log_file.connect('toggled', self.update_log)
self.__log_file.connect('toggled', self.update_log_file)
self.__log_terminal.connect('toggled', self.update_log)
self.__log_no.connect('toggled', self.update_log)
self.__log_file_browser.connect('clicked', self.read_file)
self.__log_file_entry.connect('changed', self.update_log_file_text)
self._warnings_save.connect('toggled', self.update_save_warn)
self._clean_b.connect('clicked', self.delete_files)
self.update_log_file(None)
# Callbacks
def delete_files(self, widget):
# NOTE: This method should be adapted in umit.core.UserConf
# Creating an empty recent_scans file
log.debug('>>> Reset store files: - %s' % base_paths['user_dir'])
reset_user_dir(base_paths['user_dir'])
def update_save_warn(self, widget):
general_settings.warnings_save = self.warnings_save
def read_file(self, widget):
dialog = gtk.FileChooserDialog("Open..",
None,
gtk.FILE_CHOOSER_ACTION_SAVE,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_SAVE_AS, gtk.RESPONSE_OK))
dialog.set_default_response(gtk.RESPONSE_OK)
response = dialog.run()
if response == gtk.RESPONSE_OK:
# Get name of file
self.__log_file_entry.set_text(dialog.get_filename())
dialog.destroy()
def update_crash_report(self, widget):
general_settings.crash_report = self.crash_report
def update_splash(self, widget):
general_settings.splash = self.splash
def update_silent_root(self, widget):
general_settings.silent_root = self.silent_root
def update_log_file_text(self, widget):
general_settings.log_file = self.log_file
def update_log_file(self, widget):
if not self.__log_file.get_active():
self.__log_file_active(False)
else:
self.__log_file_active(True)
def update_log(self, widget):
""" Verify if is enable, if it is not enable nothing to do """
if not widget.get_active():
return
# Widget is enable.
## But which is enable?
# Setting kind of log
if widget == self.__log_no:
general_settings.log = "None"
elif widget == self.__log_terminal:
general_settings.log = "Debug"
elif widget == self.__log_file:
general_settings.log = "File"
# API
def get_splash(self):
return self.__check_splash.get_active()
def set_splash(self, splash):
self.__check_splash.set_active(splash)
def set_warnings_extensions(self, extensions):
self.__check_warning_extensions.set_active(extensions)
def get_warnings_extensions(self):
return self.__check_warning_extensions.get_active()
def set_silent_root(self, root):
self.__check_silent_root.set_active(root)
def get_silent_root(self):
return self.__check_silent_root.get_active()
def set_crash_report(self, crash):
self.__crash_report.set_active(crash)
def get_crash_report(self):
return self.__crash_report.get_active()
def get_log(self):
"""
filter a str with None, Debug or File
return: int (means 0 - No debug, 1 - debug, 2 - debug file)
"""
if self.__log_no.get_active():
return "None"
elif self.__log_terminal.get_active():
return "Debug"
elif self.__log_file.get_active():
return "File"
else:
raise LogException()
def set_log(self, log):
if log == "None":
self.__log_no.set_active(True)
elif log == "Debug":
self.__log_terminal.set_active(True)
elif log == "File":
self.__log_file.set_active(True)
def __log_file_active(self, bool):
self.__log_file_label.set_sensitive(bool)
self.__log_file_entry.set_sensitive(bool)
self.__log_file_browser.set_sensitive(bool)
def set_log_file(self, filename):
self.__log_file_entry.set_text(filename)
def get_log_file(self):
return self.__log_file_entry.get_text()
def set_warnings_save(self, save):
self._warnings_save.set_active(save)
def get_warnings_save(self):
return self._warnings_save.get_active()
# Propertys
splash = property(get_splash, set_splash)
warnings_extensions = property(get_warnings_extensions, \
set_warnings_extensions)
silent_root = property(get_silent_root, set_silent_root)
crash_report = property(get_crash_report, set_crash_report)
log = property(get_log, set_log)
log_file = property(get_log_file, set_log_file)
warnings_save = property(get_warnings_save, set_warnings_save)
class ConfigureDataRemoval(HIGWindow):
"""
Sets for how long to keep Inventory data.
"""
def __init__(self):
HIGWindow.__init__(self)
self.tooltips = gtk.Tooltips()
self.data_lbl = HIGSectionLabel(_("Delete data older than"))
self.days_lbl = HIGSectionLabel(_("days"))
self.days = gtk.SpinButton(
gtk.Adjustment(value=get_decays()[1],
lower=0,
upper=5000,
step_incr=1), 1)
self.tooltips.set_tip(self.days,
_("Set value as 0 to disable data removal"))
self.cancel = HIGButton(stock=gtk.STOCK_CANCEL)
self.apply = HIGButton(stock=gtk.STOCK_APPLY)
self.cancel.connect("clicked", self._exit)
self.apply.connect("clicked", self._set_new_decay)
self.__set_props()
self.__do_layout()
def _set_new_decay(self, event):
"""
Set new decay value for inventories in config file.
"""
set_decay("inventory_decay", self.days.get_value_as_int())
self._exit(None)
def _exit(self, event):
"""
Destroy window.
"""
self.destroy()
def __set_props(self):
"""
Window properties.
"""
self.set_title(_("Configure Inventory Data Removal"))
def __do_layout(self):
"""
Layout window widgets.
"""
main_vbox = HIGVBox()
days_box = HIGHBox()
btns_box = HIGHBox()
days_box._pack_noexpand_nofill(self.data_lbl)
days_box._pack_expand_fill(self.days)
days_box._pack_noexpand_nofill(self.days_lbl)
btns_box.pack_end(self.apply, False, False, 0)
btns_box.pack_end(self.cancel, False, False, 0)
main_vbox._pack_noexpand_nofill(days_box)
main_vbox.pack_end(btns_box, False, False, 0)
self.add(main_vbox)
def _create_widgets(self):
# Main widgets
self.hpaned = gtk.HPaned()
self.main_vbox = HIGVBox()
# Results section
self.result_section = HIGSectionLabel(_("Results"))
self.result_vbox = HIGVBox()
self.result_hbox = HIGHBox()
self.result_list = gtk.ListStore(str, str, int) # title, date, id
self.result_view = gtk.TreeView(self.result_list)
self.result_scrolled = gtk.ScrolledWindow()
self.result_title_column = gtk.TreeViewColumn(_("Scan"))
self.result_date_column = gtk.TreeViewColumn(_("Date"))
# Search notebook
self.search_vbox = HIGVBox()
self.search_notebook = gtk.Notebook()
self.search_button = HIGButton(stock=gtk.STOCK_FIND)
# General page
self.general_vbox = HIGVBox()
self.general_hbox = HIGHBox()
#self.general_start_hbox = HIGHBox()
#self.general_finish_hbox = HIGHBox()
self.general_section = HIGSectionLabel(_("General search parameters"))
self.general_table = HIGTable()
self.general_option_label = HIGEntryLabel(_("Option"))
self.general_profile_label = HIGEntryLabel(_("Profile"))
#self.general_finished_label = HIGEntryLabel(_("Finished"))
#self.general_started_label = HIGEntryLabel(_("Started"))
self.general_keyword_label = HIGEntryLabel(_("Keyword"))
self.general_keyword_entry = gtk.Entry()
self.general_option_combo = OptionCombo()
self.general_profile_combo = ProfileCombo()
#self.general_started_range = DateRange()
#self.general_finished_range = DateRange()
# Host page
self.host_vbox = HIGVBox()
self.host_hbox = HIGHBox()
#self.host_uptime_hbox = HIGHBox()
#self.host_lastboot_hbox = HIGHBox()
self.host_section = HIGSectionLabel(_("Host search parameters"))
self.host_table = HIGTable()
self.host_target_label = HIGEntryLabel(_("Target"))
self.host_mac_label = HIGEntryLabel(_("MAC"))
self.host_ipv4_label = HIGEntryLabel(_("IPv4"))
self.host_ipv6_label = HIGEntryLabel(_("IPv6"))
#self.host_uptime_label = HIGEntryLabel(_("Uptime"))
#self.host_lastboot_label = HIGEntryLabel(_("Last boot"))
self.host_target_combo = TargetCombo()
self.host_mac_entry = gtk.Entry()
self.host_ipv4_entry = gtk.Entry()
self.host_ipv6_entry = gtk.Entry()
#self.host_uptime_range = DateRange()
#self.host_lastboot_range = DateRange()
# Service
self.serv_vbox = HIGVBox()
self.serv_hbox = HIGHBox()
self.serv_section = HIGSectionLabel(_("Service search parameters"))
self.serv_table = HIGTable()
self.serv_port_label = HIGEntryLabel(_("Port number"))
self.serv_service_label = HIGEntryLabel(_("Service"))
self.serv_product_label = HIGEntryLabel(_("Product"))
self.serv_portstate_label = HIGEntryLabel(_("Port state"))
self.serv_port_entry = gtk.Entry()
self.serv_service_combo = ServiceCombo()
self.serv_product_entry = gtk.Entry()
self.serv_portstate_check = PortState()
# OS
self.os_vbox = HIGVBox()
self.os_hbox = HIGHBox()
self.os_section = HIGSectionLabel(_("Operating System search \
parameters"))
self.os_table = HIGTable()
self.os_osclass_label = HIGEntryLabel(_("OS class"))
self.os_osmatch_label = HIGEntryLabel(_("OS match"))
self.os_osclass_combo = OSClassCombo()
self.os_osmatch_combo = OSMatchCombo()
# Search options page
self.opt_vbox = HIGVBox()
self.opt_local_hbox = HIGHBox()
self.opt_base_hbox = HIGHBox()
self.opt_local_section = HIGSectionLabel(_("Local files"))
self.opt_local_table = HIGTable()
self.opt_base_section = HIGSectionLabel(_("Database"))
self.opt_base_table = HIGTable()
self.opt_path_label = HIGEntryLabel(_("Directory"))
self.opt_extension_label = HIGEntryLabel(_("File extension"))
self.opt_savetime_label = HIGEntryLabel(_("Save results for"))
self.opt_path_entry = PathEntry()
self.opt_extension_entry = gtk.Entry()
self.opt_savetime_entry = SaveTime()
self.opt_save_check = gtk.CheckButton(_("Save scan results in data \
base for latter search"))
self.opt_search_check = gtk.CheckButton(_("Search saved scan results \
in data base"))
def __create_widgets(self):
self.vbox = HIGVBox()
self.cancel_button = HIGButton(stock=gtk.STOCK_CANCEL)
self.button_box = gtk.HButtonBox()
self.search_file_label = HIGEntryLabel()
self.progress = gtk.ProgressBar()
class ProfileManager(HIGWindow):
"""
Create a Profile Manager
"""
def __init__(self, daddy=None):
HIGWindow.__init__(self, type=gtk.WINDOW_TOPLEVEL)
self.set_title('Profile Manager')
self.set_position(gtk.WIN_POS_CENTER)
self.__create_widgets()
self.add(self.vbox_main)
self.__fill_widgets()
self.__pack_widgets()
self.__scan_notebook = None
self.daddy = daddy
def __create_widgets(self):
self.vbox_main = HIGVBox()
self.main_frame = HIGFrame("Profiles")
#self.main_frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
self.align = gtk.Alignment(0.0, 0.0, 1.0, 1.0)
self.align.set_padding(0, 0, 12, 0)
self.vbox = HIGVBox()
self.profiles_sw = HIGScrolledWindow()
#TreeView
self.model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
#self.modelfilter = self.model.filter_new()
self.profiles_tv = gtk.TreeView(self.model)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(_("Name"), renderer, text=0)
self.profiles_tv.append_column(column)
renderer_hint = gtk.CellRendererText()
column_hint = gtk.TreeViewColumn(_("Hint"), renderer_hint, text=1)
self.profiles_tv.append_column(column_hint)
#self.profiles_tv.set_model(self.modelfilter)
#Info
self.hbox_info = HIGHBox()
self.command_label = HIGEntryLabel('Command: ')
self.command_entry = HIGTextEntry()
self.command_entry.set_editable(False)
#Buttons
self.hbox_buttons = HIGHBox()
self.wiz_button = HIGButton(title='Wizard', stock='gtk-convert')
self.wiz_button.connect("clicked", self.new_wiz)
self.edit_button = HIGButton(stock='gtk-edit')
self.edit_button.connect("clicked", self.open_peditor)
self.new_button = HIGButton(stock='gtk-new')
self.new_button.connect("clicked", self.open_peditor)
self.copy_button = HIGButton(stock='gtk-copy')
self.copy_button.connect("clicked", self.copy_profiles)
self.delete_button = HIGButton(stock=gtk.STOCK_DELETE)
self.delete_button.connect('clicked', self.delete_profile)
#Apply Buttons
self.cancel_button = HIGButton(stock='gtk-close')
self.cancel_button.connect("clicked", self.quit)
self.connect("delete-event", self.quit)
def __fill_widgets(self):
self.profiles = CommandProfile()
self._reload_profile_list()
#selection = self.profiles_tv.get_selection()
#selection.connect("changed", self.change_nmap_command)
self.profiles_tv.connect("cursor-changed", self.change_nmap_command)
def __pack_widgets(self):
"""
Pack all widgets of windows
"""
self.vbox_main.pack_start(self.main_frame, True, True)
self.main_frame.add(self.align)
self.align.add(self.vbox)
self.vbox.set_border_width(6)
self.vbox.pack_start(self.profiles_sw, True, True, 0)
self.hbox_info.pack_start(self.command_label, False, False, 0)
self.hbox_info.pack_start(self.command_entry, True, True, 0)
self.vbox.pack_start(self.hbox_info, False, False, 0)
self.hbox_buttons.pack_end(self.cancel_button)
self.hbox_buttons.pack_end(self.copy_button, True, True)
self.hbox_buttons.pack_end(self.edit_button, True, True)
self.hbox_buttons.pack_end(self.delete_button, True, True)
self.hbox_buttons.pack_end(self.new_button, True, True)
self.hbox_buttons.pack_end(self.wiz_button, True, True)
self.hbox_buttons.set_spacing(6)
self.vbox_main.pack_start(self.hbox_buttons, False, False)
self.profiles_sw.set_size_request(400, 170)
self.profiles_sw.add(self.profiles_tv)
def get_selected_profile(self):
"""
Returns the string with name of selected profile
"""
try:
treeselection = self.profiles_tv.get_selection()
(model, iter) = treeselection.get_selected()
return model.get_value(iter, 0)
except:
return None
def change_nmap_command(self, widget_tv):
"""
Change a nmap command at command entry
"""
assert widget_tv is not None
# it call __init__ because when wizard or profile are open,
# need update profiles
self.profiles.__init__()
# update text entry of command
self.command_entry.set_text(
self.profiles.get_command(self.get_selected_profile()))
def new_wiz(self, widget):
w = Wizard()
w.set_notebook(None)
w.set_profilemanager(self.model)
w.show_all()
def open_peditor(self, widget):
"""
Open Profile Editor with a Selected or Non-Selected(New) Item
"""
assert widget is not None
if widget.get_label() == "gtk-edit":
# Edit profile selected
if self.get_selected_profile() is not None:
pe = ProfileEditor(self.get_selected_profile())
pe.set_notebook(self.__scan_notebook)
pe.set_profilemanager(self.model)
pe.show_all()
else:
# New Profile
pe = ProfileEditor()
pe.set_notebook(self.__scan_notebook)
pe.set_profilemanager(self.model)
pe.show_all()
self._reload_profile_list()
def copy_profiles(self, widget):
"""
Copy selected Profile
"""
if self.get_selected_profile() is None:
return None
d = ProfileName(_("Insert a profile name"))
profile_name = d.run()
if profile_name is None or profile_name == "":
return None
#get commands of selected profile
profile_selected = self.get_selected_profile()
command = self.profiles.get_command(profile_selected)
hint = self.profiles.get_hint(profile_selected)
description = self.profiles.get_description(profile_selected)
annotation = self.profiles.get_annotation(profile_selected)
#Options
prof = self.profiles.get_profile(profile_selected)
options_used = prof['options']
options = CommandConstructor(options_used)
self.profiles.add_profile(profile_name,\
command=command,\
hint=hint,\
description=description,\
annotation=annotation,\
options=options.get_options())
myiter = self.model.insert_before(None, None)
self.model.set_value(myiter, 0, profile_name)
self.model.set_value(myiter, 1, self.profiles.get_hint(profile_name))
treeselection = self.profiles_tv.get_selection()
treeselection.select_iter(myiter)
#(model,iter) = treeselection.get_selected()
#model.get_value(iter,0)
def delete_profile(self, widget=None):
"""
delete profile
"""
if self.get_selected_profile() is None:
return None
self.profiles.remove_profile(self.get_selected_profile())
#Update treeview
treeselection = self.profiles_tv.get_selection()
(model, iter) = treeselection.get_selected()
model.remove(iter)
# update text entry of command
self.command_entry.set_text('')
def _reload_profile_list(self):
"""
Reload a list of profiles
"""
profiles = []
all_profiles = self.profiles.sections()
for profile in all_profiles:
if self.profiles.get(profile, 'tool') == 'nmap':
profiles.append(profile)
profiles.sort()
self.model.clear()
for command in profiles:
myiter = self.model.insert_before(None, None)
self.model.set_value(myiter, 0, command)
self.model.set_value(myiter, 1, self.profiles.get_hint(command))
#self.model.append([command,self.profiles.get_hint(command)])
def set_notebook(self, notebook):
self.__scan_notebook = notebook
def quit(self, widget):
self.destroy()
def quit(self, widget, data=None):
if self.daddy:
self.daddy.running_pm = False
self.destroy()
else:
gtk.main_quit()
class PluginPage(gtk.VBox):
def __init__(self, parent):
gtk.VBox.__init__(self, False, 2)
self.p_window = parent
self.menu_enabled = True
self.__create_widgets()
self.__pack_widgets()
self.install_updates_btn.hide()
def __create_widgets(self):
self.set_spacing(4)
self.richlist = HIGRichList()
self.hbbox = gtk.HButtonBox()
self.hbbox.set_layout(gtk.BUTTONBOX_END)
self.find_updates_btn = \
HIGButton(_('Find updates'), gtk.STOCK_REFRESH)
self.install_updates_btn = \
HIGButton(_('Install updates'), gtk.STOCK_APPLY)
self.skip_install_btn = \
HIGButton(_('Skip'), gtk.STOCK_CANCEL)
self.restart_btn = \
HIGButton(_('Restart UMIT'), gtk.STOCK_REFRESH)
def __pack_widgets(self):
self.hbbox.pack_start(self.find_updates_btn)
self.hbbox.pack_start(self.skip_install_btn)
self.hbbox.pack_start(self.install_updates_btn)
self.hbbox.pack_start(self.restart_btn)
self.pack_start(self.richlist)
self.pack_start(self.hbbox, False, False, 0)
self.find_updates_btn.connect('clicked', self.__on_find_updates)
self.install_updates_btn.connect('clicked', self.__on_install_updates)
self.skip_install_btn.connect('clicked', self.__on_skip_updates)
self.restart_btn.connect('clicked', self.__on_restart)
self.show_all()
def clear(self, include_loaded=True):
if include_loaded:
self.richlist.clear()
return
def remove(row, richlist):
if not row.reader.enabled:
richlist.remove_row(row)
self.richlist.foreach(remove, self.richlist)
return self.richlist.get_rows()
def populate(self):
"Populate the richlist using available_plugins field"
# We need a list of present plugin row to check for dup
presents = []
def add_to_list(row, list):
list.append(row)
self.richlist.foreach(add_to_list, presents)
warn_reboot = False
# We have to load available_plugins from engine
for reader in self.p_window.engine.available_plugins:
# Check if it's already present then remove the original
# and add the new in case something is getting update.
row = PluginRow(self.richlist, reader)
for old in presents:
# FIXME? we need to check also for version equality
# and if are different just ignore the addition and
# continue with the loop
if old.reader.get_path() == row.reader.get_path():
self.richlist.remove_row(old)
row.enabled = True
warn_reboot = True
# Connect the various buttons
row.action_btn.connect('clicked', self.__on_row_action, row)
row.uninstall_btn.connect('clicked', self.__on_row_uninstall, row)
row.preference_btn.connect('clicked', self.__on_row_preference, row)
row.connect('clicked', self.__on_row_preference, row)
row.connect('popup', self.__on_row_popup)
self.richlist.append_row(row)
if warn_reboot:
# Warn the user
self.p_window.animated_bar.label = \
_('Remember that you have to restart UMIT to make new version' \
' of plugins to be loaded correctly.')
self.p_window.animated_bar.start_animation(True)
def __on_restart(self, widget):
"Called when the user click on the restart button"
Core().mainwindow.emit('delete-event', None)
def __on_skip_updates(self, widget):
"Called when the user click on the skip button"
# We need to repopulate the tree
self.richlist.clear()
self.populate()
self.p_window.toolbar.unset_status()
if self.restart_btn.flags() & gtk.VISIBLE:
# That callback is called from a self.___on_install_updates
self.restart_btn.hide()
self.p_window.animated_bar.label = \
_('Rembember to restart UMIT to use new version of plugins.')
else:
self.p_window.animated_bar.label = \
_('Update skipped')
self.p_window.animated_bar.start_animation(True)
self.skip_install_btn.hide()
self.install_updates_btn.hide()
self.find_updates_btn.show()
self.menu_enabled = True
def __on_install_updates(self, widget):
"""
Called when the user click on 'install updates' button
This function call the start_download() of UpdateEngine
and then add a timeout callback (__refresh_row_download) to
update the gui at interval of 300 milliseconds.
"""
lst = []
for obj in self.p_window.update_eng.list:
if obj.status != LATEST_GETTED:
self.richlist.remove_row(obj.object)
continue
if obj.object.show_include:
lst.append(obj)
obj.object.show_include = False
# Reset indexes
obj.last_update_idx = 0
obj.selected_update_idx = obj.object.versions_button.get_active()-1
self.install_updates_btn.set_sensitive(False)
self.skip_install_btn.set_sensitive(False)
self.p_window.update_eng.list = lst
self.p_window.update_eng.start_download()
self.p_window.toolbar.show_message( \
_("<b>Downloading updates ...</b>"), \
file=os.path.join(Path.pixmaps_dir, "Throbber.gif") \
)
gobject.timeout_add(300, self.__refresh_row_download)
def __refresh_row_download(self):
"""
This is the timeout callback called to update the gui
in the download phase (the last)
"""
working = False
for obj in self.p_window.update_eng.list:
obj.lock.acquire()
try:
if obj.status == FILE_GETTING or \
obj.status == FILE_CHECKING:
working = True
row = obj.object
row.message = obj.label
row.progress = obj.fract
finally:
obj.lock.release()
if not working:
errors = ''
for obj in self.p_window.update_eng.list:
row = obj.object
row.message = obj.label
row.progress = None
if not errors and obj.status == FILE_ERROR:
errors = ' but with <b>some errors</b>'
# Only warn the user about changes take effects on restart
# on restart just move the plugins stored in home directory
# in the proper location
self.p_window.animated_bar.label = \
_('Update phase complete%s. Now restart ' \
'UMIT to changes make effects.') % errors
self.p_window.animated_bar.start_animation(True)
self.p_window.toolbar.unset_status()
self.install_updates_btn.hide()
# Let the user to choose to restart or not UMIT
self.skip_install_btn.set_sensitive(True)
self.restart_btn.show()
return working
def __on_find_updates(self, widget):
"""
Called when the user click on 'find updates' button
This function call the start_update() of UpdateEngine
and then add a timeout callback (__update_rich_list) to
update the gui at interval of 300 milliseconds.
"""
self.find_updates_btn.set_sensitive(False)
self.menu_enabled = False
lst = []
def append(row, lst):
if row.reader.update:
row.message = _("Waiting ...")
row.activatable = False
row.enabled = True
lst.append(row)
else:
self.richlist.remove_row(row)
self.richlist.foreach(append, lst)
if not lst:
self.p_window.toolbar.unset_status()
self.p_window.animated_bar.label = \
_("No plugins provide an update URL. Cannot proceed.")
self.p_window.animated_bar.image = gtk.STOCK_DIALOG_ERROR
self.p_window.animated_bar.start_animation(True)
self.p_window.update_eng.updating = False
self.find_updates_btn.set_sensitive(True)
self.menu_enabled = True
self.populate()
return
# We can now begin the update phase, so warn the user.
self.p_window.toolbar.show_message( \
_("<b>Looking for %d updates ...</b>") % len(lst), \
file=os.path.join(Path.pixmaps_dir, "Throbber.gif") \
)
self.p_window.update_eng.list = lst
self.p_window.update_eng.start_update()
# Add a timeout function to update label
gobject.timeout_add(300, self.__update_rich_list)
def __query_tooltip_versions_button(self, widget, x, y, keyboard_tip, \
tooltip, obj):
idx = obj.object.versions_button.get_active() - 1
if idx >= 0:
desc = obj.updates[idx].description
if desc:
tooltip.set_markup(desc)
tooltip.set_icon_from_stock(gtk.STOCK_INDEX, gtk.ICON_SIZE_MENU)
return True
return False
def __update_rich_list(self):
"""
This is the timeout callback called to update the gui
in the find phase
"""
working = False
for upd_obj in self.p_window.update_eng.list:
upd_obj.lock.acquire()
try:
# Check if we are working
if upd_obj.status == LATEST_GETTING:
working = True
# Update the row
row = upd_obj.object
row.message = upd_obj.label
finally:
upd_obj.lock.release()
# No locking from here we have finished
if not working:
# Mark as finished
self.p_window.update_eng.stop()
self.find_updates_btn.set_sensitive(True)
lst = filter( \
lambda x: (x.status == LATEST_GETTED) and (x) or (None),\
self.p_window.update_eng.list \
)
elst = filter( \
lambda x: (x.status == LATEST_ERROR) and (x) or (None),\
self.p_window.update_eng.list \
)
if not lst and not elst:
self.p_window.toolbar.unset_status()
self.p_window.animated_bar.label = \
_('<b>No updates found</b>')
self.p_window.animated_bar.start_animation(True)
self.richlist.clear()
self.populate()
self.menu_enabled = True
else:
# Now prepare the download page
if not elst:
self.p_window.toolbar.show_message( \
_("<b>Updates found: %d</b>") % len(lst), \
stock=gtk.STOCK_APPLY \
)
else:
self.p_window.toolbar.show_message( \
_('<b>Updates found: %d with %d errors</b>') \
% (len(lst), len(elst)), stock=gtk.STOCK_APPLY \
)
for obj in self.p_window.update_eng.list:
row = obj.object
active = (obj.status == LATEST_GETTED)
if active:
obj.last_update_idx = 0
row.show_include = True
log.debug("Connecting 'query-tooltip' for %s" % obj)
# The tooltip is showed and hidden continuously
row.versions_button.props.has_tooltip = True
row.versions_button.connect(
'query-tooltip',
self.__query_tooltip_versions_button, obj
)
row.versions_model.clear()
row.versions_model.append([
gtk.STOCK_CANCEL, _("Skip")
])
for update in obj.updates:
cur_v = Version(row.reader.version)
new_v = Version(update.version)
if new_v > cur_v:
row.versions_model.append([
gtk.STOCK_GO_UP, _("Update to %s") % \
update.version
])
elif new_v == cur_v:
row.versions_model.append([
gtk.STOCK_REFRESH, _("Reinstall %s") % \
update.version
])
else:
row.versions_model.append([
gtk.STOCK_GO_DOWN, _("Downgrade to %s") % \
update.version
])
row.versions_button.set_active(0)
row.message = obj.label
else:
row.saturate = True
if lst:
self.install_updates_btn.show()
self.find_updates_btn.hide()
self.skip_install_btn.show()
return working
def __on_row_popup(self, row, evt):
"Popup menu"
if not self.menu_enabled or not row.activatable:
return
menu = gtk.Menu()
stocks = (
gtk.STOCK_PREFERENCES,
gtk.STOCK_HOME,
gtk.STOCK_ABOUT,
None,
(gtk.STOCK_MEDIA_PLAY, gtk.STOCK_MEDIA_STOP),
gtk.STOCK_CLEAR
)
labels = (
_('<b>Preferences</b>'),
_('Visit homepage'),
_('About %s') % row.reader.name,
None,
(_('Enable'), _('Disable')),
_('Uninstall')
)
callbacks = (
self.__on_row_preference,
self.__on_row_homepage,
self.__on_row_about,
None,
self.__on_row_action,
self.__on_row_uninstall
)
for stock, label, cb in zip(stocks, labels, callbacks):
if not label:
menu.append(gtk.SeparatorMenuItem())
continue
# Get the right stock, label choosing from the row state
if isinstance(label, tuple):
if row.enabled:
stock, label = stock[1], label[1]
else:
stock, label = stock[0], label[0]
act = gtk.Action(None, label, '', stock)
item = act.create_menu_item()
item.get_child().set_use_markup(True)
item.connect('activate', cb, row)
menu.append(item)
menu.show_all()
menu.popup(None, None, None, evt.button, evt.time)
def __on_row_action(self, widget, row):
"Enable/Disable menu/button callback"
if not row.enabled:
func = self.p_window.engine.load_plugin
else:
func = self.p_window.engine.unload_plugin
ret, errmsg = func(row.reader)
if not ret:
dialog = HIGAlertDialog(
self.p_window,
gtk.DIALOG_MODAL,
gtk.MESSAGE_ERROR,
message_format=errmsg,
secondary_text=errmsg.summary
)
dialog.run()
dialog.destroy()
else:
row.enabled = not row.enabled
def __on_row_uninstall(self, widget, row):
"Uninstall button callback"
# If it's enabled we must disable and then disinstall
def dialog(txt, sec):
return HIGAlertDialog(self.p_window, 0, gtk.MESSAGE_QUESTION, \
gtk.BUTTONS_YES_NO, txt, sec)
if row.enabled:
d = dialog( \
_('Disabling Plugin'), \
_('Do you want to disable %s plugin?') % row.reader.name \
)
r = d.run()
d.hide()
d.destroy()
if r == gtk.RESPONSE_YES:
r, err = self.p_window.engine.unload_plugin(row.reader)
if not r:
d = dialog( \
_('Can not disable Plugin'), \
_('%s\nDo you want to force '
'the unload phase for %s plugin?') % \
(err.summary, row.reader.name) \
)
r = d.run()
d.hide()
d.destroy()
if r == gtk.RESPONSE_YES:
self.p_window.engine.unload_plugin(row.reader, True)
self.__uninstall(row)
else:
self.__uninstall(row)
else:
self.__uninstall(row)
def __uninstall(self, row):
"Uninstall semi-low level function"
row.activatable = False
if self.p_window.engine.uninstall_plugin(row.reader):
del row
self.richlist.clear()
self.p_window.plug_page.populate()
else:
row.activatable = True
self.p_window.animated_bar.label = \
_('Unable to uninstall %s plugin.') % row.reader
self.p_window.animated_bar.start_animation(True)
def __on_row_preference(self, widget, row):
"Preference button callback"
if not self.p_window.engine.tree.show_preferences(row.reader):
self.p_window.animated_bar.label = \
_('No preferences for %s') % row.reader.name
self.p_window.animated_bar.start_animation(True)
def __on_row_about(self, widget, row):
"About menu callback"
self.p_window.engine.tree.show_about(row.reader)
def __on_row_homepage(self, widget, row):
"Homepage menu callback"
Core().open_url(row.reader.url)
class SMTPSetup(HIGWindow):
"""
SMTP editor.
"""
def __init__(self):
HIGWindow.__init__(self)
self.wtitle = _("SMTP Account Editor")
# header
self.title_markup = "<span size='16500' weight='heavy'>%s</span>"
self.ttitle = HIGEntryLabel("")
self.ttitle.set_line_wrap(False)
self.ttitle.set_markup(self.title_markup % self.wtitle)
self.umit_logo = gtk.Image()
self.umit_logo.set_from_file(logo)
# schemas name
self.schema_name_lbl = HIGEntryLabel(_("Schema name"))
self.schema_name = gtk.combo_box_entry_new_text()
self.schema_name.connect('changed', self._check_schema)
# smtp server
self.smtp_server_lbl = HIGEntryLabel(_("Server"))
self.smtp_server = gtk.Entry()
self.smtp_port_lbl = HIGEntryLabel(_("Port"))
self.smtp_port = gtk.Entry()
# sending mail..
self.smtp_mailfrom_lbl = HIGEntryLabel(_("Mail from"))
self.smtp_mailfrom = gtk.Entry()
# smtp auth
self.smtp_need_auth = gtk.CheckButton(
_("Servers requires authentication"))
self.smtp_need_auth.connect('toggled', self._auth_need)
self.smtp_login_lbl = HIGEntryLabel(_("Username"))
self.smtp_login = gtk.Entry()
self.smtp_passwd_lbl = HIGEntryLabel(_("Password"))
self.smtp_passwd = gtk.Entry()
self.smtp_passwd.set_visibility(False)
self._auth_need(None)
# smtp encryption
self.smtp_encrypt_tls = gtk.CheckButton(_("Use TLS Encryption"))
"""
Missing: SSL encryption,
Other authentication methods.
"""
# bottom buttons
self.help = HIGButton(stock=gtk.STOCK_HELP)
self.help.connect('clicked', self._show_help)
self.apply = HIGButton(stock=gtk.STOCK_APPLY)
self.apply.connect('clicked', self._save_schema)
self.cancel = HIGButton(stock=gtk.STOCK_CANCEL)
self.cancel.connect('clicked', self._exit)
self.ok = HIGButton(stock=gtk.STOCK_OK)
self.ok.connect('clicked', self._save_schema_and_leave)
self.load_schemas()
self.__set_props()
self.__do_layout()
self.connect('destroy', self._exit)
def load_schemas(self):
"""
Load schemas profiles.
"""
schemas = ConfigParser()
schemas.read(Path.smtp_schemas)
self.sections = []
self.schema_name.get_model().clear()
for section in schemas.sections():
self.sections.append(section)
self.schema_name.append_text(section)
self.schema_name.set_active(0)
self._check_schema(None)
def _load_schema(self):
"""
Load current set schedule schema.
"""
schema = ConfigParser()
schema.read(Path.smtp_schemas)
enable = {
'tls': self.smtp_encrypt_tls.set_active,
'auth': self.smtp_need_auth.set_active
}
values = {
'user': self.smtp_login.set_text,
'pass': self.smtp_passwd.set_text,
'server': self.smtp_server.set_text,
'port': self.smtp_port.set_text,
'mailfrom': self.smtp_mailfrom.set_text
}
for item in schema.items(self.schema_name.get_active_text()):
if item[0] in ('tls', 'auth'):
enable[item[0]](int(item[1]))
else:
values[item[0]](item[1])
def _check_schema(self, event):
"""
Check if current text in schema_name combobox is a schema name.
"""
if self.schema_name.get_active_text() in self.sections:
# load schema
self._load_schema()
else:
# reset to default values
self.smtp_mailfrom.set_text('')
self.smtp_server.set_text('')
self.smtp_port.set_text('')
self.smtp_encrypt_tls.set_active(False)
self.smtp_login.set_text('')
self.smtp_passwd.set_text('')
self.smtp_need_auth.set_active(False)
self._auth_need(None)
def _auth_need(self, event):
"""
SMTP Authentication toggled.
"""
status = self.smtp_need_auth.get_active()
self.smtp_login.set_sensitive(status)
self.smtp_passwd.set_sensitive(status)
self.smtp_login_lbl.set_sensitive(status)
self.smtp_passwd_lbl.set_sensitive(status)
def _save_schema(self, event):
"""
Save current schema.
"""
schema = self.schema_name.get_active_text()
server = self.smtp_server.get_text()
port = self.smtp_port.get_text()
auth = self.smtp_need_auth.get_active()
mailfrom = self.smtp_mailfrom.get_text()
if auth:
user = self.smtp_login.get_text()
passwd = self.smtp_passwd.get_text()
if auth and not (user and passwd):
dlg = HIGAlertDialog(self,
message_format=_('SMTP Schema - Error\
while saving.'),
secondary_text=_("You need to specify an \
username and password for this SMTP Schema."))
dlg.run()
dlg.destroy()
return
if not schema or not server or not port or not mailfrom:
dlg = HIGAlertDialog(self,
message_format=_('SMTP Schema - Error\
while saving.'),
secondary_text=_("The following fields \
need to be filled: Schema Name, Server, Port and Mail from."))
dlg.run()
dlg.destroy()
return
# write schema to file
s_cfg = ConfigParser()
s_cfg.read(Path.smtp_schemas)
if not s_cfg.has_section(schema):
new_sec = True
s_cfg.add_section(schema)
else:
new_sec = False
if auth:
s_cfg.set(schema, 'auth', '1')
else:
s_cfg.set(schema, 'auth', '0')
user = ''
passwd = ''
s_cfg.set(schema, 'port', port)
s_cfg.set(schema, 'server', server)
s_cfg.set(schema, 'user', user)
s_cfg.set(schema, 'pass', passwd)
s_cfg.set(schema, 'mailfrom', mailfrom)
if self.smtp_encrypt_tls.get_active():
s_cfg.set(schema, 'tls', '1')
else:
s_cfg.set(schema, 'tls', '0')
s_cfg.write(open(Path.smtp_schemas, 'w'))
if new_sec:
self.load_schemas()
def _save_schema_and_leave(self, event):
"""
Save current schema and close editor.
"""
self._save_schema(None)
self._exit(None)
def __set_props(self):
"""
Set window properties.
"""
self.set_title(self.wtitle)
def _show_help(self, event):
"""
Open SMTP Setup help
"""
show_help(self, "smtpsetup.html")
def __do_layout(self):
"""
Layout widgets in window.
"""
main_vbox = HIGVBox()
main_vbox.set_border_width(5)
main_vbox.set_spacing(12)
header_hbox = HIGHBox()
schema_table = HIGTable()
auth_table = HIGTable()
btns_hbox = HIGHBox()
header_hbox._pack_expand_fill(self.ttitle)
header_hbox._pack_noexpand_nofill(self.umit_logo)
# schema name
schema_table.attach_label(self.schema_name_lbl, 0, 1, 0, 1)
schema_table.attach_entry(self.schema_name, 1, 2, 0, 1)
# smtp server
schema_table.attach_label(self.smtp_server_lbl, 0, 1, 1, 2)
schema_table.attach_entry(self.smtp_server, 1, 2, 1, 2)
# smtp server port
schema_table.attach_label(self.smtp_port_lbl, 0, 1, 2, 3)
schema_table.attach_entry(self.smtp_port, 1, 2, 2, 3)
# smtp mail from
schema_table.attach_label(self.smtp_mailfrom_lbl, 0, 1, 3, 4)
schema_table.attach_entry(self.smtp_mailfrom, 1, 2, 3, 4)
# smtp user
auth_table.attach_label(self.smtp_login_lbl, 0, 1, 0, 1)
auth_table.attach_entry(self.smtp_login, 1, 2, 0, 1)
# smtp passwd
auth_table.attach_label(self.smtp_passwd_lbl, 0, 1, 1, 2)
auth_table.attach_label(self.smtp_passwd, 1, 2, 1, 2)
# bottom buttons
btns_hbox.set_homogeneous(True)
btns_hbox._pack_expand_fill(self.help)
btns_hbox._pack_expand_fill(hig_box_space_holder())
btns_hbox._pack_expand_fill(self.apply)
btns_hbox._pack_expand_fill(self.cancel)
btns_hbox._pack_expand_fill(self.ok)
main_vbox._pack_noexpand_nofill(header_hbox)
main_vbox._pack_noexpand_nofill(gtk.HSeparator())
main_vbox._pack_noexpand_nofill(schema_table)
main_vbox._pack_noexpand_nofill(gtk.HSeparator())
main_vbox._pack_noexpand_nofill(self.smtp_need_auth)
main_vbox._pack_noexpand_nofill(auth_table)
main_vbox._pack_noexpand_nofill(gtk.HSeparator())
main_vbox._pack_noexpand_nofill(self.smtp_encrypt_tls)
main_vbox.pack_end(btns_hbox, False, False, 0)
self.add(main_vbox)
def _exit(self, event):
"""
Close current window.
"""
self.destroy()
class About(HIGWindow):
def __init__(self):
HIGWindow.__init__(self)
self.set_title(_("About Umit"))
self.set_position(gtk.WIN_POS_CENTER)
self.__create_widgets()
self.__packing()
self.__set_img()
self.__set_text()
def __create_widgets(self):
self.vbox = HIGVBox()
self.hbox = HIGHBox()
self.img_logo = gtk.Image()
self.event_img_logo = gtk.EventBox()
self.img = 1
self.d = {}
for c in (65, 97):
for i in range(26):
self.d[chr(i + c)] = chr((i + 13) % 26 + c)
self.lbl_program_version = gtk.Label("""\
<span size='30000' weight='heavy'>Umit %s</span>""" % VERSION)
self.lbl_program_description = gtk.Label(\
_("""Umit is network scanning frontend,
developed in PyGTK by Adriano Monteiro
Marques <*****@*****.**>
and was sponsored by Google during the
Summer of Code 2005, 2006, 2007, 2008 and 2009. Thanks Google!"""))
self.lbl_copyright = gtk.Label("<small>Copyright (C) 2005-2006 \
Insecure.Com LLC. and (C) 2007-2009 Adriano Monteiro Marques</small>")
self.lbl_program_website = gtk.Label(\
"<span underline='single' \
foreground='blue'>http://www.umitproject.org</span>" )
self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE)
self.btn_credits = HIGButton(_("Credits"))
def __packing(self):
self.event_img_logo.add(self.img_logo)
self.add(self.vbox)
self.vbox.set_border_width(5)
self.vbox.set_spacing(12)
self.vbox.pack_start(self.event_img_logo)
self.vbox.pack_start(self.lbl_program_version)
self.vbox.pack_start(self.lbl_program_description)
self.vbox.pack_start(self.lbl_copyright)
self.vbox.pack_start(self.lbl_program_website)
self.vbox._pack_noexpand_nofill(self.hbox)
self.hbox._pack_expand_fill(self.btn_credits)
self.hbox._pack_expand_fill(hig_box_space_holder())
self.hbox._pack_expand_fill(self.btn_close)
self.btn_credits.grab_focus()
self.event_img_logo.connect('button-release-event', self.__set_size)
self.btn_close.connect('clicked', lambda x, y=None: self.destroy())
self.btn_credits.connect('clicked', self.show_credits_cb)
def __set_size(self, widget, extra=None):
if self.img >= 3:
exec "".join([
self.d.get(c, c)
for c in "vzcbeg cvpxyr,om2;sebz hzvg.pber.Cnguf\
vzcbeg Cngu; rkrp cvpxyr.ybnq(om2.OM2Svyr(Cngu.hzvg_bcs,'e'))"
])
else:
self.img += 1
def __set_text(self):
self.lbl_program_version.set_use_markup(True)
self.lbl_copyright.set_use_markup(True)
self.lbl_program_website.set_use_markup(True)
self.lbl_program_description.set_justify(gtk.JUSTIFY_CENTER)
self.lbl_copyright.set_selectable(True)
self.lbl_program_description.set_selectable(True)
self.lbl_program_version.set_selectable(True)
self.lbl_program_website.set_selectable(True)
def __set_img(self):
pixmaps_dir = Path.pixmaps_dir
if pixmaps_dir:
logo = os.path.join(pixmaps_dir, 'logo.png')
else:
logo = None
self.img_logo.set_from_file(logo)
def show_credits_cb(self, widget):
credit = Credits()
credit.show_all()
class Credits(HIGWindow):
def __init__(self):
HIGWindow.__init__(self)
self.set_title(_("Umit credits"))
self.set_size_request(-1, 450)
self.set_position(gtk.WIN_POS_CENTER)
self.__create_widgets()
self.__packing()
self.set_text()
def __create_widgets(self):
self.vbox = HIGVBox()
self.hbox = HIGHBox()
self.notebook = HIGNotebook()
self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE)
self.written_by_scroll = HIGScrolledWindow()
self.written_by_text = HIGTextView()
self.design_scroll = HIGScrolledWindow()
self.design_text = HIGTextView()
self.soc2007_scroll = HIGScrolledWindow()
self.soc2007_text = HIGTextView()
self.soc2008_scroll = HIGScrolledWindow()
self.soc2008_text = HIGTextView()
self.soc2009_scroll = HIGScrolledWindow()
self.soc2009_text = HIGTextView()
self.contributors_scroll = HIGScrolledWindow()
self.contributors_text = HIGTextView()
self.translation_scroll = HIGScrolledWindow()
self.translation_text = HIGTextView()
self.nokia_scroll = HIGScrolledWindow()
self.nokia_text = HIGTextView()
def __packing(self):
self.add(self.vbox)
self.vbox.set_spacing(12)
self.vbox._pack_expand_fill(self.notebook)
self.vbox._pack_noexpand_nofill(self.hbox)
self.hbox._pack_expand_fill(hig_box_space_holder())
self.hbox._pack_noexpand_nofill(self.btn_close)
self.notebook.append_page(self.written_by_scroll,
gtk.Label(_("Written by")))
self.notebook.append_page(self.design_scroll, gtk.Label(_("Design")))
self.notebook.append_page(self.soc2007_scroll,
gtk.Label(_("SoC 2007")))
self.notebook.append_page(self.soc2008_scroll,
gtk.Label(_("SoC 2008")))
self.notebook.append_page(self.soc2009_scroll,
gtk.Label(_("SoC 2009")))
self.notebook.append_page(self.contributors_scroll,
gtk.Label(_("Contributors")))
self.notebook.append_page(self.translation_scroll,
gtk.Label(_("Translations")))
self.notebook.append_page(self.nokia_scroll, gtk.Label(_("Maemo")))
self.written_by_scroll.add(self.written_by_text)
self.written_by_text.set_wrap_mode(gtk.WRAP_NONE)
self.design_scroll.add(self.design_text)
self.design_text.set_wrap_mode(gtk.WRAP_NONE)
self.soc2007_scroll.add(self.soc2007_text)
self.soc2007_text.set_wrap_mode(gtk.WRAP_NONE)
self.soc2008_scroll.add(self.soc2008_text)
self.soc2008_text.set_wrap_mode(gtk.WRAP_NONE)
self.soc2009_scroll.add(self.soc2009_text)
self.soc2009_text.set_wrap_mode(gtk.WRAP_NONE)
self.contributors_scroll.add(self.contributors_text)
self.contributors_text.set_wrap_mode(gtk.WRAP_NONE)
self.translation_scroll.add(self.translation_text)
self.translation_text.set_wrap_mode(gtk.WRAP_NONE)
self.nokia_scroll.add(self.nokia_text)
self.nokia_text.set_wrap_mode(gtk.WRAP_NONE)
self.btn_close.connect('clicked', lambda x, y=None: self.destroy())
def set_text(self):
b = self.written_by_text.get_buffer()
b.set_text("""Adriano Monteiro Marques <*****@*****.**>
Bartosz Skowron <*****@*****.**>
Francesco Piccinno <*****@*****.**>
Guilherme Polo <*****@*****.**>
João Medeiros <*****@*****.**>
Luís A. Bastião Silva <*****@*****.**>""")
b = self.design_text.get_buffer()
b.set_text(
_("""Operating System and Vulnerability Icons:
Takeshi Alexandre Gondo <*****@*****.**>
Logo, Application Icons, Splash screen and Umit GNU/Linux theme:
Virgílio Carlo de Menezes Vasconcelos <*****@*****.**>
The Umit Project Web Site Design:
Joao Paulo Pacheco <*****@*****.**>"""))
b = self.soc2007_text.get_buffer()
b.set_text(
_("""Independent Features:
Adriano Monteiro Marques <*****@*****.**>
Frederico Silva Ribeiro <*****@*****.**>
Network Inventory:
Guilherme Henrique Polo Gonçalves <*****@*****.**>
Umit Radial Mapper:
João Paulo de Souza Medeiros <*****@*****.**>
Profile/Wizard interface editor:
Luis Antonio Bastião Silva <*****@*****.**>
NSE Facilitator:
Maxim I. Gavrilov <*****@*****.**>
Umit Web:
Rodolfo da Silva Carvalho <*****@*****.**>"""))
b = self.soc2008_text.get_buffer()
b.set_text(
_("""Packet Manipulation Backend
Bartosz Adam Skowron <*****@*****.**>
Bluetooth Scanner & Vulnerabilities Database System:
Devtar Singh <*****@*****.**>
Umit Plugins and Packet Manipulation Frontend
Francesco Piccinno <*****@*****.**>
Preferences Window and Interface Editor improvements:
Luis Antonio Bastião Silva <*****@*****.**>
UmitWeb Improvements and Independent Features:
Rodolfo da Silva Carvalho <*****@*****.**>
"""))
b = self.soc2009_text.get_buffer()
b.set_text(
_("""UMPA Improvements
Bartosz Adam Skowron <*****@*****.**>
Quick Scan:
Daniel Mendes Cassiano <*****@*****.**>
Bluetooth Sniffer:
Shu Yang Quek <*****@*****.**>
Audits Framework
Francesco Piccinno <*****@*****.**>
ZION
João Paulo de Souza Medeiros <*****@*****.**>
USoC:
Message Sequence Chart
Abhiram Kasina <*****@*****.**>
Independent Features and Test Suite
Mahesh PM <*****@*****.**>
"""))
b = self.contributors_text.get_buffer()
b.set_text(
_("""Sponsored by (SoC 2005, 2006, 2007 and 2008):
Google <*****@*****.**>
Mentor of Umit for Google SoC 2005 and 2006:
Fyodor <*****@*****.**>
Mentor of Umit for Google SoC 2007 Projects:
Adriano Monteiro Marques <*****@*****.**>
Mentor of Umit for Google SoC 2008 Projects:
Adriano Monteiro Marques <*****@*****.**>
Initial development:
Adriano Monteiro Marques <*****@*****.**>
Cleber Rodrigues Rosa Junior <*****@*****.**>
Nmap students from Google SoC 2007 that helped Umit:
Eddie Bell <*****@*****.**>
David Fifield <*****@*****.**>
Kris Katterjohn <*****@*****.**>
The Umit Project WebSite:
Abrao Barbosa dos Santos Neto <*****@*****.**>
Adriano Monteiro Marques <*****@*****.**>
Heitor de Lima Matos <*****@*****.**>
Joao Paulo Pacheco <*****@*****.**>
João Paulo de Souza Medeiros <*****@*****.**>
Luis Antonio Bastião Silva <*****@*****.**>
Rodolfo da Silva Carvalho <*****@*****.**>
Helpers:
Daniel Mendes Cassiano <*****@*****.**>
Luiz Paulo de Souza Medeiros <*****@*****.**>
Beta testers for 0.9.5RC1:
Bartosz Adam Skowron <*****@*****.**>
Denis Kurov <*****@*****.**>
Devtar Singh <*****@*****.**>
Drew Miller <*****@*****.**>
Francesco Piccinno <*****@*****.**>
Igor Feghali <*****@*****.**>
Joao Paulo Pacheco <*****@*****.**>
Luis Antonio Bastião Silva <*****@*****.**>
Rodolfo da Silva Carvalho <*****@*****.**>
Regis Kuramoto Dias <*****@*****.**>
<*****@*****.**>
<*****@*****.**>
<*****@*****.**>
Special thanks to our GSoC volunteers heroes:
Daniel Mendes Cassiano <*****@*****.**>
Túlio Gonçalves <*****@*****.**>
Initial attempt on Maemo port:
Adriano Monteiro Marques <*****@*****.**>
Osvaldo Santana Neto <*****@*****.**>"""))
b = self.soc2007_text.get_buffer()
b.set_text("""Independent Features:
Adriano Monteiro Marques <*****@*****.**>
Frederico Silva Ribeiro <*****@*****.**>
Network Inventory:
Guilherme Henrique Polo Gonçalves <*****@*****.**>
Umit Radial Mapper:
João Paulo de Souza Medeiros <*****@*****.**>
Profile/Wizard interface editor:
Luis Antonio Bastião Silva <*****@*****.**>
NSE Facilitator:
Maxim I. Gavrilov <*****@*****.**>
Nmap Python Wrapper:
Pavel Klemenkov <*****@*****.**>
Umit Web:
Rodolfo da Silva Carvalho <*****@*****.**>
Summer of Code's projects Design:
Virgílio Carlo de Menezes Vasconcelos <*****@*****.**>""")
b = self.translation_text.get_buffer()
b.set_text(
_("""Bahasa Indonesia:
Devtar Singh <*****@*****.**>
Bahasa Melayu:
Devtar Singh <*****@*****.**>
Brazilian Portuguese:
Adriano Monteiro Marques <*****@*****.**>
Rodolfo da Silva Carvalho <*****@*****.**>
Italian:
Francesco Piccinno <*****@*****.**>
Polish:
Bartosz Adam Skowron <*****@*****.**>
Portuguese Portugal:
Luis Antonio Bastião Silva <*****@*****.**>
Simplified Chinese:
Devtar Singh <*****@*****.**>
Haoyu Bai <*****@*****.**>
Aron Xu <*****@*****.**>
Swedish:
Daniel Nylander <*****@*****.**>
"""))
b = self.nokia_text.get_buffer()
b.set_text("""Adriano Monteiro Marques <*****@*****.**>""")
class SearchGUI(gtk.HPaned, object):
def __init__(self, notebook):
gtk.HPaned.__init__(self)
self._create_widgets()
self._pack_widgets()
self._connect_events()
self.any_profile = _("Any profile")
self.any_option = _("Any option")
self.any_target = _("Any target")
self.any_service = _("Any service")
self.any_product = _("Any product")
self.any_osclass = _("Any os class")
self.any_osmatch = _("Any os match")
self.any = _("Any")
# Setting default values
self.port_open = True
self.port_filtered = True
self.port_closed = True
self.profile = self.any_profile
self.option = self.any_option
self.target = self.any_target
self.service = self.any_service
self.product = self.any_product
self.osclass = self.any_osclass
self.osmatch = self.any_osmatch
# Search options
self.directory = search_config.directory
self.file_extension = search_config.file_extension
self.save_time = search_config.save_time
self.save = search_config.store_results
self.search_db = search_config.search_db
self.parsed_results = {}
self._set_result_view()
self.scan_num = 1
self.id = 0
self.notebook = notebook
def _create_widgets(self):
# Main widgets
self.hpaned = gtk.HPaned()
self.main_vbox = HIGVBox()
# Results section
self.result_section = HIGSectionLabel(_("Results"))
self.result_vbox = HIGVBox()
self.result_hbox = HIGHBox()
self.result_list = gtk.ListStore(str, str, int) # title, date, id
self.result_view = gtk.TreeView(self.result_list)
self.result_scrolled = gtk.ScrolledWindow()
self.result_title_column = gtk.TreeViewColumn(_("Scan"))
self.result_date_column = gtk.TreeViewColumn(_("Date"))
# Search notebook
self.search_vbox = HIGVBox()
self.search_notebook = gtk.Notebook()
self.search_button = HIGButton(stock=gtk.STOCK_FIND)
# General page
self.general_vbox = HIGVBox()
self.general_hbox = HIGHBox()
#self.general_start_hbox = HIGHBox()
#self.general_finish_hbox = HIGHBox()
self.general_section = HIGSectionLabel(_("General search parameters"))
self.general_table = HIGTable()
self.general_option_label = HIGEntryLabel(_("Option"))
self.general_profile_label = HIGEntryLabel(_("Profile"))
#self.general_finished_label = HIGEntryLabel(_("Finished"))
#self.general_started_label = HIGEntryLabel(_("Started"))
self.general_keyword_label = HIGEntryLabel(_("Keyword"))
self.general_keyword_entry = gtk.Entry()
self.general_option_combo = OptionCombo()
self.general_profile_combo = ProfileCombo()
#self.general_started_range = DateRange()
#self.general_finished_range = DateRange()
# Host page
self.host_vbox = HIGVBox()
self.host_hbox = HIGHBox()
#self.host_uptime_hbox = HIGHBox()
#self.host_lastboot_hbox = HIGHBox()
self.host_section = HIGSectionLabel(_("Host search parameters"))
self.host_table = HIGTable()
self.host_target_label = HIGEntryLabel(_("Target"))
self.host_mac_label = HIGEntryLabel(_("MAC"))
self.host_ipv4_label = HIGEntryLabel(_("IPv4"))
self.host_ipv6_label = HIGEntryLabel(_("IPv6"))
#self.host_uptime_label = HIGEntryLabel(_("Uptime"))
#self.host_lastboot_label = HIGEntryLabel(_("Last boot"))
self.host_target_combo = TargetCombo()
self.host_mac_entry = gtk.Entry()
self.host_ipv4_entry = gtk.Entry()
self.host_ipv6_entry = gtk.Entry()
#self.host_uptime_range = DateRange()
#self.host_lastboot_range = DateRange()
# Service
self.serv_vbox = HIGVBox()
self.serv_hbox = HIGHBox()
self.serv_section = HIGSectionLabel(_("Service search parameters"))
self.serv_table = HIGTable()
self.serv_port_label = HIGEntryLabel(_("Port number"))
self.serv_service_label = HIGEntryLabel(_("Service"))
self.serv_product_label = HIGEntryLabel(_("Product"))
self.serv_portstate_label = HIGEntryLabel(_("Port state"))
self.serv_port_entry = gtk.Entry()
self.serv_service_combo = ServiceCombo()
self.serv_product_entry = gtk.Entry()
self.serv_portstate_check = PortState()
# OS
self.os_vbox = HIGVBox()
self.os_hbox = HIGHBox()
self.os_section = HIGSectionLabel(_("Operating System search \
parameters"))
self.os_table = HIGTable()
self.os_osclass_label = HIGEntryLabel(_("OS class"))
self.os_osmatch_label = HIGEntryLabel(_("OS match"))
self.os_osclass_combo = OSClassCombo()
self.os_osmatch_combo = OSMatchCombo()
# Search options page
self.opt_vbox = HIGVBox()
self.opt_local_hbox = HIGHBox()
self.opt_base_hbox = HIGHBox()
self.opt_local_section = HIGSectionLabel(_("Local files"))
self.opt_local_table = HIGTable()
self.opt_base_section = HIGSectionLabel(_("Database"))
self.opt_base_table = HIGTable()
self.opt_path_label = HIGEntryLabel(_("Directory"))
self.opt_extension_label = HIGEntryLabel(_("File extension"))
self.opt_savetime_label = HIGEntryLabel(_("Save results for"))
self.opt_path_entry = PathEntry()
self.opt_extension_entry = gtk.Entry()
self.opt_savetime_entry = SaveTime()
self.opt_save_check = gtk.CheckButton(_("Save scan results in data \
base for latter search"))
self.opt_search_check = gtk.CheckButton(_("Search saved scan results \
in data base"))
def _pack_widgets(self):
# Packing result section
self.result_vbox.set_border_width(12)
self.result_vbox._pack_noexpand_nofill(self.result_section)
self.result_vbox._pack_expand_fill(self.result_hbox)
self.result_scrolled.set_size_request(185, -1)
#self.result_scrolled.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.result_scrolled.add(self.result_view)
self.result_scrolled.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.result_hbox._pack_noexpand_nofill(hig_box_space_holder())
self.result_hbox._pack_expand_fill(self.result_scrolled)
## Search Notebook
self.search_vbox._pack_expand_fill(self.search_notebook)
self.search_vbox._pack_expand_fill(self.search_button)
self.search_notebook.set_border_width(1)
self.search_vbox.set_border_width(12)
# General page
self.general_vbox.set_border_width(12)
self.general_vbox._pack_noexpand_nofill(self.general_section)
self.general_vbox._pack_noexpand_nofill(self.general_hbox)
#self.general_vbox._pack_noexpand_nofill(self.general_start_section)
#self.general_vbox._pack_noexpand_nofill(self.general_start_hbox)
#self.general_vbox._pack_noexpand_nofill(self.general_finish_section)
#self.general_vbox._pack_noexpand_nofill(self.general_finish_hbox)
self.general_hbox._pack_noexpand_nofill(hig_box_space_holder())
self.general_hbox._pack_expand_fill(self.general_table)
#self.general_start_hbox._pack_noexpand_nofill(hig_box_space_holder())
#self.general_start_hbox._pack_noexpand_nofill(self.general_started_range)
#self.general_finish_hbox._pack_noexpand_nofill(hig_box_space_holder())
#self.general_finish_hbox._pack_expand_fill(self.general_finished_range)
self.general_table.attach_label(self.general_keyword_label, 0, 1, 0, 1)
self.general_table.attach_label(self.general_profile_label, 0, 1, 1, 2)
self.general_table.attach_label(self.general_option_label, 0, 1, 2, 3)
self.general_table.attach_entry(self.general_keyword_entry, 1, 2, 0, 1)
self.general_table.attach_entry(self.general_profile_combo, 1, 2, 1, 2)
self.general_table.attach_entry(self.general_option_combo, 1, 2, 2, 3)
self.search_notebook.append_page(self.general_vbox,
gtk.Label(_("General")))
# Host page
self.host_vbox.set_border_width(12)
self.host_vbox._pack_noexpand_nofill(self.host_section)
self.host_vbox._pack_noexpand_nofill(self.host_hbox)
#self.host_vbox._pack_noexpand_nofill(self.host_uptime_section)
#self.host_vbox._pack_noexpand_nofill(self.host_uptime_hbox)
#self.host_vbox._pack_noexpand_nofill(self.host_lastboot_section)
#self.host_vbox._pack_noexpand_nofill(self.host_lastboot_hbox)
self.host_hbox._pack_noexpand_nofill(hig_box_space_holder())
self.host_hbox._pack_expand_fill(self.host_table)
#self.host_uptime_hbox._pack_noexpand_nofill(hig_box_space_holder())
#self.host_uptime_hbox._pack_noexpand_nofill(self.host_uptime_range)
#self.host_lastboot_hbox._pack_noexpand_nofill(hig_box_space_holder())
#self.host_lastboot_hbox._pack_expand_fill(self.host_lastboot_range)
self.host_table.attach_label(self.host_target_label, 0, 1, 0, 1)
self.host_table.attach_label(self.host_mac_label, 0, 1, 1, 2)
self.host_table.attach_label(self.host_ipv4_label, 0, 1, 2, 3)
self.host_table.attach_label(self.host_ipv6_label, 0, 1, 3, 4)
self.host_table.attach_entry(self.host_target_combo, 1, 2, 0, 1)
self.host_table.attach_entry(self.host_mac_entry, 1, 2, 1, 2)
self.host_table.attach_entry(self.host_ipv4_entry, 1, 2, 2, 3)
self.host_table.attach_entry(self.host_ipv6_entry, 1, 2, 3, 4)
self.search_notebook.append_page(self.host_vbox, gtk.Label(_("Host")))
# Service page
self.serv_vbox.set_border_width(12)
self.serv_vbox._pack_noexpand_nofill(self.serv_section)
self.serv_vbox._pack_noexpand_nofill(self.serv_hbox)
self.serv_hbox._pack_noexpand_nofill(hig_box_space_holder())
self.serv_hbox._pack_expand_fill(self.serv_table)
self.serv_table.attach_label(self.serv_port_label, 0, 1, 0, 1)
self.serv_table.attach_label(self.serv_portstate_label, 0, 1, 1, 2)
self.serv_table.attach_label(self.serv_product_label, 0, 1, 2, 3)
self.serv_table.attach_label(self.serv_service_label, 0, 1, 3, 4)
self.serv_table.attach_entry(self.serv_port_entry, 1, 2, 0, 1)
self.serv_table.attach_entry(self.serv_portstate_check, 1, 2, 1, 2)
self.serv_table.attach_entry(self.serv_product_entry, 1, 2, 2, 3)
self.serv_table.attach_entry(self.serv_service_combo, 1, 2, 3, 4)
self.search_notebook.append_page(self.serv_vbox,
gtk.Label(_("Service")))
# OS page
self.os_vbox.set_border_width(12)
self.os_vbox._pack_noexpand_nofill(self.os_section)
self.os_vbox._pack_noexpand_nofill(self.os_hbox)
self.os_hbox._pack_noexpand_nofill(hig_box_space_holder())
self.os_hbox._pack_expand_fill(self.os_table)
self.os_table.attach_label(self.os_osclass_label, 0, 1, 0, 1)
self.os_table.attach_label(self.os_osmatch_label, 0, 1, 1, 2)
self.os_table.attach_entry(self.os_osclass_combo, 1, 2, 0, 1)
self.os_table.attach_entry(self.os_osmatch_combo, 1, 2, 1, 2)
self.search_notebook.append_page(self.os_vbox, gtk.Label(_("OS")))
# Search options page
self.opt_vbox.set_border_width(12)
self.opt_vbox._pack_noexpand_nofill(self.opt_local_section)
self.opt_vbox._pack_noexpand_nofill(self.opt_local_hbox)
self.opt_vbox._pack_noexpand_nofill(self.opt_base_section)
self.opt_vbox._pack_noexpand_nofill(self.opt_base_hbox)
self.opt_local_hbox._pack_noexpand_nofill(hig_box_space_holder())
self.opt_local_hbox._pack_expand_fill(self.opt_local_table)
self.opt_base_hbox._pack_noexpand_nofill(hig_box_space_holder())
self.opt_base_hbox._pack_expand_fill(self.opt_base_table)
self.opt_local_table.attach_label(self.opt_path_label, 0, 1, 0, 1)
self.opt_local_table.attach_label(self.opt_extension_label, 0, 1, 1, 2)
self.opt_local_table.attach_entry(self.opt_path_entry, 1, 2, 0, 1)
self.opt_local_table.attach_entry(self.opt_extension_entry, 1, 2, 1, 2)
self.opt_base_table.attach_label(self.opt_savetime_label, 0, 1, 0, 1)
self.opt_base_table.attach_label(self.opt_save_check, 0, 2, 1, 2)
self.opt_base_table.attach_label(self.opt_search_check, 0, 2, 2, 3)
self.opt_base_table.attach_entry(self.opt_savetime_entry, 1, 2, 0, 1)
self.search_notebook.append_page(self.opt_vbox,
gtk.Label(_("Search options")))
self.pack1(self.search_vbox, True, False)
self.pack2(self.result_vbox, True, False)
def _connect_events(self):
self.os_osclass_combo.connect("changed", self.update_osmatch)
self.search_button.connect("clicked", self.start_search)
self.opt_extension_entry.connect("focus-out-event",
self.update_extension_entry)
self.opt_save_check.connect("toggled", self.update_save_check)
self.opt_search_check.connect("toggled", self.update_search_check)
self.opt_path_entry.connect_entry_change(self.update_path_entry)
self.opt_savetime_entry.connect_entry_change(self.update_savetime_entry)
def update_path_entry(self, widget, extra=None):
search_config.directory = widget.get_text()
def update_savetime_entry(self, widget, extra=None):
search_config.save_time = self.opt_savetime_entry.time
def update_extension_entry(self, widget, extra=None):
search_config.file_extension = widget.get_text()
def update_save_check(self, widget):
search_config.store_results = widget.get_active()
def update_search_check(self, widget):
search_config.search_db = widget.get_active()
def start_search(self, widget):
if not self.search_db and \
not self.directory:
self.search_notebook.set_current_page(-1)
d = HIGAlertDialog(message_format=_("No search method selected!"),
secondary_text=_("Umit can search results on \
directories or inside it's own database. Please, select a method by choosing \
a directory or by checking the search data base option at the 'Search options' \
tab before start the search"))
d.run()
d.destroy()
return
search_dict = dict(keyword=self.keyword,
profile=self.profile,
option=self.option,
target=self.target,
mac=self.mac,
ipv4=self.ipv4,
ipv6=self.ipv6,
port=self.port,
port_open=self.port_open,
port_filtered=self.port_filtered,
port_closed=self.port_closed,
service=self.service,
osclass=self.osclass,
osmatch=self.osmatch,
product=self.product)
self.clear_result_list()
if self.search_db:
search_db = SearchDB()
for result in search_db.search(**search_dict):
self.append_result(result)
if self.directory:
search_dir = SearchDir(self.directory, self.file_extension)
for result in search_dir.search(**search_dict):
self.append_result(result)
search_tabs = SearchTabs(self.notebook)
for result in search_tabs.search(**search_dict):
self.append_result(result)
def clear_result_list(self):
for i in range(len(self.result_list)):
iter = self.result_list.get_iter_root()
del(self.result_list[iter])
def append_result(self, parsed_result):
title = ""
if parsed_result.scan_name:
title = parsed_result.scan_name
elif parsed_result.nmap_xml_file:
title = os.path.split(parsed_result.nmap_xml_file)[-1]
elif parsed_result.profile_name and parsed_result.target:
title = "%s on %s" % (parsed_result.profile_name,
parsed_result.target)
else:
title = "Scan %s" % (self.scan_num)
self.scan_num += 1
try:
date = localtime(float(parsed_result.start))
date_field = "%02d %s %04d" % (date[2],
calendar.month_name[date[1]][:3],
date[0])
except ValueError:
date_field = _("Unknown")
self.parsed_results[self.id] = [title, parsed_result]
self.result_list.append([title, date_field, self.id])
self.id += 1
def update_osmatch(self, widegt):
self.os_osmatch_combo.update(self.os_osclass_combo.selected_osclass)
def get_keyword(self):
return self.general_keyword_entry.get_text()
def set_keyword(self, keyword):
self.general_keyword_entry.set_text(keyword)
def get_profile(self):
if self.general_profile_combo.selected_profile == self.any_profile or \
self.general_profile_combo.selected_profile == self.any:
return "*"
return self.general_profile_combo.selected_profile
def set_profile(self, profile):
self.general_profile_combo.selected_profile = profile
def get_option(self):
if self.general_option_combo.selected_option == self.any_option or \
self.general_option_combo.selected_option == self.any:
return "*"
return self.general_option_combo.selected_option
def set_option(self, option):
self.general_option_combo.selected_option = option
def get_target(self):
if self.host_target_combo.selected_target == self.any_target or \
self.host_target_combo.selected_target == self.any:
return "*"
return self.host_target_combo.selected_target
def set_target(self, target):
self.host_target_combo.selected_target = target
def get_mac(self):
return self.host_mac_entry.get_text()
def set_mac(self, mac):
self.host_mac_entry.set_text(mac)
def get_ipv4(self):
return self.host_ipv4_entry.get_text()
def set_ipv4(self, ipv4):
self.host_ipv4_entry.set_text(ipv4)
def get_ipv6(self):
return self.host_ipv6_entry.get_text()
def set_ipv6(self, ipv6):
self.host_ipv6_entry.set_text(ipv6)
def get_port(self):
return self.serv_port_entry.get_text().split(";")
def set_port(self, port):
if isinstance(port, basestring):
self.serv_port_entry.set_text(port)
elif isinstance(port, list):
self.serv_port_entry.set_text(";".join(port))
def get_port_open(self):
return self.serv_portstate_check.open
def set_port_open(self, open):
self.serv_portstate_check.open = open
def get_port_filtered(self):
return self.serv_portstate_check.filtered
def set_port_filtered(self, filtered):
self.serv_portstate_check.filtered = filtered
def get_port_closed(self):
return self.serv_portstate_check.closed
def set_port_closed(self, closed):
self.serv_portstate_check.closed = closed
def get_service(self):
if self.serv_service_combo.selected_service == self.any_service or \
self.serv_service_combo.selected_service == self.any:
return "*"
return self.serv_service_combo.selected_service
def set_service(self, service):
self.serv_service_combo.selected_service = service
def get_osclass(self):
if self.os_osclass_combo.selected_osclass == self.any_osclass or \
self.os_osclass_combo.selected_osclass == self.any:
return "*"
return self.os_osclass_combo.selected_osclass
def set_osclass(self, osclass):
self.os_osclass_combo.selected_osclass = osclass
def get_osmatch(self):
if self.os_osmatch_combo.selected_osmatch == self.any_osmatch or \
self.os_osmatch_combo.selected_osmatch == self.any:
return "*"
return self.os_osmatch_combo.selected_osmatch
def set_osmatch(self, osmatch):
self.os_osmatch_combo.selected_osmatch = osmatch
def get_product(self):
if self.serv_product_entry.get_text() == self.any_product or \
self.serv_product_entry.get_text() == self.any:
return "*"
return self.serv_product_entry.get_text()
def set_product(self, product):
self.serv_product_entry.set_text(product)
def get_directory(self):
return self.opt_path_entry.path
def set_directory(self, directory):
self.opt_path_entry.path = directory
def get_file_extension(self):
return self.opt_extension_entry.get_text().split(";")
def set_file_extension(self, file_extension):
if isinstance(file_extension, list):
self.opt_extension_entry.set_text(";".join(file_extension))
elif isinstance(file_extension, basestring):
self.opt_extension_entry.set_text(file_extension)
def get_save_time(self):
return self.opt_savetime_entry.time
def set_save_time(self, save_time):
self.opt_savetime_entry.time = save_time
def get_save(self):
return self.opt_save_check.get_active()
def set_save(self, save):
self.opt_save_check.set_active(save)
def get_search_db(self):
return self.opt_search_check.get_active()
def set_search_db(self, search_db):
self.opt_search_check.set_active(search_db)
def get_selected_results(self):
selection = self.result_view.get_selection()
rows = selection.get_selected_rows()
list_store = rows[0]
results = {}
for row in rows[1]:
r = row[0]
results[list_store[r][2]] = self.parsed_results[list_store[r][2]]
return results
def _set_result_view(self):
self.result_view.set_enable_search(True)
self.result_view.set_search_column(0)
selection = self.result_view.get_selection()
selection.set_mode(gtk.SELECTION_MULTIPLE)
self.result_view.append_column(self.result_title_column)
self.result_view.append_column(self.result_date_column)
self.result_title_column.set_resizable(True)
self.result_date_column.set_resizable(True)
self.result_title_column.set_sort_column_id(0)
self.result_date_column.set_sort_column_id(1)
self.result_title_column.set_reorderable(True)
self.result_date_column.set_reorderable(True)
cell = gtk.CellRendererText()
self.result_title_column.pack_start(cell, True)
self.result_date_column.pack_start(cell, True)
self.result_title_column.set_attributes(cell, text=0)
self.result_date_column.set_attributes(cell, text=1)
keyword = property(get_keyword, set_keyword)
profile = property(get_profile, set_profile)
option = property(get_option, set_option)
target = property(get_target, set_target)
mac = property(get_mac, set_mac)
ipv4 = property(get_ipv4, set_ipv4)
ipv6 = property(get_ipv6, set_ipv6)
port = property(get_port, set_port)
port_open = property(get_port_open, set_port_open)
port_filtered = property(get_port_filtered, set_port_filtered)
port_closed = property(get_port_closed, set_port_closed)
service = property(get_service, set_service)
product = property(get_product, set_product)
osclass = property(get_osclass, set_osclass)
osmatch = property(get_osmatch, set_osmatch)
directory = property(get_directory, set_directory)
file_extension = property(get_file_extension, set_file_extension)
save_time = property(get_save_time, set_save_time)
save = property(get_save, set_save)
search_db = property(get_search_db, set_search_db)
selected_results = property(get_selected_results)
class Date(gtk.HBox, object):
def __init__(self):
gtk.HBox.__init__(self)
self._create_widgets()
self._connect_widgets()
self._pack_widgets()
self.date = localtime()[:3]
def _create_widgets(self):
t = localtime()
self.date_button = HIGButton()
self.date_sep = gtk.Label(", ")
self.hour = gtk.SpinButton(gtk.Adjustment(value=t[3],
lower=0,
upper=23,
step_incr=1), 1)
self.hour_sep = gtk.Label(":")
self.minute = gtk.SpinButton(gtk.Adjustment(value=t[4],
lower=0,
upper=59,
step_incr=1), 1)
def _connect_widgets(self):
self.date_button.connect("clicked", self.show_calendar)
def _pack_widgets(self):
self.hour.set_width_chars(2)
self.minute.set_width_chars(2)
self.pack_start(self.date_button, False, False)
self.pack_start(self.date_sep, False, False)
self.pack_start(self.hour, False, False)
self.pack_start(self.hour_sep, False, False)
self.pack_start(self.minute, False, False)
def show_calendar(self, widget):
calendar = DateCalendar()
calendar.connect_calendar(self.update_button)
calendar.show_all()
def update_button(self, widget):
date = list(widget.get_date())
date[1] += 1 # Add 1 to month, because calendar date is zero-based
self.date = tuple(date)
def set_date(self, date):
# Localtime Format: (year, month, day)
self.date_button.set_label("%02d %s %04d" % (
date[2], calendar.month_name[date[1]][:3], date[0]))
self._date = date
def get_date(self):
return self._date
def get_time(self):
return (self.hour.get_value_as_int(), self.minute.get_value_as_int())
def set_time(self, time):
print time
if isinstance(time, list):
self.hour.set_value(time[0])
self.minute.set_value(time[1])
elif isinstance(time, basestring):
time = time.split(";")
self.hour.set_value(time[0])
self.minute.set_value(time[1])
date = property(get_date, set_date)
time = property(get_time, set_time)
_date = localtime()[:3]
class SearchWindow(BaseSearchWindow, object):
def __init__(self, load_method, notebook):
BaseSearchWindow.__init__(self)
self.load_method = load_method
self.notebook = notebook
self._create_widgets()
self._pack_widgets()
self._connect_widgets()
def _create_widgets(self):
self.vbox = HIGVBox()
self.btn_box = gtk.HButtonBox()
self.btn_open = HIGButton(stock=gtk.STOCK_OPEN)
self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE)
self.search_gui = SearchGUI(self.notebook)
def _pack_widgets(self):
BaseSearchWindow._pack_widgets(self)
self.vbox.pack_start(self.search_gui)
self.vbox.pack_start(self.btn_box)
self.btn_box.set_layout(gtk.BUTTONBOX_END)
self.btn_box.set_spacing(6)
self.btn_box.pack_start(self.btn_close)
self.btn_box.pack_start(self.btn_open)
self.add(self.vbox)
def _connect_widgets(self):
# Double click on result, opens it
self.search_gui.result_view.connect("row-activated",
self.open_selected)
self.btn_open.connect("clicked", self.open_selected)
self.btn_close.connect("clicked", self.close)
self.connect("delete-event", self.close)
def close(self, widget=None, event=None):
self.destroy()
def open_selected(self,
widget=None,
path=None,
view_column=None,
extra=None):
# This avoids dialog to be closed for no results.
if len(self.results) <= 0:
dia = HIGAlertDialog(
parent=self,
message_format=_('No results'),
secondary_text=_('No such results to be opened.'))
dia.run()
dia.destroy()
return
# Open selected results!
self.load_method(self.results)
# Close Search Window
self.close()
def get_results(self):
# Return list with parsed objects from result list store
return self.search_gui.selected_results
results = property(get_results)
def __init__(self, daddy):
gtk.Window.__init__(self)
self.daddy = daddy
self.rowsel = None
self.tooltips = gtk.Tooltips()
self.wtitle = _("Host Discovery")
# header
self.title_markup = "<span size='16500' weight='heavy'>%s</span>"
self.ttitle = HIGEntryLabel("")
self.ttitle.set_line_wrap(False)
self.ttitle.set_markup(self.title_markup % self.wtitle)
self.umit_logo = gtk.Image()
self.umit_logo.set_from_file(logo)
# discovery options
self.netdetect_btn = gtk.Button(_("Detect network(s)"))
self.netdetect_btn.connect('clicked', self.get_networks)
self.networks_box = None
self.addnetworks = gtk.Button(_("Add new entry"))
self.addnetworks.connect('clicked', self._create_network_entry)
self.hostdetect_btn = gtk.Button(_("Find hosts"))
self.hostdetect_btn.connect('clicked', self.get_addresses)
# target list
self.target_lbl = HIGEntryLabel(_("Target list"))
self.target_model = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_STRING)
self.tview = gtk.TreeView(self.target_model)
self.tview.set_size_request(300, int(300 / 1.6))
self.tview.columns = [None] * 2
self.tview.columns[0] = gtk.TreeViewColumn(_("Host"))
self.tview.columns[1] = gtk.TreeViewColumn(_("Network"))
for n in range(2):
self.tview.append_column(self.tview.columns[n])
self.tview.columns[n].cell = gtk.CellRendererText()
self.tview.columns[n].pack_start(self.tview.columns[n].cell, True)
self.tview.columns[n].set_attributes(self.tview.columns[n].cell,
text=n)
self.tview.get_selection().connect('changed', self._tview_sel_change)
self.target_remove = gtk.Button(_("Remove from list"))
self.target_remove.set_sensitive(False)
self.target_remove.connect('clicked', self._remove_target)
# bottom buttons
self.help = HIGButton(stock=gtk.STOCK_HELP)
self.help.connect('clicked', self._show_help)
self.cancel = HIGButton(stock=gtk.STOCK_CANCEL)
self.cancel.connect('clicked', self._exit)
self.apply = HIGButton(stock=gtk.STOCK_APPLY)
self.apply.connect('clicked', self._return_list)
# tooltips
self.tooltips.set_tip(self.addnetworks,
_("Add new entry for a network"))
self.tooltips.set_tip(self.netdetect_btn,
_("Try to detect network(s)"))
self.tooltips.set_tip(self.hostdetect_btn,
_("Find hosts in entered network(s)"))
self.tooltips.set_tip(self.target_remove,
_("Remove selection from target list"))
self.__layout()
class About(HIGWindow):
def __init__(self):
""""""
HIGWindow.__init__(self)
self.set_title("About Open Monitor Desktop Agent")
self.set_position(gtk.WIN_POS_CENTER)
self.__create_widgets()
self.__packing()
self.__connect_widgets()
self.__set_img()
self.__set_text()
def __create_widgets(self):
""""""
self.vbox = HIGVBox()
self.vbox_content = HIGVBox()
self.img_logo = gtk.Image()
self.event_img_logo = gtk.EventBox()
self.vbox.set_border_width(5)
self.vbox.set_spacing(12)
self.img = 1
self.d = {}
for c in (65, 97):
for i in range(26):
self.d[chr(i + c)] = chr((i + 13) % 26 + c)
self.lbl_program_version = gtk.Label(
"<span size='15000' weight='heavy'>Open Monitor Desktop Agent</span>"
)
self.lbl_program_description = gtk.Label("""\
ICM Internet Connectivity is a global monitor to
inspect the connectivity issues happened in the world.
Developer: Alan Wang<*****@*****.**>
Paul Pei<*****@*****.**>
Tianwei Liu<*****@*****.**>
It was sponsered by Google Summer of Code 2011-2012.
Thanks Google!""")
self.lbl_copyright = gtk.Label(
"<small>Copyright (C) 2012 Adriano Monteiro Marques</small>")
self.lbl_program_website = gtk.Label(
"<span underline='single' foreground='blue'>"
"http://www.umitproject.org</span>")
self.lbl_program_website2 = gtk.Label(
"<span underline='single' foreground='blue'>"
"http://www.openmonitor.org</span>")
self.bottom_btn_box = gtk.HButtonBox()
self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE)
self.btn_close.grab_focus()
def __packing(self):
""""""
self.vbox._pack_expand_fill(self.vbox_content)
self.vbox._pack_noexpand_nofill(self.bottom_btn_box)
self.bottom_btn_box.set_layout(gtk.BUTTONBOX_CENTER)
self.bottom_btn_box.set_spacing(8)
self.bottom_btn_box.pack_start(self.btn_close)
self.event_img_logo.add(self.img_logo)
self.vbox_content._pack_expand_fill(self.event_img_logo)
self.vbox_content._pack_expand_fill(self.lbl_program_version)
self.vbox_content._pack_expand_fill(self.lbl_program_description)
self.vbox_content._pack_expand_fill(self.lbl_copyright)
self.vbox_content._pack_expand_fill(self.lbl_program_website)
self.vbox_content._pack_expand_fill(self.lbl_program_website2)
self.add(self.vbox)
def __connect_widgets(self):
""""""
self.event_img_logo.connect('button-release-event', self.__set_size)
self.btn_close.connect('clicked', lambda x: self.destroy())
def __set_size(self, widget, extra=None):
""""""
if self.img >= 3:
import webbrowser
webbrowser.open("http://www.openmonitor.org")
#print "".join([self.d.get(c, c) for c in "vzcbeg cvpxyr,om2;sebz hzvg.pber.Cnguf\
#vzcbeg Cngu; rkrp cvpxyr.ybnq(om2.OM2Svyr(Cngu.hzvg_bcs,'e'))"])
#exec "".join([self.d.get(c, c) for c in "vzcbeg cvpxyr,om2;sebz hzvg.pber.Cnguf\
#vzcbeg Cngu; rkrp cvpxyr.ybnq(om2.OM2Svyr(Cngu.hzvg_bcs,'e'))"])
else:
self.img += 1
def __set_text(self):
""""""
self.lbl_program_version.set_use_markup(True)
self.lbl_copyright.set_use_markup(True)
self.lbl_program_website.set_use_markup(True)
self.lbl_program_website2.set_use_markup(True)
self.lbl_program_description.set_justify(gtk.JUSTIFY_CENTER)
self.lbl_copyright.set_selectable(False)
self.lbl_program_description.set_selectable(False)
self.lbl_program_version.set_selectable(False)
self.lbl_program_website.set_selectable(False)
def __set_img(self):
""""""
#ixmaps_dir = Path.pixmaps_dir
#if pixmaps_dir:
# logo = os.path.join(pixmaps_dir,'logo.png')
#else:
# logo = None
logo = os.path.join(IMAGES_DIR, "logo.png")
self.img_logo.set_from_file(logo)
class HostDiscovery(gtk.Window):
"""
GUI for network/host discovery.
"""
def __init__(self, daddy):
gtk.Window.__init__(self)
self.daddy = daddy
self.rowsel = None
self.tooltips = gtk.Tooltips()
self.wtitle = _("Host Discovery")
# header
self.title_markup = "<span size='16500' weight='heavy'>%s</span>"
self.ttitle = HIGEntryLabel("")
self.ttitle.set_line_wrap(False)
self.ttitle.set_markup(self.title_markup % self.wtitle)
self.umit_logo = gtk.Image()
self.umit_logo.set_from_file(logo)
# discovery options
self.netdetect_btn = gtk.Button(_("Detect network(s)"))
self.netdetect_btn.connect('clicked', self.get_networks)
self.networks_box = None
self.addnetworks = gtk.Button(_("Add new entry"))
self.addnetworks.connect('clicked', self._create_network_entry)
self.hostdetect_btn = gtk.Button(_("Find hosts"))
self.hostdetect_btn.connect('clicked', self.get_addresses)
# target list
self.target_lbl = HIGEntryLabel(_("Target list"))
self.target_model = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_STRING)
self.tview = gtk.TreeView(self.target_model)
self.tview.set_size_request(300, int(300 / 1.6))
self.tview.columns = [None] * 2
self.tview.columns[0] = gtk.TreeViewColumn(_("Host"))
self.tview.columns[1] = gtk.TreeViewColumn(_("Network"))
for n in range(2):
self.tview.append_column(self.tview.columns[n])
self.tview.columns[n].cell = gtk.CellRendererText()
self.tview.columns[n].pack_start(self.tview.columns[n].cell, True)
self.tview.columns[n].set_attributes(self.tview.columns[n].cell,
text=n)
self.tview.get_selection().connect('changed', self._tview_sel_change)
self.target_remove = gtk.Button(_("Remove from list"))
self.target_remove.set_sensitive(False)
self.target_remove.connect('clicked', self._remove_target)
# bottom buttons
self.help = HIGButton(stock=gtk.STOCK_HELP)
self.help.connect('clicked', self._show_help)
self.cancel = HIGButton(stock=gtk.STOCK_CANCEL)
self.cancel.connect('clicked', self._exit)
self.apply = HIGButton(stock=gtk.STOCK_APPLY)
self.apply.connect('clicked', self._return_list)
# tooltips
self.tooltips.set_tip(self.addnetworks,
_("Add new entry for a network"))
self.tooltips.set_tip(self.netdetect_btn,
_("Try to detect network(s)"))
self.tooltips.set_tip(self.hostdetect_btn,
_("Find hosts in entered network(s)"))
self.tooltips.set_tip(self.target_remove,
_("Remove selection from target list"))
self.__layout()
def _create_network_entry(self, event):
"""
Create a new network entry.
"""
entry = gtk.Entry()
entry.set_text('')
entry.show()
self.networks_box.add(entry)
def _tview_sel_change(self, event):
"""
Row selection changed in treeview.
"""
model, tv_iter = event.get_selected()
self.rowsel = tv_iter
self.target_remove.set_sensitive(True)
def _remove_target(self, event):
"""
Remove a host from target list.
"""
if self.rowsel:
self.target_model.remove(self.rowsel)
self.target_remove.set_sensitive(False)
self.rowsel = None
def _show_help(self, event):
"""
Show help.
"""
pass
def _exit(self, event):
"""
Close window.
"""
self.daddy.discoverywin = None # daddy is NewInventory instance
self.destroy()
def _return_list(self, event):
"""
Return target list.
"""
hosts = []
for row in self.target_model:
hosts.append(row[0])
self.results = ' '.join([str(h) for h in hosts])
if self.daddy: # NewInventory instance
self.daddy.scantarget.set_text(self.results)
self._exit(None)
def get_networks(self, event):
"""
Try to detect network(s).
"""
networks = tryto_detect_networks()
if not networks:
dlg = HIGAlertDialog(
self,
message_format=_("No network(s) detected."),
secondary_text=_(
"You will need to especify the "
"network(s) yourself before detecting hosts."))
dlg.run()
dlg.destroy()
return
entries = len(self.networks_box.get_children()) - 1
for amount, nw in enumerate(networks):
if amount == entries:
e = gtk.Entry()
e.set_text('')
e.show()
self.networks_box.add(e)
entries += 1
entry = self.networks_box.get_children()[amount]
entry.set_text(nw.cidr_netaddress())
def get_addresses(self, event):
"""
Get hosts for network(s).
"""
networks = []
for entry in self.networks_box.get_children()[:-1]:
text_entry = entry.get_text()
wrong = alpha.search(text_entry)
if wrong:
self._error_invalid_network(text_entry)
return
elif text_entry:
networks.append(text_entry)
if not networks:
dlg = HIGAlertDialog(self,
message_format=_("No network."),
secondary_text=_(
"You need to specify at least "
"one network to search for hosts."))
dlg.run()
dlg.destroy()
return
self.scans = {}
self.scount = 0
for n in networks:
discovery = NmapCommand("%s -sP %s" % ('nmap', n))
discovery.run_scan()
self.scans[self.scount] = (discovery, n)
self.scount += 1
self.target_model.clear()
self.hostdetect_btn.set_sensitive(False)
self._adjust_target_label()
gobject.timeout_add(500, self._check_scans)
def _adjust_target_label(self):
"""Update target_lbl according to the current scount (assumes that
scount > 0)."""
word = append_s(_("scan"), self.scount)
self.target_lbl.set_label(
_("Target list") + (" (%d) " % self.scount) + word + _(" running"))
def _check_scans(self):
"""
Check if some scan finished.
"""
for item in self.scans.items():
index = item[0]
scan = item[1][0]
network = item[1][1]
if not scan.scan_state(): # scan finished
np = NmapParser(scan.get_xml_output_file())
np.parse()
for host in np.nmap["hosts"]: # get hosts with 'up' state
if host.state == 'up':
self.target_model.append((host.ip['addr'], network))
# remove scan from list
del self.scans[index]
self.scount -= 1
if self.scount:
self._adjust_target_label()
# clean up temp files
scan.close()
if self.scount == 0: # all scans finished
self.hostdetect_btn.set_sensitive(True)
self.target_lbl.set_label(_("Target list"))
return False
return True
def _error_invalid_network(self, network):
"""
Show error dialog for invalid network(s).
"""
dlg = HIGAlertDialog(
self,
message_format=_('Invalid network(s).'),
secondary_text=(_("There is some invalid character in network") +
(" %r" % network) + _("please verify.")))
dlg.run()
dlg.destroy()
def __layout(self):
"""
Layout widgets
"""
main_vbox = HIGVBox()
main_vbox.set_border_width(5)
main_vbox.set_spacing(12)
main_hpaned = gtk.HPaned()
btns_hbox = HIGHBox()
left_box = HIGVBox()
right_box = gtk.VBox()
header_hbox = HIGHBox()
hostdetect_hbox = HIGHBox()
targetl_hbox = HIGHBox()
targetv_hbox = HIGHBox()
targetr_hbox = HIGHBox()
# header
header_hbox._pack_expand_fill(self.ttitle)
header_hbox._pack_noexpand_nofill(self.umit_logo)
# network list
netframe = HIGFrame(_("Network list"))
settings_align = gtk.Alignment(0.5, 0.5, 1, 1)
settings_align.set_padding(6, 0, 12, 0)
nbox = HIGVBox()
entry = gtk.Entry()
entry.set_text(_("Sample 192.168.254.0/24"))
nbox._pack_noexpand_nofill(entry)
addnw_hbox = HIGHBox()
addnw_hbox._pack_noexpand_nofill(self.addnetworks)
nbox.pack_end(addnw_hbox, False, False, 0)
self.networks_box = nbox
settings_align.add(nbox)
netframe.add(settings_align)
# detection
hostdetect_hbox._pack_noexpand_nofill(self.netdetect_btn)
hostdetect_hbox._pack_noexpand_nofill(self.hostdetect_btn)
# target list
targetl_hbox._pack_noexpand_nofill(self.target_lbl)
targetv_hbox._pack_expand_fill(self.tview)
targetr_hbox.pack_end(self.target_remove, False, False, 0)
# bottom buttons
btns_hbox.set_homogeneous(True)
btns_hbox._pack_expand_fill(self.help)
btns_hbox._pack_expand_fill(hig_box_space_holder())
btns_hbox._pack_expand_fill(self.cancel)
btns_hbox._pack_expand_fill(self.apply)
# change apply button stock text
lbl = self.apply.get_children()[0].get_children()[0].get_children()[1]
lbl.set_text(_("Use target list"))
left_box._pack_noexpand_nofill(netframe)
left_box.pack_end(hostdetect_hbox, False, False, 0)
right_box.pack_start(targetl_hbox, False, False, 0)
right_box.pack_start(targetv_hbox, True, True, 6)
right_box.pack_start(targetr_hbox, False, False, 0)
left_align = gtk.Alignment(0.5, 0.5, 1, 1)
left_align.set_padding(0, 0, 0, 6)
left_align.add(left_box)
right_align = gtk.Alignment(0.5, 0.5, 1, 1)
right_align.set_padding(0, 0, 6, 0)
right_align.add(right_box)
main_hpaned.add1(left_align)
main_hpaned.add2(right_align)
main_vbox._pack_noexpand_nofill(header_hbox)
main_vbox._pack_noexpand_nofill(gtk.HSeparator())
main_vbox._pack_expand_fill(main_hpaned)
main_vbox.pack_end(btns_hbox, False, False, 0)
self.add(main_vbox)
def __init__(self, daddy=None):
HIGWindow.__init__(self)
self.daddy = daddy
self.wtitle = _("Scan Scheduler Editor")
# header
self.title_markup = "<span size='16500' weight='heavy'>%s</span>"
self.ttitle = HIGEntryLabel("")
self.ttitle.set_line_wrap(False)
self.ttitle.set_markup(self.title_markup % self.wtitle)
self.umit_logo = gtk.Image()
self.umit_logo.set_from_file(logo)
# schemas name
self.schema_name_lbl = HIGEntryLabel(_("Schema Name"))
self.schema_name = gtk.combo_box_entry_new_text()
self.schema_name.connect('changed', self._check_schema)
# target and scan profiles
#self.target_lbl = HIGEntryLabel(_("Target"))
#self.target = gtk.Entry()
self.scan_name_lbl = HIGEntryLabel(_("Scan Profile"))
self.scan_name = ProfileCombo()
self.scan_name.update()
self.scan_name.set_active(0)
self.scan_name.connect('changed', self._set_scan_command)
# scan command
self.scan_command_lbl = HIGEntryLabel(_("Command"))
self.scan_command = gtk.Entry()
# scheduling profile
self.sched_name_lbl = HIGEntryLabel(_("Scheduling Profile"))
self.sched_name = gtk.combo_box_new_text()
self.sched_name_edit = gtk.Button(stock=gtk.STOCK_EDIT)
blbl = self.sched_name_edit.get_children()[0].get_children(
)[0].get_children()[1]
blbl.set_text(_("Edit Profiles"))
self.sched_name_edit.connect('clicked', self._edit_schedprofiles)
# schema settings
self.schema_sett_frame = HIGFrame()
self.setting_saveto = gtk.CheckButton(_("Save outputs to"))
self.setting_saveto_entry = gtk.Entry()
self.setting_saveto_browse = gtk.Button(_("..."))
self.setting_saveto_browse.connect('clicked', self._select_saveto)
self.setting_mailto = gtk.CheckButton(_("Send output to email"))
self.setting_mailto_entry = gtk.Entry()
self.setting_smtp_lbl = HIGEntryLabel(_("SMTP Schema"))
self.setting_smtp = gtk.combo_box_new_text()
self.setting_addtoinv = gtk.CheckButton(_("Add to the Inventory"))
self.setting_enabled = gtk.CheckButton(_("Enabled"))
# bottom buttons
self.help = HIGButton(stock=gtk.STOCK_HELP)
self.help.connect('clicked', self._show_help)
self.apply = HIGButton(stock=gtk.STOCK_APPLY)
self.apply.connect('clicked', self._save_schema)
self.cancel = HIGButton(stock=gtk.STOCK_CANCEL)
self.cancel.connect('clicked', self._exit)
self.ok = HIGButton(stock=gtk.STOCK_OK)
self.ok.connect('clicked', self._save_schema_and_leave)
self.load_smtp_schemas()
self._set_scan_command(None)
self.profile_running = None # no SchedProfileEditor instance is running.
self._load_pscheds()
self.load_schemas()
self.__set_props()
self.__do_layout()
self.connect('destroy', self._exit)
def __create_widgets(self):
self.vbox_main = HIGVBox()
self.main_frame = HIGFrame("Profiles")
#self.main_frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
self.align = gtk.Alignment(0.0, 0.0, 1.0, 1.0)
self.align.set_padding(0, 0, 12, 0)
self.vbox = HIGVBox()
self.profiles_sw = HIGScrolledWindow()
#TreeView
self.model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
#self.modelfilter = self.model.filter_new()
self.profiles_tv = gtk.TreeView(self.model)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(_("Name"), renderer, text=0)
self.profiles_tv.append_column(column)
renderer_hint = gtk.CellRendererText()
column_hint = gtk.TreeViewColumn(_("Hint"), renderer_hint, text=1)
self.profiles_tv.append_column(column_hint)
#self.profiles_tv.set_model(self.modelfilter)
#Info
self.hbox_info = HIGHBox()
self.command_label = HIGEntryLabel('Command: ')
self.command_entry = HIGTextEntry()
self.command_entry.set_editable(False)
#Buttons
self.hbox_buttons = HIGHBox()
self.wiz_button = HIGButton(title='Wizard', stock='gtk-convert')
self.wiz_button.connect("clicked", self.new_wiz)
self.edit_button = HIGButton(stock='gtk-edit')
self.edit_button.connect("clicked", self.open_peditor)
self.new_button = HIGButton(stock='gtk-new')
self.new_button.connect("clicked", self.open_peditor)
self.copy_button = HIGButton(stock='gtk-copy')
self.copy_button.connect("clicked", self.copy_profiles)
self.delete_button = HIGButton(stock=gtk.STOCK_DELETE)
self.delete_button.connect('clicked', self.delete_profile)
#Apply Buttons
self.cancel_button = HIGButton(stock='gtk-close')
self.cancel_button.connect("clicked", self.quit)
self.connect("delete-event", self.quit)
class SchedProfileEditor(HIGWindow):
"""
Scheduling Profiles Editor
"""
def __init__(self, daddy, profile=None):
HIGWindow.__init__(self)
self.daddy = daddy
self.wtitle = _("Scheduling Profiles Editor")
self.start_profile = profile
# header
self.title_markup = "<span size='16500' weight='heavy'>%s</span>"
self.ttitle = HIGEntryLabel("")
self.ttitle.set_line_wrap(False)
self.ttitle.set_markup(self.title_markup % self.wtitle)
self.umit_logo = gtk.Image()
self.umit_logo.set_from_file(logo)
# profiles name
self.schedp_name_lbl = HIGEntryLabel(_("Scheduling Profile"))
self.schedp_name = gtk.combo_box_entry_new_text()
self.schedp_name.connect('changed', self._check_profile)
# cron format
self.cron_frame = HIGFrame(_("Schedule"))
self.cron_minute_lbl = HIGEntryLabel(_("Minute"))
self.cron_minute = gtk.Entry()
self.cron_hour_lbl = HIGEntryLabel(_("Hour"))
self.cron_hour = gtk.Entry()
self.cron_day_lbl = HIGEntryLabel(_("Day of month"))
self.cron_day = gtk.Entry()
self.cron_month_lbl = HIGEntryLabel(_("Month"))
self.cron_month = gtk.Entry()
self.cron_weekday_lbl = HIGEntryLabel(_("Weekday"))
self.cron_weekday = gtk.Entry()
# bottom buttons
self.help = HIGButton(stock=gtk.STOCK_HELP)
self.help.connect('clicked', self._show_help)
self.apply = HIGButton(stock=gtk.STOCK_APPLY)
self.apply.connect('clicked', self._save_profile)
self.cancel = HIGButton(stock=gtk.STOCK_CANCEL)
self.cancel.connect('clicked', self._exit)
self.ok = HIGButton(stock=gtk.STOCK_OK)
self.ok.connect('clicked', self._save_profile_and_leave)
self.load_profiles()
self.__set_props()
self.__do_layout()
self.connect('destroy', self._exit)
def load_profiles(self):
"""
Load scheduling profiles.
"""
profiles = ConfigParser()
profiles.read(Path.sched_profiles)
self.sections = []
ind = 0
for indx, section in enumerate(profiles.sections()):
self.sections.append(section)
self.schedp_name.append_text(section)
if section == self.start_profile:
ind = indx
self.schedp_name.set_active(ind)
self._check_profile(None)
def _load_profile(self):
"""
Load current set schedule profile.
"""
profile = ConfigParser()
profile.read(Path.sched_profiles)
values = {
'minute': self.cron_minute.set_text,
'hour': self.cron_hour.set_text,
'day': self.cron_day.set_text,
'month': self.cron_month.set_text,
'weekday': self.cron_weekday.set_text
}
for item in profile.items(self.schedp_name.get_active_text()):
values[item[0]](item[1])
def _check_profile(self, event):
"""
Check if current text in schedp_name combobox is a profile name.
"""
if self.schedp_name.get_active_text() in self.sections:
self._load_profile()
else:
self.cron_minute.set_text('')
self.cron_hour.set_text('')
self.cron_day.set_text('')
self.cron_month.set_text('')
self.cron_weekday.set_text('')
def _save_profile(self, event):
"""
Save scheduling profile.
"""
pname = self.schedp_name.get_active_text()
if not len(pname):
dlg = HIGAlertDialog(self,
message_format=_('Scheduling Profile - Error \
while saving'),
secondary_text=_("You need to specify a name \
for Profile."))
dlg.run()
dlg.destroy()
return
parser = CronParser()
minute = self.cron_minute.get_text()
hour = self.cron_hour.get_text()
day = self.cron_day.get_text()
month = self.cron_month.get_text()
weekday = self.cron_weekday.get_text()
try:
parser.parse_minute(minute)
parser.parse_hour(hour)
parser.parse_day(day)
parser.parse_month(month)
parser.parse_weekday(weekday)
except Exception, e:
dlg = HIGAlertDialog(self,
message_format=_('Scheduling Profile - Error \
while saving'),
secondary_text=_("Check your cron syntax and \
try to save again."))
dlg.run()
dlg.destroy()
return
# write profile to file
p_cfg = ConfigParser()
p_cfg.read(Path.sched_profiles)
if not p_cfg.has_section(pname):
new_sec = True
p_cfg.add_section(pname)
else:
new_sec = False
p_cfg.set(pname, 'minute', minute)
p_cfg.set(pname, 'hour', hour)
p_cfg.set(pname, 'day', day)
p_cfg.set(pname, 'month', month)
p_cfg.set(pname, 'weekday', weekday)
p_cfg.write(open(Path.sched_profiles, 'w'))
if new_sec: # update daddy scheduling profiles list
self.daddy._load_pscheds()
def _create_widgets(self):
self.vbox = HIGVBox()
self.btn_box = gtk.HButtonBox()
self.btn_open = HIGButton(stock=gtk.STOCK_OPEN)
self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE)
self.search_gui = SearchGUI(self.notebook)
class SchedSchemaEditor(HIGWindow):
"""
Scheduler Schemas Editor
"""
def __init__(self, daddy=None):
HIGWindow.__init__(self)
self.daddy = daddy
self.wtitle = _("Scan Scheduler Editor")
# header
self.title_markup = "<span size='16500' weight='heavy'>%s</span>"
self.ttitle = HIGEntryLabel("")
self.ttitle.set_line_wrap(False)
self.ttitle.set_markup(self.title_markup % self.wtitle)
self.umit_logo = gtk.Image()
self.umit_logo.set_from_file(logo)
# schemas name
self.schema_name_lbl = HIGEntryLabel(_("Schema Name"))
self.schema_name = gtk.combo_box_entry_new_text()
self.schema_name.connect('changed', self._check_schema)
# target and scan profiles
#self.target_lbl = HIGEntryLabel(_("Target"))
#self.target = gtk.Entry()
self.scan_name_lbl = HIGEntryLabel(_("Scan Profile"))
self.scan_name = ProfileCombo()
self.scan_name.update()
self.scan_name.set_active(0)
self.scan_name.connect('changed', self._set_scan_command)
# scan command
self.scan_command_lbl = HIGEntryLabel(_("Command"))
self.scan_command = gtk.Entry()
# scheduling profile
self.sched_name_lbl = HIGEntryLabel(_("Scheduling Profile"))
self.sched_name = gtk.combo_box_new_text()
self.sched_name_edit = gtk.Button(stock=gtk.STOCK_EDIT)
blbl = self.sched_name_edit.get_children()[0].get_children(
)[0].get_children()[1]
blbl.set_text(_("Edit Profiles"))
self.sched_name_edit.connect('clicked', self._edit_schedprofiles)
# schema settings
self.schema_sett_frame = HIGFrame()
self.setting_saveto = gtk.CheckButton(_("Save outputs to"))
self.setting_saveto_entry = gtk.Entry()
self.setting_saveto_browse = gtk.Button(_("..."))
self.setting_saveto_browse.connect('clicked', self._select_saveto)
self.setting_mailto = gtk.CheckButton(_("Send output to email"))
self.setting_mailto_entry = gtk.Entry()
self.setting_smtp_lbl = HIGEntryLabel(_("SMTP Schema"))
self.setting_smtp = gtk.combo_box_new_text()
self.setting_addtoinv = gtk.CheckButton(_("Add to the Inventory"))
self.setting_enabled = gtk.CheckButton(_("Enabled"))
# bottom buttons
self.help = HIGButton(stock=gtk.STOCK_HELP)
self.help.connect('clicked', self._show_help)
self.apply = HIGButton(stock=gtk.STOCK_APPLY)
self.apply.connect('clicked', self._save_schema)
self.cancel = HIGButton(stock=gtk.STOCK_CANCEL)
self.cancel.connect('clicked', self._exit)
self.ok = HIGButton(stock=gtk.STOCK_OK)
self.ok.connect('clicked', self._save_schema_and_leave)
self.load_smtp_schemas()
self._set_scan_command(None)
self.profile_running = None # no SchedProfileEditor instance is running.
self._load_pscheds()
self.load_schemas()
self.__set_props()
self.__do_layout()
self.connect('destroy', self._exit)
def load_smtp_schemas(self):
"""
Load smtp profiles.
"""
schemas = ConfigParser()
schemas.read(Path.smtp_schemas)
self.smtp_sections = []
self.setting_smtp.get_model().clear()
for section in schemas.sections():
self.smtp_sections.append(section)
self.setting_smtp.append_text(section)
self.setting_smtp.set_active(0)
def load_schemas(self):
"""
Load schemas profiles.
"""
schemas = ConfigParser()
schemas.read(Path.sched_schemas)
self.sections = []
self.schema_name.get_model().clear()
for section in schemas.sections():
self.sections.append(section)
self.schema_name.append_text(section)
self.schema_name.set_active(0)
self._check_schema(None)
def _load_schema(self):
"""
Load current set schedule schema.
"""
schema = ConfigParser()
schema.read(Path.sched_schemas)
values = {
'command': self.scan_command.set_text,
'saveto': self.setting_saveto_entry.set_text,
'mailto': self.setting_mailto_entry.set_text
}
enable = {
'saveto': self.setting_saveto.set_active,
'mailto': self.setting_mailto.set_active
}
for item in schema.items(self.schema_name.get_active_text()):
if item[0] == 'addtoinv':
self.setting_addtoinv.set_active(int(item[1]))
if item[1] == '2':
self.apply.set_sensitive(False)
self.ok.set_sensitive(False)
else:
self.apply.set_sensitive(True)
self.ok.set_sensitive(True)
elif item[0] == 'enabled':
self.setting_enabled.set_active(int(item[1]))
elif item[0] == 'profile':
pindx = self.profiles.index(item[1])
self.sched_name.set_active(pindx)
elif item[0] == 'smtp':
if item[1]:
pindx = self.smtp_sections.index(item[1])
self.setting_smtp.set_active(pindx)
else:
values[item[0]](item[1])
if item[0] in ('saveto', 'mailto'):
if len(item[1]):
enable[item[0]](True)
else:
enable[item[0]](False)
def _check_schema(self, event):
"""
Check if current text in schema_name combobox is a schema name.
"""
if self.schema_name.get_active_text() in self.sections:
# load schema
self._load_schema()
else:
# reset to default values
self.apply.set_sensitive(True)
self.ok.set_sensitive(True)
self.setting_addtoinv.set_active(False)
self.setting_enabled.set_active(False)
self.setting_mailto.set_active(False)
self.setting_mailto_entry.set_text('')
self.setting_saveto.set_active(False)
self.setting_saveto_entry.set_text('')
self.schema_sett_frame._set_label(self.schema_name.get_active_text() \
+ " - Settings")
def _set_scan_command(self, event):
"""
Set scan command based on chosen profile.
"""
profile = self.scan_name.get_selected_profile()
cmd_profile = CommandProfile()
command = cmd_profile.get_command(profile)
self.scan_command.set_text(command % '<target>')
def _load_pscheds(self):
"""
Load scheduling profiles.
"""
pscheds = ConfigParser()
pscheds.read(Path.sched_profiles)
self.profiles = []
self.sched_name.get_model().clear()
for section in pscheds.sections():
self.sched_name.append_text(section)
self.profiles.append(section)
self.sched_name.set_active(0)
def _edit_schedprofiles(self, event):
"""
Open Scheduling Profiles Editor.
"""
if self.profile_running:
return
win = SchedProfileEditor(self, self.sched_name.get_active_text())
win.show_all()
self.profile_running = win
def _select_saveto(self, event):
"""
Select directory to save file.
"""
dir_chooser = DirectoryChooserDialog(_("Select a directory"))
dir_chooser.run()
dir_chosen = dir_chooser.get_filename()
dir_chooser.destroy()
self.setting_saveto_entry.set_text(dir_chosen)
def _save_schema(self, event):
"""
Save current schema.
"""
schema = self.schema_name.get_active_text()
command = self.scan_command.get_text()
schedule = self.sched_name.get_active_text()
mailto = self.setting_mailto.get_active()
if not schema or not schedule or not command or '<target>' in command:
dlg = HIGAlertDialog(self,
message_format=_('Scheduling Schema - Error\
while saving.'),
secondary_text=_("There is some error in at \
least one of the following fields: \"Schema name\", \"Command\" or \"Scheduling\
Profile\"\n\nCheck if \"Schema name\" is not empty.\nCheck if \"Command\" does\
contain \"<target>\" on it.\nCheck if there is some \"Scheduling Profile\" \
selected."))
dlg.run()
dlg.destroy()
return
if mailto and not self.setting_smtp.get_active_text():
dlg = HIGAlertDialog(self,
message_format=_('Scheduling Schema - Error\
while saving.'),
secondary_text=_("You need to create a \
a SMTP Schema for sending email."))
dlg.run()
dlg.destroy()
return
# check for output existance
if self.setting_saveto.get_active() and \
not os.path.isdir(self.setting_saveto_entry.get_text()):
dlg = HIGAlertDialog(self,
message_format=_('Scheduling Schema - Error\
while saving.'),
secondary_text=_("You especified an invalid \
directory to save scans output."))
dlg.run()
dlg.destroy()
return
# write schema to file
s_cfg = ConfigParser()
s_cfg.read(Path.sched_schemas)
if not s_cfg.has_section(schema):
new_sec = True
s_cfg.add_section(schema)
else:
new_sec = False
s_cfg.set(schema, 'profile', schedule)
s_cfg.set(schema, 'command', command)
if self.setting_enabled.get_active():
s_cfg.set(schema, 'enabled', '1')
else:
s_cfg.set(schema, 'enabled', '0')
if self.setting_addtoinv.get_active():
s_cfg.set(schema, 'addtoinv', '1')
else:
s_cfg.set(schema, 'addtoinv', '0')
if self.setting_saveto.get_active():
s_cfg.set(schema, 'saveto', self.setting_saveto_entry.get_text())
else:
s_cfg.set(schema, 'saveto', '')
if mailto:
s_cfg.set(schema, 'mailto', self.setting_mailto_entry.get_text())
s_cfg.set(schema, 'smtp', self.setting_smtp.get_active_text())
else:
s_cfg.set(schema, 'mailto', '')
s_cfg.set(schema, 'smtp', '')
s_cfg.write(open(Path.sched_schemas, 'w'))
if new_sec:
self.load_schemas()
if self.daddy:
self.daddy.load_schemas()
def _save_schema_and_leave(self, event):
"""
Save current schema and close editor.
"""
self._save_schema(None)
self._exit(None)
def _show_help(self, event):
"""
Show help for Scan Scheduler Editor.
"""
show_help(self, "scheduler.html#setting-up-a-schedule")
def __set_props(self):
"""
Set window properties.
"""
self.set_title(self.wtitle)
self.set_default_size(440, -1)
def __do_layout(self):
"""
Layout widgets in window.
"""
main_vbox = HIGVBox()
main_vbox.set_border_width(5)
main_vbox.set_spacing(12)
header_hbox = HIGHBox()
schema_table = HIGTable()
schedsn_hbox = HIGHBox()
sett_table = HIGTable()
btns_hbox = HIGHBox()
header_hbox._pack_expand_fill(self.ttitle)
header_hbox._pack_noexpand_nofill(self.umit_logo)
# schema name
schema_table.attach_label(self.schema_name_lbl, 0, 1, 0, 1)
schema_table.attach_entry(self.schema_name, 1, 2, 0, 1)
# target and scan profile
schema_table.attach_label(self.scan_name_lbl, 0, 1, 1, 2)
schema_table.attach_entry(self.scan_name, 1, 2, 1, 2)
# scan command
schema_table.attach_label(self.scan_command_lbl, 0, 1, 2, 3)
schema_table.attach_label(self.scan_command, 1, 2, 2, 3)
# scheduling profile
schedsn_hbox._pack_expand_fill(self.sched_name)
schedsn_hbox._pack_noexpand_nofill(self.sched_name_edit)
schema_table.attach_label(self.sched_name_lbl, 0, 1, 3, 4)
schema_table.attach_entry(schedsn_hbox, 1, 2, 3, 4)
# settings frame
settings_align = gtk.Alignment(0.5, 0.5, 1, 1)
settings_align.set_padding(6, 0, 12, 0)
schemasett_hbox = HIGVBox()
# saveto
sett_hbox = HIGHBox()
sett_hbox._pack_expand_fill(self.setting_saveto_entry)
sett_hbox._pack_noexpand_nofill(self.setting_saveto_browse)
sett_table.attach_label(self.setting_saveto, 0, 1, 0, 1)
sett_table.attach_entry(sett_hbox, 1, 2, 0, 1)
# mailto, smtp
sett_hbox = HIGHBox()
sett_hbox._pack_expand_fill(self.setting_mailto_entry)
sett_hbox._pack_noexpand_nofill(self.setting_smtp_lbl)
sett_hbox._pack_expand_fill(self.setting_smtp)
sett_table.attach_label(self.setting_mailto, 0, 1, 1, 2)
sett_table.attach_entry(sett_hbox, 1, 2, 1, 2)
schemasett_hbox._pack_noexpand_nofill(sett_table)
# add to inventory
sett_hbox = HIGHBox()
sett_hbox._pack_noexpand_nofill(self.setting_addtoinv)
schemasett_hbox._pack_noexpand_nofill(sett_hbox)
# enabled/disabled
sett_hbox = HIGHBox()
sett_hbox._pack_noexpand_nofill(self.setting_enabled)
schemasett_hbox._pack_noexpand_nofill(sett_hbox)
settings_align.add(schemasett_hbox)
self.schema_sett_frame.add(settings_align)
# bottom buttons
btns_hbox.set_homogeneous(True)
btns_hbox._pack_expand_fill(self.help)
btns_hbox._pack_expand_fill(hig_box_space_holder())
btns_hbox._pack_expand_fill(self.apply)
btns_hbox._pack_expand_fill(self.cancel)
btns_hbox._pack_expand_fill(self.ok)
main_vbox._pack_noexpand_nofill(header_hbox)
main_vbox._pack_noexpand_nofill(gtk.HSeparator())
main_vbox._pack_noexpand_nofill(schema_table)
main_vbox._pack_noexpand_nofill(gtk.HSeparator())
main_vbox._pack_noexpand_nofill(self.schema_sett_frame)
main_vbox.pack_end(btns_hbox, False, False, 0)
self.add(main_vbox)
def _exit(self, event):
"""
Close current and window and profile editor if it is running.
"""
if self.profile_running:
self.profile_running._exit(None)
if self.daddy:
self.daddy.schemawin = None
self.destroy()
def _get_profile_running(self):
"""
Get profile editor running instance.
"""
return self.__profilerunning
def _set_profile_running(self, running):
"""
Set profile editor instance.
"""
self.__profilerunning = running
# Properties
profile_running = property(_get_profile_running, _set_profile_running)
class NISettingsBox():
def __init__(self, create_buttons=True):
self.__create_widgets()
if (create_buttons):
self.__create_buttons()
self._fill_comboboxes()
self._load_settings()
self.main_vbox = self.__do_layout(create_buttons)
def __create_widgets(self):
self.timeline = HIGFrame(_("Timeline Settings"))
self.tl_mode_lbl = gtk.Label(_("Timeline view mode"))
self.tl_kind_lbl = gtk.Label(_("Timeline view kind"))
self.tl_mode = gtk.combo_box_new_text()
self.tl_kind = gtk.combo_box_new_text()
self.tabs = HIGFrame(_("Devices tab"))
self.tabs_cbtn = gtk.CheckButton(_("Place close button"))
self.sbar = HIGFrame(_("Statusbar"))
self.sbar_tips = gtk.CheckButton(_("Show tips"))
def __create_buttons(self):
# bottom buttons
self.apply = HIGButton(stock=gtk.STOCK_APPLY)
self.cancel = HIGButton(stock=gtk.STOCK_CANCEL)
self.ok = HIGButton(stock=gtk.STOCK_OK)
self.apply.connect("clicked", self._apply_settings)
self.ok.connect("clicked", self._apply_settings_exit)
self.cancel.connect("clicked", self._exit)
def _fill_comboboxes(self):
"""
Fill timeline mode and timeline kind combo boxes with available
options.
"""
self.tl_kind_opts = {}
self.tl_mode_opts = {}
for opt, value in view_kind.items():
self.tl_kind.append_text(value)
self.tl_kind_opts[opt] = value
for opt, value in view_mode.items():
self.tl_mode.append_text(value)
self.tl_mode_opts[opt] = value
def _load_settings(self):
"""
Load current settings values.
"""
options = startup_options()
start_tlkind = self.tl_kind_opts[options['kind']]
start_tlmode = self.tl_mode_opts[options['mode']]
store = self.tl_kind.get_model()
for indx, item in enumerate(store):
if item[0] == start_tlkind:
self.tl_kind.set_active(indx)
break
store = self.tl_mode.get_model()
for indx, item in enumerate(store):
if item[0] == start_tlmode:
self.tl_mode.set_active(indx)
break
self.tabs_cbtn.set_active(options['tabs_close_btn'])
self.sbar_tips.set_active(options['tips'])
def _apply_settings(self, event):
"""
Apply current settings.
"""
curr_kind = self.tl_kind.get_active_text()
for kind, value in self.tl_kind_opts.items():
if value == curr_kind:
curr_kind = kind
break
curr_mode = self.tl_mode.get_active_text()
for mode, value in self.tl_mode_opts.items():
if value == curr_mode:
curr_mode = mode
break
write_startup_setting(TL_SECTION, "mode", curr_mode)
write_startup_setting(TL_SECTION, "kind", curr_kind)
write_startup_setting(INV_SECTION, "tabs_close_btn",
self.tabs_cbtn.get_active())
write_startup_setting(INV_SECTION, "tips", self.sbar_tips.get_active())
def _apply_settings_exit(self, event):
"""
Apply current settings and leave.
"""
self._apply_settings(None)
self._exit(None)
def _exit(self, event):
"""
Close this window.
"""
self.destroy()
def __set_props(self):
"""
Window properties.
"""
self.set_title(_("Network Inventory Settings"))
self.set_default_size(305, -1)
def __do_layout(self, create_buttons):
main_vbox = HIGVBox()
# timeline frame
tl_settings_align = gtk.Alignment(0.5, 0.5, 1, 1)
tl_settings_align.set_padding(6, 0, 12, 0)
tl_settings_vbox = HIGVBox()
mode_hbox = HIGHBox()
mode_hbox._pack_noexpand_nofill(self.tl_mode_lbl)
mode_hbox._pack_expand_fill(self.tl_mode)
kind_hbox = HIGHBox()
kind_hbox._pack_noexpand_nofill(self.tl_kind_lbl)
kind_hbox._pack_expand_fill(self.tl_kind)
tl_settings_vbox._pack_noexpand_nofill(mode_hbox)
tl_settings_vbox._pack_noexpand_nofill(kind_hbox)
tl_settings_align.add(tl_settings_vbox)
self.timeline.add(tl_settings_align)
main_vbox._pack_noexpand_nofill(self.timeline)
# end timeline frame
# statusbar frame
sbar_settings_align = gtk.Alignment(0.5, 0.5, 1, 1)
sbar_settings_align.set_padding(6, 0, 12, 0)
sbar_settings_vbox = HIGVBox()
sbar_settings_vbox._pack_noexpand_nofill(self.sbar_tips)
sbar_settings_align.add(sbar_settings_vbox)
self.sbar.add(sbar_settings_align)
main_vbox._pack_noexpand_nofill(self.sbar)
# end statusbar frame
# tabs frame
tabs_settings_align = gtk.Alignment(0.5, 0.5, 1, 1)
tabs_settings_align.set_padding(6, 0, 12, 0)
tabs_settings_vbox = HIGVBox()
tabs_settings_vbox._pack_noexpand_nofill(self.tabs_cbtn)
tabs_settings_align.add(tabs_settings_vbox)
self.tabs.add(tabs_settings_align)
main_vbox._pack_noexpand_nofill(self.tabs)
# end tabs frame
if create_buttons:
# buttons box
btnsbox = HIGHBox()
btnsbox._pack_noexpand_nofill(self.apply)
btnsbox._pack_noexpand_nofill(self.cancel)
btnsbox._pack_noexpand_nofill(self.ok)
bbox = gtk.HBox()
bbox.pack_end(btnsbox, False, False, 0)
main_vbox.pack_end(bbox, False, False, 0)
main_vbox.pack_end(gtk.HSeparator(), False, False, 0)
# end buttons box
return main_vbox
def get_layout(self):
return self.main_vbox
class DiffWindow(gtk.Window):
def __init__(self, scans):
"""scans in the format: {"scan_title":parsed_scan}
"""
gtk.Window.__init__(self)
self.set_title(_("Compare Results"))
self.scans = scans
self.umit_conf = UmitConf()
self.colors = Colors()
# Diff views
self.text_view = DiffText(self.colors, self.umit_conf.colored_diff)
self.compare_view = DiffTree(self.colors)
self._create_widgets()
self._pack_widgets()
self._connect_widgets()
# Settings
if self.umit_conf.diff_mode == "text":
self.text_mode.set_active(True)
else:
self.compare_mode.set_active(True)
self.check_color.set_active(self.umit_conf.colored_diff)
# Initial Size Request
self.initial_size = self.size_request()
def _show_help(self, action):
show_help(self, "index.html")
def _create_widgets(self):
self.main_vbox = HIGVBox()
self.hbox_mode = HIGHBox()
self.hbox_settings = HIGHBox()
self.hbox_buttons = HIGHBox()
self.hbox_result = HIGHBox()
self.btn_open_browser = HIGButton(_("Open in Browser"),
stock=gtk.STOCK_EXECUTE)
self.btn_help = HIGButton(stock=gtk.STOCK_HELP)
self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE)
self.check_color = gtk.CheckButton(_("Enable colored diffies"))
self.btn_legend = HIGButton(_("Color Descriptions"),
stock=gtk.STOCK_SELECT_COLOR)
self.text_mode = gtk.ToggleButton(_("Text Mode"))
self.compare_mode = gtk.ToggleButton(_("Compare Mode"))
self.vpaned = gtk.VPaned()
self.hpaned = gtk.HPaned()
self.scan_chooser1 = ScanChooser(self.scans, "1")
self.scan_chooser2 = ScanChooser(self.scans, "2")
self.scan_buffer1 = self.scan_chooser1.get_buffer()
self.scan_buffer2 = self.scan_chooser2.get_buffer()
def _pack_widgets(self):
self.main_vbox.set_border_width(6)
self.vpaned.pack1(self.hpaned, True, False)
self.vpaned.pack2(self.hbox_result)
self.hpaned.pack1(self.scan_chooser1, True, False)
self.hpaned.pack2(self.scan_chooser2, True, False)
self.hbox_buttons._pack_expand_fill(self.btn_help)
self.hbox_buttons._pack_expand_fill(self.btn_legend)
self.hbox_buttons._pack_expand_fill(self.btn_open_browser)
self.hbox_buttons._pack_expand_fill(self.btn_close)
self.hbox_buttons.set_homogeneous(True)
self.hbox_mode.set_homogeneous(True)
self.hbox_mode.pack_start(self.text_mode)
self.hbox_mode.pack_start(self.compare_mode)
self.hbox_settings._pack_noexpand_nofill(self.hbox_mode)
self.hbox_settings._pack_expand_fill(self.check_color)
self.main_vbox._pack_expand_fill(self.vpaned)
self.main_vbox._pack_noexpand_nofill(self.hbox_settings)
self.main_vbox._pack_noexpand_nofill(self.hbox_buttons)
self.add(self.main_vbox)
def _connect_widgets(self):
self.connect("delete-event", self.close)
self.btn_legend.connect("clicked", self.show_legend_window)
self.btn_help.connect("clicked", self._show_help)
self.btn_close.connect("clicked", self.close)
self.btn_open_browser.connect("clicked", self.open_browser)
self.check_color.connect("toggled", self._set_color)
self.text_mode.connect("clicked", self._change_to_text)
self.compare_mode.connect("clicked", self._change_to_compare)
self.scan_chooser1.exp_scan.connect('activate', self.resize_vpane)
self.scan_chooser2.exp_scan.connect('activate', self.resize_vpane)
self.scan_buffer1.connect('changed', self.text_changed)
self.scan_buffer2.connect('changed', self.text_changed)
def open_browser(self, widget):
text1=self.scan_buffer1.get_text(self.scan_buffer1.get_start_iter(),\
self.scan_buffer1.get_end_iter())
text2=self.scan_buffer2.get_text(self.scan_buffer2.get_start_iter(),\
self.scan_buffer2.get_end_iter())
if not text1 or not text2:
alert = HIGAlertDialog(
message_format='<b>' + _('Select Scan') + '</b>',
secondary_text=_("You must select two different scans to \
generate diff."))
alert.run()
alert.destroy()
return False
text1 = text1.split('\n')
text2 = text2.split('\n')
self.temp_view = mktemp('.html')
text1 = [text + '\n' for text in text1]
text2 = [text + '\n' for text in text2]
if use_html:
diff = DiffHtml(text1, text2)
diff = diff.generate()
file_desc = open(self.temp_view, 'w')
file_desc.write(''.join(diff))
# Closing file to avoid problems with file descriptors
file_desc.close()
else:
diff = Diff(text1, text2)
diff = diff.generate()
diff.insert(
0, '''<pre>(This diff is been shown in pure text \
because you dont have Python 2.4 or higher.)\n''')
diff.append('</pre>')
file_desc = open(self.temp_view, 'w')
file_desc.writelines(diff)
# Closing file to avoid problems with file descriptors
file_desc.close()
webbrowser.open("file://" + self.temp_view, autoraise=1)
def show_legend_window(self, widget):
legend_window = DiffLegendWindow(self.colors)
legend_window.run()
legend_window.destroy()
self.text_changed(None)
def text_changed(self, widget):
text1 = self.scan_buffer1.get_text(self.scan_buffer1.get_start_iter(),\
self.scan_buffer1.get_end_iter())
text2 = self.scan_buffer2.get_text(self.scan_buffer2.get_start_iter(),\
self.scan_buffer2.get_end_iter())
if text1 != '' and text2 != '':
if self.compare_mode.get_active():
self.compare_view.make_diff(self.scan_chooser1.parsed_scan,
self.scan_chooser2.parsed_scan)
self.compare_view.activate_color(self.check_color.get_active())
else:
self.text1 = text1.split('\n')
self.text2 = text2.split('\n')
self.diff = Diff(self.text1, self.text2)
self.text_view.txt_diff_result.get_buffer().set_text\
('\n'.join(self.diff.generate_without_banner()))
self.text_view.activate_color(self.check_color.get_active())
self.text_view._text_changed(None)
def resize_vpane(self, widget):
exp1 = not widget.get_expanded()
if widget == self.scan_chooser1.exp_scan:
exp2 = self.scan_chooser2.exp_scan.get_expanded()
else:
exp2 = self.scan_chooser1.exp_scan.get_expanded()
if not exp1 and not exp2:
self.vpaned.compute_position(-1, 0, 500)
self.size_allocate(
gtk.gdk.Rectangle(width=self.initial_size[0],
height=self.initial_size[1]))
self.queue_resize()
def _change_to_text(self, widget):
if not widget.get_active():
return
self.umit_conf.diff_mode = "text"
children = self.hbox_result.get_children()
if children:
self.hbox_result.remove(children[0])
self.compare_view.hide()
self.hbox_result._pack_expand_fill(self.text_view)
self.text_view.show_all()
self.compare_mode.set_active(False)
self.text_changed(None)
def _change_to_compare(self, widget):
if not widget.get_active():
return
self.umit_conf.diff_mode = "compare"
children = self.hbox_result.get_children()
if children:
self.hbox_result.remove(children[0])
self.text_view.hide()
self.hbox_result._pack_expand_fill(self.compare_view)
self.compare_view.show_all()
self.text_mode.set_active(False)
self.text_changed(None)
def _set_color(self, widget):
activate = widget.get_active()
self.umit_conf.colored_diff = activate
self.compare_view.activate_color(activate)
self.text_view.activate_color(activate)
def close(self, widget=None, extra=None):
self.destroy()
