/mandos/trunk

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2016-02-28 12:29:12 UTC
  • Revision ID: teddy@recompile.se-20160228122912-6yxw70vq8oze7ogc
http://bugs.debian.org/811159
Remove version specific packages from Debian dependencies.

* debian/control (Source: mandos/Build-Depends-Indep): Remove
  "python2.7", "python2.7-dbus", "python2.7-avahi", and
  "python2.7-gobject"; replace with "python (= 2.7)", "python-dbus",
  "python-avahi", "python-gobject".

Thanks: Scott Kitterman <debian@kitterman.com>
Closes: #811159

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-2016 Teddy Hogeborn
15
 
# Copyright © 2008-2016 Björn Påhlsson
 
14
# Copyright © 2008-2015 Teddy Hogeborn
 
15
# Copyright © 2008-2015 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
34
34
from __future__ import (division, absolute_import, print_function,
35
35
                        unicode_literals)
36
36
 
37
 
try:
38
 
    from future_builtins import *
39
 
except ImportError:
40
 
    pass
 
37
from future_builtins import *
41
38
 
42
39
try:
43
40
    import SocketServer as socketserver
79
76
 
80
77
import dbus
81
78
import dbus.service
82
 
from gi.repository import GLib
 
79
try:
 
80
    import gobject
 
81
except ImportError:
 
82
    from gi.repository import GObject as gobject
 
83
import avahi
83
84
from dbus.mainloop.glib import DBusGMainLoop
84
85
import ctypes
85
86
import ctypes.util
97
98
if sys.version_info.major == 2:
98
99
    str = unicode
99
100
 
100
 
version = "1.7.6"
 
101
version = "1.7.1"
101
102
stored_state_file = "clients.pickle"
102
103
 
103
104
logger = logging.getLogger()
118
119
        return interface_index
119
120
 
120
121
 
121
 
def copy_function(func):
122
 
    """Make a copy of a function"""
123
 
    if sys.version_info.major == 2:
124
 
        return types.FunctionType(func.func_code,
125
 
                                  func.func_globals,
126
 
                                  func.func_name,
127
 
                                  func.func_defaults,
128
 
                                  func.func_closure)
129
 
    else:
130
 
        return types.FunctionType(func.__code__,
131
 
                                  func.__globals__,
132
 
                                  func.__name__,
133
 
                                  func.__defaults__,
134
 
                                  func.__closure__)
135
 
 
136
 
 
137
122
def initlogger(debug, level=logging.WARNING):
138
123
    """init logger and add loglevel"""
139
124
    
166
151
    
167
152
    def __init__(self):
168
153
        self.tempdir = tempfile.mkdtemp(prefix="mandos-")
169
 
        self.gpg = "gpg"
170
 
        try:
171
 
            output = subprocess.check_output(["gpgconf"])
172
 
            for line in output.splitlines():
173
 
                name, text, path = line.split(b":")
174
 
                if name == "gpg":
175
 
                    self.gpg = path
176
 
                    break
177
 
        except OSError as e:
178
 
            if e.errno != errno.ENOENT:
179
 
                raise
180
154
        self.gnupgargs = ['--batch',
181
 
                          '--homedir', self.tempdir,
 
155
                          '--home', self.tempdir,
182
156
                          '--force-mdc',
183
157
                          '--quiet',
184
158
                          '--no-use-agent']
223
197
                dir=self.tempdir) as passfile:
224
198
            passfile.write(passphrase)
225
199
            passfile.flush()
226
 
            proc = subprocess.Popen([self.gpg, '--symmetric',
 
200
            proc = subprocess.Popen(['gpg', '--symmetric',
227
201
                                     '--passphrase-file',
228
202
                                     passfile.name]
229
203
                                    + self.gnupgargs,
241
215
                dir = self.tempdir) as passfile:
242
216
            passfile.write(passphrase)
243
217
            passfile.flush()
244
 
            proc = subprocess.Popen([self.gpg, '--decrypt',
 
218
            proc = subprocess.Popen(['gpg', '--decrypt',
245
219
                                     '--passphrase-file',
246
220
                                     passfile.name]
247
221
                                    + self.gnupgargs,
253
227
            raise PGPError(err)
254
228
        return decrypted_plaintext
255
229
 
256
 
# Pretend that we have an Avahi module
257
 
class Avahi(object):
258
 
    """This isn't so much a class as it is a module-like namespace.
259
 
    It is instantiated once, and simulates having an Avahi module."""
260
 
    IF_UNSPEC = -1              # avahi-common/address.h
261
 
    PROTO_UNSPEC = -1           # avahi-common/address.h
262
 
    PROTO_INET = 0              # avahi-common/address.h
263
 
    PROTO_INET6 = 1             # avahi-common/address.h
264
 
    DBUS_NAME = "org.freedesktop.Avahi"
265
 
    DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"
266
 
    DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
267
 
    DBUS_PATH_SERVER = "/"
268
 
    def string_array_to_txt_array(self, t):
269
 
        return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
270
 
                           for s in t), signature="ay")
271
 
    ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h
272
 
    ENTRY_GROUP_COLLISION = 3   # avahi-common/defs.h
273
 
    ENTRY_GROUP_FAILURE = 4     # avahi-common/defs.h
274
 
    SERVER_INVALID = 0          # avahi-common/defs.h
275
 
    SERVER_REGISTERING = 1      # avahi-common/defs.h
276
 
    SERVER_RUNNING = 2          # avahi-common/defs.h
277
 
    SERVER_COLLISION = 3        # avahi-common/defs.h
278
 
    SERVER_FAILURE = 4          # avahi-common/defs.h
279
 
avahi = Avahi()
280
230
 
281
231
class AvahiError(Exception):
282
232
    def __init__(self, value, *args, **kwargs):
486
436
    
487
437
    _library = ctypes.cdll.LoadLibrary(
488
438
        ctypes.util.find_library("gnutls"))
489
 
    _need_version = b"3.3.0"
 
439
    _need_version = "3.3.0"
490
440
    def __init__(self):
491
441
        # Need to use class name "GnuTLS" here, since this method is
492
442
        # called before the assignment to the "gnutls" global variable
526
476
    openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
527
477
    openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
528
478
    log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
529
 
    credentials_type_t = ctypes.c_int
 
479
    credentials_type_t = ctypes.c_int # 
530
480
    transport_ptr_t = ctypes.c_void_p
531
481
    close_request_t = ctypes.c_int
532
482
    
754
704
    checker:    subprocess.Popen(); a running checker process used
755
705
                                    to see if the client lives.
756
706
                                    'None' if no process is running.
757
 
    checker_callback_tag: a GLib event source tag, or None
 
707
    checker_callback_tag: a gobject event source tag, or None
758
708
    checker_command: string; External command which is run to check
759
709
                     if client lives.  %() expansions are done at
760
710
                     runtime with vars(self) as dict, so that for
761
711
                     instance %(name)s can be used in the command.
762
 
    checker_initiator_tag: a GLib event source tag, or None
 
712
    checker_initiator_tag: a gobject event source tag, or None
763
713
    created:    datetime.datetime(); (UTC) object creation
764
714
    client_structure: Object describing what attributes a client has
765
715
                      and is used for storing the client at exit
766
716
    current_checker_command: string; current running checker_command
767
 
    disable_initiator_tag: a GLib event source tag, or None
 
717
    disable_initiator_tag: a gobject event source tag, or None
768
718
    enabled:    bool()
769
719
    fingerprint: string (40 or 32 hexadecimal digits); used to
770
720
                 uniquely identify the client
833
783
            client["fingerprint"] = (section["fingerprint"].upper()
834
784
                                     .replace(" ", ""))
835
785
            if "secret" in section:
836
 
                client["secret"] = codecs.decode(section["secret"]
837
 
                                                 .encode("utf-8"),
838
 
                                                 "base64")
 
786
                client["secret"] = section["secret"].decode("base64")
839
787
            elif "secfile" in section:
840
788
                with open(os.path.expanduser(os.path.expandvars
841
789
                                             (section["secfile"])),
894
842
        self.changedstate = multiprocessing_manager.Condition(
895
843
            multiprocessing_manager.Lock())
896
844
        self.client_structure = [attr
897
 
                                 for attr in self.__dict__.keys()
 
845
                                 for attr in self.__dict__.iterkeys()
898
846
                                 if not attr.startswith("_")]
899
847
        self.client_structure.append("client_structure")
900
848
        
926
874
        if not quiet:
927
875
            logger.info("Disabling client %s", self.name)
928
876
        if getattr(self, "disable_initiator_tag", None) is not None:
929
 
            GLib.source_remove(self.disable_initiator_tag)
 
877
            gobject.source_remove(self.disable_initiator_tag)
930
878
            self.disable_initiator_tag = None
931
879
        self.expires = None
932
880
        if getattr(self, "checker_initiator_tag", None) is not None:
933
 
            GLib.source_remove(self.checker_initiator_tag)
 
881
            gobject.source_remove(self.checker_initiator_tag)
934
882
            self.checker_initiator_tag = None
935
883
        self.stop_checker()
936
884
        self.enabled = False
937
885
        if not quiet:
938
886
            self.send_changedstate()
939
 
        # Do not run this again if called by a GLib.timeout_add
 
887
        # Do not run this again if called by a gobject.timeout_add
940
888
        return False
941
889
    
942
890
    def __del__(self):
946
894
        # Schedule a new checker to be started an 'interval' from now,
947
895
        # and every interval from then on.
948
896
        if self.checker_initiator_tag is not None:
949
 
            GLib.source_remove(self.checker_initiator_tag)
950
 
        self.checker_initiator_tag = GLib.timeout_add(
 
897
            gobject.source_remove(self.checker_initiator_tag)
 
898
        self.checker_initiator_tag = gobject.timeout_add(
951
899
            int(self.interval.total_seconds() * 1000),
952
900
            self.start_checker)
953
901
        # Schedule a disable() when 'timeout' has passed
954
902
        if self.disable_initiator_tag is not None:
955
 
            GLib.source_remove(self.disable_initiator_tag)
956
 
        self.disable_initiator_tag = GLib.timeout_add(
 
903
            gobject.source_remove(self.disable_initiator_tag)
 
904
        self.disable_initiator_tag = gobject.timeout_add(
957
905
            int(self.timeout.total_seconds() * 1000), self.disable)
958
906
        # Also start a new checker *right now*.
959
907
        self.start_checker()
995
943
        if timeout is None:
996
944
            timeout = self.timeout
997
945
        if self.disable_initiator_tag is not None:
998
 
            GLib.source_remove(self.disable_initiator_tag)
 
946
            gobject.source_remove(self.disable_initiator_tag)
999
947
            self.disable_initiator_tag = None
1000
948
        if getattr(self, "enabled", False):
1001
 
            self.disable_initiator_tag = GLib.timeout_add(
 
949
            self.disable_initiator_tag = gobject.timeout_add(
1002
950
                int(timeout.total_seconds() * 1000), self.disable)
1003
951
            self.expires = datetime.datetime.utcnow() + timeout
1004
952
    
1059
1007
                args = (pipe[1], subprocess.call, command),
1060
1008
                kwargs = popen_args)
1061
1009
            self.checker.start()
1062
 
            self.checker_callback_tag = GLib.io_add_watch(
1063
 
                pipe[0].fileno(), GLib.IO_IN,
 
1010
            self.checker_callback_tag = gobject.io_add_watch(
 
1011
                pipe[0].fileno(), gobject.IO_IN,
1064
1012
                self.checker_callback, pipe[0], command)
1065
 
        # Re-run this periodically if run by GLib.timeout_add
 
1013
        # Re-run this periodically if run by gobject.timeout_add
1066
1014
        return True
1067
1015
    
1068
1016
    def stop_checker(self):
1069
1017
        """Force the checker process, if any, to stop."""
1070
1018
        if self.checker_callback_tag:
1071
 
            GLib.source_remove(self.checker_callback_tag)
 
1019
            gobject.source_remove(self.checker_callback_tag)
1072
1020
            self.checker_callback_tag = None
1073
1021
        if getattr(self, "checker", None) is None:
1074
1022
            return
1548
1496
                interface_names.add(alt_interface)
1549
1497
                # Is this a D-Bus signal?
1550
1498
                if getattr(attribute, "_dbus_is_signal", False):
1551
 
                    # Extract the original non-method undecorated
1552
 
                    # function by black magic
1553
1499
                    if sys.version_info.major == 2:
 
1500
                        # Extract the original non-method undecorated
 
1501
                        # function by black magic
1554
1502
                        nonmethod_func = (dict(
1555
1503
                            zip(attribute.func_code.co_freevars,
1556
1504
                                attribute.__closure__))
1557
1505
                                          ["func"].cell_contents)
1558
1506
                    else:
1559
 
                        nonmethod_func = (dict(
1560
 
                            zip(attribute.__code__.co_freevars,
1561
 
                                attribute.__closure__))
1562
 
                                          ["func"].cell_contents)
 
1507
                        nonmethod_func = attribute
1563
1508
                    # Create a new, but exactly alike, function
1564
1509
                    # object, and decorate it to be a new D-Bus signal
1565
1510
                    # with the alternate D-Bus interface name
1566
 
                    new_function = copy_function(nonmethod_func)
 
1511
                    if sys.version_info.major == 2:
 
1512
                        new_function = types.FunctionType(
 
1513
                            nonmethod_func.func_code,
 
1514
                            nonmethod_func.func_globals,
 
1515
                            nonmethod_func.func_name,
 
1516
                            nonmethod_func.func_defaults,
 
1517
                            nonmethod_func.func_closure)
 
1518
                    else:
 
1519
                        new_function = types.FunctionType(
 
1520
                            nonmethod_func.__code__,
 
1521
                            nonmethod_func.__globals__,
 
1522
                            nonmethod_func.__name__,
 
1523
                            nonmethod_func.__defaults__,
 
1524
                            nonmethod_func.__closure__)
1567
1525
                    new_function = (dbus.service.signal(
1568
1526
                        alt_interface,
1569
1527
                        attribute._dbus_signature)(new_function))
1608
1566
                            alt_interface,
1609
1567
                            attribute._dbus_in_signature,
1610
1568
                            attribute._dbus_out_signature)
1611
 
                        (copy_function(attribute)))
 
1569
                        (types.FunctionType(attribute.func_code,
 
1570
                                            attribute.func_globals,
 
1571
                                            attribute.func_name,
 
1572
                                            attribute.func_defaults,
 
1573
                                            attribute.func_closure)))
1612
1574
                    # Copy annotations, if any
1613
1575
                    try:
1614
1576
                        attr[attrname]._dbus_annotations = dict(
1626
1588
                        attribute._dbus_access,
1627
1589
                        attribute._dbus_get_args_options
1628
1590
                        ["byte_arrays"])
1629
 
                                      (copy_function(attribute)))
 
1591
                                      (types.FunctionType(
 
1592
                                          attribute.func_code,
 
1593
                                          attribute.func_globals,
 
1594
                                          attribute.func_name,
 
1595
                                          attribute.func_defaults,
 
1596
                                          attribute.func_closure)))
1630
1597
                    # Copy annotations, if any
1631
1598
                    try:
1632
1599
                        attr[attrname]._dbus_annotations = dict(
1641
1608
                    # to the class.
1642
1609
                    attr[attrname] = (
1643
1610
                        dbus_interface_annotations(alt_interface)
1644
 
                        (copy_function(attribute)))
 
1611
                        (types.FunctionType(attribute.func_code,
 
1612
                                            attribute.func_globals,
 
1613
                                            attribute.func_name,
 
1614
                                            attribute.func_defaults,
 
1615
                                            attribute.func_closure)))
1645
1616
            if deprecate:
1646
1617
                # Deprecate all alternate interfaces
1647
1618
                iname="_AlternateDBusNames_interface_annotation{}"
1660
1631
            if interface_names:
1661
1632
                # Replace the class with a new subclass of it with
1662
1633
                # methods, signals, etc. as created above.
1663
 
                if sys.version_info.major == 2:
1664
 
                    cls = type(b"{}Alternate".format(cls.__name__),
1665
 
                               (cls, ), attr)
1666
 
                else:
1667
 
                    cls = type("{}Alternate".format(cls.__name__),
1668
 
                               (cls, ), attr)
 
1634
                cls = type(b"{}Alternate".format(cls.__name__),
 
1635
                           (cls, ), attr)
1669
1636
        return cls
1670
1637
    
1671
1638
    return wrapper
1829
1796
    
1830
1797
    def approve(self, value=True):
1831
1798
        self.approved = value
1832
 
        GLib.timeout_add(int(self.approval_duration.total_seconds()
1833
 
                             * 1000), self._reset_approved)
 
1799
        gobject.timeout_add(int(self.approval_duration.total_seconds()
 
1800
                                * 1000), self._reset_approved)
1834
1801
        self.send_changedstate()
1835
1802
    
1836
1803
    ## D-Bus methods, signals & properties
2046
2013
                if (getattr(self, "disable_initiator_tag", None)
2047
2014
                    is None):
2048
2015
                    return
2049
 
                GLib.source_remove(self.disable_initiator_tag)
2050
 
                self.disable_initiator_tag = GLib.timeout_add(
 
2016
                gobject.source_remove(self.disable_initiator_tag)
 
2017
                self.disable_initiator_tag = gobject.timeout_add(
2051
2018
                    int((self.expires - now).total_seconds() * 1000),
2052
2019
                    self.disable)
2053
2020
    
2073
2040
            return
2074
2041
        if self.enabled:
2075
2042
            # Reschedule checker run
2076
 
            GLib.source_remove(self.checker_initiator_tag)
2077
 
            self.checker_initiator_tag = GLib.timeout_add(
 
2043
            gobject.source_remove(self.checker_initiator_tag)
 
2044
            self.checker_initiator_tag = gobject.timeout_add(
2078
2045
                value, self.start_checker)
2079
2046
            self.start_checker() # Start one now, too
2080
2047
    
2484
2451
        gnutls_priority GnuTLS priority string
2485
2452
        use_dbus:       Boolean; to emit D-Bus signals or not
2486
2453
    
2487
 
    Assumes a GLib.MainLoop event loop.
 
2454
    Assumes a gobject.MainLoop event loop.
2488
2455
    """
2489
2456
    
2490
2457
    def __init__(self, server_address, RequestHandlerClass,
2515
2482
    
2516
2483
    def add_pipe(self, parent_pipe, proc):
2517
2484
        # Call "handle_ipc" for both data and EOF events
2518
 
        GLib.io_add_watch(
 
2485
        gobject.io_add_watch(
2519
2486
            parent_pipe.fileno(),
2520
 
            GLib.IO_IN | GLib.IO_HUP,
 
2487
            gobject.IO_IN | gobject.IO_HUP,
2521
2488
            functools.partial(self.handle_ipc,
2522
2489
                              parent_pipe = parent_pipe,
2523
2490
                              proc = proc))
2527
2494
                   proc = None,
2528
2495
                   client_object=None):
2529
2496
        # error, or the other end of multiprocessing.Pipe has closed
2530
 
        if condition & (GLib.IO_ERR | GLib.IO_HUP):
 
2497
        if condition & (gobject.IO_ERR | gobject.IO_HUP):
2531
2498
            # Wait for other process to exit
2532
2499
            proc.join()
2533
2500
            return False
2540
2507
            fpr = request[1]
2541
2508
            address = request[2]
2542
2509
            
2543
 
            for c in self.clients.values():
 
2510
            for c in self.clients.itervalues():
2544
2511
                if c.fingerprint == fpr:
2545
2512
                    client = c
2546
2513
                    break
2554
2521
                parent_pipe.send(False)
2555
2522
                return False
2556
2523
            
2557
 
            GLib.io_add_watch(
 
2524
            gobject.io_add_watch(
2558
2525
                parent_pipe.fileno(),
2559
 
                GLib.IO_IN | GLib.IO_HUP,
 
2526
                gobject.IO_IN | gobject.IO_HUP,
2560
2527
                functools.partial(self.handle_ipc,
2561
2528
                                  parent_pipe = parent_pipe,
2562
2529
                                  proc = proc,
2944
2911
            logger.error("Could not open file %r", pidfilename,
2945
2912
                         exc_info=e)
2946
2913
    
2947
 
    for name, group in (("_mandos", "_mandos"),
2948
 
                        ("mandos", "mandos"),
2949
 
                        ("nobody", "nogroup")):
 
2914
    for name in ("_mandos", "mandos", "nobody"):
2950
2915
        try:
2951
2916
            uid = pwd.getpwnam(name).pw_uid
2952
 
            gid = pwd.getpwnam(group).pw_gid
 
2917
            gid = pwd.getpwnam(name).pw_gid
2953
2918
            break
2954
2919
        except KeyError:
2955
2920
            continue
2959
2924
    try:
2960
2925
        os.setgid(gid)
2961
2926
        os.setuid(uid)
2962
 
        if debug:
2963
 
            logger.debug("Did setuid/setgid to {}:{}".format(uid,
2964
 
                                                             gid))
2965
2927
    except OSError as error:
2966
 
        logger.warning("Failed to setuid/setgid to {}:{}: {}"
2967
 
                       .format(uid, gid, os.strerror(error.errno)))
2968
2928
        if error.errno != errno.EPERM:
2969
2929
            raise
2970
2930
    
2992
2952
        # Close all input and output, do double fork, etc.
2993
2953
        daemon()
2994
2954
    
2995
 
    # multiprocessing will use threads, so before we use GLib we need
2996
 
    # to inform GLib that threads will be used.
2997
 
    GLib.threads_init()
 
2955
    # multiprocessing will use threads, so before we use gobject we
 
2956
    # need to inform gobject that threads will be used.
 
2957
    gobject.threads_init()
2998
2958
    
2999
2959
    global main_loop
3000
2960
    # From the Avahi example code
3001
2961
    DBusGMainLoop(set_as_default=True)
3002
 
    main_loop = GLib.MainLoop()
 
2962
    main_loop = gobject.MainLoop()
3003
2963
    bus = dbus.SystemBus()
3004
2964
    # End of Avahi example code
3005
2965
    if use_dbus:
3049
3009
    if server_settings["restore"]:
3050
3010
        try:
3051
3011
            with open(stored_state_path, "rb") as stored_state:
3052
 
                if sys.version_info.major == 2:                
3053
 
                    clients_data, old_client_settings = pickle.load(
3054
 
                        stored_state)
3055
 
                else:
3056
 
                    bytes_clients_data, bytes_old_client_settings = (
3057
 
                        pickle.load(stored_state, encoding = "bytes"))
3058
 
                    ### Fix bytes to strings
3059
 
                    ## clients_data
3060
 
                    # .keys()
3061
 
                    clients_data = { (key.decode("utf-8")
3062
 
                                      if isinstance(key, bytes)
3063
 
                                      else key): value
3064
 
                                     for key, value in
3065
 
                                     bytes_clients_data.items() }
3066
 
                    del bytes_clients_data
3067
 
                    for key in clients_data:
3068
 
                        value = { (k.decode("utf-8")
3069
 
                                   if isinstance(k, bytes) else k): v
3070
 
                                  for k, v in
3071
 
                                  clients_data[key].items() }
3072
 
                        clients_data[key] = value
3073
 
                        # .client_structure
3074
 
                        value["client_structure"] = [
3075
 
                            (s.decode("utf-8")
3076
 
                             if isinstance(s, bytes)
3077
 
                             else s) for s in
3078
 
                            value["client_structure"] ]
3079
 
                        # .name & .host
3080
 
                        for k in ("name", "host"):
3081
 
                            if isinstance(value[k], bytes):
3082
 
                                value[k] = value[k].decode("utf-8")
3083
 
                    ## old_client_settings
3084
 
                    # .keys()
3085
 
                    old_client_settings = {
3086
 
                        (key.decode("utf-8")
3087
 
                         if isinstance(key, bytes)
3088
 
                         else key): value
3089
 
                        for key, value in
3090
 
                        bytes_old_client_settings.items() }
3091
 
                    del bytes_old_client_settings
3092
 
                    # .host
3093
 
                    for value in old_client_settings.values():
3094
 
                        if isinstance(value["host"], bytes):
3095
 
                            value["host"] = (value["host"]
3096
 
                                             .decode("utf-8"))
 
3012
                clients_data, old_client_settings = pickle.load(
 
3013
                    stored_state)
3097
3014
            os.remove(stored_state_path)
3098
3015
        except IOError as e:
3099
3016
            if e.errno == errno.ENOENT:
3200
3117
        del pidfile
3201
3118
        del pidfilename
3202
3119
    
3203
 
    for termsig in (signal.SIGHUP, signal.SIGTERM):
3204
 
        GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,
3205
 
                             lambda: main_loop.quit() and False)
 
3120
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
 
3121
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
3206
3122
    
3207
3123
    if use_dbus:
3208
3124
        
3239
3155
            def GetAllClients(self):
3240
3156
                "D-Bus method"
3241
3157
                return dbus.Array(c.dbus_object_path for c in
3242
 
                                  tcp_server.clients.values())
 
3158
                                  tcp_server.clients.itervalues())
3243
3159
            
3244
3160
            @dbus_annotations({"org.freedesktop.DBus.Deprecated":
3245
3161
                               "true"})
3250
3166
                return dbus.Dictionary(
3251
3167
                    { c.dbus_object_path: c.GetAll(
3252
3168
                        "se.recompile.Mandos.Client")
3253
 
                      for c in tcp_server.clients.values() },
 
3169
                      for c in tcp_server.clients.itervalues() },
3254
3170
                    signature="oa{sv}")
3255
3171
            
3256
3172
            @dbus.service.method(_interface, in_signature="o")
3257
3173
            def RemoveClient(self, object_path):
3258
3174
                "D-Bus method"
3259
 
                for c in tcp_server.clients.values():
 
3175
                for c in tcp_server.clients.itervalues():
3260
3176
                    if c.dbus_object_path == object_path:
3261
3177
                        del tcp_server.clients[c.name]
3262
3178
                        c.remove_from_connection()
3322
3238
        # removed/edited, old secret will thus be unrecovable.
3323
3239
        clients = {}
3324
3240
        with PGPEngine() as pgp:
3325
 
            for client in tcp_server.clients.values():
 
3241
            for client in tcp_server.clients.itervalues():
3326
3242
                key = client_settings[client.name]["secret"]
3327
3243
                client.encrypted_secret = pgp.encrypt(client.secret,
3328
3244
                                                      key)
3352
3268
                    prefix='clients-',
3353
3269
                    dir=os.path.dirname(stored_state_path),
3354
3270
                    delete=False) as stored_state:
3355
 
                pickle.dump((clients, client_settings), stored_state,
3356
 
                            protocol = 2)
 
3271
                pickle.dump((clients, client_settings), stored_state)
3357
3272
                tempname = stored_state.name
3358
3273
            os.rename(tempname, stored_state_path)
3359
3274
        except (IOError, OSError) as e:
3384
3299
    
3385
3300
    atexit.register(cleanup)
3386
3301
    
3387
 
    for client in tcp_server.clients.values():
 
3302
    for client in tcp_server.clients.itervalues():
3388
3303
        if use_dbus:
3389
3304
            # Emit D-Bus signal for adding
3390
3305
            mandos_dbus_service.client_added_signal(client)
3419
3334
                sys.exit(1)
3420
3335
            # End of Avahi example code
3421
3336
        
3422
 
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3423
 
                          lambda *args, **kwargs:
3424
 
                          (tcp_server.handle_request
3425
 
                           (*args[2:], **kwargs) or True))
 
3337
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
 
3338
                             lambda *args, **kwargs:
 
3339
                             (tcp_server.handle_request
 
3340
                              (*args[2:], **kwargs) or True))
3426
3341
        
3427
3342
        logger.debug("Starting main loop")
3428
3343
        main_loop.run()