chiark / gitweb /
282266c009651b004ec940f7b79aac2b84f5c3c7
[hippotat.git] / hippotatlib / __init__.py
1 # -*- python -*-
2 #
3 # Hippotat - Asinine IP Over HTTP program
4 # hippotatlib/__init__.py - common library code
5 #
6 # Copyright 2017 Ian Jackson
7 #
8 # GPLv3+
9 #
10 #    This program is free software: you can redistribute it and/or modify
11 #    it under the terms of the GNU General Public License as published by
12 #    the Free Software Foundation, either version 3 of the License, or
13 #    (at your option) any later version.
14 #
15 #    This program is distributed in the hope that it will be useful,
16 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
17 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 #    GNU General Public License for more details.
19 #
20 #    You should have received a copy of the GNU General Public License
21 #    along with this program, in the file GPLv3.  If not,
22 #    see <http://www.gnu.org/licenses/>.
23
24
25 import signal
26 signal.signal(signal.SIGINT, signal.SIG_DFL)
27
28 import sys
29 import os
30
31 from zope.interface import implementer
32
33 import twisted
34 from twisted.internet import reactor
35 import twisted.internet.endpoints
36 import twisted.logger
37 from twisted.logger import LogLevel
38 import twisted.python.constants
39 from twisted.python.constants import NamedConstant
40
41 import ipaddress
42 from ipaddress import AddressValueError
43
44 from optparse import OptionParser
45 import configparser
46 from configparser import ConfigParser
47 from configparser import NoOptionError
48
49 from functools import partial
50
51 import collections
52 import time
53 import codecs
54 import traceback
55
56 import re as regexp
57
58 import hippotatlib.slip as slip
59
60 class DBG(twisted.python.constants.Names):
61   INIT = NamedConstant()
62   CONFIG = NamedConstant()
63   ROUTE = NamedConstant()
64   DROP = NamedConstant()
65   OWNSOURCE = NamedConstant()
66   FLOW = NamedConstant()
67   HTTP = NamedConstant()
68   TWISTED = NamedConstant()
69   QUEUE = NamedConstant()
70   HTTP_CTRL = NamedConstant()
71   QUEUE_CTRL = NamedConstant()
72   HTTP_FULL = NamedConstant()
73   CTRL_DUMP = NamedConstant()
74   SLIP_FULL = NamedConstant()
75   DATA_COMPLETE = NamedConstant()
76
77 _hex_codec = codecs.getencoder('hex_codec')
78
79 #---------- logging ----------
80
81 org_stderr = sys.stderr
82
83 log = twisted.logger.Logger()
84
85 debug_set = set()
86 debug_def_detail = DBG.HTTP
87
88 def log_debug(dflag, msg, idof=None, d=None):
89   if dflag not in debug_set: return
90   #print('---------------->',repr((dflag, msg, idof, d)), file=sys.stderr)
91   if idof is not None:
92     msg = '[%#x] %s' % (id(idof), msg)
93   if d is not None:
94     trunc = ''
95     if not DBG.DATA_COMPLETE in debug_set:
96       if len(d) > 64:
97         d = d[0:64]
98         trunc = '...'
99     d = _hex_codec(d)[0].decode('ascii')
100     msg += ' ' + d + trunc
101   log.info('{dflag} {msgcore}', dflag=dflag, msgcore=msg)
102
103 def logevent_is_boringtwisted(event):
104   try:
105     if event.get('log_level') != LogLevel.info:
106       return False
107     dflag = event.get('dflag')
108     if dflag is False                            : return False
109     if dflag                         in debug_set: return False
110     if dflag is None and DBG.TWISTED in debug_set: return False
111     return True
112   except Exception:
113     print('EXCEPTION (IN BORINGTWISTED CHECK)',
114           traceback.format_exc(), file=org_stderr)
115     return False
116
117 @implementer(twisted.logger.ILogFilterPredicate)
118 class LogNotBoringTwisted:
119   def __call__(self, event):
120     return (
121       twisted.logger.PredicateResult.no
122       if logevent_is_boringtwisted(event) else
123       twisted.logger.PredicateResult.yes
124     )
125
126 #---------- default config ----------
127
128 defcfg = '''
129 [COMMON]
130 max_batch_down = 65536
131 max_queue_time = 10
132 target_requests_outstanding = 3
133 http_timeout = 30
134 http_timeout_grace = 5
135 max_requests_outstanding = 6
136 max_batch_up = 4000
137 http_retry = 5
138 port = 80
139 vroutes = ''
140 ifname_client = hippo%%d
141 ifname_server = shippo%%d
142
143 #[server] or [<client>] overrides
144 ipif = userv root ipif %(local)s,%(peer)s,%(mtu)s,slip,%(ifname)s %(rnets)s
145
146 # relating to virtual network
147 mtu = 1500
148
149 # addrs = 127.0.0.1 ::1
150 # url
151
152 # relating to virtual network
153 vvnetwork = 172.24.230.192
154 # vnetwork = <prefix>/<len>
155 # vaddr    = <ipaddr>
156 # vrelay   = <ipaddr>
157
158
159 # [<client-ip4-or-ipv6-address>]
160 # secret = <secret>    # used by both, must match
161
162 [LIMIT]
163 max_batch_down = 262144
164 max_queue_time = 121
165 http_timeout = 121
166 target_requests_outstanding = 10
167 '''
168
169 # these need to be defined here so that they can be imported by import *
170 cfg = ConfigParser(strict=False)
171 optparser = OptionParser()
172
173 _mimetrans = bytes.maketrans(b'-'+slip.esc, slip.esc+b'-')
174 def mime_translate(s):
175   # SLIP-encoded packets cannot contain ESC ESC.
176   # Swap `-' and ESC.  The result cannot contain `--'
177   return s.translate(_mimetrans)
178
179 class ConfigResults:
180   def __init__(self):
181     pass
182   def __repr__(self):
183     return 'ConfigResults('+repr(self.__dict__)+')'
184
185 def log_discard(packet, iface, saddr, daddr, why):
186   log_debug(DBG.DROP,
187             'discarded packet [%s] %s -> %s: %s' % (iface, saddr, daddr, why),
188             d=packet)
189
190 #---------- packet parsing ----------
191
192 def packet_addrs(packet):
193   version = packet[0] >> 4
194   if version == 4:
195     addrlen = 4
196     saddroff = 3*4
197     factory = ipaddress.IPv4Address
198   elif version == 6:
199     addrlen = 16
200     saddroff = 2*4
201     factory = ipaddress.IPv6Address
202   else:
203     raise ValueError('unsupported IP version %d' % version)
204   saddr = factory(packet[ saddroff           : saddroff + addrlen   ])
205   daddr = factory(packet[ saddroff + addrlen : saddroff + addrlen*2 ])
206   return (saddr, daddr)
207
208 #---------- address handling ----------
209
210 def ipaddr(input):
211   try:
212     r = ipaddress.IPv4Address(input)
213   except AddressValueError:
214     r = ipaddress.IPv6Address(input)
215   return r
216
217 def ipnetwork(input):
218   try:
219     r = ipaddress.IPv4Network(input)
220   except NetworkValueError:
221     r = ipaddress.IPv6Network(input)
222   return r
223
224 #---------- ipif (SLIP) subprocess ----------
225
226 class SlipStreamDecoder():
227   def __init__(self, desc, on_packet):
228     self._buffer = b''
229     self._on_packet = on_packet
230     self._desc = desc
231     self._log('__init__')
232
233   def _log(self, msg, **kwargs):
234     log_debug(DBG.SLIP_FULL, 'slip %s: %s' % (self._desc, msg), **kwargs)
235
236   def inputdata(self, data):
237     self._log('inputdata', d=data)
238     data = self._buffer + data
239     self._buffer = b''
240     packets = slip.decode(data, True)
241     self._buffer = packets.pop()
242     for packet in packets:
243       self._maybe_packet(packet)
244     self._log('bufremain', d=self._buffer)
245
246   def _maybe_packet(self, packet):
247     self._log('maybepacket', d=packet)
248     if len(packet):
249       self._on_packet(packet)
250
251   def flush(self):
252     self._log('flush')
253     data = self._buffer
254     self._buffer = b''
255     packets = slip.decode(data)
256     assert(len(packets) == 1)
257     self._maybe_packet(packets[0])
258
259 class _IpifProcessProtocol(twisted.internet.protocol.ProcessProtocol):
260   def __init__(self, router):
261     self._router = router
262     self._decoder = SlipStreamDecoder('ipif', self.slip_on_packet)
263   def connectionMade(self): pass
264   def outReceived(self, data):
265     self._decoder.inputdata(data)
266   def slip_on_packet(self, packet):
267     (saddr, daddr) = packet_addrs(packet)
268     if saddr.is_link_local or daddr.is_link_local:
269       log_discard(packet, 'ipif', saddr, daddr, 'link-local')
270       return
271     self._router(packet, saddr, daddr)
272   def processEnded(self, status):
273     status.raiseException()
274
275 def start_ipif(command, router):
276   ipif = _IpifProcessProtocol(router)
277   reactor.spawnProcess(ipif,
278                        '/bin/sh',['sh','-xc', command],
279                        childFDs={0:'w', 1:'r', 2:2},
280                        env=None)
281   return ipif
282
283 def queue_inbound(ipif, packet):
284   log_debug(DBG.FLOW, "queue_inbound", d=packet)
285   ipif.transport.write(slip.delimiter)
286   ipif.transport.write(slip.encode(packet))
287   ipif.transport.write(slip.delimiter)
288
289 #---------- packet queue ----------
290
291 class PacketQueue():
292   def __init__(self, desc, max_queue_time):
293     self._desc = desc
294     assert(desc + '')
295     self._max_queue_time = max_queue_time
296     self._pq = collections.deque() # packets
297
298   def _log(self, dflag, msg, **kwargs):
299     log_debug(dflag, self._desc+' pq: '+msg, **kwargs)
300
301   def append(self, packet):
302     self._log(DBG.QUEUE, 'append', d=packet)
303     self._pq.append((time.monotonic(), packet))
304
305   def nonempty(self):
306     self._log(DBG.QUEUE, 'nonempty ?')
307     while True:
308       try: (queuetime, packet) = self._pq[0]
309       except IndexError:
310         self._log(DBG.QUEUE, 'nonempty ? empty.')
311         return False
312
313       age = time.monotonic() - queuetime
314       if age > self._max_queue_time:
315         # strip old packets off the front
316         self._log(DBG.QUEUE, 'dropping (old)', d=packet)
317         self._pq.popleft()
318         continue
319
320       self._log(DBG.QUEUE, 'nonempty ? nonempty.')
321       return True
322
323   def process(self, sizequery, moredata, max_batch):
324     # sizequery() should return size of batch so far
325     # moredata(s) should add s to batch
326     self._log(DBG.QUEUE, 'process...')
327     while True:
328       try: (dummy, packet) = self._pq[0]
329       except IndexError:
330         self._log(DBG.QUEUE, 'process... empty')
331         break
332
333       self._log(DBG.QUEUE_CTRL, 'process... packet', d=packet)
334
335       encoded = slip.encode(packet)
336       sofar = sizequery()  
337
338       self._log(DBG.QUEUE_CTRL,
339                 'process... (sofar=%d, max=%d) encoded' % (sofar, max_batch),
340                 d=encoded)
341
342       if sofar > 0:
343         if sofar + len(slip.delimiter) + len(encoded) > max_batch:
344           self._log(DBG.QUEUE_CTRL, 'process... overflow')
345           break
346         moredata(slip.delimiter)
347
348       moredata(encoded)
349       self._pq.popleft()
350
351 #---------- error handling ----------
352
353 _crashing = False
354
355 def crash(err):
356   global _crashing
357   _crashing = True
358   print('========== CRASH ==========', err,
359         '===========================', file=sys.stderr)
360   try: reactor.stop()
361   except twisted.internet.error.ReactorNotRunning: pass
362
363 def crash_on_defer(defer):
364   defer.addErrback(lambda err: crash(err))
365
366 def crash_on_critical(event):
367   if event.get('log_level') >= LogLevel.critical:
368     crash(twisted.logger.formatEvent(event))
369
370 #---------- config processing ----------
371
372 def _cfg_process_putatives():
373   servers = { }
374   clients = { }
375   # maps from abstract object to canonical name for cs's
376
377   def putative(cmap, abstract, canoncs):
378     try:
379       current_canoncs = cmap[abstract]
380     except KeyError:
381       pass
382     else:
383       assert(current_canoncs == canoncs)
384     cmap[abstract] = canoncs
385
386   server_pat = r'[-.0-9A-Za-z]+'
387   client_pat = r'[.:0-9a-f]+'
388   server_re = regexp.compile(server_pat)
389   serverclient_re = regexp.compile(
390         server_pat + r' ' + '(?:' + client_pat + '|LIMIT)')
391
392   for cs in cfg.sections():
393     def dbg(m):
394       log_debug_config('putatives: section [%s] %s' % (cs, m))
395
396     def log_ignore(why):
397       dbg('X ignore: %s' % (why))
398       print('warning: ignoring config section [%s] (%s)' % (cs, why),
399             file=sys.stderr)
400
401     if cs == 'LIMIT' or cs == 'COMMON':
402       # plan A "[LIMIT]" or "[COMMON]"
403       dbg('A ignore')
404       continue
405
406     try:
407       # plan B "[<client>]" part 1
408       ci = ipaddr(cs)
409     except AddressValueError:
410
411       if server_re.fullmatch(cs):
412         # plan C "[<servername>]"
413         dbg('C <server>')
414         putative(servers, cs, cs)
415         continue
416
417       if serverclient_re.fullmatch(cs):
418         # plan D "[<servername> <client>]" part 1
419         (pss,pcs) = cs.split(' ')
420
421         if pcs == 'LIMIT':
422           # plan E "[<servername> LIMIT]"
423           dbg('E <server> LIMIT')
424           continue
425
426         try:
427           # plan D "[<servername> <client>]" part 2
428           ci = ipaddr(pcs)
429         except AddressValueError:
430           # plan F branch 1 "[<some thing we do not understand>]"
431           log_ignore('bad-addr')
432           continue
433
434         else: # no AddressValueError
435           # plan D "[<servername> <client>]" part 3
436           dbg('D <server> <client>')
437           putative(clients, ci, pcs)
438           putative(servers, pss, pss)
439           continue
440       else:
441         # plan F branch 2 "[<some thing we do not understand>]"
442         log_ignore('nomatch '+ repr(serverclient_re))
443
444     else: # no AddressValueError
445       # plan B "[<client>" part 2
446       dbg('B <client>')
447       putative(clients, ci, cs)
448       continue
449
450   return (servers, clients)
451
452 def cfg_process_general(c, ss):
453   c.mtu = cfg1getint(ss, 'mtu')
454
455 def cfg_process_saddrs(c, ss):
456   class ServerAddr():
457     def __init__(self, port, addrspec):
458       self.port = port
459       # also self.addr
460       try:
461         self.addr = ipaddress.IPv4Address(addrspec)
462         self._endpointfactory = twisted.internet.endpoints.TCP4ServerEndpoint
463         self._inurl = b'%s'
464       except AddressValueError:
465         self.addr = ipaddress.IPv6Address(addrspec)
466         self._endpointfactory = twisted.internet.endpoints.TCP6ServerEndpoint
467         self._inurl = b'[%s]'
468     def make_endpoint(self):
469       return self._endpointfactory(reactor, self.port,
470                                    interface= '%s' % self.addr)
471     def url(self):
472       url = b'http://' + (self._inurl % str(self.addr).encode('ascii'))
473       if self.port != 80: url += b':%d' % self.port
474       url += b'/'
475       return url
476     def __repr__(self):
477       return 'ServerAddr'+repr((self.port,self.addr))
478
479   c.port = cfg1getint(ss,'port')
480   c.saddrs = [ ]
481   for addrspec in cfg1get(ss, 'addrs').split():
482     sa = ServerAddr(c.port, addrspec)
483     c.saddrs.append(sa)
484
485 def cfg_process_vnetwork(c, ss):
486   c.vnetwork = ipnetwork(cfg1get(ss,'vnetwork'))
487   if c.vnetwork.num_addresses < 3 + 2:
488     raise ValueError('vnetwork needs at least 2^3 addresses')
489
490 def cfg_process_vaddr(c, ss):
491   try:
492     c.vaddr = cfg1get(ss,'vaddr')
493   except NoOptionError:
494     cfg_process_vnetwork(c, ss)
495     c.vaddr = next(c.vnetwork.hosts())
496
497 def cfg_search_section(key,sections):
498   for section in sections:
499     if cfg.has_option(section, key):
500       return section
501   raise NoOptionError(key, repr(sections))
502
503 def cfg_get_raw(*args, **kwargs):
504   # for passing to cfg_search
505   return cfg.get(*args, raw=True, **kwargs)
506
507 def cfg_search(getter,key,sections):
508   section = cfg_search_section(key,sections)
509   return getter(section, key)
510
511 def cfg1get(section,key, getter=cfg.get,**kwargs):
512   section = cfg_search_section(key,[section,'COMMON'])
513   return getter(section,key,**kwargs)
514
515 def cfg1getint(section,key, **kwargs):
516   return cfg1get(section,key, getter=cfg.getint,**kwargs);
517
518 def cfg_process_client_limited(cc,ss,sections,key):
519   val = cfg_search(cfg1getint, key, sections)
520   lim = cfg_search(cfg1getint, key, ['%s LIMIT' % ss, 'LIMIT'])
521   cc.__dict__[key] = min(val,lim)
522
523 def cfg_process_client_common(cc,ss,cs,ci):
524   # returns sections to search in, iff secret is defined, otherwise None
525   cc.ci = ci
526
527   sections = ['%s %s' % (ss,cs),
528               cs,
529               ss,
530               'COMMON']
531
532   try: pwsection = cfg_search_section('secret', sections)
533   except NoOptionError: return None
534     
535   pw = cfg1get(pwsection, 'secret')
536   cc.secret = pw.encode('utf-8')
537
538   cfg_process_client_limited(cc,ss,sections,'target_requests_outstanding')
539   cfg_process_client_limited(cc,ss,sections,'http_timeout')
540
541   return sections
542
543 def cfg_process_ipif(c, sections, varmap):
544   for d, s in varmap:
545     try: v = getattr(c, s)
546     except AttributeError: continue
547     setattr(c, d, v)
548
549   #print('CFGIPIF',repr((varmap, sections, c.__dict__)),file=sys.stderr)
550
551   section = cfg_search_section('ipif', sections)
552   c.ipif_command = cfg1get(section,'ipif', vars=c.__dict__)
553
554 #---------- startup ----------
555
556 def log_debug_config(m):
557   if not DBG.CONFIG in debug_set: return
558   print('DBG.CONFIG:', m)
559
560 def common_startup(process_cfg):
561   # calls process_cfg(putative_clients, putative_servers)
562
563   # ConfigParser hates #-comments after values
564   trailingcomments_re = regexp.compile(r'#.*')
565   cfg.read_string(trailingcomments_re.sub('', defcfg))
566   need_defcfg = True
567
568   def readconfig(pathname, mandatory=True):
569     def log(m, p=pathname):
570       if not DBG.CONFIG in debug_set: return
571       log_debug_config('%s: %s' % (m, p))
572
573     try:
574       files = os.listdir(pathname)
575
576     except FileNotFoundError:
577       if mandatory: raise
578       log('skipped')
579       return
580
581     except NotADirectoryError:
582       cfg.read(pathname)
583       log('read file')
584       return
585
586     # is a directory
587     log('directory')
588     re = regexp.compile('[^-A-Za-z0-9_]')
589     for f in os.listdir(pathname):
590       if re.search(f): continue
591       subpath = pathname + '/' + f
592       try:
593         os.stat(subpath)
594       except FileNotFoundError:
595         log('entry skipped', subpath)
596         continue
597       cfg.read(subpath)
598       log('entry read', subpath)
599       
600   def oc_config(od,os, value, op):
601     nonlocal need_defcfg
602     need_defcfg = False
603     readconfig(value)
604
605   def oc_extra_config(od,os, value, op):
606     readconfig(value)
607
608   def read_defconfig():
609     readconfig('/etc/hippotat/config.d', False)
610     readconfig('/etc/hippotat/secrets.d', False)
611     readconfig('/etc/hippotat/master.cfg',   False)
612
613   def oc_defconfig(od,os, value, op):
614     nonlocal need_defcfg
615     need_defcfg = False
616     read_defconfig(value)
617
618   def dfs_less_detailed(dl):
619     return [df for df in DBG.iterconstants() if df <= dl]
620
621   def ds_default(od,os,dl,op):
622     global debug_set
623     debug_set.clear
624     debug_set |= set(dfs_less_detailed(debug_def_detail))
625
626   def ds_select(od,os, spec, op):
627     for it in spec.split(','):
628
629       if it.startswith('-'):
630         mutator = debug_set.discard
631         it = it[1:]
632       else:
633         mutator = debug_set.add
634
635       if it == '+':
636         dfs = DBG.iterconstants()
637
638       else:
639         if it.endswith('+'):
640           mapper = dfs_less_detailed
641           it = it[0:len(it)-1]
642         else:
643           mapper = lambda x: [x]
644
645           try:
646             dfspec = DBG.lookupByName(it)
647           except ValueError:
648             optparser.error('unknown debug flag %s in --debug-select' % it)
649
650         dfs = mapper(dfspec)
651
652       for df in dfs:
653         mutator(df)
654
655   optparser.add_option('-D', '--debug',
656                        nargs=0,
657                        action='callback',
658                        help='enable default debug (to stdout)',
659                        callback= ds_default)
660
661   optparser.add_option('--debug-select',
662                        nargs=1,
663                        type='string',
664                        metavar='[-]DFLAG[+]|[-]+,...',
665                        help=
666 '''enable (`-': disable) each specified DFLAG;
667 `+': do same for all "more interesting" DFLAGSs;
668 just `+': all DFLAGs.
669   DFLAGS: ''' + ' '.join([df.name for df in DBG.iterconstants()]),
670                        action='callback',
671                        callback= ds_select)
672
673   optparser.add_option('-c', '--config',
674                        nargs=1,
675                        type='string',
676                        metavar='CONFIGFILE',
677                        dest='configfile',
678                        action='callback',
679                        callback= oc_config)
680
681   optparser.add_option('--extra-config',
682                        nargs=1,
683                        type='string',
684                        metavar='CONFIGFILE',
685                        dest='configfile',
686                        action='callback',
687                        callback= oc_extra_config)
688
689   optparser.add_option('--default-config',
690                        action='callback',
691                        callback= oc_defconfig)
692
693   (opts, args) = optparser.parse_args()
694   if len(args): optparser.error('no non-option arguments please')
695
696   if need_defcfg:
697     read_defconfig()
698
699   try:
700     (pss, pcs) = _cfg_process_putatives()
701     process_cfg(opts, pss, pcs)
702   except (configparser.Error, ValueError):
703     traceback.print_exc(file=sys.stderr)
704     print('\nInvalid configuration, giving up.', file=sys.stderr)
705     sys.exit(12)
706
707
708   #print('X', debug_set, file=sys.stderr)
709
710   log_formatter = twisted.logger.formatEventAsClassicLogText
711   stdout_obs = twisted.logger.FileLogObserver(sys.stdout, log_formatter)
712   stderr_obs = twisted.logger.FileLogObserver(sys.stderr, log_formatter)
713   pred = twisted.logger.LogLevelFilterPredicate(LogLevel.error)
714   stdsomething_obs = twisted.logger.FilteringLogObserver(
715     stderr_obs, [pred], stdout_obs
716   )
717   global file_log_observer
718   file_log_observer = twisted.logger.FilteringLogObserver(
719     stdsomething_obs, [LogNotBoringTwisted()]
720   )
721   #log_observer = stdsomething_obs
722   twisted.logger.globalLogBeginner.beginLoggingTo(
723     [ file_log_observer, crash_on_critical ]
724     )
725
726 def common_run():
727   log_debug(DBG.INIT, 'entering reactor')
728   if not _crashing: reactor.run()
729   print('ENDED', file=sys.stderr)
730   sys.exit(16)