move sigint

[hippotat] / hippotat / __init__.py

# -*- python -*-

import signal
signal.signal(signal.SIGINT, signal.SIG_DFL)

import twisted
from twisted.internet import reactor

import ipaddress
from ipaddress import AddressValueError

import hippotat.slip as slip

#---------- packet parsing ----------

def packet_addrs(packet):
  version = packet[0] >> 4
  if version == 4:
    addrlen = 4
    saddroff = 3*4
    factory = ipaddress.IPv4Address
  elif version == 6:
    addrlen = 16
    saddroff = 2*4
    factory = ipaddress.IPv6Address
  else:
    raise ValueError('unsupported IP version %d' % version)
  saddr = factory(packet[ saddroff           : saddroff + addrlen   ])
  daddr = factory(packet[ saddroff + addrlen : saddroff + addrlen*2 ])
  return (saddr, daddr)

#---------- address handling ----------

def ipaddr(input):
  try:
    r = ipaddress.IPv4Address(input)
  except AddressValueError:
    r = ipaddress.IPv6Address(input)
  return r

def ipnetwork(input):
  try:
    r = ipaddress.IPv4Network(input)
  except NetworkValueError:
    r = ipaddress.IPv6Network(input)
  return r

#---------- ipif (SLIP) subprocess ----------

class _IpifProcessProtocol(twisted.internet.protocol.ProcessProtocol):
  def __init__(self, router):
    self._buffer = b''
    self._router = router
  def connectionMade(self): pass
  def outReceived(self, data):
    #print('RECV ', repr(data))
    self._buffer += data
    packets = slip.decode(self._buffer)
    self._buffer = packets.pop()
    for packet in packets:
      if not len(packet): continue
      (saddr, daddr) = packet_addrs(packet)
      self._router(packet, saddr, daddr)
  def processEnded(self, status):
    status.raiseException()

def start_ipif(command, router):
  global ipif
  ipif = _IpifProcessProtocol(router)
  reactor.spawnProcess(ipif,
                       '/bin/sh',['sh','-xc', command],
                       childFDs={0:'w', 1:'r', 2:2})

def queue_inbound(packet):
  ipif.transport.write(slip.delimiter)
  ipif.transport.write(slip.encode(packet))
  ipif.transport.write(slip.delimiter)

#---------- packet queue ----------

class PacketQueue():
  def __init__(self, max_queue_time):
    self._max_queue_time = max_queue_time
    self._pq = collections.deque() # packets

  def append(self, packet):
    self._pq.append((time.monotonic(), packet))

  def nonempty(self):
    while True:
      try: (queuetime, packet) = self._pq[0]
      except IndexError: return False

      age = time.monotonic() - queuetime
      if age > self.max_queue_time:
        # strip old packets off the front
        self._pq.popleft()
        continue

      return True

  def popleft(self):
    # caller must have checked nonempty
    try: (dummy, packet) = self._pq[0]
    except IndexError: return None
    return packet