pymin/services/nat/__init__.py

   1 # vim: set encoding=utf-8 et sw=4 sts=4 :
   2
   3 from os import path
   4
   5 from pymin.seqtools import Sequence
   6 from pymin.dispatcher import Handler, handler, HandlerError
   7 from pymin.services.util import Restorable, ConfigWriter, RestartHandler, \
   8                                 ReloadHandler, TransactionalHandler, \
   9                                 ListSubHandler, call
  10
  11 __ALL__ = ('NatHandler', 'Error')
  12
  13 class Error(HandlerError):
  14     r"""
  15     Error(command) -> Error instance :: Base NatHandler exception class.
  16
  17     All exceptions raised by the NatHandler inherits from this one, so you can
  18     easily catch any NatHandler exception.
  19
  20     message - A descriptive error message.
  21     """
  22     pass
  23
  24 class PortForward(Sequence):
  25     r"""PortForward(dev, protocol, port, dst[, dst_port[, ...]]) -> PortForward.
  26
  27     dev - Netword device to use.
  28     protocol - TCP or UDP.
  29     port - Port to forward.
  30     dst - Destination IP address.
  31     dst_port - Destination port (at dst).
  32     src_net - Source network to apply the forward (as IP/mask).
  33     dst_net - Source network to apply the forward (as IP/mask).
  34     """
  35
  36     def __init__(self, dev, protocol, port, dst, dst_port=None, src_net=None,
  37                        dst_net=None):
  38         r"Initialize object, see class documentation for details."
  39         # TODO Validate
  40         self.dev = dev
  41         self.protocol = protocol
  42         self.port = port
  43         self.dst = dst
  44         self.dst_port = dst_port
  45         self.src_net = src_net
  46         self.dst_net = dst_net
  47
  48     def update(self, dev=None, protocol=None, port=None, dst=None,
  49                     dst_port=None, src_net=None, dst_net=None):
  50         r"update([dev[, ...]]) -> Update the values of a port (see class doc)."
  51         # TODO Validate
  52         if dev is not None: self.dev = dev
  53         if protocol is not None: self.protocol = protocol
  54         if port is not None: self.port = port
  55         if dst is not None: self.dst = dst
  56         if dst_port is not None: self.dst_port = dst_port
  57         if src_net is not None: self.src_net = src_net
  58         if dst_net is not None: self.dst_net = dst_net
  59
  60     def as_tuple(self):
  61         r"Return a tuple representing the port forward."
  62         return (self.dev, self.protocol, self.port, self.dst, self.dst_port,
  63                     self.src_net, self.dst_net)
  64
  65     def as_call_list(self, index=None):
  66         if self.dst_port is not None:
  67             self.dst = self.dst + ':' + self.dst_port
  68         cmd = ['-t', 'nat', '-I', 'PREROUTING']
  69         if index is not None:
  70             cmd.append(str(index))
  71         cmd.extend(('-i', self.dev, '-j', 'DNAT', '--to', self.dst,
  72                 '-p', self.protocol, '--dport', self.port))
  73         if self.src_net is not None:
  74             cmd.extend(('-s', self.src_net))
  75         if self.dst_net is not None:
  76             cmd.extend(('-d', self.dst_net))
  77         return cmd
  78
  79 class PortForwardHandler(ListSubHandler):
  80     r"""PortForwardHandler(parent) -> PortForwardHandler instance.
  81
  82     This class is a helper for NatHandler to do all the work related to port
  83     forwarding.
  84
  85     parent - The parent service handler.
  86     """
  87
  88     handler_help = u"Manage NAT port forwarding."
  89
  90     _cont_subhandler_attr = 'ports'
  91     _cont_subhandler_class = PortForward
  92
  93 class SNat(Sequence):
  94     r"""SNat(dev, src[, src_net]) -> SNat instance.
  95
  96     dev - Netword device to use.
  97     src - Source IP address.
  98     src_net - Source network to apply the NAT (as IP/mask).
  99     """
 100
 101     def __init__(self, dev, src, src_net=None):
 102         r"Initialize object, see class documentation for details."
 103         # TODO Validate
 104         self.dev = dev
 105         self.src = src
 106         self.src_net = src_net
 107
 108     def update(self, dev=None, src=None, src_net=None):
 109         r"update([dev[, ...]]) -> Update the values of a snat (see class doc)."
 110         # TODO Validate
 111         if dev is not None: self.dev = dev
 112         if src is not None: self.src = src
 113         if src_net is not None: self.src_net = src_net
 114
 115     def __cmp__(self, other):
 116         r"Compares two SNat objects."
 117         return cmp(self.as_tuple(), other.as_tuple())
 118
 119     def as_tuple(self):
 120         r"Return a tuple representing the snat."
 121         return (self.dev, self.src, self.src_net)
 122
 123     def as_call_list(self, index=None):
 124         cmd = ['-t', 'nat', '-I', 'POSTROUTING']
 125         if index is not None:
 126             cmd.append(str(index))
 127         cmd.extend(('-o', self.dev, '-j', 'SNAT', '--to', self.src))
 128         if self.src_net is not None:
 129             cmd.extend(('-s', self.src_net))
 130         return cmd
 131
 132 class SNatHandler(ListSubHandler):
 133     r"""SNatHandler(parent) -> SNatHandler instance.
 134
 135     This class is a helper for NatHandler to do all the work related to
 136     Source NAT.
 137
 138     parent - The parent service handler.
 139     """
 140
 141     handler_help = u"Manage source NAT."
 142
 143     _cont_subhandler_attr = 'snats'
 144     _cont_subhandler_class = SNat
 145
 146 class Masq(Sequence):
 147     r"""Masq(dev, src_net) -> Masq instance.
 148
 149     dev - Netword device to use.
 150     src_net - Source network to apply the masquerade (as IP/mask).
 151     """
 152
 153     def __init__(self, dev, src_net):
 154         r"Initialize object, see class documentation for details."
 155         # TODO Validate
 156         self.dev = dev
 157         self.src_net = src_net
 158
 159     def update(self, dev=None, src_net=None):
 160         r"update([dev[, ...]]) -> Update the values of a masq (see class doc)."
 161         # TODO Validate
 162         if dev is not None: self.dev = dev
 163         if src_net is not None: self.src_net = src_net
 164
 165     def __cmp__(self, other):
 166         r"Compares two Masq objects."
 167         return cmp(self.as_tuple(), other.as_tuple())
 168
 169     def as_tuple(self):
 170         r"Return a tuple representing the masquerade."
 171         return (self.dev, self.src_net)
 172
 173     def as_call_list(self, index=None):
 174         cmd = ['-t', 'nat', '-I', 'POSTROUTING']
 175         if index is not None:
 176             cmd.append(str(index))
 177         cmd.extend(('-o', self.dev, '-j', 'MASQUERADE', '-s', self.src_net))
 178         return cmd
 179
 180 class MasqHandler(ListSubHandler):
 181     r"""MasqHandler(parent) -> MasqHandler instance.
 182
 183     This class is a helper for NatHandler to do all the work related to
 184     masquerading.
 185
 186     parent - The parent service handler.
 187     """
 188
 189     handler_help = u"Manage NAT masquerading."
 190
 191     _cont_subhandler_attr = 'masqs'
 192     _cont_subhandler_class = Masq
 193
 194 class NatHandler(Restorable, ConfigWriter, RestartHandler, ReloadHandler,
 195                       TransactionalHandler):
 196     r"""NatHandler([pickle_dir[, config_dir]]) -> NatHandler instance.
 197
 198     Handles NAT commands using iptables.
 199
 200     pickle_dir - Directory where to write the persistent configuration data.
 201
 202     config_dir - Directory where to store de generated configuration files.
 203
 204     Both defaults to the current working directory.
 205     """
 206
 207     handler_help = u"Manage NAT (Network Address Translation) service."
 208
 209     _persistent_attrs = ('ports', 'snats', 'masqs')
 210
 211     _restorable_defaults = dict(
 212         ports=list(),
 213         snats=list(),
 214         masqs=list(),
 215     )
 216
 217     @handler(u'Start the service.')
 218     def start(self):
 219         for (index, port) in enumerate(self.ports):
 220             call(['iptables'] + port.as_call_list(index+1))
 221         for (index, snat) in enumerate(self.snats):
 222             call(['iptables'] + snat.as_call_list(index+1))
 223         for (index, masq) in enumerate(self.masqs):
 224             call(['iptables'] + masq.as_call_list(index+1))
 225
 226     @handler(u'Stop the service.')
 227     def stop(self):
 228         call(('iptables', '-t', 'nat', '-F'))
 229
 230     def __init__(self, pickle_dir='.'):
 231         r"Initialize the object, see class documentation for details."
 232         self._persistent_dir = pickle_dir
 233         self._restore()
 234         self.forward = PortForwardHandler(self)
 235         self.snat = SNatHandler(self)
 236         self.masq = MasqHandler(self)
 237
 238
 239 if __name__ == '__main__':
 240
 241     import os
 242
 243     handler = NatHandler()
 244
 245     def dump():
 246         print '-' * 80
 247         print 'Forwarded ports:'
 248         print handler.forward.show()
 249         print '-' * 10
 250         print 'SNat:'
 251         print handler.snat.show()
 252         print '-' * 10
 253         print 'Masq:'
 254         print handler.masq.show()
 255         print '-' * 80
 256
 257     dump()
 258     handler.forward.add('eth0','tcp','80', '192.168.0.9', '8080')
 259     handler.forward.update(0, dst_net='192.168.0.188/32')
 260     handler.forward.add('eth0', 'udp', '53', '192.168.1.0')
 261     handler.commit()
 262     handler.stop()
 263     dump()
 264     handler.snat.add('eth0', '192.168.0.9')
 265     handler.snat.update(0, src_net='192.168.0.188/32')
 266     handler.snat.add('eth0', '192.168.1.0')
 267     handler.commit()
 268     dump()
 269     dump()
 270     handler.masq.add('eth0', '192.168.0.9/24')
 271     handler.masq.update(0, src_net='192.168.0.188/30')
 272     handler.masq.add('eth1', '192.168.1.0/24')
 273     handler.commit()
 274     dump()
 275
 276     os.system('rm -f *.pkl')
 277