if event.get('log_level') != LogLevel.info:
return yes
dflag = event.get('dflag')
+ if dflag is False : return yes
if dflag in debug_set: return yes
if dflag is None and DBG.TWISTED in debug_set: return yes
return no
max_requests_outstanding = 6
max_batch_up = 4000
http_retry = 5
+port = 80
+vroutes = ''
#[server] or [<client>] overrides
ipif = userv root ipif %(local)s,%(peer)s,%(mtu)s,slip %(rnets)s
# relating to virtual network
mtu = 1500
-[server]
+[SERVER]
+server = SERVER
# addrs = 127.0.0.1 ::1
-port = 80
# url
# relating to virtual network
-routes = ''
-vnetwork = 172.24.230.192
-# network = <prefix>/<len>
-# server = <ipaddr>
-# relay = <ipaddr>
+vvnetwork = 172.24.230.192
+# vnetwork = <prefix>/<len>
+# vadd r = <ipaddr>
+# vrelay = <ipaddr>
# [<client-ip4-or-ipv6-address>]
# password = <password> # used by both, must match
-[limits]
+[LIMIT]
max_batch_down = 262144
max_queue_time = 121
http_timeout = 121
return s.translate(_mimetrans)
class ConfigResults:
- def __init__(self, d = { }):
- self.__dict__ = d
+ def __init__(self):
+ pass
def __repr__(self):
return 'ConfigResults('+repr(self.__dict__)+')'
-c = ConfigResults()
-
def log_discard(packet, iface, saddr, daddr, why):
log_debug(DBG.DROP,
'discarded packet [%s] %s -> %s: %s' % (iface, saddr, daddr, why),
def inputdata(self, data):
self._log('inputdata', d=data)
- packets = slip.decode(data)
- packets[0] = self._buffer + packets[0]
+ data = self._buffer + data
+ self._buffer = b''
+ packets = slip.decode(data, True)
self._buffer = packets.pop()
for packet in packets:
self._maybe_packet(packet)
def flush(self):
self._log('flush')
- self._maybe_packet(self._buffer)
+ data = self._buffer
self._buffer = b''
+ packets = slip.decode(data)
+ assert(len(packets) == 1)
+ self._maybe_packet(packets[0])
class _IpifProcessProtocol(twisted.internet.protocol.ProcessProtocol):
def __init__(self, router):
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},
env=None)
+ return ipif
-def queue_inbound(packet):
+def queue_inbound(ipif, packet):
log_debug(DBG.FLOW, "queue_inbound", d=packet)
ipif.transport.write(slip.delimiter)
ipif.transport.write(slip.encode(packet))
#---------- config processing ----------
-def process_cfg_common_always():
- global mtu
- c.mtu = cfg.get('virtual','mtu')
+def _cfg_process_putatives():
+ servers = { }
+ clients = { }
+ # maps from abstract object to canonical name for cs's
-def process_cfg_ipif(section, varmap):
- for d, s in varmap:
- try: v = getattr(c, s)
- except AttributeError: continue
- setattr(c, d, v)
+ def putative(cmap, abstract, canoncs):
+ try:
+ current_canoncs = cmap[abstract]
+ except KeyError:
+ pass
+ else:
+ assert(current_canoncs == canoncs)
+ cmap[abstract] = canoncs
+
+ server_pat = r'[-.0-9A-Za-z]+'
+ client_pat = r'[.:0-9a-f]+'
+ server_re = regexp.compile(server_pat)
+ serverclient_re = regexp.compile(server_pat + r' ' + client_pat)
- #print(repr(c))
+ for cs in cfg.sections():
+ if cs == 'LIMIT':
+ # plan A "[LIMIT]"
+ continue
- c.ipif_command = cfg.get(section,'ipif', vars=c.__dict__)
+ try:
+ # plan B "[<client>]" part 1
+ ci = ipaddr(cs)
+ except AddressValueError:
-def process_cfg_network():
- c.network = ipnetwork(cfg.get('virtual','network'))
- if c.network.num_addresses < 3 + 2:
- raise ValueError('network needs at least 2^3 addresses')
+ if server_re.fullmatch(cs):
+ # plan C "[<servername>]"
+ putative(servers, cs, cs)
+ continue
-def process_cfg_server():
+ if serverclient_re.fullmatch(cs):
+ # plan D "[<servername> <client>]" part 1
+ (pss,pcs) = cs.split(' ')
+
+ if pcs == 'LIMIT':
+ # plan E "[<servername> LIMIT]"
+ continue
+
+ try:
+ # plan D "[<servername> <client>]" part 2
+ ci = ipaddr(pc)
+ except AddressValueError:
+ # plan F "[<some thing we do not understand>]"
+ # well, we ignore this
+ print('warning: ignoring config section %s' % cs, file=sys.stderr)
+ continue
+
+ else: # no AddressValueError
+ # plan D "[<servername> <client]" part 3
+ putative(clients, ci, pcs)
+ putative(servers, pss, pss)
+ continue
+
+ else: # no AddressValueError
+ # plan B "[<client>" part 2
+ putative(clients, ci, cs)
+ continue
+
+ return (servers, clients)
+
+def cfg_process_common(c, ss):
+ c.mtu = cfg.getint(ss, 'mtu')
+
+def cfg_process_saddrs(c, ss):
+ class ServerAddr():
+ def __init__(self, port, addrspec):
+ self.port = port
+ # also self.addr
+ try:
+ self.addr = ipaddress.IPv4Address(addrspec)
+ self._endpointfactory = twisted.internet.endpoints.TCP4ServerEndpoint
+ self._inurl = b'%s'
+ except AddressValueError:
+ self.addr = ipaddress.IPv6Address(addrspec)
+ self._endpointfactory = twisted.internet.endpoints.TCP6ServerEndpoint
+ self._inurl = b'[%s]'
+ def make_endpoint(self):
+ return self._endpointfactory(reactor, self.port, self.addr)
+ def url(self):
+ url = b'http://' + (self._inurl % str(self.addr).encode('ascii'))
+ if self.port != 80: url += b':%d' % self.port
+ url += b'/'
+ return url
+
+ c.port = cfg.getint(ss,'port')
+ c.saddrs = [ ]
+ for addrspec in cfg.get(ss, 'addrs').split():
+ sa = ServerAddr(c.port, addrspec)
+ c.saddrs.append(sa)
+
+def cfg_process_vnetwork(c, ss):
+ c.vnetwork = ipnetwork(cfg.get(ss,'vnetwork'))
+ if c.vnetwork.num_addresses < 3 + 2:
+ raise ValueError('vnetwork needs at least 2^3 addresses')
+
+def cfg_process_vaddr(c, ss):
try:
- c.server = cfg.get('virtual','server')
+ c.vaddr = cfg.get(ss,'vaddr')
except NoOptionError:
- process_cfg_network()
- c.server = next(c.network.hosts())
-
-class ServerAddr():
- def __init__(self, port, addrspec):
- self.port = port
- # also self.addr
- try:
- self.addr = ipaddress.IPv4Address(addrspec)
- self._endpointfactory = twisted.internet.endpoints.TCP4ServerEndpoint
- self._inurl = b'%s'
- except AddressValueError:
- self.addr = ipaddress.IPv6Address(addrspec)
- self._endpointfactory = twisted.internet.endpoints.TCP6ServerEndpoint
- self._inurl = b'[%s]'
- def make_endpoint(self):
- return self._endpointfactory(reactor, self.port, self.addr)
- def url(self):
- url = b'http://' + (self._inurl % str(self.addr).encode('ascii'))
- if self.port != 80: url += b':%d' % self.port
- url += b'/'
- return url
+ cfg_process_vnetwork(c, ss)
+ c.vaddr = next(c.vnetwork.hosts())
+
+def cfg_search_section(key,sections):
+ for section in sections:
+ if cfg.has_option(section, key):
+ return section
+ raise NoOptionError(key, repr(sections))
+
+def cfg_search(getter,key,sections):
+ section = cfg_search_section(key,sections)
+ return getter(section, key)
+
+def cfg_process_client_limited(cc,ss,sections,key):
+ val = cfg_search(cfg.getint, key, sections)
+ lim = cfg_search(cfg.getint, key, ['%s LIMIT' % ss, 'LIMIT'])
+ cc.__dict__[key] = min(val,lim)
+
+def cfg_process_client_common(cc,ss,cs,ci):
+ # returns sections to search in, iff password is defined, otherwise None
+ cc.ci = ci
+
+ sections = ['%s %s' % (ss,cs),
+ cs,
+ ss,
+ 'DEFAULT']
+
+ try: pwsection = cfg_search_section('password', sections)
+ except NoOptionError: return None
-def process_cfg_saddrs():
- try: port = cfg.getint('server','port')
- except NoOptionError: port = 80
+ pw = cfg.get(pwsection, 'password')
+ cc.password = pw.encode('utf-8')
- c.saddrs = [ ]
- for addrspec in cfg.get('server','addrs').split():
- sa = ServerAddr(port, addrspec)
- c.saddrs.append(sa)
+ cfg_process_client_limited(cc,ss,sections,'target_requests_outstanding')
+ cfg_process_client_limited(cc,ss,sections,'http_timeout')
-def process_cfg_clients(constructor):
- c.clients = [ ]
- for cs in cfg.sections():
- if not (':' in cs or '.' in cs): continue
- ci = ipaddr(cs)
- pw = cfg.get(cs, 'password')
- pw = pw.encode('utf-8')
- constructor(ci,cs,pw)
+ return sections
+
+def cfg_process_ipif(c, sections, varmap):
+ for d, s in varmap:
+ try: v = getattr(c, s)
+ except AttributeError: continue
+ setattr(c, d, v)
+
+ #print('CFGIPIF',repr((varmap, sections, c.__dict__)),file=sys.stderr)
+
+ section = cfg_search_section('ipif', sections)
+ c.ipif_command = cfg.get(section,'ipif', vars=c.__dict__)
#---------- startup ----------
def common_startup(process_cfg):
+ # calls process_cfg(putative_clients, putative_servers)
+
# ConfigParser hates #-comments after values
- trailingcomments_re = regexp.compile('#.*')
+ trailingcomments_re = regexp.compile(r'#.*')
cfg.read_string(trailingcomments_re.sub('', defcfg))
need_defcfg = True
readconfig('/etc/hippotat/config', False)
readconfig('/etc/hippotat/config.d', False)
- try: process_cfg()
+ try:
+ (pss, pcs) = _cfg_process_putatives()
+ process_cfg(pss, pcs)
except (configparser.Error, ValueError):
traceback.print_exc(file=sys.stderr)
print('\nInvalid configuration, giving up.', file=sys.stderr)