]> git.llucax.com Git - software/pymin.git/blob - pymin/services/firewall/__init__.py
Add a small utility to send pymin commands.
[software/pymin.git] / pymin / services / firewall / __init__.py
1 # vim: set encoding=utf-8 et sw=4 sts=4 :
2
3 # TODO See if it's better (more secure) to execute commands via python instead
4 # of using script templates.
5
6 from os import path
7
8 from pymin.seqtools import Sequence
9 from pymin.dispatcher import Handler, handler, HandlerError
10 from pymin.services.util import Restorable, ConfigWriter, ServiceHandler, \
11                                 TransactionalHandler, ListSubHandler
12
13 __ALL__ = ('FirewallHandler',)
14
15 class Rule(Sequence):
16     r"""Rule(chain, target[, src[, dst[, ...]]]) -> Rule instance.
17
18     chain - INPUT, OUTPUT or FORWARD.
19     target - ACCEPT, REJECT or DROP.
20     src - Source subnet as IP/mask.
21     dst - Destination subnet as IP/mask.
22     protocol - ICMP, UDP, TCP or ALL.
23     src_port - Source port (only for UDP or TCP protocols).
24     dst_port - Destination port (only for UDP or TCP protocols).
25     """
26
27     def __init__(self, chain, target, src=None, dst=None, protocol=None,
28                        src_port=None, dst_port=None):
29         r"Initialize object, see class documentation for details."
30         self.chain = chain
31         self.target = target
32         self.src = src
33         self.dst = dst
34         self.protocol = protocol
35         # TODO Validate that src_port and dst_port could be not None only
36         # if the protocol is UDP or TCP
37         self.src_port = src_port
38         self.dst_port = dst_port
39
40     def update(self, chain=None, target=None, src=None, dst=None, protocol=None,
41                        src_port=None, dst_port=None):
42         r"update([chain[, ...]]) -> Update the values of a rule (see Rule doc)."
43         if chain is not None: self.chain = chain
44         if target is not None: self.target = target
45         if src is not None: self.src = src
46         if dst is not None: self.dst = dst
47         if protocol is not None: self.protocol = protocol
48         # TODO Validate that src_port and dst_port could be not None only
49         # if the protocol is UDP or TCP
50         if src_port is not None: self.src_port = src_port
51         if dst_port is not None: self.dst_port = dst_port
52
53     def as_tuple(self):
54         r"Return a tuple representing the rule."
55         return (self.chain, self.target, self.src, self.dst, self.protocol,
56                     self.src_port, self.dst_port)
57
58 class RuleHandler(ListSubHandler):
59     r"""RuleHandler(parent) -> RuleHandler instance :: Handle a list of rules.
60
61     This class is a helper for FirewallHandler to do all the work related to rules
62     administration.
63
64     parent - The parent service handler.
65     """
66
67     handler_help = u"Manage firewall rules"
68
69     _cont_subhandler_attr = 'rules'
70     _cont_subhandler_class = Rule
71
72 class FirewallHandler(Restorable, ConfigWriter, ServiceHandler,
73                       TransactionalHandler):
74     r"""FirewallHandler([pickle_dir[, config_dir]]) -> FirewallHandler instance.
75
76     Handles firewall commands using iptables.
77
78     pickle_dir - Directory where to write the persistent configuration data.
79
80     config_dir - Directory where to store de generated configuration files.
81
82     Both defaults to the current working directory.
83     """
84
85     handler_help = u"Manage firewall service"
86
87     _persistent_attrs = ['rules']
88
89     _restorable_defaults = dict(rules=list())
90
91     _config_writer_files = 'iptables.sh'
92     _config_writer_tpl_dir = path.join(path.dirname(__file__), 'templates')
93
94     def __init__(self, pickle_dir='.', config_dir='.'):
95         r"Initialize the object, see class documentation for details."
96         self._persistent_dir = pickle_dir
97         self._config_writer_cfg_dir = config_dir
98         self._service_start = ('sh', path.join(self._config_writer_cfg_dir,
99                                         self._config_writer_files))
100         self._service_stop = ('iptables', '-t', 'filter', '-F')
101         self._service_restart = self._service_start
102         self._service_reload = self._service_start
103         self._config_build_templates()
104         ServiceHandler.__init__(self)
105         self.rule = RuleHandler(self)
106
107     def _get_config_vars(self, config_file):
108         return dict(rules=self.rules)
109
110
111 if __name__ == '__main__':
112
113     import os
114
115     fw_handler = FirewallHandler()
116
117     def dump():
118         print '-' * 80
119         print 'Rules:'
120         print fw_handler.rule.show()
121         print '-' * 80
122
123     dump()
124
125     fw_handler.rule.add('input','drop','icmp')
126
127     fw_handler.rule.update(0, dst='192.168.0.188/32')
128
129     fw_handler.rule.add('output','accept', '192.168.1.0/24')
130
131     fw_handler.commit()
132
133     fw_handler.stop()
134
135     dump()
136
137     os.system('rm -f *.pkl iptables.sh')
138