← Back to branch summary

~ubuntu-branches/debian/sid/gui-ufw/sid

« back to all changes in this revision

Viewing changes to view/guiGufw.py

  • Committer: Bazaar Package Importer
  • Author(s): Miriam Ruiz
  • Date: 2009-09-03 20:08:23 UTC
  • Revision ID: james.westby@ubuntu.com-20090903200823-fm7e60zl1p583i9f
Tags: upstream-9.10.2
Import upstream version 9.10.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
view/guiGufw.py
 
1
# Gufw 9.10.2 - http://gufw.tuxfamily.org
 
2
# Copyright (C) 2009 Marcos Alvarez Costales
 
3
#
 
4
# Gufw is free software; you can redistribute it and/or modify
 
5
# it under the terms of the GNU General Public License as published by
 
6
# the Free Software Foundation; either version 3 of the License, or
 
7
# (at your option) any later version.
 
8
# 
 
9
# Gufw is distributed in the hope that it will be useful,
 
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
# GNU General Public License for more details.
 
13
# 
 
14
# You should have received a copy of the GNU General Public License
 
15
# along with Gufw; if not, see http://www.gnu.org/licenses for more
 
16
# information.
 
17
 
 
18
 
 
19
import pygtk
 
20
import gtk, gtk.glade
 
21
import gobject
 
22
 
 
23
class Guigufw:
 
24
 
 
25
    def __init__(self, variable, firewall):
 
26
 
 
27
        self.variable       = variable
 
28
        self.firewall       = firewall
 
29
        
 
30
        self.glade          = gtk.glade.XML(self.variable.get_path("glade"))
 
31
        self.model          = gtk.ListStore (gobject.TYPE_INT, gobject.TYPE_STRING, gobject.TYPE_STRING,
 
32
                                             gobject.TYPE_STRING, gobject.TYPE_STRING)        
 
33
        self.render         = gtk.CellRendererText()
 
34
        self.serv_prog_type = self.variable.get_constant("service_disabled")
 
35
        
 
36
        self.set_objects_glade()
 
37
        
 
38
        self.rules          = []
 
39
        self.log_txt_buffer = self.log_txt.get_buffer()
 
40
        
 
41
        self.set_rules_header()
 
42
        self.set_initial_values()
 
43
        self.set_window_values("")
 
44
        
 
45
        self.glade.signal_autoconnect(self)
 
46
        self.glade.get_widget("winMain").show()
 
47
 
 
48
        gtk.main()
 
49
 
 
50
 
 
51
# INITIALS SETS
 
52
 
 
53
    # Set references to objects
 
54
    def set_objects_glade(self):
 
55
        # Main Window
 
56
        self.win_main            = self.glade.get_widget("winMain")
 
57
        self.cb_enabled_firewall = self.glade.get_widget("cbEnabledFirewall")
 
58
        self.cb_policy           = self.glade.get_widget("cbPolicy")
 
59
        self.lbl_policy          = self.glade.get_widget("lblDefaultPolicy")
 
60
        self.shield              = self.glade.get_widget("imgShield")
 
61
        self.tv_rules            = self.glade.get_widget("tvRules")
 
62
        self.btn_add_window      = self.glade.get_widget("btnAddWindow")
 
63
        self.btn_remove_rule     = self.glade.get_widget("btnRemove")
 
64
        self.status_bar          = self.glade.get_widget("statusBar")
 
65
        self.progress_bar        = self.glade.get_widget("progressBar")
 
66
        
 
67
        # Rules Window
 
68
        self.action_simple     = self.glade.get_widget("cbActionSimple")
 
69
        self.port_simple       = self.glade.get_widget("entryPortSimple")
 
70
        self.proto_simple      = self.glade.get_widget("cbProtoSimple")
 
71
        self.action_preconf    = self.glade.get_widget("cbActionPreconf")
 
72
        self.type_preconf      = self.glade.get_widget("cbTypePreconf")
 
73
        self.service_preconf   = self.glade.get_widget("cbServicePreconf")
 
74
        self.program_preconf   = self.glade.get_widget("cbProgramPreconf")
 
75
        self.action_advanced   = self.glade.get_widget("cbActionAdvanced")
 
76
        self.proto_advanced    = self.glade.get_widget("cbProtoAdvanced")
 
77
        self.fromip_advanced   = self.glade.get_widget("entryFromIpAdvanced")
 
78
        self.portfrom_advanced = self.glade.get_widget("entryPortFromAdvanced")
 
79
        self.toip_advanced     = self.glade.get_widget("entryToIpAdvanced")
 
80
        self.portto_advanced   = self.glade.get_widget("entryPortToAdvanced")
 
81
        self.rules_notebook    = self.glade.get_widget("rulesNotebook")
 
82
        self.add_btn_add       = self.glade.get_widget("btnAddRule")
 
83
        
 
84
        # Log Window
 
85
        self.winlog        = self.glade.get_widget("winLog")
 
86
        self.log_txt       = self.glade.get_widget("logTxt")
 
87
        self.log_btn_close = self.glade.get_widget("btnCloseLog")
 
88
        
 
89
        
 
90
        # Preference Window
 
91
        self.winpreferences = self.glade.get_widget("winPreferences")
 
92
        self.cb_ufw_log     = self.glade.get_widget("cbUfwLog")
 
93
        self.lbl_ufw_level  = self.glade.get_widget("lblLogLevel")
 
94
        self.cb_ufw_level   = self.glade.get_widget("cbLogLevel")
 
95
        self.cb_gufw_log    = self.glade.get_widget("cbGufwLog") 
 
96
        self.pref_btn_close = self.glade.get_widget("btnClosePref")
 
97
        
 
98
        # Menu
 
99
        self.menu_log  = self.glade.get_widget("menuLog")
 
100
        self.menu_pref = self.glade.get_widget("menuPreferences")
 
101
        
 
102
        # About Dialog
 
103
        self.winabout = self.glade.get_widget("winAbout")
 
104
        self.winabout.set_translator_credits(self.variable.get_constant("translators_credits"))
 
105
 
 
106
        
 
107
    # Set initial values
 
108
    def set_rules_header(self):
 
109
        # Mode
 
110
        self.tv_rules.set_model(self.model)
 
111
        self.tv_rules.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
 
112
 
 
113
        # Font
 
114
        self.render.set_property("font", self.variable.get_constant("font_rules"))
 
115
 
 
116
        # The format columns
 
117
        tree_header = gtk.TreeViewColumn (self.variable.get_text("001"), self.render, text=1, foreground=4)
 
118
        tree_header.set_resizable(True)
 
119
        self.tv_rules.append_column (tree_header)
 
120
        
 
121
        tree_header = gtk.TreeViewColumn (self.variable.get_text("002"), self.render, text=2, foreground=4)
 
122
        tree_header.set_resizable(True)
 
123
        self.tv_rules.append_column (tree_header)
 
124
        
 
125
        tree_header = gtk.TreeViewColumn (self.variable.get_text("003"), self.render, text=3, foreground=4)
 
126
        self.tv_rules.append_column (tree_header)
 
127
    
 
128
    
 
129
    # Set initial values in Interface
 
130
    def set_initial_values(self):
 
131
        # Restore previus size window
 
132
        self.get_old_size_window()
 
133
        
 
134
        # ComboBoxs
 
135
        self.action_simple.set_active(0)     
 
136
        self.proto_simple.set_active(0)    
 
137
          
 
138
        self.action_preconf.set_active(0)    
 
139
        self.type_preconf.set_active(0)      
 
140
        self.service_preconf.set_active(0)   
 
141
        self.program_preconf.set_active(0)  
 
142
         
 
143
        self.action_advanced.set_active(0)   
 
144
        self.proto_advanced.set_active(0)    
 
145
        
 
146
        # Focus
 
147
        self.btn_add_window.grab_focus()
 
148
        
 
149
    
 
150
    # Set initials status to glade objects
 
151
    def set_window_values(self, status_bar):
 
152
        # Firewall Enabled
 
153
        self.cb_enabled_firewall.set_sensitive(1)
 
154
        if self.firewall.status == self.variable.get_constant("enabled"):
 
155
            self.cb_enabled_firewall.set_active(1)
 
156
 
 
157
        # Allow/Deny/Reject
 
158
        if self.firewall.default == self.variable.get_constant("deny"):
 
159
            self.cb_policy.set_active(0)
 
160
        elif self.firewall.default == self.variable.get_constant("reject"):
 
161
            self.cb_policy.set_active(1)
 
162
        elif self.firewall.default == self.variable.get_constant("allow"):
 
163
            self.cb_policy.set_active(2)
 
164
               
 
165
        # Status bar
 
166
        self.status_bar.push(1, status_bar)
 
167
        
 
168
        # Set values by status firewall
 
169
        if self.firewall.status == self.variable.get_constant("disabled"):
 
170
            # Sensitive values
 
171
            self.cb_policy.set_sensitive(0)
 
172
            self.lbl_policy.set_sensitive(0)
 
173
            self.add_btn_add.set_sensitive(0)
 
174
            self.btn_remove_rule.set_sensitive(0)
 
175
            # Shield
 
176
            if not self.variable.dev:
 
177
                self.shield.set_from_file(self.variable.get_path("shield_disabled"))
 
178
            else:
 
179
                self.shield.set_from_file(self.variable.get_path("shield_disabled_dev"))
 
180
            
 
181
        else:
 
182
            
 
183
            # Get actual rules
 
184
            self.rules = self.firewall.get_rules_list()
 
185
            
 
186
            # Sensitive values
 
187
            self.cb_policy.set_sensitive(1)
 
188
            self.lbl_policy.set_sensitive(1)
 
189
            self.add_btn_add.set_sensitive(1)
 
190
            if len(self.rules) == 0:
 
191
                self.btn_remove_rule.set_sensitive(0)
 
192
            else:
 
193
                self.btn_remove_rule.set_sensitive(1)
 
194
 
 
195
            # Shields
 
196
            if not self.variable.dev:
 
197
                if self.firewall.default == self.variable.get_constant("allow"):
 
198
                    self.shield.set_from_file(self.variable.get_path("shield_allow"))
 
199
                elif self.firewall.default == self.variable.get_constant("deny"):
 
200
                    self.shield.set_from_file(self.variable.get_path("shield_deny"))
 
201
                elif self.firewall.default == self.variable.get_constant("reject"):
 
202
                    self.shield.set_from_file(self.variable.get_path("shield_reject"))
 
203
            else:
 
204
                if self.firewall.default == self.variable.get_constant("allow"):
 
205
                    self.shield.set_from_file(self.variable.get_path("shield_allow_dev"))
 
206
                elif self.firewall.default == self.variable.get_constant("deny"):
 
207
                    self.shield.set_from_file(self.variable.get_path("shield_deny_dev"))
 
208
                elif self.firewall.default == self.variable.get_constant("reject"):
 
209
                    self.shield.set_from_file(self.variable.get_path("shield_reject_dev"))
 
210
                
 
211
        # Menu
 
212
        self.menu_pref.set_sensitive(1)
 
213
        if self.firewall.gufw_log == self.variable.get_constant("gufw_log_on"):
 
214
            self.menu_log.set_sensitive(1)
 
215
        else:
 
216
            self.menu_log.set_sensitive(0)
 
217
           
 
218
        # Set actual rules
 
219
        self.set_rules_text()
 
220
 
 
221
        
 
222
    # View rules in GUI
 
223
    def set_rules_text(self):
 
224
        
 
225
        self.model.clear() 
 
226
 
 
227
        if self.firewall.status == self.variable.get_constant("disabled"):
 
228
            return
 
229
        
 
230
        row = 0
 
231
        
 
232
        for rule in self.rules:
 
233
        
 
234
            row += 1
 
235
            
 
236
            iterador = self.model.insert(row)
 
237
            self.model.set_value(iterador, 0, row)
 
238
            
 
239
            # Values
 
240
            self.model.set_value(iterador, 1, rule[0])
 
241
            self.model.set_value(iterador, 2, rule[1])
 
242
            self.model.set_value(iterador, 3, rule[2])
 
243
            
 
244
            # Color Allow/Deny/Limit
 
245
            # Allow?
 
246
            if rule[1] == self.variable.get_constant("allow_upper"):
 
247
                if self.firewall.default != self.variable.get_constant("allow"):
 
248
                    self.model.set_value(iterador, 4, self.variable.get_constant("color_red")) 
 
249
                else:
 
250
                    self.model.set_value(iterador, 4, self.variable.get_constant("color_gray"))
 
251
                    
 
252
            # Deny?
 
253
            elif rule[1] == self.variable.get_constant("deny_upper"):
 
254
                if self.firewall.default != self.variable.get_constant("deny"):
 
255
                    self.model.set_value(iterador, 4, self.variable.get_constant("color_green"))
 
256
                else:
 
257
                    self.model.set_value(iterador, 4, self.variable.get_constant("color_gray"))
 
258
                    
 
259
            # Reject
 
260
            elif rule[1] == self.variable.get_constant("reject_upper"):
 
261
                if self.firewall.default != self.variable.get_constant("reject"):
 
262
                    self.model.set_value(iterador, 4, self.variable.get_constant("color_blue"))
 
263
                else:
 
264
                    self.model.set_value(iterador, 4, self.variable.get_constant("color_gray"))
 
265
            
 
266
            # Limit?
 
267
            elif rule[1] == self.variable.get_constant("limit_upper"):
 
268
                self.model.set_value(iterador, 4, self.variable.get_constant("color_orange"))
 
269
                
 
270
 
 
271
 
 
272
 
 
273
 
 
274
# EVENTS
 
275
 
 
276
 
 
277
# CLOSE WINDOWS
 
278
 
 
279
    # Close Windows
 
280
    def winMain_delete_event_cb(self, widget, event):
 
281
        self.save_size_window()
 
282
        gtk.main_quit()
 
283
 
 
284
    # Menu Quit
 
285
    def menuQuit_activate_cb(self, widget):
 
286
        self.save_size_window()
 
287
        gtk.main_quit()
 
288
 
 
289
    # Button Add
 
290
    def btnAddWindow_clicked_cb(self, widget):
 
291
        self.glade.get_widget("winAdd").show()
 
292
        self.add_btn_add.grab_focus()
 
293
        self.btn_add_window.set_sensitive(0)
 
294
 
 
295
    # Close Window Add Rules
 
296
    def winAdd_delete_event_cb(self, widget, event):
 
297
        self.glade.get_widget("winAdd").hide()
 
298
        self.btn_add_window.set_sensitive(1)
 
299
        return True
 
300
 
 
301
    # Button Close Add Rules
 
302
    def btnCloseAdd_clicked_cb(self, widget):
 
303
        self.glade.get_widget("winAdd").hide()
 
304
        self.btn_add_window.set_sensitive(1)
 
305
        return True
 
306
 
 
307
    # Close preferences Window
 
308
    def winPreferences_delete_event_cb(self, widget, event):
 
309
        self.glade.get_widget("winPreferences").hide()
 
310
        return True
 
311
 
 
312
    # Close preferences Button
 
313
    def btnClosePref_clicked_cb(self, widget):
 
314
        self.glade.get_widget("winPreferences").hide()
 
315
        return True
 
316
 
 
317
    # Close Log Window
 
318
    def winLog_delete_event_cb(self, widget, event):
 
319
        self.glade.get_widget("winLog").hide()
 
320
        return True
 
321
 
 
322
    # Close Log button
 
323
    def btnCloseLog_clicked_cb(self, widget):
 
324
        self.glade.get_widget("winLog").hide()
 
325
        return True
 
326
 
 
327
    # Press Scape Key Add Window
 
328
    def winAdd_key_press_event_cb(self, widget, event):
 
329
        if event.keyval == gtk.keysyms.Escape :
 
330
            self.glade.get_widget("winAdd").hide()
 
331
            self.btn_add_window.set_sensitive(1)
 
332
            return True    
 
333
            
 
334
    # Press Scape Key Preferences Window
 
335
    def winPreferences_key_press_event_cb(self, widget, event):
 
336
        if event.keyval == gtk.keysyms.Escape :
 
337
            self.glade.get_widget("winPreferences").hide()
 
338
            return True  
 
339
    
 
340
    # Press Scape Key Log Window
 
341
    def winLog_key_press_event_cb(self, widget, event):
 
342
        if event.keyval == gtk.keysyms.Escape :
 
343
            self.glade.get_widget("winLog").hide()
 
344
            return True  
 
345
    
 
346
 
 
347
    # Save Actual size window
 
348
    def get_old_size_window(self):    
 
349
        win_width,win_height = self.firewall.get_old_size_window()
 
350
        screen_width         = gtk.gdk.screen_width()
 
351
        screen_height        = gtk.gdk.screen_height()
 
352
 
 
353
        # Maximize
 
354
        if ( win_width == screen_width ) and ( win_height == screen_height ):
 
355
            self.win_main.maximize()
 
356
            
 
357
        # Not Maximize
 
358
        else:
 
359
            if win_width > screen_width:
 
360
                win_width = screen_width
 
361
            if win_height > screen_height:
 
362
                win_height = screen_height
 
363
                
 
364
            self.win_main.resize(win_width,win_height)
 
365
 
 
366
 
 
367
    # Save Actual size window
 
368
    def save_size_window(self):
 
369
        win_width, win_height = self.win_main.get_size()
 
370
        screen_width          = gtk.gdk.screen_width()
 
371
        screen_height         = gtk.gdk.screen_height()
 
372
        
 
373
        if not self.firewall.maximized:
 
374
            if win_width > screen_width:
 
375
                win_width = screen_width
 
376
            if win_height > screen_height:
 
377
                win_height = screen_height
 
378
                
 
379
            self.firewall.save_size_window(win_width, win_height)
 
380
        
 
381
        else:
 
382
            self.firewall.save_size_window(screen_width, screen_height)
 
383
 
 
384
 
 
385
    def winMain_window_state_event_cb(self, widget, event):
 
386
        if event.changed_mask & gtk.gdk.WINDOW_STATE_MAXIMIZED:
 
387
            self.firewall.maximized = not self.firewall.maximized
 
388
 
 
389
 
 
390
 
 
391
 
 
392
 
 
393
# MENU
 
394
 
 
395
    # Show Preferences
 
396
    def menuPreferences_activate_cb(self, widget):
 
397
        # Set initial values
 
398
        if self.firewall.ufw_log == self.variable.get_constant("ufw_log_off"):
 
399
            self.cb_ufw_log.set_active(0)
 
400
            self.cb_ufw_level.set_sensitive(0)
 
401
            self.lbl_ufw_level.set_sensitive(0)
 
402
            
 
403
        else:
 
404
            self.cb_ufw_log.set_active(1)
 
405
            self.cb_ufw_level.set_sensitive(1)
 
406
            self.lbl_ufw_level.set_sensitive(1)
 
407
            if self.firewall.ufw_log == self.variable.get_constant("ufw_log_low"):
 
408
                self.cb_ufw_level.set_active(0)
 
409
            elif self.firewall.ufw_log == self.variable.get_constant("ufw_log_medium"):
 
410
                self.cb_ufw_level.set_active(1)
 
411
            else:
 
412
                self.cb_ufw_level.set_active(2)
 
413
            
 
414
            
 
415
        if self.firewall.gufw_log != self.variable.get_constant("gufw_log_off"):
 
416
            self.cb_gufw_log.set_active(1)
 
417
        else:
 
418
            self.cb_gufw_log.set_active(0)
 
419
            
 
420
        # Show Window
 
421
        self.status_bar.push(1, "")
 
422
        self.winpreferences.show()
 
423
        self.pref_btn_close.grab_focus()
 
424
        
 
425
 
 
426
    # Change Logging Level
 
427
    def cbLogLevel_changed_cb(self, widget):
 
428
        if ( self.cb_ufw_level.get_active() == 0 ) and ( self.firewall.ufw_log != self.variable.get_constant("ufw_log_low") ):
 
429
            self.firewall.set_ufw_log(self.variable.get_constant("ufw_log_low"))
 
430
        elif ( self.cb_ufw_level.get_active() == 1 ) and ( self.firewall.ufw_log != self.variable.get_constant("ufw_log_medium") ):
 
431
            self.firewall.set_ufw_log(self.variable.get_constant("ufw_log_medium"))
 
432
        elif ( self.cb_ufw_level.get_active() == 2 ) and ( self.firewall.ufw_log != self.variable.get_constant("ufw_log_high") ):
 
433
            self.firewall.set_ufw_log(self.variable.get_constant("ufw_log_high"))
 
434
 
 
435
 
 
436
    # Open About Dialog
 
437
    def menuAbout_activate_cb(self, widget):
 
438
        self.status_bar.push(1, "")
 
439
        self.winabout.show()
 
440
        self.winabout.run()
 
441
        self.winabout.hide()
 
442
        
 
443
    
 
444
    # Log Window
 
445
    def menuLog_activate_cb(self, widget):
 
446
        # Set Log Text
 
447
        log_strings  = self.firewall.get_log()
 
448
        txt = ""
 
449
 
 
450
        for string in log_strings:
 
451
            txt = "".join([txt, string, "\n"])
 
452
            
 
453
        self.log_txt_buffer.set_text(txt)
 
454
        
 
455
        self.status_bar.push(1, "")
 
456
        
 
457
        # Show Window
 
458
        self.winlog.show()
 
459
        self.log_btn_close.grab_focus()
 
460
        
 
461
        
 
462
        
 
463
        
 
464
       
 
465
# BUTTONS PREFERENCE WINDOW 
 
466
 
 
467
    # ufw Log CheckButton
 
468
    def cbUfwLog_toggled_cb(self, widget):
 
469
        if self.firewall.ufw_log != self.variable.get_constant("ufw_log_off") and self.cb_ufw_log.get_active() == 0:
 
470
            self.firewall.set_ufw_log(self.variable.get_constant("ufw_log_off"))
 
471
            self.cb_ufw_log.set_active(0)
 
472
            self.cb_ufw_level.set_sensitive(0)
 
473
            self.lbl_ufw_level.set_sensitive(0)
 
474
            
 
475
        elif self.firewall.ufw_log == self.variable.get_constant("ufw_log_off") and self.cb_ufw_log.get_active() == 1:
 
476
            self.firewall.set_ufw_log(self.variable.get_constant("ufw_log_on"))
 
477
            self.cb_ufw_log.set_active(1)
 
478
            self.cb_ufw_level.set_sensitive(1)
 
479
            self.cb_ufw_level.set_active(0)
 
480
            self.lbl_ufw_level.set_sensitive(1)
 
481
            
 
482
            
 
483
        self.status_bar.push(1, "")
 
484
       
 
485
    # Gufw Log CheckButton   
 
486
    def cbGufwLog_toggled_cb(self, widget):
 
487
        if self.firewall.gufw_log != self.variable.get_constant("gufw_log_on") and self.cb_gufw_log.get_active() == 1:
 
488
            self.firewall.set_gufw_log(self.variable.get_constant("gufw_log_on"))
 
489
        elif self.firewall.gufw_log != self.variable.get_constant("gufw_log_off") and self.cb_gufw_log.get_active() == 0:
 
490
            self.firewall.set_gufw_log(self.variable.get_constant("gufw_log_off"))
 
491
        
 
492
        self.set_window_values("")
 
493
 
 
494
 
 
495
 
 
496
 
 
497
 
 
498
 
 
499
 
 
500
# BUTTONS LOG WINDOW
 
501
 
 
502
    # Clear Log
 
503
    def btnClearLog_clicked_cb(self, widget):
 
504
        self.firewall.refresh_log()
 
505
        self.log_txt_buffer.set_text("")
 
506
        
 
507
        
 
508
    # Change Wrapping
 
509
    def cbWrapping_toggled_cb(self, widget):
 
510
        if self.firewall.wrap == self.variable.get_constant("wrap_on"):
 
511
            self.firewall.set_wrap(self.variable.get_constant("wrap_off"))
 
512
            self.log_txt.set_wrap_mode(gtk.WRAP_NONE)
 
513
        else:
 
514
            self.firewall.set_wrap(self.variable.get_constant("wrap_on"))
 
515
            self.log_txt.set_wrap_mode(gtk.WRAP_WORD)
 
516
 
 
517
        
 
518
 
 
519
 
 
520
 
 
521
 
 
522
 
 
523
       
 
524
# BUTTONS MAIN WINDOW
 
525
       
 
526
    # Button Firewall Enabled
 
527
    def cbEnabledFirewall_clicked_cb(self, widget):
 
528
        if self.firewall.status == self.variable.get_constant("enabled"):
 
529
            self.firewall.set_status(self.variable.get_constant("disabled"))
 
530
            self.add_btn_add.set_sensitive(0)
 
531
            self.set_window_values(self.variable.get_text("009"))
 
532
        else:
 
533
            self.firewall.set_status(self.variable.get_constant("enabled"))
 
534
            self.add_btn_add.set_sensitive(1)
 
535
            self.set_window_values(self.variable.get_text("008"))
 
536
            
 
537
 
 
538
    # Policy (Deny/Allow/Reject All)
 
539
    def cbPolicy_changed_cb(self, widget):
 
540
        # Apply?
 
541
        if self.firewall.default == self.variable.get_constant("deny") and self.cb_policy.get_active() == 0:
 
542
            return
 
543
        if self.firewall.default == self.variable.get_constant("reject") and self.cb_policy.get_active() == 1:
 
544
            return
 
545
        if self.firewall.default == self.variable.get_constant("allow") and self.cb_policy.get_active() == 2:
 
546
            return
 
547
            
 
548
        if self.cb_policy.get_active() == 0:
 
549
            self.firewall.set_default(self.variable.get_constant("deny"))
 
550
            self.set_window_values(self.variable.get_text("006"))
 
551
        elif self.cb_policy.get_active() == 1:
 
552
            self.firewall.set_default(self.variable.get_constant("reject"))
 
553
            self.set_window_values(self.variable.get_text("011"))
 
554
        elif self.cb_policy.get_active() == 2:
 
555
            self.firewall.set_default(self.variable.get_constant("allow"))
 
556
            self.set_window_values(self.variable.get_text("007"))
 
557
            
 
558
 
 
559
    # Button Remove Rules(s)
 
560
    def btnRemove_clicked_cb(self, widget):
 
561
        # Remove in 2 plane
 
562
        task = self.remove_rules()
 
563
        gobject.idle_add(task.next)
 
564
        
 
565
    
 
566
    # Remove Rules Method
 
567
    def remove_rules(self):
 
568
        tree,iter  = self.tv_rules.get_selection().get_selected_rows()
 
569
        removed    = 0
 
570
        actual_row = 0
 
571
        total_rows = len(iter)
 
572
           
 
573
        if total_rows == 0:
 
574
            self.set_window_values(self.variable.get_text("010"))
 
575
            yield None
 
576
            return
 
577
 
 
578
        # No sensitive buttons
 
579
        # Main Window
 
580
        self.cb_enabled_firewall.set_sensitive(0)
 
581
        self.cb_policy.set_sensitive(0)
 
582
        self.btn_remove_rule.set_sensitive(0)
 
583
        # Rules Window
 
584
        self.add_btn_add.set_sensitive(0)
 
585
        # Menus
 
586
        self.menu_pref.set_sensitive(0)
 
587
 
 
588
        # For one row: Selected
 
589
        for item in iter:
 
590
 
 
591
            # Get rule selected (To/Action/From)
 
592
            actual_rule_to   = tree.get_value(tree.get_iter(item),1)
 
593
            actual_rule      = tree.get_value(tree.get_iter(item),2)
 
594
            actual_rule_from = tree.get_value(tree.get_iter(item),3)
 
595
            
 
596
            # Move Progress Bar
 
597
            actual_row += 1
 
598
            progress = float(actual_row) / float(total_rows)
 
599
            if progress > 1:
 
600
                progress = 1.0
 
601
            self.progress_bar.set_fraction(progress)
 
602
            yield True
 
603
 
 
604
            result = self.firewall.remove_rule(actual_rule_to, actual_rule, actual_rule_from)
 
605
            if result.find(self.variable.get_constant("rule_deleted")) != -1:
 
606
                removed += 1
 
607
 
 
608
        # Clean Progress Bar
 
609
        self.progress_bar.set_fraction(0)
 
610
        
 
611
        if removed == 1:
 
612
            self.set_window_values(self.variable.get_text("014"))
 
613
        elif removed > 1:
 
614
            self.set_window_values(self.variable.get_text("019"))
 
615
        else:
 
616
            self.set_window_values(self.variable.get_text("012"))
 
617
 
 
618
        yield None
 
619
 
 
620
 
 
621
        
 
622
 
 
623
# BUTTONS ADD WINDOW
 
624
    
 
625
    # Add rule Button
 
626
    def btnAddRule_clicked_cb(self, widget):
 
627
        # Add a simple rule
 
628
        if self.rules_notebook.get_current_page() == 0:
 
629
            self.add_rule_preconf()
 
630
        # Add a preconfigured rule
 
631
        elif self.rules_notebook.get_current_page() == 1:
 
632
            self.add_rule_simple()
 
633
        # Add an advanced rule
 
634
        elif self.rules_notebook.get_current_page() == 2:
 
635
            self.add_rule_advanced()
 
636
            
 
637
  
 
638
    # Add a simple rule
 
639
    def add_rule_simple(self):
 
640
        # Allow|deny|Limit
 
641
        if self.action_simple.get_active() == 0:
 
642
            action = self.variable.get_constant("allow")
 
643
        elif self.action_simple.get_active() == 1:
 
644
            action = self.variable.get_constant("deny")
 
645
        elif self.action_simple.get_active() == 2:
 
646
            action = self.variable.get_constant("reject")
 
647
        else:
 
648
            action = self.variable.get_constant("limit")
 
649
        
 
650
        # Protocol
 
651
        if self.proto_simple.get_active() == 0:
 
652
            protocol = self.variable.get_constant("tcp")
 
653
        elif self.proto_simple.get_active() == 1:
 
654
            protocol = self.variable.get_constant("udp")
 
655
        else:
 
656
            protocol = self.variable.get_constant("both")
 
657
 
 
658
        # Port
 
659
        port = self.port_simple.get_text()
 
660
        
 
661
        # ? -> !
 
662
        if port == "asturianu":
 
663
            dlg_egg = gtk.MessageDialog(None, buttons=gtk.BUTTONS_CLOSE, message_format="Tamos fartos de glayar...\nl'asturianu llingua OFICIAL!")
 
664
            dlg_egg.run()
 
665
            dlg_egg.destroy()
 
666
            return
 
667
        
 
668
        # Validate port
 
669
        if port == "":
 
670
            self.set_window_values(self.variable.get_text("015"))
 
671
            return
 
672
            
 
673
        # Validate both and not range ports
 
674
        if ( port.find(":") != -1 ) and protocol == self.variable.get_constant("both"):
 
675
            self.set_window_values(self.variable.get_text("017"))
 
676
            return
 
677
            
 
678
        # Add rule
 
679
        result = self.firewall.add_rule(self.variable.get_constant("service_no"), action, protocol, "", "", "", port)
 
680
        if result.find(self.variable.get_constant("rule_added"))   != -1 or \
 
681
            result.find(self.variable.get_constant("rule_updated")) != -1:
 
682
            self.set_window_values(self.variable.get_text("013"))
 
683
        else:
 
684
            self.set_window_values(self.variable.get_text("012"))
 
685
        
 
686
        
 
687
    # Add a preconfigured rule
 
688
    def add_rule_preconf(self):
 
689
        # Allow|deny|Limit
 
690
        if self.action_preconf.get_active() == 0:
 
691
            action = self.variable.get_constant("allow")
 
692
        elif self.action_preconf.get_active() == 1:
 
693
            action = self.variable.get_constant("deny")
 
694
        elif self.action_preconf.get_active() == 2:
 
695
            action = self.variable.get_constant("reject")
 
696
        else:
 
697
            action = self.variable.get_constant("limit")
 
698
 
 
699
        # Service?
 
700
        if self.serv_prog_type == self.variable.get_constant("service_enabled"):
 
701
            port_proto = self.variable.get_service(self.service_preconf.get_active_text()) 
 
702
            if port_proto.find(self.variable.get_constant("tcp")) != -1:
 
703
                port     = port_proto.replace(self.variable.get_constant("tcp"), "")
 
704
                protocol = self.variable.get_constant("tcp")
 
705
            elif port_proto.find(self.variable.get_constant("udp")) != -1:
 
706
                port     = port_proto.replace(self.variable.get_constant("udp"), "")
 
707
                protocol = self.variable.get_constant("udp")
 
708
            elif port_proto.find(self.variable.get_constant("both")) != -1:
 
709
                port     = port_proto.replace(self.variable.get_constant("both"), "")
 
710
                protocol = self.variable.get_constant("both")
 
711
            else:
 
712
                port     = port_proto
 
713
                protocol = ""
 
714
                
 
715
            # TODO Add rule service
 
716
            result = self.firewall.add_rule(self.variable.get_constant("service_yes"), action, protocol, "", "", "", port)
 
717
            if result.find(self.variable.get_constant("rule_added"))   != -1 or \
 
718
                result.find(self.variable.get_constant("rule_updated")) != -1:
 
719
                self.set_window_values(self.variable.get_text("013"))
 
720
            else:
 
721
                self.set_window_values(self.variable.get_text("012"))
 
722
              
 
723
        # Program?
 
724
        else:
 
725
            port_proto   = self.variable.get_program(self.program_preconf.get_active_text()) 
 
726
            ports_protos = port_proto.split("#")
 
727
            added        = 0
 
728
            
 
729
            for prog in ports_protos:
 
730
                if prog.find(self.variable.get_constant("tcp")) != -1:
 
731
                    port     = prog.replace(self.variable.get_constant("tcp"), "")
 
732
                    protocol = self.variable.get_constant("tcp")
 
733
                elif prog.find(self.variable.get_constant("udp")) != -1:
 
734
                    port     = prog.replace(self.variable.get_constant("udp"), "")
 
735
                    protocol = self.variable.get_constant("udp")
 
736
                elif prog.find(self.variable.get_constant("both")) != -1:
 
737
                    port     = prog.replace(self.variable.get_constant("both"), "")
 
738
                    protocol = self.variable.get_constant("both")
 
739
                    
 
740
                # TODO Add rule program
 
741
                result = self.firewall.add_rule(self.variable.get_constant("service_no"), action, protocol, "", "", "", port)
 
742
                if result.find(self.variable.get_constant("rule_added"))   != -1 or \
 
743
                    result.find(self.variable.get_constant("rule_updated")) != -1:
 
744
                    added += 1
 
745
                    
 
746
            if added == 1: 
 
747
                self.set_window_values(self.variable.get_text("013"))
 
748
            elif added > 1:
 
749
                self.set_window_values(self.variable.get_text("020"))
 
750
            else:
 
751
                self.set_window_values(self.variable.get_text("012"))
 
752
                
 
753
    
 
754
    # Add an advanced rule
 
755
    def add_rule_advanced(self):
 
756
        # Deny|Reject|Allow|Limit
 
757
        if self.action_advanced.get_active() == 0:
 
758
            action = self.variable.get_constant("allow")
 
759
        elif self.action_advanced.get_active() == 1:
 
760
            action = self.variable.get_constant("deny")
 
761
        elif self.action_advanced.get_active() == 2:
 
762
            action = self.variable.get_constant("reject")
 
763
        else:
 
764
            action = self.variable.get_constant("limit")
 
765
 
 
766
        # Protocol
 
767
        if self.proto_advanced.get_active() == 0:
 
768
            protocol = self.variable.get_constant("tcp")
 
769
        elif self.proto_advanced.get_active() == 1:
 
770
            protocol = self.variable.get_constant("udp")
 
771
        else:
 
772
            protocol = self.variable.get_constant("both")
 
773
                
 
774
        # From
 
775
        fromip   = self.fromip_advanced.get_text()
 
776
        fromport = self.portfrom_advanced.get_text()
 
777
        
 
778
        # To
 
779
        toip   = self.toip_advanced.get_text()
 
780
        toport = self.portto_advanced.get_text() 
 
781
        
 
782
        # Validate values
 
783
        if fromip == "" and fromport == "" and toip == "" and toport == "":
 
784
            self.set_window_values(self.variable.get_text("016"))
 
785
            return
 
786
 
 
787
        # Validate both and not range ports in FROM
 
788
        if ( fromport != "" and fromport.find(":") != -1 ) and protocol == self.variable.get_constant("both"):
 
789
            self.set_window_values(self.variable.get_text("017"))
 
790
            return
 
791
        # Validate both and not range ports in TO            
 
792
        if ( toport != "" and toport.find(":") != -1 ) and protocol == self.variable.get_constant("both"):
 
793
            self.set_window_values(self.variable.get_text("017"))
 
794
            return
 
795
                    
 
796
        # Add rule program
 
797
        result = self.firewall.add_rule(self.variable.get_constant("service_no"), action, protocol, fromip, fromport, toip, toport)
 
798
        if result.find(self.variable.get_constant("rule_added"))   != -1 or \
 
799
           result.find(self.variable.get_constant("rule_updated")) != -1:
 
800
            self.set_window_values(self.variable.get_text("013"))
 
801
        else:
 
802
            self.set_window_values(self.variable.get_text("012"))
 
803
 
 
804
        
 
805
    # Change between Service/Program
 
806
    def cbTypePreconf_changed_cb(self, widget):
 
807
        if self.serv_prog_type == self.variable.get_constant("service_enabled"):
 
808
            self.serv_prog_type = self.variable.get_constant("service_disabled")
 
809
            self.service_preconf.hide()   
 
810
            self.program_preconf.show()   
 
811
        else:
 
812
            self.serv_prog_type = self.variable.get_constant("service_enabled")
 
813
            self.service_preconf.show()   
 
814
            self.program_preconf.hide()   
 
815
 
 
816
 
 
817
    # Clear values
 
818
    def btnCleanAdvanced_clicked_cb(self, widget):
 
819
        self.fromip_advanced.set_text("")
 
820
        self.portfrom_advanced.set_text("")
 
821
        self.toip_advanced.set_text("")
 
822
        self.portto_advanced.set_text("")