services/nat/__init__.py

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