/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2014-07-25 23:42:53 UTC
  • mto: (237.7.272 trunk)
  • mto: This revision was merged to the branch mainline in revision 321.
  • Revision ID: teddy@recompile.se-20140725234253-m11fdsv01fetbk51
Use the .major attribute on sys.version_info instead of using "[0]".

The components of sys.version_info can now be accessed by attributes
instead of by numerical index, so do that.

* mandos-ctl: Get major version by using "sys.version_info.major".
* mandos-monitor: - '' -

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
1
 
#!/usr/bin/python
 
1
#!/usr/bin/python2.7
2
2
# -*- mode: python; coding: utf-8 -*-
3
3
# 
4
4
# Mandos server - give out binary blobs to connecting clients.
11
11
# "AvahiService" class, and some lines in "main".
12
12
# 
13
13
# Everything else is
14
 
# Copyright © 2008-2013 Teddy Hogeborn
15
 
# Copyright © 2008-2013 Björn Påhlsson
 
14
# Copyright © 2008-2014 Teddy Hogeborn
 
15
# Copyright © 2008-2014 Björn Påhlsson
16
16
# 
17
17
# This program is free software: you can redistribute it and/or modify
18
18
# it under the terms of the GNU General Public License as published by
88
88
    except ImportError:
89
89
        SO_BINDTODEVICE = None
90
90
 
91
 
version = "1.6.2"
 
91
version = "1.6.7"
92
92
stored_state_file = "clients.pickle"
93
93
 
94
94
logger = logging.getLogger()
95
 
syslogger = (logging.handlers.SysLogHandler
96
 
             (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
97
 
              address = str("/dev/log")))
 
95
syslogger = None
98
96
 
99
97
try:
100
98
    if_nametoindex = (ctypes.cdll.LoadLibrary
116
114
def initlogger(debug, level=logging.WARNING):
117
115
    """init logger and add loglevel"""
118
116
    
 
117
    global syslogger
 
118
    syslogger = (logging.handlers.SysLogHandler
 
119
                 (facility =
 
120
                  logging.handlers.SysLogHandler.LOG_DAEMON,
 
121
                  address = str("/dev/log")))
119
122
    syslogger.setFormatter(logging.Formatter
120
123
                           ('Mandos [%(process)d]: %(levelname)s:'
121
124
                            ' %(message)s'))
335
338
        elif state == avahi.ENTRY_GROUP_FAILURE:
336
339
            logger.critical("Avahi: Error in group state changed %s",
337
340
                            unicode(error))
338
 
            raise AvahiGroupError("State changed: {0!s}"
 
341
            raise AvahiGroupError("State changed: {!s}"
339
342
                                  .format(error))
340
343
    
341
344
    def cleanup(self):
392
395
        """Add the new name to the syslog messages"""
393
396
        ret = AvahiService.rename(self)
394
397
        syslogger.setFormatter(logging.Formatter
395
 
                               ('Mandos ({0}) [%(process)d]:'
 
398
                               ('Mandos ({}) [%(process)d]:'
396
399
                                ' %(levelname)s: %(message)s'
397
400
                                .format(self.name)))
398
401
        return ret
399
402
 
400
403
 
401
 
def timedelta_to_milliseconds(td):
402
 
    "Convert a datetime.timedelta() to milliseconds"
403
 
    return ((td.days * 24 * 60 * 60 * 1000)
404
 
            + (td.seconds * 1000)
405
 
            + (td.microseconds // 1000))
406
 
 
407
 
 
408
404
class Client(object):
409
405
    """A representation of a client host served by this server.
410
406
    
465
461
                        "enabled": "True",
466
462
                        }
467
463
    
468
 
    def timeout_milliseconds(self):
469
 
        "Return the 'timeout' attribute in milliseconds"
470
 
        return timedelta_to_milliseconds(self.timeout)
471
 
    
472
 
    def extended_timeout_milliseconds(self):
473
 
        "Return the 'extended_timeout' attribute in milliseconds"
474
 
        return timedelta_to_milliseconds(self.extended_timeout)
475
 
    
476
 
    def interval_milliseconds(self):
477
 
        "Return the 'interval' attribute in milliseconds"
478
 
        return timedelta_to_milliseconds(self.interval)
479
 
    
480
 
    def approval_delay_milliseconds(self):
481
 
        return timedelta_to_milliseconds(self.approval_delay)
482
 
    
483
464
    @staticmethod
484
465
    def config_parser(config):
485
466
        """Construct a new dict of client settings of this form:
510
491
                          "rb") as secfile:
511
492
                    client["secret"] = secfile.read()
512
493
            else:
513
 
                raise TypeError("No secret or secfile for section {0}"
 
494
                raise TypeError("No secret or secfile for section {}"
514
495
                                .format(section))
515
496
            client["timeout"] = string_to_delta(section["timeout"])
516
497
            client["extended_timeout"] = string_to_delta(
533
514
            server_settings = {}
534
515
        self.server_settings = server_settings
535
516
        # adding all client settings
536
 
        for setting, value in settings.iteritems():
 
517
        for setting, value in settings.items():
537
518
            setattr(self, setting, value)
538
519
        
539
520
        if self.enabled:
622
603
        if self.checker_initiator_tag is not None:
623
604
            gobject.source_remove(self.checker_initiator_tag)
624
605
        self.checker_initiator_tag = (gobject.timeout_add
625
 
                                      (self.interval_milliseconds(),
 
606
                                      (int(self.interval
 
607
                                           .total_seconds() * 1000),
626
608
                                       self.start_checker))
627
609
        # Schedule a disable() when 'timeout' has passed
628
610
        if self.disable_initiator_tag is not None:
629
611
            gobject.source_remove(self.disable_initiator_tag)
630
612
        self.disable_initiator_tag = (gobject.timeout_add
631
 
                                   (self.timeout_milliseconds(),
632
 
                                    self.disable))
 
613
                                      (int(self.timeout
 
614
                                           .total_seconds() * 1000),
 
615
                                       self.disable))
633
616
        # Also start a new checker *right now*.
634
617
        self.start_checker()
635
618
    
666
649
            self.disable_initiator_tag = None
667
650
        if getattr(self, "enabled", False):
668
651
            self.disable_initiator_tag = (gobject.timeout_add
669
 
                                          (timedelta_to_milliseconds
670
 
                                           (timeout), self.disable))
 
652
                                          (int(timeout.total_seconds()
 
653
                                               * 1000), self.disable))
671
654
            self.expires = datetime.datetime.utcnow() + timeout
672
655
    
673
656
    def need_approval(self):
690
673
        # If a checker exists, make sure it is not a zombie
691
674
        try:
692
675
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
693
 
        except (AttributeError, OSError) as error:
694
 
            if (isinstance(error, OSError)
695
 
                and error.errno != errno.ECHILD):
696
 
                raise error
 
676
        except AttributeError:
 
677
            pass
 
678
        except OSError as error:
 
679
            if error.errno != errno.ECHILD:
 
680
                raise
697
681
        else:
698
682
            if pid:
699
683
                logger.warning("Checker was a zombie")
703
687
        # Start a new checker if needed
704
688
        if self.checker is None:
705
689
            # Escape attributes for the shell
706
 
            escaped_attrs = dict(
707
 
                (attr, re.escape(unicode(getattr(self, attr))))
708
 
                for attr in
709
 
                self.runtime_expansions)
 
690
            escaped_attrs = { attr:
 
691
                                  re.escape(unicode(getattr(self,
 
692
                                                            attr)))
 
693
                              for attr in self.runtime_expansions }
710
694
            try:
711
695
                command = self.checker_command % escaped_attrs
712
696
            except TypeError as error:
793
777
    # "Set" method, so we fail early here:
794
778
    if byte_arrays and signature != "ay":
795
779
        raise ValueError("Byte arrays not supported for non-'ay'"
796
 
                         " signature {0!r}".format(signature))
 
780
                         " signature {!r}".format(signature))
797
781
    def decorator(func):
798
782
        func._dbus_is_property = True
799
783
        func._dbus_interface = dbus_interface
878
862
        If called like _is_dbus_thing("method") it returns a function
879
863
        suitable for use as predicate to inspect.getmembers().
880
864
        """
881
 
        return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
 
865
        return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
882
866
                                   False)
883
867
    
884
868
    def _get_all_dbus_things(self, thing):
933
917
            # The byte_arrays option is not supported yet on
934
918
            # signatures other than "ay".
935
919
            if prop._dbus_signature != "ay":
936
 
                raise ValueError
 
920
                raise ValueError("Byte arrays not supported for non-"
 
921
                                 "'ay' signature {!r}"
 
922
                                 .format(prop._dbus_signature))
937
923
            value = dbus.ByteArray(b''.join(chr(byte)
938
924
                                            for byte in value))
939
925
        prop(value)
1003
989
                                              (prop,
1004
990
                                               "_dbus_annotations",
1005
991
                                               {}))
1006
 
                        for name, value in annots.iteritems():
 
992
                        for name, value in annots.items():
1007
993
                            ann_tag = document.createElement(
1008
994
                                "annotation")
1009
995
                            ann_tag.setAttribute("name", name)
1012
998
                # Add interface annotation tags
1013
999
                for annotation, value in dict(
1014
1000
                    itertools.chain.from_iterable(
1015
 
                        annotations().iteritems()
 
1001
                        annotations().items()
1016
1002
                        for name, annotations in
1017
1003
                        self._get_all_dbus_things("interface")
1018
1004
                        if name == if_tag.getAttribute("name")
1019
 
                        )).iteritems():
 
1005
                        )).items():
1020
1006
                    ann_tag = document.createElement("annotation")
1021
1007
                    ann_tag.setAttribute("name", annotation)
1022
1008
                    ann_tag.setAttribute("value", value)
1078
1064
    """
1079
1065
    def wrapper(cls):
1080
1066
        for orig_interface_name, alt_interface_name in (
1081
 
            alt_interface_names.iteritems()):
 
1067
            alt_interface_names.items()):
1082
1068
            attr = {}
1083
1069
            interface_names = set()
1084
1070
            # Go though all attributes of the class
1201
1187
                                        attribute.func_closure)))
1202
1188
            if deprecate:
1203
1189
                # Deprecate all alternate interfaces
1204
 
                iname="_AlternateDBusNames_interface_annotation{0}"
 
1190
                iname="_AlternateDBusNames_interface_annotation{}"
1205
1191
                for interface_name in interface_names:
1206
1192
                    @dbus_interface_annotations(interface_name)
1207
1193
                    def func(self):
1216
1202
            if interface_names:
1217
1203
                # Replace the class with a new subclass of it with
1218
1204
                # methods, signals, etc. as created above.
1219
 
                cls = type(b"{0}Alternate".format(cls.__name__),
 
1205
                cls = type(b"{}Alternate".format(cls.__name__),
1220
1206
                           (cls,), attr)
1221
1207
        return cls
1222
1208
    return wrapper
1263
1249
                   to the D-Bus.  Default: no transform
1264
1250
        variant_level: D-Bus variant level.  Default: 1
1265
1251
        """
1266
 
        attrname = "_{0}".format(dbus_name)
 
1252
        attrname = "_{}".format(dbus_name)
1267
1253
        def setter(self, value):
1268
1254
            if hasattr(self, "dbus_object_path"):
1269
1255
                if (not hasattr(self, attrname) or
1299
1285
    approval_delay = notifychangeproperty(dbus.UInt64,
1300
1286
                                          "ApprovalDelay",
1301
1287
                                          type_func =
1302
 
                                          timedelta_to_milliseconds)
 
1288
                                          lambda td: td.total_seconds()
 
1289
                                          * 1000)
1303
1290
    approval_duration = notifychangeproperty(
1304
1291
        dbus.UInt64, "ApprovalDuration",
1305
 
        type_func = timedelta_to_milliseconds)
 
1292
        type_func = lambda td: td.total_seconds() * 1000)
1306
1293
    host = notifychangeproperty(dbus.String, "Host")
1307
1294
    timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1308
 
                                   type_func =
1309
 
                                   timedelta_to_milliseconds)
 
1295
                                   type_func = lambda td:
 
1296
                                       td.total_seconds() * 1000)
1310
1297
    extended_timeout = notifychangeproperty(
1311
1298
        dbus.UInt64, "ExtendedTimeout",
1312
 
        type_func = timedelta_to_milliseconds)
 
1299
        type_func = lambda td: td.total_seconds() * 1000)
1313
1300
    interval = notifychangeproperty(dbus.UInt64,
1314
1301
                                    "Interval",
1315
1302
                                    type_func =
1316
 
                                    timedelta_to_milliseconds)
 
1303
                                    lambda td: td.total_seconds()
 
1304
                                    * 1000)
1317
1305
    checker_command = notifychangeproperty(dbus.String, "Checker")
1318
1306
    
1319
1307
    del notifychangeproperty
1347
1335
                                       *args, **kwargs)
1348
1336
    
1349
1337
    def start_checker(self, *args, **kwargs):
1350
 
        old_checker = self.checker
1351
 
        if self.checker is not None:
1352
 
            old_checker_pid = self.checker.pid
1353
 
        else:
1354
 
            old_checker_pid = None
 
1338
        old_checker_pid = getattr(self.checker, "pid", None)
1355
1339
        r = Client.start_checker(self, *args, **kwargs)
1356
1340
        # Only if new checker process was started
1357
1341
        if (self.checker is not None
1366
1350
    
1367
1351
    def approve(self, value=True):
1368
1352
        self.approved = value
1369
 
        gobject.timeout_add(timedelta_to_milliseconds
1370
 
                            (self.approval_duration),
1371
 
                            self._reset_approved)
 
1353
        gobject.timeout_add(int(self.approval_duration.total_seconds()
 
1354
                                * 1000), self._reset_approved)
1372
1355
        self.send_changedstate()
1373
1356
    
1374
1357
    ## D-Bus methods, signals & properties
1477
1460
                           access="readwrite")
1478
1461
    def ApprovalDelay_dbus_property(self, value=None):
1479
1462
        if value is None:       # get
1480
 
            return dbus.UInt64(self.approval_delay_milliseconds())
 
1463
            return dbus.UInt64(self.approval_delay.total_seconds()
 
1464
                               * 1000)
1481
1465
        self.approval_delay = datetime.timedelta(0, 0, 0, value)
1482
1466
    
1483
1467
    # ApprovalDuration - property
1485
1469
                           access="readwrite")
1486
1470
    def ApprovalDuration_dbus_property(self, value=None):
1487
1471
        if value is None:       # get
1488
 
            return dbus.UInt64(timedelta_to_milliseconds(
1489
 
                    self.approval_duration))
 
1472
            return dbus.UInt64(self.approval_duration.total_seconds()
 
1473
                               * 1000)
1490
1474
        self.approval_duration = datetime.timedelta(0, 0, 0, value)
1491
1475
    
1492
1476
    # Name - property
1558
1542
                           access="readwrite")
1559
1543
    def Timeout_dbus_property(self, value=None):
1560
1544
        if value is None:       # get
1561
 
            return dbus.UInt64(self.timeout_milliseconds())
 
1545
            return dbus.UInt64(self.timeout.total_seconds() * 1000)
1562
1546
        old_timeout = self.timeout
1563
1547
        self.timeout = datetime.timedelta(0, 0, 0, value)
1564
1548
        # Reschedule disabling
1575
1559
                gobject.source_remove(self.disable_initiator_tag)
1576
1560
                self.disable_initiator_tag = (
1577
1561
                    gobject.timeout_add(
1578
 
                        timedelta_to_milliseconds(self.expires - now),
1579
 
                        self.disable))
 
1562
                        int((self.expires - now).total_seconds()
 
1563
                            * 1000), self.disable))
1580
1564
    
1581
1565
    # ExtendedTimeout - property
1582
1566
    @dbus_service_property(_interface, signature="t",
1583
1567
                           access="readwrite")
1584
1568
    def ExtendedTimeout_dbus_property(self, value=None):
1585
1569
        if value is None:       # get
1586
 
            return dbus.UInt64(self.extended_timeout_milliseconds())
 
1570
            return dbus.UInt64(self.extended_timeout.total_seconds()
 
1571
                               * 1000)
1587
1572
        self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1588
1573
    
1589
1574
    # Interval - property
1591
1576
                           access="readwrite")
1592
1577
    def Interval_dbus_property(self, value=None):
1593
1578
        if value is None:       # get
1594
 
            return dbus.UInt64(self.interval_milliseconds())
 
1579
            return dbus.UInt64(self.interval.total_seconds() * 1000)
1595
1580
        self.interval = datetime.timedelta(0, 0, 0, value)
1596
1581
        if getattr(self, "checker_initiator_tag", None) is None:
1597
1582
            return
1702
1687
            logger.debug("Protocol version: %r", line)
1703
1688
            try:
1704
1689
                if int(line.strip().split()[0]) > 1:
1705
 
                    raise RuntimeError
 
1690
                    raise RuntimeError(line)
1706
1691
            except (ValueError, IndexError, RuntimeError) as error:
1707
1692
                logger.error("Unknown protocol version: %s", error)
1708
1693
                return
1757
1742
                        if self.server.use_dbus:
1758
1743
                            # Emit D-Bus signal
1759
1744
                            client.NeedApproval(
1760
 
                                client.approval_delay_milliseconds(),
1761
 
                                client.approved_by_default)
 
1745
                                client.approval_delay.total_seconds()
 
1746
                                * 1000, client.approved_by_default)
1762
1747
                    else:
1763
1748
                        logger.warning("Client %s was not approved",
1764
1749
                                       client.name)
1770
1755
                    #wait until timeout or approved
1771
1756
                    time = datetime.datetime.now()
1772
1757
                    client.changedstate.acquire()
1773
 
                    client.changedstate.wait(
1774
 
                        float(timedelta_to_milliseconds(delay)
1775
 
                              / 1000))
 
1758
                    client.changedstate.wait(delay.total_seconds())
1776
1759
                    client.changedstate.release()
1777
1760
                    time2 = datetime.datetime.now()
1778
1761
                    if (time2 - time) >= delay:
1915
1898
    
1916
1899
    def add_pipe(self, parent_pipe, proc):
1917
1900
        """Dummy function; override as necessary"""
1918
 
        raise NotImplementedError
 
1901
        raise NotImplementedError()
1919
1902
 
1920
1903
 
1921
1904
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2186
2169
    token_duration = Token(re.compile(r"P"), None,
2187
2170
                           frozenset((token_year, token_month,
2188
2171
                                      token_day, token_time,
2189
 
                                      token_week))),
 
2172
                                      token_week)))
2190
2173
    # Define starting values
2191
2174
    value = datetime.timedelta() # Value so far
2192
2175
    found_token = None
2193
 
    followers = frozenset(token_duration,) # Following valid tokens
 
2176
    followers = frozenset((token_duration,)) # Following valid tokens
2194
2177
    s = duration                # String left to parse
2195
2178
    # Loop until end token is found
2196
2179
    while found_token is not token_end:
2256
2239
            elif suffix == "w":
2257
2240
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2258
2241
            else:
2259
 
                raise ValueError("Unknown suffix {0!r}"
 
2242
                raise ValueError("Unknown suffix {!r}"
2260
2243
                                 .format(suffix))
2261
 
        except (ValueError, IndexError) as e:
 
2244
        except IndexError as e:
2262
2245
            raise ValueError(*(e.args))
2263
2246
        timevalue += delta
2264
2247
    return timevalue
2279
2262
        # Close all standard open file descriptors
2280
2263
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2281
2264
        if not stat.S_ISCHR(os.fstat(null).st_mode):
2282
 
            raise OSError(errno.ENODEV,
2283
 
                          "{0} not a character device"
 
2265
            raise OSError(errno.ENODEV, "{} not a character device"
2284
2266
                          .format(os.devnull))
2285
2267
        os.dup2(null, sys.stdin.fileno())
2286
2268
        os.dup2(null, sys.stdout.fileno())
2296
2278
    
2297
2279
    parser = argparse.ArgumentParser()
2298
2280
    parser.add_argument("-v", "--version", action="version",
2299
 
                        version = "%(prog)s {0}".format(version),
 
2281
                        version = "%(prog)s {}".format(version),
2300
2282
                        help="show version number and exit")
2301
2283
    parser.add_argument("-i", "--interface", metavar="IF",
2302
2284
                        help="Bind to interface IF")
2335
2317
                        help="Directory to save/restore state in")
2336
2318
    parser.add_argument("--foreground", action="store_true",
2337
2319
                        help="Run in foreground", default=None)
 
2320
    parser.add_argument("--no-zeroconf", action="store_false",
 
2321
                        dest="zeroconf", help="Do not use Zeroconf",
 
2322
                        default=None)
2338
2323
    
2339
2324
    options = parser.parse_args()
2340
2325
    
2341
2326
    if options.check:
2342
2327
        import doctest
2343
 
        doctest.testmod()
2344
 
        sys.exit()
 
2328
        fail_count, test_count = doctest.testmod()
 
2329
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2345
2330
    
2346
2331
    # Default values for config file for server-global settings
2347
2332
    server_defaults = { "interface": "",
2358
2343
                        "socket": "",
2359
2344
                        "statedir": "/var/lib/mandos",
2360
2345
                        "foreground": "False",
 
2346
                        "zeroconf": "True",
2361
2347
                        }
2362
2348
    
2363
2349
    # Parse config file for server-global settings
2390
2376
    for option in ("interface", "address", "port", "debug",
2391
2377
                   "priority", "servicename", "configdir",
2392
2378
                   "use_dbus", "use_ipv6", "debuglevel", "restore",
2393
 
                   "statedir", "socket", "foreground"):
 
2379
                   "statedir", "socket", "foreground", "zeroconf"):
2394
2380
        value = getattr(options, option)
2395
2381
        if value is not None:
2396
2382
            server_settings[option] = value
2401
2387
            server_settings[option] = unicode(server_settings[option])
2402
2388
    # Force all boolean options to be boolean
2403
2389
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
2404
 
                   "foreground"):
 
2390
                   "foreground", "zeroconf"):
2405
2391
        server_settings[option] = bool(server_settings[option])
2406
2392
    # Debug implies foreground
2407
2393
    if server_settings["debug"]:
2410
2396
    
2411
2397
    ##################################################################
2412
2398
    
 
2399
    if (not server_settings["zeroconf"] and
 
2400
        not (server_settings["port"]
 
2401
             or server_settings["socket"] != "")):
 
2402
            parser.error("Needs port or socket to work without"
 
2403
                         " Zeroconf")
 
2404
    
2413
2405
    # For convenience
2414
2406
    debug = server_settings["debug"]
2415
2407
    debuglevel = server_settings["debuglevel"]
2418
2410
    stored_state_path = os.path.join(server_settings["statedir"],
2419
2411
                                     stored_state_file)
2420
2412
    foreground = server_settings["foreground"]
 
2413
    zeroconf = server_settings["zeroconf"]
2421
2414
    
2422
2415
    if debug:
2423
2416
        initlogger(debug, logging.DEBUG)
2430
2423
    
2431
2424
    if server_settings["servicename"] != "Mandos":
2432
2425
        syslogger.setFormatter(logging.Formatter
2433
 
                               ('Mandos ({0}) [%(process)d]:'
 
2426
                               ('Mandos ({}) [%(process)d]:'
2434
2427
                                ' %(levelname)s: %(message)s'
2435
2428
                                .format(server_settings
2436
2429
                                        ["servicename"])))
2444
2437
    global mandos_dbus_service
2445
2438
    mandos_dbus_service = None
2446
2439
    
 
2440
    socketfd = None
 
2441
    if server_settings["socket"] != "":
 
2442
        socketfd = server_settings["socket"]
2447
2443
    tcp_server = MandosServer((server_settings["address"],
2448
2444
                               server_settings["port"]),
2449
2445
                              ClientHandler,
2453
2449
                              gnutls_priority=
2454
2450
                              server_settings["priority"],
2455
2451
                              use_dbus=use_dbus,
2456
 
                              socketfd=(server_settings["socket"]
2457
 
                                        or None))
 
2452
                              socketfd=socketfd)
2458
2453
    if not foreground:
2459
2454
        pidfilename = "/run/mandos.pid"
2460
2455
        if not os.path.isdir("/run/."):
2481
2476
        os.setuid(uid)
2482
2477
    except OSError as error:
2483
2478
        if error.errno != errno.EPERM:
2484
 
            raise error
 
2479
            raise
2485
2480
    
2486
2481
    if debug:
2487
2482
        # Enable all possible GnuTLS debugging
2530
2525
            use_dbus = False
2531
2526
            server_settings["use_dbus"] = False
2532
2527
            tcp_server.use_dbus = False
2533
 
    protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2534
 
    service = AvahiServiceToSyslog(name =
2535
 
                                   server_settings["servicename"],
2536
 
                                   servicetype = "_mandos._tcp",
2537
 
                                   protocol = protocol, bus = bus)
2538
 
    if server_settings["interface"]:
2539
 
        service.interface = (if_nametoindex
2540
 
                             (str(server_settings["interface"])))
 
2528
    if zeroconf:
 
2529
        protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
 
2530
        service = AvahiServiceToSyslog(name =
 
2531
                                       server_settings["servicename"],
 
2532
                                       servicetype = "_mandos._tcp",
 
2533
                                       protocol = protocol, bus = bus)
 
2534
        if server_settings["interface"]:
 
2535
            service.interface = (if_nametoindex
 
2536
                                 (str(server_settings["interface"])))
2541
2537
    
2542
2538
    global multiprocessing_manager
2543
2539
    multiprocessing_manager = multiprocessing.Manager()
2567
2563
            os.remove(stored_state_path)
2568
2564
        except IOError as e:
2569
2565
            if e.errno == errno.ENOENT:
2570
 
                logger.warning("Could not load persistent state: {0}"
 
2566
                logger.warning("Could not load persistent state: {}"
2571
2567
                                .format(os.strerror(e.errno)))
2572
2568
            else:
2573
2569
                logger.critical("Could not load persistent state:",
2578
2574
                           "EOFError:", exc_info=e)
2579
2575
    
2580
2576
    with PGPEngine() as pgp:
2581
 
        for client_name, client in clients_data.iteritems():
 
2577
        for client_name, client in clients_data.items():
2582
2578
            # Skip removed clients
2583
2579
            if client_name not in client_settings:
2584
2580
                continue
2609
2605
                if datetime.datetime.utcnow() >= client["expires"]:
2610
2606
                    if not client["last_checked_ok"]:
2611
2607
                        logger.warning(
2612
 
                            "disabling client {0} - Client never "
 
2608
                            "disabling client {} - Client never "
2613
2609
                            "performed a successful checker"
2614
2610
                            .format(client_name))
2615
2611
                        client["enabled"] = False
2616
2612
                    elif client["last_checker_status"] != 0:
2617
2613
                        logger.warning(
2618
 
                            "disabling client {0} - Client "
2619
 
                            "last checker failed with error code {1}"
 
2614
                            "disabling client {} - Client last"
 
2615
                            " checker failed with error code {}"
2620
2616
                            .format(client_name,
2621
2617
                                    client["last_checker_status"]))
2622
2618
                        client["enabled"] = False
2625
2621
                                             .utcnow()
2626
2622
                                             + client["timeout"])
2627
2623
                        logger.debug("Last checker succeeded,"
2628
 
                                     " keeping {0} enabled"
 
2624
                                     " keeping {} enabled"
2629
2625
                                     .format(client_name))
2630
2626
            try:
2631
2627
                client["secret"] = (
2634
2630
                                ["secret"]))
2635
2631
            except PGPError:
2636
2632
                # If decryption fails, we use secret from new settings
2637
 
                logger.debug("Failed to decrypt {0} old secret"
 
2633
                logger.debug("Failed to decrypt {} old secret"
2638
2634
                             .format(client_name))
2639
2635
                client["secret"] = (
2640
2636
                    client_settings[client_name]["secret"])
2648
2644
        clients_data[client_name] = client_settings[client_name]
2649
2645
    
2650
2646
    # Create all client objects
2651
 
    for client_name, client in clients_data.iteritems():
 
2647
    for client_name, client in clients_data.items():
2652
2648
        tcp_server.clients[client_name] = client_class(
2653
2649
            name = client_name, settings = client,
2654
2650
            server_settings = server_settings)
2737
2733
    
2738
2734
    def cleanup():
2739
2735
        "Cleanup function; run on exit"
2740
 
        service.cleanup()
 
2736
        if zeroconf:
 
2737
            service.cleanup()
2741
2738
        
2742
2739
        multiprocessing.active_children()
2743
2740
        wnull.close()
2757
2754
                
2758
2755
                # A list of attributes that can not be pickled
2759
2756
                # + secret.
2760
 
                exclude = set(("bus", "changedstate", "secret",
2761
 
                               "checker", "server_settings"))
 
2757
                exclude = { "bus", "changedstate", "secret",
 
2758
                            "checker", "server_settings" }
2762
2759
                for name, typ in (inspect.getmembers
2763
2760
                                  (dbus.service.Object)):
2764
2761
                    exclude.add(name)
2787
2784
                except NameError:
2788
2785
                    pass
2789
2786
            if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2790
 
                logger.warning("Could not save persistent state: {0}"
 
2787
                logger.warning("Could not save persistent state: {}"
2791
2788
                               .format(os.strerror(e.errno)))
2792
2789
            else:
2793
2790
                logger.warning("Could not save persistent state:",
2794
2791
                               exc_info=e)
2795
 
                raise e
 
2792
                raise
2796
2793
        
2797
2794
        # Delete all clients, and settings from config
2798
2795
        while tcp_server.clients:
2822
2819
    tcp_server.server_activate()
2823
2820
    
2824
2821
    # Find out what port we got
2825
 
    service.port = tcp_server.socket.getsockname()[1]
 
2822
    if zeroconf:
 
2823
        service.port = tcp_server.socket.getsockname()[1]
2826
2824
    if use_ipv6:
2827
2825
        logger.info("Now listening on address %r, port %d,"
2828
2826
                    " flowinfo %d, scope_id %d",
2834
2832
    #service.interface = tcp_server.socket.getsockname()[3]
2835
2833
    
2836
2834
    try:
2837
 
        # From the Avahi example code
2838
 
        try:
2839
 
            service.activate()
2840
 
        except dbus.exceptions.DBusException as error:
2841
 
            logger.critical("D-Bus Exception", exc_info=error)
2842
 
            cleanup()
2843
 
            sys.exit(1)
2844
 
        # End of Avahi example code
 
2835
        if zeroconf:
 
2836
            # From the Avahi example code
 
2837
            try:
 
2838
                service.activate()
 
2839
            except dbus.exceptions.DBusException as error:
 
2840
                logger.critical("D-Bus Exception", exc_info=error)
 
2841
                cleanup()
 
2842
                sys.exit(1)
 
2843
            # End of Avahi example code
2845
2844
        
2846
2845
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2847
2846
                             lambda *args, **kwargs: